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,12 @@ test('Create an error with last argument null', (t) => {
   t.assert.ok(err instanceof Error)
   t.assert.ifError(err.cause)
 })
+
+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)
+})

test/instanceof.test.js

@@ -0,0 +1,168 @@
+'use strict'
+
+const cp = require('node:child_process')
+const fs = require('node:fs')
+const path = require('node:path')
+const os = require('node:os')
+const test = require('node:test')
+const { createError, FastifyError } = require('..')
+
+test('check if createError creates an Error which is instanceof Error', (t) => {
+  t.plan(3)
+
+  const CustomFastifyError = createError('CODE', 'Not available')
+  const err = CustomFastifyError()
+
+  t.assert.ok(err instanceof Error)
+  t.assert.ok(err instanceof SyntaxError === false)
+  t.assert.ok(err instanceof TypeError === false)
+})
+
+test('check if createError creates an Error which is instanceof FastifyError', (t) => {
+  t.plan(4)
+
+  const CustomFastifyError = createError('CODE', 'Not available')
+  const err = CustomFastifyError()
+
+  t.assert.ok(err instanceof Error)
+  t.assert.ok(err instanceof FastifyError)
+  t.assert.ok(err instanceof SyntaxError === false)
+  t.assert.ok(err instanceof TypeError === false)
+})
+
+test('check if createError creates an Error with the right BaseConstructor', (t) => {
+  t.plan(2)
+
+  const CustomFastifyError = createError('CODE', 'Not available', 500, TypeError)
+  const err = CustomFastifyError()
+
+  t.assert.ok(err instanceof Error)
+  t.assert.ok(err instanceof TypeError)
+})
+
+test('check if createError creates an Error with the right BaseConstructor, which is a FastifyError', (t) => {
+  t.plan(6)
+
+  const BaseFastifyError = createError('CODE', 'Not available', 500, TypeError)
+  const CustomFastifyError = createError('CODE', 'Not available', 500, BaseFastifyError)
+  const err = CustomFastifyError()
+
+  t.assert.ok(err instanceof Error)
+  t.assert.ok(err instanceof TypeError)
+  t.assert.ok(err instanceof FastifyError)
+  t.assert.ok(err instanceof BaseFastifyError)
+  t.assert.ok(err instanceof CustomFastifyError)
+  t.assert.ok(err instanceof SyntaxError === false)
+})
+
+test('instanceof', async (t) => {
+  const assertsPlanned = 2
+  t.plan(assertsPlanned)
+
+  const testCwd = path.resolve(os.tmpdir())
+
+  fs.mkdirSync(path.resolve(testCwd, 'node_modules', 'fastify-error'), { recursive: true })
+
+  fs.copyFileSync(path.resolve(process.cwd(), 'index.js'), path.resolve(testCwd, 'node_modules', 'fastify-error', 'index.js'))
+  fs.copyFileSync(path.resolve(process.cwd(), 'package.json'), path.resolve(testCwd, 'node_modules', 'fastify-error', 'package.json'))
+
+  fs.mkdirSync(path.resolve(testCwd, 'node_modules', 'main', 'node_modules', 'fastify-error'), { recursive: true })
+
+  fs.copyFileSync(path.resolve(process.cwd(), 'index.js'), path.resolve(testCwd, 'node_modules', 'main', 'node_modules', 'fastify-error', 'index.js'))
+  fs.copyFileSync(path.resolve(process.cwd(), 'package.json'), path.resolve(testCwd, 'node_modules', 'main', 'node_modules', 'fastify-error', 'package.json'))
+
+  fs.writeFileSync(path.resolve(testCwd, 'node_modules', 'main', 'package.json'), `
+    {
+      "name": "main",
+      "version": "1.0.0",
+      "description": "main",
+      "main": "index.js",
+      "dependencies": {
+        "fastify-error": "1.0.0"
+      }
+    }
+    `)
+  fs.writeFileSync(path.resolve(testCwd, 'node_modules', 'main', 'index.js'), `
+    'use strict'
+
+    const { createError } = require('fastify-error')
+
+    const Boom = createError('Boom', 'Boom', 500)
+
+    module.exports.foo = function foo () {
+        throw new Boom('foo go Boom')
+    }
+    `)
+
+  fs.writeFileSync(path.resolve(testCwd, 'package.json'), `
+    {
+      "name": "test",
+      "version": "1.0.0",
+      "description": "main",
+      "main": "index.js",
+      "dependencies": {
+        "fastify-error": "1.0.0",
+        "main": "1.0.0"
+      }
+    }
+    `)
+  fs.writeFileSync(path.resolve(testCwd, 'index.js'), `
+    'use strict'
+    const { createError, FastifyError } = require('fastify-error')
+    const { foo } = require('main')
+
+    const Boom = createError('Boom', 'Boom', 500)
+
+    try {
+        foo()
+    } catch (err) {
+        process.send(err instanceof FastifyError)
+        process.send(err instanceof Boom)
+    }
+    `)
+
+  const finishedPromise = {
+    promise: undefined,
+    reject: undefined,
+    resolve: undefined,
+  }
+
+  finishedPromise.promise = new Promise((resolve, reject) => {
+    finishedPromise.resolve = resolve
+    finishedPromise.reject = reject
+  })
+
+  const child = cp.fork(path.resolve(testCwd, 'index.js'), {
+    cwd: testCwd,
+    stdio: 'pipe',
+    env: {
+      ...process.env,
+      NODE_OPTIONS: '--no-warnings'
+    },
+  })
+
+  let messageCount = 0
+  child.on('message', message => {
+    try {
+      switch (messageCount) {
+        case 0:
+          t.assert.strictEqual(message, true, 'instanceof FastifyError')
+          break
+        case 1:
+          t.assert.strictEqual(message, false, 'instanceof Boom')
+          break
+      }
+      if (++messageCount === assertsPlanned) {
+        finishedPromise.resolve()
+      }
+    } catch (err) {
+      finishedPromise.reject(err)
+    }
+  })
+
+  child.on('error', err => {
+    finishedPromise.reject(err)
+  })
+
+  await finishedPromise.promise
+})

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)
+}