feat: add captureStackTrace parameter (#145)

* feat: add captureStackTrace parameter

* fix name

* add tests

* change test description

Author: gurgunday

README.md

@@ -16,13 +16,14 @@ npm i @fastify/error
 The module exports a function that you can use for consistent error objects, it takes 4 parameters:
 
 ```
-createError(code, message [, statusCode [, Base]])
+createError(code, message [, statusCode [, Base [, captureStackTrace]]])
 ```
 
 - `code` (`string`, required) - The error code, you can access it later with `error.code`. For consistency, we recommend prefixing plugin error codes with `FST_`
 - `message` (`string`, required) - The error message. You can also use interpolated strings for formatting the message.
 - `statusCode` (`number`, optional) - The status code that Fastify will use if the error is sent via HTTP.
 - `Base` (`ErrorConstructor`, optional) - The base error object that will be used. (eg `TypeError`, `RangeError`)
+- `captureStackTrace` (`boolean`, optional) - Whether to capture the stack trace or not.
 
 ```js
 const createError = require('@fastify/error')

index.js

@@ -6,7 +6,7 @@ function toString () {
   return `${this.name} [${this.code}]: ${this.message}`
 }
 
-function createError (code, message, statusCode = 500, Base = Error) {
+function createError (code, message, statusCode = 500, Base = Error, captureStackTrace = createError.captureStackTrace) {
   if (!code) throw new Error('Fastify error code must not be empty')
   if (!message) throw new Error('Fastify error message must not be empty')
 
@@ -29,7 +29,7 @@ function createError (code, message, statusCode = 500, Base = Error) {
 
     this.message = format(message, ...args)
 
-    Error.stackTraceLimit !== 0 && Error.captureStackTrace(this, FastifyError)
+    Error.stackTraceLimit && captureStackTrace && Error.captureStackTrace(this, FastifyError)
   }
 
   FastifyError.prototype = Object.create(Base.prototype, {
@@ -48,6 +48,8 @@ function createError (code, message, statusCode = 500, Base = Error) {
   return FastifyError
 }
 
+createError.captureStackTrace = true
+
 module.exports = createError
 module.exports.default = createError
 module.exports.createError = createError

test/index.test.js

@@ -138,6 +138,36 @@ test('Create error with different base', (t) => {
   t.assert.ok(err.stack)
 })
 
+test('Create error with different base (no stack) (global)', (t) => {
+  t.plan(7)
+
+  createError.captureStackTrace = false
+  const NewError = createError('CODE', 'hey %s', 500, TypeError)
+  const err = new NewError('dude')
+  t.assert.ok(err instanceof Error)
+  t.assert.ok(err instanceof TypeError)
+  t.assert.equal(err.name, 'FastifyError')
+  t.assert.equal(err.message, 'hey dude')
+  t.assert.equal(err.code, 'CODE')
+  t.assert.equal(err.statusCode, 500)
+  t.assert.equal(err.stack, undefined)
+  createError.captureStackTrace = true
+})
+
+test('Create error with different base (no stack) (parameter)', (t) => {
+  t.plan(7)
+
+  const NewError = createError('CODE', 'hey %s', 500, TypeError, false)
+  const err = new NewError('dude')
+  t.assert.ok(err instanceof Error)
+  t.assert.ok(err instanceof TypeError)
+  t.assert.equal(err.name, 'FastifyError')
+  t.assert.equal(err.message, 'hey dude')
+  t.assert.equal(err.code, 'CODE')
+  t.assert.equal(err.statusCode, 500)
+  t.assert.equal(err.stack, undefined)
+})
+
 test('FastifyError.toString returns code', (t) => {
   t.plan(1)
 

types/index.d.ts

@@ -2,21 +2,24 @@ declare function createError<C extends string, SC extends number, Arg extends un
   code: C,
   message: string,
   statusCode: SC,
-  Base?: ErrorConstructor
+  Base?: ErrorConstructor,
+  captureStackTrace?: boolean
 ): createError.FastifyErrorConstructor<{ code: C, statusCode: SC }, Arg>
 
 declare function createError<C extends string, Arg extends unknown[] = [any?, any?, any?]> (
   code: C,
   message: string,
   statusCode?: number,
-  Base?: ErrorConstructor
+  Base?: ErrorConstructor,
+  captureStackTrace?: boolean
 ): createError.FastifyErrorConstructor<{ code: C }, Arg>
 
 declare function createError<Arg extends unknown[] = [any?, any?, any?]> (
   code: string,
   message: string,
   statusCode?: number,
-  Base?: ErrorConstructor
+  Base?: ErrorConstructor,
+  captureStackTrace?: boolean
 ): createError.FastifyErrorConstructor<{ code: string }, Arg>
 
 type CreateError = typeof createError

types/index.test-d.ts

@@ -9,6 +9,14 @@ expectType<'ERROR_CODE'>(err.code)
 expectType<string>(err.message)
 expectType<number | undefined>(err.statusCode)
 
+const CustomErrorNoStackTrace = createError('ERROR_CODE', 'message', undefined, undefined, false)
+expectType<FastifyErrorConstructor<{ code: 'ERROR_CODE' }>>(CustomErrorNoStackTrace)
+const errNoStackTrace = new CustomErrorNoStackTrace()
+expectType<FastifyError & { code: 'ERROR_CODE' }>(errNoStackTrace)
+expectType<'ERROR_CODE'>(errNoStackTrace.code)
+expectType<string>(errNoStackTrace.message)
+expectType<number | undefined>(errNoStackTrace.statusCode)
+
 const CustomTypedError = createError('OTHER_CODE', 'message', 400)
 expectType<FastifyErrorConstructor<{ code: 'OTHER_CODE', statusCode: 400 }>>(CustomTypedError)
 const typed = new CustomTypedError()