feat: implement instanceof

index.js

@@ -2,6 +2,8 @@
 
 const { format } = require('node:util')
 
+const FastifyErrorSymbol = Symbol.for('fastify-error')
+
 function toString () {
   return `${this.name} [${this.code}]: ${this.message}`
 }
@@ -38,7 +40,13 @@ function createError (code, message, statusCode = 500, Base = Error, captureStac
       enumerable: false,
       writable: true,
       configurable: true
-    }
+    },
+    [FastifyErrorSymbol]: {
+      value: true,
+      enumerable: false,
+      writable: false,
+      configurable: false
+    },
   })
 
   FastifyError.prototype[Symbol.toStringTag] = 'Error'
@@ -50,6 +58,16 @@ function createError (code, message, statusCode = 500, Base = Error, captureStac
 
 createError.captureStackTrace = true
 
+const FastifyErrorConstructor = createError('FST_ERR', 'Fastify Error', 500, Error)
+Object.defineProperty(FastifyErrorConstructor, Symbol.hasInstance, {
+  value: function (instance) {
+    return instance && instance[FastifyErrorSymbol]
+  },
+  configurable: true,
+  enumerable: false
+})
+
 module.exports = createError
+module.exports.FastifyError = FastifyErrorConstructor
 module.exports.default = createError
 module.exports.createError = createError

test/index.test.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const test = require('node:test')
-const createError = require('..')
+const { createError, FastifyError } = require('..')
 
 test('Create error with zero parameter', (t) => {
   t.plan(6)
@@ -221,3 +221,30 @@ test('Create an error with last argument null', (t) => {
   t.assert.ok(err instanceof Error)
   t.assert.ifError(err.cause)
 })
+
+test('check if instanceof works', (t) => {
+  t.plan(7)
+
+  const NewError = createError('CODE', 'Not available')
+  const err = NewError()
+
+  const FastifySyntaxError = createError('CODE', 'Not available', 500, SyntaxError)
+  const syntaxErr = new FastifySyntaxError()
+
+  t.assert.ok(err instanceof Error)
+  t.assert.ok(err instanceof FastifyError)
+  t.assert.ok(err instanceof SyntaxError === false)
+  t.assert.ok(new Error() instanceof FastifyError === false)
+  t.assert.ok(syntaxErr instanceof SyntaxError)
+  t.assert.ok(syntaxErr instanceof FastifyError)
+  t.assert.ok(syntaxErr instanceof FastifySyntaxError)
+})
+
+test('check if FastifyError is instantiable', (t) => {
+  t.plan(2)
+
+  const err = new FastifyError()
+
+  t.assert.ok(err instanceof FastifyError)
+  t.assert.ok(err instanceof Error)
+})

types/index.d.ts

@@ -40,6 +40,8 @@ declare namespace createError {
     readonly prototype: FastifyError & E
   }
 
+  export const FastifyError: FastifyErrorConstructor
+
   export const createError: CreateError
   export { createError as default }
 }

types/index.test-d.ts

@@ -77,3 +77,16 @@ expectError(new CustomTypedArgError6('a', 'b', 'c', 'd', 'e'))
 const CustomErrorWithErrorConstructor = createError('ERROR_CODE', 'message', 500, TypeError)
 expectType<FastifyErrorConstructor<{ code: 'ERROR_CODE', statusCode: 500 }>>(CustomErrorWithErrorConstructor)
 CustomErrorWithErrorConstructor({ cause: new Error('Error') })
+const customErrorWithErrorConstructor = CustomErrorWithErrorConstructor()
+if (customErrorWithErrorConstructor instanceof FastifyError) {
+  expectType<'ERROR_CODE'>(customErrorWithErrorConstructor.code)
+  expectType<string>(customErrorWithErrorConstructor.message)
+  expectType<500>(customErrorWithErrorConstructor.statusCode)
+}
+
+const error = new FastifyError('ERROR_CODE', 'message', 500)
+if (error instanceof FastifyError) {
+  expectType<string>(error.code)
+  expectType<string>(error.message)
+  expectType<number | undefined>(error.statusCode)
+}