Adding EntityGoneError

index.ts

@@ -26,7 +26,7 @@ export {
   type InternalErrorParams,
 } from './src/errors/InternalError'
 export { ResponseStatusError } from './src/errors/ResponseStatusError'
-export { isResponseStatusError } from './src/errors/errorTypeGuards'
+export { isResponseStatusError, isEntityGoneError } from './src/errors/errorTypeGuards'
 
 export { ConfigScope } from './src/config/ConfigScope'
 export { ensureClosingSlashTransformer } from './src/config/configTransformers'
@@ -94,12 +94,13 @@ export {
 export { type MayOmit } from './src/common/may-omit'
 export { type FreeformRecord } from './src/common/commonTypes'
 export {
-  RequestValidationError,
-  AccessDeniedError,
-  EntityNotFoundError,
   type ValidationError,
   type CommonErrorParams,
   type OptionalMessageErrorParams,
+  RequestValidationError,
+  AccessDeniedError,
+  EntityNotFoundError,
+  EntityGoneError,
   AuthFailedError,
 } from './src/errors/publicErrors'
 

src/errors/errorTypeGuards.spec.ts

@@ -2,7 +2,8 @@ import { describe } from 'vitest'
 
 import { InternalError } from './InternalError'
 import { ResponseStatusError } from './ResponseStatusError'
-import { isResponseStatusError } from './errorTypeGuards'
+import { isEntityGoneError, isResponseStatusError } from './errorTypeGuards'
+import { EntityGoneError, EntityNotFoundError } from './publicErrors'
 
 describe('errorTypeGuards', () => {
   describe('isResponseStatusError', () => {
@@ -22,4 +23,29 @@ describe('errorTypeGuards', () => {
       expect(isResponseStatusError(error)).toBe(false)
     })
   })
+
+  describe('isEntityGoneError', () => {
+    it('Returns true for EntityGoneError', () => {
+      const error = new EntityGoneError({
+        message: 'message',
+      })
+
+      expect(isEntityGoneError(error)).toBe(true)
+    })
+
+    it('Returns false for not a EntityGoneError', () => {
+      const errors = [
+        'whatever string',
+        1,
+        new Error('message'),
+        new InternalError({
+          message: 'message',
+          errorCode: 'CODE',
+        }),
+        new EntityNotFoundError({ message: 'message' }),
+      ]
+
+      expect(errors.map(isEntityGoneError).every((e) => e === false)).toBe(true)
+    })
+  })
 })

src/errors/errorTypeGuards.ts

@@ -1,5 +1,12 @@
+import { isPublicNonRecoverableError } from '../utils/typeUtils'
+
 import type { ResponseStatusError } from './ResponseStatusError'
+import type { EntityGoneError } from './publicErrors'
 
 export function isResponseStatusError(entity: unknown): entity is ResponseStatusError {
   return 'isResponseStatusError' in (entity as ResponseStatusError)
 }
+
+export function isEntityGoneError(entity: unknown): entity is EntityGoneError {
+  return isPublicNonRecoverableError(entity) && entity.httpStatusCode === 410
+}

src/errors/publicErrors.ts

@@ -54,6 +54,17 @@ export class EntityNotFoundError extends PublicNonRecoverableError {
   }
 }
 
+export class EntityGoneError extends PublicNonRecoverableError {
+  constructor(params: CommonErrorParams) {
+    super({
+      message: params.message,
+      errorCode: 'ENTITY_GONE',
+      httpStatusCode: 410,
+      details: params.details,
+    })
+  }
+}
+
 export class AuthFailedError extends PublicNonRecoverableError {
   constructor(params: OptionalMessageErrorParams = {}) {
     super({