@devp0nt/error0 1.0.0-next.55 → 1.0.0-next.57

package/src/plugins/cause.test.ts

@@ -1,106 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-import { Error0 } from '../index.js'
-import { causePlugin } from './cause.js'
-
-describe('causePlugin', () => {
-  const statusPlugin = Error0.plugin().use('prop', 'status', {
-    init: (input: number) => input,
-    resolve: ({ flow }) => flow.find((value) => typeof value === 'number'),
-    serialize: ({ resolved }) => resolved,
-    deserialize: ({ value }) => (typeof value === 'number' ? value : undefined),
-  })
-
-  const codes = ['NOT_FOUND', 'BAD_REQUEST', 'UNAUTHORIZED'] as const
-  type Code = (typeof codes)[number]
-  const codePlugin = Error0.plugin().use('prop', 'code', {
-    init: (input: Code) => input,
-    resolve: ({ flow }) => flow.find((value) => typeof value === 'string' && codes.includes(value)),
-    serialize: ({ resolved, isPublic }) => (isPublic ? undefined : resolved),
-    deserialize: ({ value }) =>
-      typeof value === 'string' && codes.includes(value as Code) ? (value as Code) : undefined,
-  })
-
-  it('serializes and deserializes nested Error0 causes', () => {
-    const AppError = Error0.use(statusPlugin)
-      .use(codePlugin)
-      .use(causePlugin({ isPublic: true }))
-    const deepCauseError = new AppError('deep cause')
-    const causeError = new AppError('cause', { status: 409, code: 'NOT_FOUND', cause: deepCauseError })
-    const error = new AppError('root', { status: 500, cause: causeError })
-
-    const json = AppError.serialize(error, false)
-    expect(typeof json.cause).toBe('object')
-    expect((json.cause as any).message).toBe('cause')
-    expect((json.cause as any).status).toBe(409)
-    expect((json.cause as any).code).toBe('NOT_FOUND')
-    expect((json.cause as any).cause).toBeDefined()
-    expect((json.cause as any).cause.message).toBe('deep cause')
-    expect((json.cause as any).cause.status).toBe(undefined)
-    expect((json.cause as any).cause.code).toBe(undefined)
-    expect((json.cause as any).cause.cause).toBeUndefined()
-
-    const recreated = AppError.from(json)
-    expect(recreated).toBeInstanceOf(AppError)
-    expect(recreated.cause).toBeInstanceOf(AppError)
-    expect((recreated.cause as any).status).toBe(409)
-    expect((recreated.cause as any).code).toBe('NOT_FOUND')
-    expect((recreated.cause as any).cause).toBeInstanceOf(AppError)
-    expect((recreated.cause as any).cause.message).toBe('deep cause')
-    expect((recreated.cause as any).cause.status).toBe(undefined)
-    expect((recreated.cause as any).cause.code).toBe(undefined)
-    expect((recreated.cause as any).cause.cause).toBeUndefined()
-  })
-
-  it('supports variants', () => {
-    class DbError extends Error {
-      query: string
-      constructor(message: string, options: { cause?: unknown; query: string }) {
-        super(message, { cause: options.cause })
-        this.query = options.query
-        this.name = 'DbError'
-      }
-      static serialize(error: DbError): Record<string, unknown> {
-        return {
-          message: error.message,
-          query: error.query,
-        }
-      }
-      static from(error: unknown): DbError {
-        if (error instanceof DbError) {
-          return error
-        }
-        const object = typeof error === 'object' && error !== null ? (error as Record<string, unknown>) : {}
-        const message =
-          typeof object.message === 'string' ? object.message : typeof error === 'string' ? error : 'Unknown error'
-        const query = typeof object.query === 'string' ? object.query : 'NOT_FOUND'
-        return new DbError(message, { cause: error, query })
-      }
-      static isSerialized(serializedCause: unknown): boolean {
-        return (
-          typeof serializedCause === 'object' &&
-          serializedCause !== null &&
-          'query' in serializedCause &&
-          typeof serializedCause.query === 'string'
-        )
-      }
-    }
-    const AppError = Error0.use(statusPlugin)
-      .use(codePlugin)
-      .use(
-        causePlugin({
-          variants: {
-            DbError,
-          },
-        }),
-      )
-    const dbError = new DbError('test', { query: 'SELECT * FROM users' })
-    const error = new AppError('root', { status: 500, cause: dbError })
-    const json = AppError.serialize(error, false)
-    expect(json.cause).toBeDefined()
-    expect((json.cause as any).query).toBe('SELECT * FROM users')
-    const recreated = AppError.from(json)
-    expect(recreated).toBeInstanceOf(AppError)
-    expect(recreated.cause).toBeInstanceOf(DbError)
-    expect((recreated.cause as any).query).toBe('SELECT * FROM users')
-  })
-})

package/src/plugins/cause.ts

@@ -1,45 +0,0 @@
-import { Error0 } from '../index.js'
-
-type Variant = {
-  new (...args: any[]): unknown
-  [Symbol.hasInstance]: (value: any) => boolean
-  isSerialized: (serializedCause: any) => boolean
-  serialize: (error: any) => unknown
-  from: (error: any) => unknown
-}
-
-export const causePlugin = <TVariants extends Record<string, Variant> = Record<never, Variant>>({
-  isPublic = false,
-  variants = undefined,
-}: { isPublic?: boolean; variants?: TVariants } = {}) =>
-  Error0.plugin().cause({
-    serialize: ({ cause, isPublic: _isPublic, is, serialize }) => {
-      if (!isPublic && _isPublic) {
-        return undefined
-      }
-      if (variants) {
-        for (const variant of Object.values(variants)) {
-          if (cause instanceof variant) {
-            return variant.serialize(cause)
-          }
-        }
-      }
-      if (is(cause)) {
-        return serialize(cause)
-      }
-      return undefined
-    },
-    deserialize: ({ cause, fromSerialized, isSerialized }) => {
-      if (variants) {
-        for (const variant of Object.values(variants)) {
-          if (variant.isSerialized(cause)) {
-            return variant.from(cause)
-          }
-        }
-      }
-      if (isSerialized(cause)) {
-        return fromSerialized(cause)
-      }
-      return cause
-    },
-  })

package/src/plugins/code.test.ts

@@ -1,27 +0,0 @@
-import { describe, expect, expectTypeOf, it } from 'bun:test'
-import { Error0 } from '../index.js'
-import { codePlugin } from './code.js'
-
-describe('codePlugin', () => {
-  const codes = ['NOT_FOUND', 'BAD_REQUEST', 'UNAUTHORIZED'] as const
-
-  it('serializes and deserializes allowed codes', () => {
-    const AppError = Error0.use(codePlugin({ codes: [...codes] }))
-    const error = new AppError('test', { code: 'NOT_FOUND' })
-
-    expect(error.code).toBe('NOT_FOUND')
-    expectTypeOf<typeof error.code>().toEqualTypeOf<'NOT_FOUND' | 'BAD_REQUEST' | 'UNAUTHORIZED' | undefined>()
-
-    const json = AppError.serialize(error, false)
-    expect(json.code).toBe('NOT_FOUND')
-
-    const recreated = AppError.from(json)
-    expect(recreated.code).toBe('NOT_FOUND')
-  })
-
-  it('ignores code values outside the allowed list', () => {
-    const AppError = Error0.use(codePlugin({ codes: [...codes] }))
-    const recreated = AppError.from({ message: 'test', code: 'SOMETHING_ELSE' })
-    expect(recreated.code).toBeUndefined()
-  })
-})

package/src/plugins/code.ts

@@ -1,20 +0,0 @@
-import { Error0 } from '../index.js'
-
-export const codePlugin = <TCode extends string>({
-  codes,
-  isPublic = false,
-}: { codes?: TCode[]; isPublic?: boolean } = {}) => {
-  const isCode = (value: unknown): value is TCode =>
-    typeof value === 'string' && (!codes || codes.includes(value as TCode))
-  return Error0.plugin().prop('code', {
-    init: (code: TCode) => code,
-    resolve: ({ flow }) => flow.find(Boolean),
-    serialize: ({ resolved, isPublic: _isPublic }) => {
-      if (!isPublic && _isPublic) {
-        return undefined
-      }
-      return resolved
-    },
-    deserialize: ({ value, record }) => (isCode(value) ? value : undefined),
-  })
-}

package/src/plugins/expected.test.ts

@@ -1,66 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-import { Error0 } from '../index.js'
-import { expectedPlugin } from './expected.js'
-
-describe('expectedPlugin', () => {
-  const statusPlugin = Error0.plugin().use('prop', 'status', {
-    init: (input: number) => input,
-    resolve: ({ flow }) => flow.find((value) => typeof value === 'number'),
-    serialize: ({ resolved }) => resolved,
-    deserialize: ({ value }) => (typeof value === 'number' ? value : undefined),
-  })
-
-  it('can be used to control error tracker behavior', () => {
-    const AppError = Error0.use(statusPlugin).use(expectedPlugin({ isPublic: true }))
-    const errorExpected = new AppError('test', { status: 400, expected: true })
-    const errorUnexpected = new AppError('test', { status: 400, expected: false })
-    const usualError = new Error('test')
-    const errorFromUsualError = AppError.from(usualError)
-    const errorWithExpectedErrorAsCause = new AppError('test', { status: 400, cause: errorExpected })
-    const errorWithUnexpectedErrorAsCause = new AppError('test', { status: 400, cause: errorUnexpected })
-    expect(errorExpected.expected).toBe(true)
-    expect(errorUnexpected.expected).toBe(false)
-    expect(AppError.isExpected(usualError)).toBe(false)
-    expect(errorFromUsualError.expected).toBe(false)
-    expect(errorFromUsualError.isExpected()).toBe(false)
-    expect(errorWithExpectedErrorAsCause.expected).toBe(true)
-    expect(errorWithExpectedErrorAsCause.isExpected()).toBe(true)
-    expect(errorWithUnexpectedErrorAsCause.expected).toBe(false)
-    expect(errorWithUnexpectedErrorAsCause.isExpected()).toBe(false)
-  })
-
-  it('resolves to false when any cause has false', () => {
-    const AppError = Error0.use(expectedPlugin({ isPublic: true }))
-    const root = new AppError('root', { expected: true })
-    const middle = new AppError('middle', { expected: false, cause: root })
-    const leaf = new AppError('leaf', { expected: false, cause: middle })
-    expect(leaf.expected).toBe(false)
-    expect(leaf.isExpected()).toBe(false)
-  })
-
-  it('treats undefined expected as unexpected', () => {
-    const AppError = Error0.use(expectedPlugin({ isPublic: true }))
-    const error = new AppError('without expected')
-    expect(error.expected).toBe(false)
-    expect(error.isExpected()).toBe(false)
-  })
-
-  it('supports override', () => {
-    const AppError = Error0.use(statusPlugin).use(
-      expectedPlugin({
-        isPublic: true,
-        override: (error) => {
-          return error.message.includes('CRITICAL') ? false : undefined
-        },
-      }),
-    )
-    const errorNonCritical = new AppError('USUAL: test', { status: 400 })
-    const errorNonCriticalExpected = new AppError('USUAL: test', { status: 400, expected: true })
-    const errorCritical = new AppError('CRITICAL: test', { status: 400 })
-    const errorCriticalExpected = new AppError('CRITICAL: test', { status: 400, expected: true })
-    expect(errorNonCritical.expected).toBe(false) // becouse expected was not provided at all
-    expect(errorNonCriticalExpected.expected).toBe(true)
-    expect(errorCritical.expected).toBe(false)
-    expect(errorCriticalExpected.expected).toBe(false)
-  })
-})

package/src/plugins/expected.ts

@@ -1,48 +0,0 @@
-import { Error0 } from '../index.js'
-
-const isExpected = ({
-  flow,
-  error,
-  override,
-}: {
-  flow: unknown[]
-  error: Error0
-  override?: (error: any) => boolean | undefined
-}) => {
-  if (override) {
-    const overridden = override(error)
-    if (overridden !== undefined) {
-      return overridden
-    }
-  }
-  let expected = false
-  for (const value of flow) {
-    if (value === false) {
-      return false
-    }
-    if (value === true) {
-      expected = true
-    }
-  }
-  return expected
-}
-
-export const expectedPlugin = <TError extends Error0>({
-  isPublic = false,
-  override,
-}: { isPublic?: boolean; override?: (error: TError) => boolean | undefined } = {}) =>
-  Error0.plugin()
-    .prop('expected', {
-      init: (input: boolean) => input,
-      resolve: ({ flow, error }) => isExpected({ flow, error, override }),
-      serialize: ({ resolved, isPublic: _isPublic }) => {
-        if (isPublic && _isPublic) {
-          return undefined
-        }
-        return resolved
-      },
-      deserialize: ({ value }) => (typeof value === 'boolean' ? value : undefined),
-    })
-    .method('isExpected', (error) => {
-      return isExpected({ flow: error.flow('expected'), error, override })
-    })

package/src/plugins/flat-original.test.ts

@@ -1,45 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-import { Error0 } from '../index.js'
-import { flatOriginalPlugin } from './flat-original.js'
-
-describe('flatOriginalPlugin', () => {
-  it('without plugin original error comes to cause', () => {
-    const usualError = new Error('another error')
-    const error = Error0.from(usualError)
-    expect(error).toBeInstanceOf(Error0)
-    expect(error).toBeInstanceOf(Error)
-    expect(error.name).toBe('Error0')
-    expect(error.cause).not.toBeInstanceOf(Error0)
-    expect(error.cause).toBeInstanceOf(Error)
-    expect(error.cause).toBe(usualError)
-    expect((error.cause as any).name).toBe('Error')
-    expect(error.causes()).toEqual([error, usualError])
-  })
-
-  it('with plugin original error becomes error0 itself', () => {
-    const usualError = new Error('another error')
-    const AppError = Error0.use(flatOriginalPlugin())
-    const error = AppError.from(usualError)
-    expect(error).toBeInstanceOf(AppError)
-    expect(error).toBeInstanceOf(Error0)
-    expect(error).toBeInstanceOf(Error)
-    expect(error.message).toBe(usualError.message)
-    expect(error.stack).toBe(usualError.stack)
-    expect(error.name).toBe('Error0')
-    expect(error.cause).toBeUndefined()
-  })
-
-  it('with plugin original error becomes error0 itself but keep it own causes', () => {
-    const causeError = new Error('cause error')
-    const usualError = new Error('another error', { cause: causeError })
-    const AppError = Error0.use(flatOriginalPlugin())
-    const error = AppError.from(usualError)
-    expect(error).toBeInstanceOf(AppError)
-    expect(error).toBeInstanceOf(Error0)
-    expect(error).toBeInstanceOf(Error)
-    expect(error.message).toBe(usualError.message)
-    expect(error.stack).toBe(usualError.stack)
-    expect(error.name).toBe('Error0')
-    expect(error.causes()).toEqual([error, causeError])
-  })
-})

package/src/plugins/flat-original.ts

@@ -1,12 +0,0 @@
-import { Error0 } from '../index.js'
-
-export const flatOriginalPlugin = ({ prefix }: { prefix?: string } = {}) => {
-  return Error0.plugin().adapt((error) => {
-    const cause = error.cause
-    if (cause instanceof Error && cause.constructor === Error) {
-      error.cause = cause.cause
-      error.message = `${prefix ?? ''}${cause.message}`
-      error.stack = cause.stack
-    }
-  })
-}

package/src/plugins/message-merge.test.ts

@@ -1,32 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-import { Error0 } from '../index.js'
-import { messageMergePlugin } from './message-merge.js'
-
-describe('messageMergePlugin', () => {
-  const statusPlugin = Error0.plugin().use('prop', 'status', {
-    init: (input: number) => input,
-    resolve: ({ flow }) => flow.find((value) => typeof value === 'number'),
-    serialize: ({ resolved }) => resolved,
-    deserialize: ({ value }) => (typeof value === 'number' ? value : undefined),
-  })
-
-  const codes = ['NOT_FOUND', 'BAD_REQUEST', 'UNAUTHORIZED'] as const
-  type Code = (typeof codes)[number]
-  const codePlugin = Error0.plugin().use('prop', 'code', {
-    init: (input: Code) => input,
-    resolve: ({ flow }) => flow.find((value) => typeof value === 'string' && codes.includes(value)),
-    serialize: ({ resolved, isPublic }) => (isPublic ? undefined : resolved),
-    deserialize: ({ value }) =>
-      typeof value === 'string' && codes.includes(value as Code) ? (value as Code) : undefined,
-  })
-
-  it('can merge message across causes in one serialized value', () => {
-    const AppError = Error0.use(statusPlugin).use(codePlugin).use(messageMergePlugin())
-    const error1 = new AppError('test1', { status: 400, code: 'NOT_FOUND' })
-    const error2 = new AppError('test2', { status: 401, cause: error1 })
-    expect(error1.message).toBe('test1')
-    expect(error2.message).toBe('test2')
-    expect(error1.serialize().message).toBe('test1')
-    expect(error2.serialize().message).toBe('test2: test1')
-  })
-})

package/src/plugins/message-merge.ts

@@ -1,19 +0,0 @@
-import { Error0 } from '../index.js'
-
-export const messageMergePlugin = ({
-  delimiter = ': ',
-  fallback = 'Unknown error',
-}: { delimiter?: string; fallback?: string } = {}) =>
-  Error0.plugin().use('message', {
-    serialize: ({ error }) => {
-      return (
-        error
-          .causes()
-          .map((cause) => {
-            return cause instanceof Error ? cause.message : undefined
-          })
-          .filter((value): value is string => typeof value === 'string')
-          .join(delimiter) || fallback
-      )
-    },
-  })

package/src/plugins/meta.test.ts

@@ -1,32 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-import { Error0 } from '../index.js'
-import { metaPlugin } from './meta.js'
-
-describe('metaPlugin', () => {
-  it('merges meta across causes into current error', () => {
-    const AppError = Error0.use(metaPlugin())
-    const root = new AppError('root', { meta: { requestId: 'r1', source: 'db' } })
-    const leaf = new AppError('leaf', { meta: { route: '/ideas', source: 'api' }, cause: root })
-    expect(leaf.resolve().meta).toEqual({
-      requestId: 'r1',
-      source: 'api',
-      route: '/ideas',
-    })
-  })
-
-  it('serializes meta only for private output and keeps json-safe values', () => {
-    const AppError = Error0.use(metaPlugin())
-    const error = new AppError('test', {
-      meta: {
-        ok: true,
-        nested: { id: 1 },
-        skip: () => 'x',
-      },
-    })
-    expect(AppError.serialize(error, false).meta).toEqual({
-      ok: true,
-      nested: { id: 1 },
-    })
-    expect('meta' in AppError.serialize(error, true)).toBe(false)
-  })
-})

package/src/plugins/meta.ts

@@ -1,59 +0,0 @@
-import { Error0 } from '../index.js'
-
-type Json = null | boolean | number | string | Json[] | { [key: string]: Json }
-
-const toJsonSafe = (input: unknown): Json | undefined => {
-  if (input === null) {
-    return null
-  }
-  if (typeof input === 'string' || typeof input === 'number' || typeof input === 'boolean') {
-    return input
-  }
-  if (Array.isArray(input)) {
-    return input.map((value) => toJsonSafe(value)) as Json[]
-  }
-  if (typeof input === 'object') {
-    const output: Record<string, Json> = {}
-    for (const [key, value] of Object.entries(input as Record<string, unknown>)) {
-      const jsonValue = toJsonSafe(value)
-      if (jsonValue !== undefined) {
-        output[key] = jsonValue
-      }
-    }
-    return output
-  }
-  return undefined
-}
-
-const isMetaRecord = (value: unknown): value is Record<string, unknown> =>
-  typeof value === 'object' && value !== null && !Array.isArray(value)
-
-export const metaPlugin = ({ isPublic = false }: { isPublic?: boolean } = {}) =>
-  Error0.plugin().prop('meta', {
-    init: (input: Record<string, unknown>) => input,
-    resolve: ({ flow }) => {
-      const values = flow.filter(isMetaRecord)
-      if (values.length === 0) {
-        return undefined
-      }
-
-      // Merge cause meta into the current error; nearer errors win on conflicts.
-      const merged: Record<string, unknown> = {}
-      for (const value of [...values].reverse()) {
-        Object.assign(merged, value)
-      }
-      return merged
-    },
-    serialize: ({ resolved, isPublic: _isPublic }) => {
-      if (!isPublic && _isPublic) {
-        return undefined
-      }
-      return toJsonSafe(resolved)
-    },
-    deserialize: ({ value }) => {
-      if (!isMetaRecord(value)) {
-        return undefined
-      }
-      return value
-    },
-  })

package/src/plugins/stack-merge.test.ts

@@ -1,57 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-import { Error0 } from '../index.js'
-import { stackMergePlugin } from './stack-merge.js'
-
-const fixStack = (stack: string | undefined) => {
-  if (!stack) {
-    return stack
-  }
-  const lines = stack.split('\n')
-  const fixedLines = lines.map((line) => {
-    const withoutPath = line.replace(/\(.*\)$/, '(...)')
-    return withoutPath
-  })
-  return fixedLines.join('\n')
-}
-
-describe('stackMergePlugin', () => {
-  const statusPlugin = Error0.plugin().use('prop', 'status', {
-    init: (input: number) => input,
-    resolve: ({ flow }) => flow.find((value) => typeof value === 'number'),
-    serialize: ({ resolved }) => resolved,
-    deserialize: ({ value }) => (typeof value === 'number' ? value : undefined),
-  })
-
-  const codes = ['NOT_FOUND', 'BAD_REQUEST', 'UNAUTHORIZED'] as const
-  type Code = (typeof codes)[number]
-  const codePlugin = Error0.plugin().use('prop', 'code', {
-    init: (input: Code) => input,
-    resolve: ({ flow }) => flow.find((value) => typeof value === 'string' && codes.includes(value)),
-    serialize: ({ resolved, isPublic }) => (isPublic ? undefined : resolved),
-    deserialize: ({ value }) =>
-      typeof value === 'string' && codes.includes(value as Code) ? (value as Code) : undefined,
-  })
-
-  it('can merge stack across causes in one serialized value', () => {
-    const AppError = Error0.use(statusPlugin).use(codePlugin).use(stackMergePlugin())
-    const error1 = new AppError('test1', { status: 400, code: 'NOT_FOUND' })
-    const error2 = new AppError('test2', { status: 401, cause: error1 })
-    const mergedStack1 = error1.serialize(false).stack as string
-    const mergedStack2 = error2.serialize(false).stack as string
-    const mergedStack2Public = error2.serialize(true).stack as string | undefined
-    expect(mergedStack1).toContain('Error0: test1')
-    expect(mergedStack2).toContain('Error0: test2')
-    expect(mergedStack2).toContain('Error0: test1')
-    expect(fixStack(mergedStack1)).toMatchInlineSnapshot(`
-      "Error0: test1
-          at <anonymous> (...)"
-    `)
-    expect(fixStack(mergedStack2)).toMatchInlineSnapshot(`
-      "Error0: test2
-          at <anonymous> (...)
-      Error0: test1
-          at <anonymous> (...)"
-    `)
-    expect(mergedStack2Public).toBeUndefined()
-  })
-})

package/src/plugins/stack-merge.ts

@@ -1,19 +0,0 @@
-import { Error0 } from '../index.js'
-
-export const stackMergePlugin = ({
-  isPublic = false,
-  delimiter = '\n',
-}: { isPublic?: boolean; delimiter?: string } = {}) =>
-  Error0.plugin().stack({
-    serialize: ({ error, isPublic: _isPublic }) => {
-      if (!isPublic && _isPublic) {
-        return undefined
-      }
-      return error
-        .causes()
-        .flatMap((cause) => {
-          return cause instanceof Error && cause.stack && typeof cause.stack === 'string' ? cause.stack : []
-        })
-        .join(delimiter)
-    },
-  })

package/src/plugins/status.test.ts

@@ -1,54 +0,0 @@
-import { describe, expect, expectTypeOf, it } from 'bun:test'
-import { Error0 } from '../index.js'
-import { statusPlugin } from './status.js'
-
-describe('statusPlugin', () => {
-  const statuses = {
-    BAD_REQUEST: 400,
-    UNAUTHORIZED: 401,
-    NOT_FOUND: 404,
-  } as const
-
-  it('maps status keys to numeric values', () => {
-    const AppError = Error0.use(statusPlugin({ statuses }))
-    const error = new AppError('test', { status: 'NOT_FOUND' })
-
-    expectTypeOf<typeof error.status>().toEqualTypeOf<number | undefined>()
-    expect(error.status).toBe(404)
-
-    const json = AppError.serialize(error, false)
-    expect(json.status).toBe(404)
-  })
-
-  it('accepts numeric status values when no statuses map is provided', () => {
-    const AppError = Error0.use(statusPlugin())
-    const error = new AppError('test', { status: 500 })
-    expect(error.status).toBe(500)
-  })
-
-  it('if status number not in list, it is not converts to undefined by default', () => {
-    const AppError = Error0.use(statusPlugin({ statuses }))
-    const error = new AppError('test', { status: 999 })
-    expect(error.status).toBe(999)
-  })
-
-  it('if status number not in list, it converts to undefined if strict is true', () => {
-    const AppError = Error0.use(statusPlugin({ statuses, strict: true }))
-    const error = new AppError('test', { status: 999 })
-    expect(error.status).toBeUndefined()
-  })
-
-  it('not allowed incorrect status name', () => {
-    const AppError = Error0.use(statusPlugin({ statuses }))
-    // @ts-expect-error - incorrect status name
-    const error = new AppError('test', { status: 'SOMETHING_ELSE' })
-    expect(error.status).toBeUndefined()
-  })
-
-  it('not allowed status name if statuses not provided', () => {
-    const AppError = Error0.use(statusPlugin())
-    // @ts-expect-error - incorrect status name
-    const error = new AppError('test', { status: 'SOMETHING_ELSE' })
-    expect(error.status).toBeUndefined()
-  })
-})