adjust checking for internal and public errors

index.ts

@@ -2,11 +2,13 @@ export type { ErrorDetails } from './src/errors/types'
 
 export {
   PublicNonRecoverableError,
+  isPublicNonRecoverableError,
   type PublicNonRecoverableErrorParams,
 } from './src/errors/PublicNonRecoverableError'
 
 export {
   InternalError,
+  isInternalError,
   type InternalErrorParams,
 } from './src/errors/InternalError'
 export { isEntityGoneError } from './src/errors/errorTypeGuards'
@@ -48,10 +50,8 @@ export {
 
 export {
   isError,
-  isInternalError,
   isStandardizedError,
   isObject,
-  isPublicNonRecoverableError,
   hasMessage,
 } from './src/utils/typeUtils'
 export { type StandardizedError } from './src/utils/typeUtils'

package.json

@@ -11,11 +11,7 @@
         "url": "git://github.com/lokalise/node-core.git"
     },
     "license": "Apache-2.0",
-    "files": [
-        "dist/**",
-        "LICENSE",
-        "README.md"
-    ],
+    "files": ["dist/**", "LICENSE", "README.md"],
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
     "type": "commonjs",

src/errors/InternalError.spec.ts

@@ -0,0 +1,34 @@
+import { InternalError, isInternalError } from './InternalError'
+
+describe('InternalError', () => {
+  describe('isInternalError', () => {
+    it('returns false for native Error', () => {
+      const err = new Error('Unknown')
+
+      expect(isInternalError(err)).toBe(false)
+    })
+
+    it('detects if error is internal', () => {
+      const err = new InternalError({
+        message: 'Unknown',
+        errorCode: 'INTERNAL_ERROR',
+      })
+
+      expect(isInternalError(err)).toBe(true)
+    })
+
+    it('detects if error is public for extended error', () => {
+      class ExtendedInternalError extends InternalError {
+        constructor() {
+          super({
+            message: 'Unknown',
+            errorCode: 'INTERNAL_ERROR',
+          })
+        }
+      }
+      const err = new ExtendedInternalError()
+
+      expect(isInternalError(err)).toBe(true)
+    })
+  })
+})

src/errors/InternalError.ts

@@ -1,3 +1,4 @@
+import { isError } from '../utils/typeUtils'
 import type { ErrorDetails } from './types'
 
 export type InternalErrorParams<T = ErrorDetails> = {
@@ -7,16 +8,30 @@ export type InternalErrorParams<T = ErrorDetails> = {
   cause?: unknown
 }
 
+const INTERNAL_ERROR_SYMBOL_KEY = 'INTERNAL_ERROR_KEY'
+const internalErrorSymbol = Symbol.for(INTERNAL_ERROR_SYMBOL_KEY)
+
 export class InternalError<T = ErrorDetails> extends Error {
+  readonly [internalErrorSymbol] = true
   public readonly details?: T
   public readonly errorCode: string
 
   constructor(params: InternalErrorParams<T>) {
     super(params.message, {
       cause: params.cause,
     })
-    this.name = 'InternalError'
+    // set the name as the class name for every class that extends InternalError
+    this.name = this.constructor.name
     this.details = params.details
     this.errorCode = params.errorCode
   }
 }
+
+export function isInternalError(error: unknown): error is InternalError {
+  return (
+    isError(error) &&
+    // biome-ignore lint/suspicious/noExplicitAny: checking for existence of prop outside or Error interface
+    ((error as any)[Symbol.for(INTERNAL_ERROR_SYMBOL_KEY)] === true ||
+      error.name === 'InternalError')
+  )
+}

src/errors/PublicNonRecoverableError.spec.ts

@@ -1,12 +1,43 @@
-import { PublicNonRecoverableError } from './PublicNonRecoverableError'
+import { PublicNonRecoverableError, isPublicNonRecoverableError } from './PublicNonRecoverableError'
 
 describe('PublicNonRecoverableError', () => {
   it('sets http status code to 500 by default', () => {
     const error = new PublicNonRecoverableError({
-      message: 'error',
+      message: 'Unknown',
       errorCode: 'PUBLIC_ERROR',
     })
 
     expect(error.httpStatusCode).toBe(500)
   })
+
+  describe('isPublicNonRecoverableError', () => {
+    it('returns false for native Error', () => {
+      const err = new Error('Unknown')
+
+      expect(isPublicNonRecoverableError(err)).toBe(false)
+    })
+
+    it('detects if error is public', () => {
+      const err = new PublicNonRecoverableError({
+        message: 'Unknown',
+        errorCode: 'PUBLIC_ERROR',
+      })
+
+      expect(isPublicNonRecoverableError(err)).toBe(true)
+    })
+
+    it('detects if error is public for extended error', () => {
+      class ExtendedPublicNonRecoverableError extends PublicNonRecoverableError {
+        constructor() {
+          super({
+            message: 'Unknown',
+            errorCode: 'PUBLIC_ERROR',
+          })
+        }
+      }
+      const err = new ExtendedPublicNonRecoverableError()
+
+      expect(isPublicNonRecoverableError(err)).toBe(true)
+    })
+  })
 })

src/errors/PublicNonRecoverableError.ts

@@ -1,3 +1,4 @@
+import { isError } from '../utils/typeUtils'
 import type { ErrorDetails } from './types'
 
 export type PublicNonRecoverableErrorParams<T = ErrorDetails> = {
@@ -8,10 +9,14 @@ export type PublicNonRecoverableErrorParams<T = ErrorDetails> = {
   cause?: unknown
 }
 
+const PUBLIC_NON_RECOVERABLE_ERROR_SYMBOL_KEY = 'PUBLIC_NON_RECOVERABLE_ERROR_KEY'
+const publicNonRecoverableErrorSymbol = Symbol.for(PUBLIC_NON_RECOVERABLE_ERROR_SYMBOL_KEY)
+
 /**
  * This error is returned to the consumer of API
  */
 export class PublicNonRecoverableError<T = ErrorDetails> extends Error {
+  readonly [publicNonRecoverableErrorSymbol] = true
   public readonly details?: T
   public readonly errorCode: string
   public readonly httpStatusCode: number
@@ -20,9 +25,19 @@ export class PublicNonRecoverableError<T = ErrorDetails> extends Error {
     super(params.message, {
       cause: params.cause,
     })
-    this.name = 'PublicNonRecoverableError'
+    // set the name as the class name for every class that extends PublicNonRecoverableError
+    this.name = this.constructor.name
     this.details = params.details
     this.errorCode = params.errorCode
     this.httpStatusCode = params.httpStatusCode ?? 500
   }
 }
+
+export function isPublicNonRecoverableError(error: unknown): error is PublicNonRecoverableError {
+  return (
+    isError(error) &&
+    // biome-ignore lint/suspicious/noExplicitAny: checking for existence of prop outside or Error interface
+    ((error as any)[Symbol.for(PUBLIC_NON_RECOVERABLE_ERROR_SYMBOL_KEY)] === true ||
+      error.name === 'PublicNonRecoverableError')
+  )
+}

src/errors/errorTypeGuards.ts

@@ -1,4 +1,4 @@
-import { isPublicNonRecoverableError } from '../utils/typeUtils'
+import { isPublicNonRecoverableError } from '../errors/PublicNonRecoverableError'
 
 import type { EntityGoneError } from './publicErrors'
 

src/utils/typeUtils.spec.ts

@@ -1,14 +1,7 @@
 import { InternalError } from '../errors/InternalError'
 import { PublicNonRecoverableError } from '../errors/PublicNonRecoverableError'
 
-import {
-  hasMessage,
-  isError,
-  isInternalError,
-  isObject,
-  isPublicNonRecoverableError,
-  isStandardizedError,
-} from './typeUtils'
+import { hasMessage, isError, isObject, isStandardizedError } from './typeUtils'
 
 describe('typeUtils', () => {
   describe('isError', () => {
@@ -55,46 +48,6 @@ describe('typeUtils', () => {
     })
   })
 
-  describe('isInternalError', () => {
-    it('true for InternalError', () => {
-      const error = new InternalError({
-        message: 'dummy',
-        errorCode: 'code',
-      })
-
-      expect(isInternalError(error)).toBe(true)
-    })
-
-    it('false for PublicNonRecoverableError', () => {
-      const error = new PublicNonRecoverableError({
-        message: 'dummy',
-        errorCode: 'code',
-      })
-
-      expect(isInternalError(error)).toBe(false)
-    })
-  })
-
-  describe('isPublicNonRecoverableError', () => {
-    it('false for InternalError', () => {
-      const error = new InternalError({
-        message: 'dummy',
-        errorCode: 'code',
-      })
-
-      expect(isPublicNonRecoverableError(error)).toBe(false)
-    })
-
-    it('true for PublicNonRecoverableError', () => {
-      const error = new PublicNonRecoverableError({
-        message: 'dummy',
-        errorCode: 'code',
-      })
-
-      expect(isPublicNonRecoverableError(error)).toBe(true)
-    })
-  })
-
   describe('hasMessage', () => {
     it('true for something with message', () => {
       const error = new InternalError({

src/utils/typeUtils.ts

@@ -1,6 +1,3 @@
-import type { InternalError } from '../errors/InternalError'
-import type { PublicNonRecoverableError } from '../errors/PublicNonRecoverableError'
-
 // Error structure commonly used in libraries, e. g. fastify
 export type StandardizedError = {
   code: string
@@ -19,16 +16,8 @@ export function isStandardizedError(error: unknown): error is StandardizedError
   return isObject(error) && typeof error.code === 'string' && typeof error.message === 'string'
 }
 
-export function isInternalError(error: unknown): error is InternalError {
-  return isObject(error) && error.name === 'InternalError'
-}
-
 export function isError(maybeError: unknown): maybeError is Error {
   return (
     maybeError instanceof Error || Object.prototype.toString.call(maybeError) === '[object Error]'
   )
 }
-
-export function isPublicNonRecoverableError(error: unknown): error is PublicNonRecoverableError {
-  return isObject(error) && error.name === 'PublicNonRecoverableError'
-}