@devp0nt/error0 1.0.0-next.45 → 1.0.0-next.47

package/src/index.test.ts

@@ -74,7 +74,7 @@ describe('Error0', () => {
   })
 
   it('class helpers prop/method/adapt mirror use API', () => {
-    const AppError = Error0.prop('status', {
+    const AppError = Error0.use('prop', 'status', {
       init: (value: number) => value,
       resolve: ({ own, flow }) => {
         return typeof own === 'number' ? own : undefined
@@ -82,8 +82,8 @@ describe('Error0', () => {
       serialize: ({ value }) => value,
       deserialize: ({ value }) => (typeof value === 'number' ? value : undefined),
     })
-      .method('isStatus', (error, expectedStatus: number) => error.status === expectedStatus)
-      .adapt((error) => {
+      .use('method', 'isStatus', (error, expectedStatus: number) => error.status === expectedStatus)
+      .use('adapt', (error) => {
         if (error.cause instanceof Error && error.status === undefined) {
           return { status: 500 }
         }
@@ -165,7 +165,7 @@ describe('Error0', () => {
   })
 
   it('serialize uses identity by default and skips undefined plugin values', () => {
-    const AppError = Error0.use(statusPlugin).prop('code', {
+    const AppError = Error0.use(statusPlugin).use('prop', 'code', {
       init: (input: string) => input,
       resolve: ({ flow }) => flow.find(Boolean),
       serialize: () => undefined,
@@ -185,30 +185,38 @@ describe('Error0', () => {
   })
 
   it('stack plugin can customize stack serialization without defining prop plugin', () => {
-    const AppError = Error0.stack(({ value }) => (value ? `custom:${value}` : undefined))
+    const AppError = Error0.use('stack', { serialize: ({ 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)
+  it('stack plugin can keep default stack via identity function', () => {
+    const AppError = Error0.use('stack', { serialize: ({ value }) => value })
     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)
+  it('stack plugin can disable stack serialization via function', () => {
+    const AppError = Error0.use('stack', { serialize: () => undefined })
     const error = new AppError('test')
     const json = AppError.serialize(error)
     expect('stack' in json).toBe(false)
   })
 
+  it('stack plugin rejects boolean config', () => {
+    expect(() => Error0.use('stack', true as any)).toThrow('expects { serialize: function }')
+  })
+
+  it('message plugin rejects boolean config', () => {
+    expect(() => Error0.use('message', true as any)).toThrow('expects { serialize: function }')
+  })
+
   it('prop("stack") throws and suggests using stack plugin', () => {
     expect(() =>
-      Error0.prop('stack', {
+      Error0.use('prop', 'stack', {
         init: (input: string) => input,
         resolve: ({ own }) => (typeof own === 'string' ? own : undefined),
         serialize: ({ value }) => value,
@@ -228,6 +236,26 @@ describe('Error0', () => {
     ).toThrow('reserved prop key')
   })
 
+  it('prop("message") throws and suggests using message plugin', () => {
+    expect(() =>
+      Error0.use('prop', 'message', {
+        resolve: ({ own }) => own as string,
+        serialize: ({ value }) => value,
+        deserialize: ({ value }) => (typeof value === 'string' ? value : undefined),
+      }),
+    ).toThrow('reserved prop key')
+  })
+
+  it('plugin builder also rejects prop("message") as reserved key', () => {
+    expect(() =>
+      Error0.plugin().prop('message', {
+        resolve: ({ own }) => own as string,
+        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' })
@@ -249,22 +277,12 @@ 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 })
 
+  it('by default causes not serialized', () => {
+    const AppError = Error0.use(statusPlugin).use(codePlugin)
+    const error = new AppError('test', { status: 400, code: 'NOT_FOUND' })
     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')
+    expect('cause' in json).toBe(false)
   })
 
   it('serialize can hide props for public output', () => {
@@ -277,7 +295,7 @@ describe('Error0', () => {
   })
 
   it('prop init without input arg infers undefined-only constructor input', () => {
-    const AppError = Error0.prop('computed', {
+    const AppError = Error0.use('prop', 'computed', {
       init: () => undefined as number | undefined,
       resolve: ({ flow }) => flow.find((item) => typeof item === 'number'),
       serialize: ({ value }) => value,
@@ -294,7 +312,7 @@ describe('Error0', () => {
   })
 
   it('prop without init omits constructor input and infers resolve output', () => {
-    const AppError = Error0.prop('statusCode', {
+    const AppError = Error0.use('prop', 'statusCode', {
       resolve: ({ flow }) => flow.find((item) => typeof item === 'number'),
       serialize: ({ value }) => value,
       deserialize: ({ value }) => (typeof value === 'number' ? value : undefined),
@@ -310,7 +328,7 @@ describe('Error0', () => {
   })
 
   it('prop output type is inferred from resolve type', () => {
-    const AppError = Error0.prop('x', {
+    const AppError = Error0.use('prop', 'x', {
       init: (input: number) => input,
       resolve: ({ flow }) => flow.find((item) => typeof item === 'number') || 500,
       serialize: ({ value }) => value,
@@ -323,7 +341,7 @@ describe('Error0', () => {
     expectTypeOf(AppError.own(error, 'x')).toEqualTypeOf<number | undefined>()
     expectTypeOf(AppError.flow(error, 'x')).toEqualTypeOf<Array<number | undefined>>()
 
-    Error0.prop('x', {
+    Error0.plugin().prop('x', {
       init: (input: number) => input,
       // @ts-expect-error - resolve type extends init type
       resolve: ({ flow }) => 'string',
@@ -333,7 +351,7 @@ describe('Error0', () => {
   })
 
   it('own/flow are typed by output type, not resolve type', () => {
-    const AppError = Error0.prop('code', {
+    const AppError = Error0.use('prop', 'code', {
       init: (input: number | 'fallback') => input,
       resolve: ({ flow }) => flow.find((item) => typeof item === 'number') ?? 500,
       serialize: ({ value }) => value,
@@ -354,12 +372,12 @@ describe('Error0', () => {
   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', {
+    const AppError = Error0.use('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', {
+    }).use('prop', 'code', {
       init: (input: Code) => input,
       resolve: ({ flow }) => flow.find(isCode),
       serialize: ({ value }) => value,
@@ -381,12 +399,12 @@ describe('Error0', () => {
   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', {
+    const AppError = Error0.use('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', {
+    }).use('prop', 'code', {
       init: (input: Code) => input,
       resolve: ({ flow }) => flow.find(isCode),
       serialize: ({ value }) => value,
@@ -408,19 +426,19 @@ describe('Error0', () => {
   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', {
+    const AppError = Error0.use('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', {
+      .use('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)
+      .use('method', 'isStatus', (error, status: number) => error.status === status)
 
     const root = new AppError('root', { status: 400, code: 'A' })
     const leaf = new AppError('leaf', { cause: root })
@@ -436,7 +454,7 @@ describe('Error0', () => {
   })
 
   it('prop resolved type can be not undefined with init not provided', () => {
-    const AppError = Error0.prop('x', {
+    const AppError = Error0.use('prop', 'x', {
       resolve: ({ flow }) => flow.find((item) => typeof item === 'number') || 500,
       serialize: ({ value }) => value,
       deserialize: ({ value }) => (typeof value === 'number' ? value : undefined),
@@ -446,7 +464,7 @@ describe('Error0', () => {
     expect(error.x).toBe(500)
     expectTypeOf<typeof error.x>().toEqualTypeOf<number>()
 
-    Error0.prop('x', {
+    Error0.plugin().prop('x', {
       init: (input: number) => input,
       // @ts-expect-error - resolve type extends init type
       resolve: ({ flow }) => 'string',
@@ -456,7 +474,7 @@ describe('Error0', () => {
   })
 
   it('serialize/deserialize can be set to false to disable them', () => {
-    const AppError = Error0.prop('status', {
+    const AppError = Error0.use('prop', 'status', {
       init: (input: number) => input,
       resolve: ({ flow }) => flow.find((item) => typeof item === 'number'),
       serialize: false,
@@ -516,7 +534,7 @@ describe('Error0', () => {
     assert.ok(parsedError)
     const AppError = Error0.use(statusPlugin)
       .use(codePlugin)
-      .adapt((error) => {
+      .use('adapt', (error) => {
         if (error.cause instanceof ZodError) {
           error.message = `Validation Error: ${error.message}`
           return {
@@ -536,41 +554,19 @@ describe('Error0', () => {
     expect(error1.code).toBe(undefined)
   })
 
-  it('expected prop can be realized to send or not to send error to your error tracker', () => {
-    const AppError = Error0.use(statusPlugin)
-      .prop('expected', {
-        init: (input: boolean) => input,
-        resolve: ({ flow }) => flow.find((value) => typeof value === 'boolean'),
-        serialize: ({ value }) => value,
-        deserialize: ({ value }) => (typeof value === 'boolean' ? value : undefined),
-      })
-      .method('isExpected', (error) => {
-        return error.expected ?? false
-      })
-    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(undefined)
-    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('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),
+      .use('message', {
+        serialize: ({ error }) =>
+          error
+            .causes()
+            .map((cause) => {
+              return cause instanceof Error ? cause.message : undefined
+            })
+            .filter((value): value is string => typeof value === 'string')
+            .join(': '),
       })
     const error1 = new AppError('test1', { status: 400, code: 'NOT_FOUND' })
     const error2 = new AppError({ message: 'test2', status: 401, cause: error1 })
@@ -584,15 +580,16 @@ describe('Error0', () => {
   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'),
-      )
+      .use('stack', {
+        serialize: ({ 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
@@ -612,26 +609,6 @@ describe('Error0', () => {
     `)
   })
 
-  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> (...)"
-    `)
-  })
 
   it('Error0 assignable to LikeError0', () => {
     type LikeError0 = {