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

package/src/index.test.ts

@@ -20,37 +20,23 @@ const fixStack = (stack: string | undefined) => {
 }
 
 describe('Error0', () => {
-  const statusExtension = Error0.extension()
+  const statusPlugin = Error0.plugin()
     .prop('status', {
-      input: (value: number) => value,
-      output: (error) => {
-        for (const value of error.flow('status')) {
-          const status = Number(value)
-          if (!Number.isNaN(status)) {
-            return status
-          }
-        }
-        return undefined
-      },
-      serialize: (value) => value,
+      init: (input: number) => input,
+      resolve: ({ flow }) => flow.find(Boolean),
+      serialize: ({ value }) => value,
+      deserialize: ({ value }) => (typeof value === 'number' ? value : undefined),
     })
     .method('isStatus', (error, status: number) => error.status === status)
 
   const codes = ['NOT_FOUND', 'BAD_REQUEST', 'UNAUTHORIZED'] as const
   type Code = (typeof codes)[number]
-  const codeExtension = Error0.extension().extend('prop', 'code', {
-    input: (value: Code) => value,
-    output: (error) => {
-      for (const value of error.flow('code')) {
-        if (typeof value === 'string') {
-          if (codes.includes(value as Code)) {
-            return value as Code
-          }
-        }
-      }
-      return undefined
-    },
-    serialize: (value, error, isPublic) => (isPublic ? undefined : value),
+  const codePlugin = Error0.plugin().use('prop', 'code', {
+    init: (input: Code) => input,
+    resolve: ({ flow }) => flow.find(Boolean),
+    serialize: ({ value, isPublic }) => (isPublic ? undefined : value),
+    deserialize: ({ value }) =>
+      typeof value === 'string' && codes.includes(value as Code) ? (value as Code) : undefined,
   })
 
   it('simple', () => {
@@ -66,19 +52,12 @@ describe('Error0', () => {
     `)
   })
 
-  it('with direct prop extension', () => {
-    const AppError = Error0.extend('prop', 'status', {
-      input: (value: number) => value,
-      output: (error: Error0) => {
-        for (const value of error.flow('status')) {
-          const status = Number(value)
-          if (!Number.isNaN(status)) {
-            return status
-          }
-        }
-        return undefined
-      },
-      serialize: (value: number | undefined) => value,
+  it('with direct prop plugin', () => {
+    const AppError = Error0.use('prop', 'status', {
+      init: (input: number) => input,
+      resolve: ({ flow }) => flow.find(Boolean),
+      serialize: ({ value }) => value,
+      deserialize: ({ value }) => (typeof value === 'number' ? value : undefined),
     })
     const error = new AppError('test', { status: 400 })
     expect(error).toBeInstanceOf(AppError)
@@ -94,8 +73,32 @@ describe('Error0', () => {
     expectTypeOf<typeof AppError>().toExtend<ClassError0>()
   })
 
-  it('with defined extension', () => {
-    const AppError = Error0.extend(statusExtension)
+  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
+      },
+      serialize: ({ value }) => value,
+      deserialize: ({ value }) => (typeof value === 'number' ? value : undefined),
+    })
+      .method('isStatus', (error, expectedStatus: number) => error.status === expectedStatus)
+      .adapt((error) => {
+        if (error.cause instanceof Error && error.status === undefined) {
+          return { status: 500 }
+        }
+        return undefined
+      })
+
+    const error = AppError.from(new Error('inner'))
+    expect(error.status).toBe(500)
+    expect(error.isStatus(500)).toBe(true)
+    expect(AppError.isStatus(error, 500)).toBe(true)
+    expectTypeOf<typeof AppError>().toExtend<ClassError0>()
+  })
+
+  it('with defined plugin', () => {
+    const AppError = Error0.use(statusPlugin)
     const error = new AppError('test', { status: 400 })
     expect(error).toBeInstanceOf(AppError)
     expect(error).toBeInstanceOf(Error0)
@@ -109,9 +112,9 @@ describe('Error0', () => {
     `)
   })
 
-  it('twice extended Error0 extends previous by types', () => {
-    const AppError1 = Error0.extend(statusExtension)
-    const AppError2 = AppError1.extend(codeExtension)
+  it('twice used Error0 extends previous by types', () => {
+    const AppError1 = Error0.use(statusPlugin)
+    const AppError2 = AppError1.use(codePlugin)
     const error1 = new AppError1('test', { status: 400 })
     const error2 = new AppError2('test', { status: 400, code: 'NOT_FOUND' })
     expect(error1.status).toBe(400)
@@ -126,7 +129,7 @@ describe('Error0', () => {
   })
 
   it('can have cause', () => {
-    const AppError = Error0.extend(statusExtension)
+    const AppError = Error0.use(statusPlugin)
     const anotherError = new Error('another error')
     const error = new AppError('test', { status: 400, cause: anotherError })
     expect(error.status).toBe(400)
@@ -140,7 +143,7 @@ describe('Error0', () => {
   })
 
   it('can have many causes', () => {
-    const AppError = Error0.extend(statusExtension)
+    const AppError = Error0.use(statusPlugin)
     const anotherError = new Error('another error')
     const error1 = new AppError('test1', { status: 400, cause: anotherError })
     const error2 = new AppError('test2', { status: 400, cause: error1 })
@@ -150,7 +153,7 @@ describe('Error0', () => {
   })
 
   it('properties floating', () => {
-    const AppError = Error0.extend(statusExtension).extend(codeExtension)
+    const AppError = Error0.use(statusPlugin).use(codePlugin)
     const anotherError = new Error('another error')
     const error1 = new AppError('test1', { status: 400, cause: anotherError })
     const error2 = new AppError('test2', { code: 'NOT_FOUND', cause: error1 })
@@ -161,51 +164,40 @@ describe('Error0', () => {
     expect(Error0.causes(error2)).toEqual([error2, error1, anotherError])
   })
 
-  it('serialize uses identity by default and skips undefined extension values', () => {
-    const AppError = Error0.extend(statusExtension).extend('prop', 'code', {
-      input: (value: string) => value,
-      output: (error) => {
-        for (const value of error.flow('code')) {
-          if (typeof value === 'string') {
-            return value
-          }
-        }
-        return undefined
-      },
+  it('serialize uses identity by default and skips undefined plugin values', () => {
+    const AppError = Error0.use(statusPlugin).prop('code', {
+      init: (input: string) => input,
+      resolve: ({ flow }) => flow.find(Boolean),
       serialize: () => undefined,
+      deserialize: ({ value }) => (typeof value === 'string' ? value : undefined),
     })
     const error = new AppError('test', { status: 401, code: 'secret' })
-    const json = AppError.serialize(error) as Record<string, unknown>
+    const json = AppError.serialize(error)
     expect(json.status).toBe(401)
     expect('code' in json).toBe(false)
   })
 
-  it('serialize keeps stack by default without stack extension', () => {
-    const AppError = Error0.extend(statusExtension)
+  it('serialize keeps stack by default without stack plugin', () => {
+    const AppError = Error0.use(statusPlugin)
     const error = new AppError('test', { status: 500 })
-    const json = AppError.serialize(error) as Record<string, unknown>
+    const json = AppError.serialize(error)
     expect(json.stack).toBe(error.stack)
   })
 
-  it('stack extension can customize serialization of stack prop', () => {
-    const AppError = Error0.extend('prop', 'stack', {
-      input: (value: string) => value,
-      output: (error: Error0) => {
-        const stack = error.own('stack')
-        if (typeof stack === 'string') {
-          return stack
-        }
-        return undefined
-      },
-      serialize: () => undefined,
+  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),
     })
     const error = new AppError('test')
-    const json = AppError.serialize(error) as Record<string, unknown>
+    const json = AppError.serialize(error)
     expect('stack' in json).toBe(false)
   })
 
-  it('.serialize() -> .from() roundtrip keeps extension values', () => {
-    const AppError = Error0.extend(statusExtension).extend(codeExtension)
+  it('.serialize() -> .from() roundtrip keeps plugin values', () => {
+    const AppError = Error0.use(statusPlugin).use(codePlugin)
     const error = new AppError('test', { status: 409, code: 'NOT_FOUND' })
     const json = AppError.serialize(error, false)
     const recreated = AppError.from(json)
@@ -215,31 +207,57 @@ describe('Error0', () => {
     expect(AppError.serialize(recreated, false)).toEqual(json)
   })
 
-  it('computed values and rich methods work in static/instance modes', () => {
-    const AppError = Error0.extend(statusExtension)
-      .extend(codeExtension)
-      .extend('computed', 'summary', (error) => {
-        return `${error.message}:${error.code ?? 'none'}`
-      })
-      .extend('method', 'hasCode', (error, expectedCode: string) => error.code === expectedCode)
-
-    const error = new AppError('test', { status: 400, code: 'NOT_FOUND' })
-    expect(error.summary).toBe('test:NOT_FOUND')
-    expect(error.hasCode('NOT_FOUND')).toBe(true)
-    expect(AppError.hasCode(error, 'NOT_FOUND')).toBe(true)
-    expect(AppError.hasCode('just string', 'NOT_FOUND')).toBe(false)
-    expect('summary' in AppError.serialize(error)).toBe(false)
+  it('.serialize() floated props and not serialize causes', () => {
+    const AppError = Error0.use(statusPlugin).use(codePlugin)
+    const error1 = new AppError('test', { status: 409 })
+    const error2 = new AppError('test', { code: 'NOT_FOUND', cause: error1 })
+    const json = AppError.serialize(error2, false)
+    expect(json.status).toBe(409)
+    expect(json.code).toBe('NOT_FOUND')
+    expect('cause' in json).toBe(false)
   })
 
   it('serialize can hide props for public output', () => {
-    const AppError = Error0.extend(statusExtension).extend(codeExtension)
+    const AppError = Error0.use(statusPlugin).use(codePlugin)
     const error = new AppError('test', { status: 401, code: 'NOT_FOUND' })
-    const privateJson = AppError.serialize(error, false) as Record<string, unknown>
-    const publicJson = AppError.serialize(error, true) as Record<string, unknown>
+    const privateJson = AppError.serialize(error, false)
+    const publicJson = AppError.serialize(error, true)
     expect(privateJson.code).toBe('NOT_FOUND')
     expect('code' in publicJson).toBe(false)
   })
 
+  it('prop init without input arg infers undefined-only constructor input', () => {
+    const AppError = Error0.prop('computed', {
+      init: () => undefined as number | undefined,
+      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.computed).toBe(undefined)
+    expectTypeOf<typeof error.computed>().toEqualTypeOf<number | undefined>()
+
+    // @ts-expect-error - computed input is disallowed when init has no input arg
+    // eslint-disable-next-line no-new
+    new AppError('test', { computed: 123 })
+  })
+
+  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'),
+      serialize: false,
+      deserialize: false,
+    })
+    const error = new AppError('test', { status: 401 })
+    const json = AppError.serialize(error)
+    expect('status' in json).toBe(false)
+
+    const recreated = AppError.from({ ...json, status: 999 })
+    expect(recreated.status).toBe(undefined)
+  })
+
   it('by default error0 created from another error has same message', () => {
     const schema = z.object({
       x: z.string(),
@@ -251,16 +269,16 @@ describe('Error0', () => {
     expect(error.message).toBe(parsedError.message)
   })
 
-  it('refine message and other props via direct transformations', () => {
+  it('adapt message and other props via direct transformations', () => {
     const schema = z.object({
       x: z.string(),
     })
     const parseResult = schema.safeParse({ x: 123 })
     const parsedError = parseResult.error
     assert.ok(parsedError)
-    const AppError = Error0.extend(statusExtension)
-      .extend(codeExtension)
-      .extend('refine', (error) => {
+    const AppError = Error0.use(statusPlugin)
+      .use(codePlugin)
+      .use('adapt', (error) => {
         if (error.cause instanceof ZodError) {
           error.status = 422
           error.code = 'NOT_FOUND'
@@ -277,16 +295,16 @@ describe('Error0', () => {
     expect(error1.code).toBe(undefined)
   })
 
-  it('refine message and other props via return output values from extension', () => {
+  it('adapt message and other props via return output values from plugin', () => {
     const schema = z.object({
       x: z.string(),
     })
     const parseResult = schema.safeParse({ x: 123 })
     const parsedError = parseResult.error
     assert.ok(parsedError)
-    const AppError = Error0.extend(statusExtension)
-      .extend(codeExtension)
-      .extend('refine', (error) => {
+    const AppError = Error0.use(statusPlugin)
+      .use(codePlugin)
+      .adapt((error) => {
         if (error.cause instanceof ZodError) {
           error.message = `Validation Error: ${error.message}`
           return {
@@ -307,21 +325,15 @@ describe('Error0', () => {
   })
 
   it('expected prop can be realized to send or not to send error to your error tracker', () => {
-    const AppError = Error0.extend(statusExtension)
-      .extend('prop', 'expected', {
-        input: (value: boolean) => value,
-        output: (error) => {
-          for (const value of error.flow('expected')) {
-            if (typeof value === 'boolean') {
-              return value
-            }
-          }
-          return undefined
-        },
-        serialize: (value) => value,
+    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),
       })
-      .extend('method', 'isExpected', (error) => {
-        return error.expected || false
+      .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 })
@@ -342,13 +354,13 @@ describe('Error0', () => {
 
   // we will have no variants
   // becouse you can thorw any errorm and when you do AppError.from(yourError)
-  // can use refine to assign desired props to error, it is enough for transport
+  // can use adapt to assign desired props to error, it is enough for transport
   // you even can create computed or method to retrieve your error, so no problems with variants
 
   // it('can create and recongnize variant', () => {
-  //   const AppError = Error0.extend(statusExtension)
-  //     .extend(codeExtension)
-  //     .extend('prop', 'userId', {
+  //   const AppError = Error0.use(statusPlugin)
+  //     .use(codePlugin)
+  //     .use('prop', 'userId', {
   //       input: (value: string) => value,
   //       output: (error) => {
   //         for (const value of error.flow('userId')) {