@devp0nt/error0 1.0.0-next.42 → 1.0.0-next.44

package/src/index.test.ts

@@ -1,8 +1,8 @@
 import { describe, expect, expectTypeOf, it } from 'bun:test'
+import * as assert from 'node:assert'
+import z, { ZodError } from 'zod'
 import type { ClassError0 } from './index.js'
 import { Error0 } from './index.js'
-import z, { ZodError } from 'zod'
-import * as assert from 'node:assert'
 
 const fixStack = (stack: string | undefined) => {
   if (!stack) {
@@ -76,8 +76,8 @@ describe('Error0', () => {
   it('class helpers prop/method/adapt mirror use API', () => {
     const AppError = Error0.prop('status', {
       init: (value: number) => value,
-      resolve: ({ value, flow }) => {
-        return typeof value === 'number' ? value : undefined
+      resolve: ({ own, flow }) => {
+        return typeof own === 'number' ? own : undefined
       },
       serialize: ({ value }) => value,
       deserialize: ({ value }) => (typeof value === 'number' ? value : undefined),
@@ -184,18 +184,50 @@ describe('Error0', () => {
     expect(json.stack).toBe(error.stack)
   })
 
-  it('stack plugin can customize serialization of stack prop', () => {
-    const AppError = Error0.prop('stack', {
-      init: (input: string) => input,
-      resolve: ({ value }) => (typeof value === 'string' ? value : undefined),
-      serialize: ({ value }) => undefined,
-      deserialize: ({ value }) => (typeof value === 'string' ? value : undefined),
-    })
+  it('stack plugin can customize stack serialization without defining prop plugin', () => {
+    const AppError = Error0.stack(({ value }) => (value ? `custom:${value}` : undefined))
+    const error = new AppError('test')
+    const json = AppError.serialize(error)
+    expect(typeof json.stack).toBe('string')
+    expect((json.stack as string).startsWith('custom:')).toBe(true)
+  })
+
+  it('stack plugin serialize true keeps default stack', () => {
+    const AppError = Error0.stack(true)
+    const error = new AppError('test')
+    const json = AppError.serialize(error)
+    expect(json.stack).toBe(error.stack)
+  })
+
+  it('stack plugin serialize false disables stack serialization', () => {
+    const AppError = Error0.stack(false)
     const error = new AppError('test')
     const json = AppError.serialize(error)
     expect('stack' in json).toBe(false)
   })
 
+  it('prop("stack") throws and suggests using stack plugin', () => {
+    expect(() =>
+      Error0.prop('stack', {
+        init: (input: string) => input,
+        resolve: ({ own }) => (typeof own === 'string' ? own : undefined),
+        serialize: ({ value }) => value,
+        deserialize: ({ value }) => (typeof value === 'string' ? value : undefined),
+      }),
+    ).toThrow('reserved prop key')
+  })
+
+  it('plugin builder also rejects prop("stack") as reserved key', () => {
+    expect(() =>
+      Error0.plugin().prop('stack', {
+        init: (input: string) => input,
+        resolve: ({ own }) => (typeof own === 'string' ? own : undefined),
+        serialize: ({ value }) => value,
+        deserialize: ({ value }) => (typeof value === 'string' ? value : undefined),
+      }),
+    ).toThrow('reserved prop key')
+  })
+
   it('.serialize() -> .from() roundtrip keeps plugin values', () => {
     const AppError = Error0.use(statusPlugin).use(codePlugin)
     const error = new AppError('test', { status: 409, code: 'NOT_FOUND' })
@@ -217,6 +249,24 @@ describe('Error0', () => {
     expect('cause' in json).toBe(false)
   })
 
+  it('cause plugin true serializes and deserializes nested Error0 causes', () => {
+    const AppError = Error0.use(statusPlugin).use(codePlugin).cause(true)
+    const causeError = new AppError('cause', { status: 409, code: 'NOT_FOUND' })
+    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 Record<string, unknown>).message).toBe('cause')
+    expect((json.cause as Record<string, unknown>).status).toBe(409)
+    expect((json.cause as Record<string, unknown>).code).toBe('NOT_FOUND')
+
+    const recreated = AppError.from(json)
+    expect(recreated).toBeInstanceOf(AppError)
+    expect(recreated.cause).toBeInstanceOf(AppError)
+    expect((recreated.cause as InstanceType<typeof AppError>).status).toBe(409)
+    expect((recreated.cause as InstanceType<typeof AppError>).code).toBe('NOT_FOUND')
+  })
+
   it('serialize can hide props for public output', () => {
     const AppError = Error0.use(statusPlugin).use(codePlugin)
     const error = new AppError('test', { status: 401, code: 'NOT_FOUND' })
@@ -243,10 +293,172 @@ describe('Error0', () => {
     new AppError('test', { computed: 123 })
   })
 
+  it('prop without init omits constructor input and infers resolve output', () => {
+    const AppError = Error0.prop('statusCode', {
+      resolve: ({ flow }) => flow.find((item) => typeof item === 'number'),
+      serialize: ({ value }) => value,
+      deserialize: ({ value }) => (typeof value === 'number' ? value : undefined),
+    })
+
+    const error = new AppError('test')
+    expect(error.statusCode).toBe(undefined)
+    expectTypeOf<typeof error.statusCode>().toEqualTypeOf<number | undefined>()
+
+    // @ts-expect-error - statusCode input is disallowed when init is omitted
+    // eslint-disable-next-line no-new
+    new AppError('test', { statusCode: 123 })
+  })
+
+  it('prop output type is inferred from resolve type', () => {
+    const AppError = Error0.prop('x', {
+      init: (input: number) => input,
+      resolve: ({ flow }) => flow.find((item) => typeof item === 'number') || 500,
+      serialize: ({ value }) => value,
+      deserialize: ({ value }) => (typeof value === 'number' ? value : undefined),
+    })
+
+    const error = new AppError('test')
+    expect(error.x).toBe(500)
+    expectTypeOf<typeof error.x>().toEqualTypeOf<number>()
+    expectTypeOf(AppError.own(error, 'x')).toEqualTypeOf<number | undefined>()
+    expectTypeOf(AppError.flow(error, 'x')).toEqualTypeOf<Array<number | undefined>>()
+
+    Error0.prop('x', {
+      init: (input: number) => input,
+      // @ts-expect-error - resolve type extends init type
+      resolve: ({ flow }) => 'string',
+      serialize: ({ value }) => value,
+      deserialize: ({ value }) => (typeof value === 'number' ? value : undefined),
+    })
+  })
+
+  it('own/flow are typed by output type, not resolve type', () => {
+    const AppError = Error0.prop('code', {
+      init: (input: number | 'fallback') => input,
+      resolve: ({ flow }) => flow.find((item) => typeof item === 'number') ?? 500,
+      serialize: ({ value }) => value,
+      deserialize: ({ value }) => (typeof value === 'number' || value === 'fallback' ? value : undefined),
+    })
+    const error = new AppError('test')
+
+    expect(error.code).toBe(500)
+    expect(AppError.own(error, 'code')).toBe(undefined)
+    expect(AppError.own(error)).toEqual({ code: undefined })
+    expect(error.own()).toEqual({ code: undefined })
+    expectTypeOf<typeof error.code>().toEqualTypeOf<number>()
+    expectTypeOf(AppError.own(error, 'code')).toEqualTypeOf<number | 'fallback' | undefined>()
+    expectTypeOf(AppError.own(error)).toEqualTypeOf<{ code: number | 'fallback' | undefined }>()
+    expectTypeOf(AppError.flow(error, 'code')).toEqualTypeOf<Array<number | 'fallback' | undefined>>()
+  })
+
+  it('own/flow runtime behavior across causes', () => {
+    type Code = 'A' | 'B'
+    const isCode = (item: unknown): item is Code => item === 'A' || item === 'B'
+    const AppError = Error0.prop('status', {
+      init: (input: number) => input,
+      resolve: ({ flow }) => flow.find((item) => typeof item === 'number'),
+      serialize: ({ value }) => value,
+      deserialize: ({ value }) => (typeof value === 'number' ? value : undefined),
+    }).prop('code', {
+      init: (input: Code) => input,
+      resolve: ({ flow }) => flow.find(isCode),
+      serialize: ({ value }) => value,
+      deserialize: ({ value }) => (value === 'A' || value === 'B' ? value : undefined),
+    })
+
+    const root = new AppError('root', { status: 400, code: 'A' })
+    const mid = new AppError('mid', { cause: root })
+    const leaf = new AppError('leaf', { status: 500, cause: mid })
+
+    expect(leaf.own()).toEqual({ status: 500, code: undefined })
+    expect(AppError.own(leaf)).toEqual({ status: 500, code: undefined })
+    expect(leaf.flow('status')).toEqual([500, undefined, 400])
+    expect(AppError.flow(leaf, 'status')).toEqual([500, undefined, 400])
+    expect(leaf.flow('code')).toEqual([undefined, undefined, 'A'])
+    expect(AppError.flow(leaf, 'code')).toEqual([undefined, undefined, 'A'])
+  })
+
+  it('own/flow have strong types for static and instance methods', () => {
+    type Code = 'A' | 'B'
+    const isCode = (item: unknown): item is Code => item === 'A' || item === 'B'
+    const AppError = Error0.prop('status', {
+      init: (input: number) => input,
+      resolve: ({ flow }) => flow.find((item) => typeof item === 'number'),
+      serialize: ({ value }) => value,
+      deserialize: ({ value }) => (typeof value === 'number' ? value : undefined),
+    }).prop('code', {
+      init: (input: Code) => input,
+      resolve: ({ flow }) => flow.find(isCode),
+      serialize: ({ value }) => value,
+      deserialize: ({ value }) => (value === 'A' || value === 'B' ? value : undefined),
+    })
+
+    const error = new AppError('test', { status: 400, code: 'A' })
+
+    expectTypeOf(error.own('status')).toEqualTypeOf<number | undefined>()
+    expectTypeOf(error.own('code')).toEqualTypeOf<Code | undefined>()
+
+    expectTypeOf(AppError.own(error, 'status')).toEqualTypeOf<number | undefined>()
+    expectTypeOf(AppError.own(error, 'code')).toEqualTypeOf<Code | undefined>()
+    expectTypeOf(AppError.own(error)).toEqualTypeOf<{ status: number | undefined; code: Code | undefined }>()
+    expectTypeOf(AppError.flow(error, 'status')).toEqualTypeOf<Array<number | undefined>>()
+    expectTypeOf(AppError.flow(error, 'code')).toEqualTypeOf<Array<Code | undefined>>()
+  })
+
+  it('resolve returns plain resolved props object without methods', () => {
+    type Code = 'A' | 'B'
+    const isCode = (item: unknown): item is Code => item === 'A' || item === 'B'
+    const AppError = Error0.prop('status', {
+      init: (input: number) => input,
+      resolve: ({ flow }) => flow.find((item) => typeof item === 'number') ?? 500,
+      serialize: ({ value }) => value,
+      deserialize: ({ value }) => (typeof value === 'number' ? value : undefined),
+    })
+      .prop('code', {
+        init: (input: Code) => input,
+        resolve: ({ flow }) => flow.find(isCode),
+        serialize: ({ value }) => value,
+        deserialize: ({ value }) => (value === 'A' || value === 'B' ? value : undefined),
+      })
+      .method('isStatus', (error, status: number) => error.status === status)
+
+    const root = new AppError('root', { status: 400, code: 'A' })
+    const leaf = new AppError('leaf', { cause: root })
+
+    const resolvedStatic = AppError.resolve(leaf)
+    const resolvedInstance = leaf.resolve()
+    expect(resolvedStatic).toEqual({ status: 400, code: 'A' })
+    expect(resolvedInstance).toEqual({ status: 400, code: 'A' })
+    expect('isStatus' in resolvedStatic).toBe(false)
+    expect(Object.keys(resolvedInstance)).toEqual(['status', 'code'])
+
+    expectTypeOf(resolvedStatic).toEqualTypeOf<{ status: number; code: Code | undefined }>()
+  })
+
+  it('prop resolved type can be not undefined with init not provided', () => {
+    const AppError = Error0.prop('x', {
+      resolve: ({ flow }) => flow.find((item) => typeof item === 'number') || 500,
+      serialize: ({ value }) => value,
+      deserialize: ({ value }) => (typeof value === 'number' ? value : undefined),
+    })
+
+    const error = new AppError('test')
+    expect(error.x).toBe(500)
+    expectTypeOf<typeof error.x>().toEqualTypeOf<number>()
+
+    Error0.prop('x', {
+      init: (input: number) => input,
+      // @ts-expect-error - resolve type extends init type
+      resolve: ({ flow }) => 'string',
+      serialize: ({ value }) => value,
+      deserialize: ({ value }) => (typeof value === 'number' ? value : undefined),
+    })
+  })
+
   it('serialize/deserialize can be set to false to disable them', () => {
     const AppError = Error0.prop('status', {
       init: (input: number) => input,
-      resolve: ({ value, flow }) => value ?? flow.find((item) => typeof item === 'number'),
+      resolve: ({ flow }) => flow.find((item) => typeof item === 'number'),
       serialize: false,
       deserialize: false,
     })
@@ -352,6 +564,75 @@ describe('Error0', () => {
     expect(errorWithUnexpectedErrorAsCause.isExpected()).toBe(false)
   })
 
+  it('messages can be combined on serialization', () => {
+    const AppError = Error0.use(statusPlugin)
+      .use(codePlugin)
+      .prop('message', {
+        resolve: ({ own }) => own as string,
+        serialize: ({ value, error }) => error.flow('message').join(': '),
+        deserialize: ({ value }) => (typeof value === 'string' ? value : undefined),
+      })
+    const error1 = new AppError('test1', { status: 400, code: 'NOT_FOUND' })
+    const error2 = new AppError({ message: 'test2', status: 401, cause: error1 })
+    expect(error1.message).toEqual('test1')
+    expect(error2.message).toEqual('test2')
+    expect((error2.cause as any)?.message).toEqual('test1')
+    expect(error1.serialize().message).toEqual('test1')
+    expect(error2.serialize().message).toEqual('test2: test1')
+  })
+
+  it('stack plugin can merge stack across causes in one serialized value', () => {
+    const AppError = Error0.use(statusPlugin)
+      .use(codePlugin)
+      .stack(({ error }) =>
+        error
+          .causes()
+          .map((cause) => {
+            return cause instanceof Error ? cause.stack : undefined
+          })
+          .filter((value): value is string => typeof value === 'string')
+          .join('\n'),
+      )
+    const error1 = new AppError('test1', { status: 400, code: 'NOT_FOUND' })
+    const error2 = new AppError('test2', { status: 401, cause: error1 })
+    const mergedStack1 = error1.serialize().stack as string
+    const mergedStack2 = error2.serialize().stack as string
+    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> (...)"
+    `)
+  })
+
+  it('stack plugin can merge stack across causes in one serialized value by helper "merge"', () => {
+    const AppError = Error0.use(statusPlugin).use(codePlugin).stack('merge')
+    const error1 = new AppError('test1', { status: 400, code: 'NOT_FOUND' })
+    const error2 = new AppError('test2', { status: 401, cause: error1 })
+    const mergedStack1 = error1.serialize().stack as string
+    const mergedStack2 = error2.serialize().stack as string
+    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> (...)"
+    `)
+  })
+
   // we will have no variants
   // becouse you can thorw any errorm and when you do AppError.from(yourError)
   // can use adapt to assign desired props to error, it is enough for transport