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

package/src/index.test.ts

@@ -1,16 +1,15 @@
-import { describe, expect, it } from 'bun:test'
-import { type AxiosError, isAxiosError } from 'axios'
+import { describe, expect, expectTypeOf, it } from 'bun:test'
+import type { ClassError0 } from './index.js'
+import { Error0 } from './index.js'
 import z, { ZodError } from 'zod'
-import { Error0, e0s } from './index.js'
-
-// TODO: test expected
+import * as assert from 'node:assert'
 
 const fixStack = (stack: string | undefined) => {
   if (!stack) {
     return stack
   }
-  // at <anonymous> (/Users/iserdmi/cc/projects/svagatron/modules/lib/error0.test.ts:103:25)
-  // >>
+  // at <anonymous> (/Users/x/error0.test.ts:103:25)
+  // ↓
   // at <anonymous> (...)
   const lines = stack.split('\n')
   const fixedLines = lines.map((line) => {
@@ -20,522 +19,360 @@ const fixStack = (stack: string | undefined) => {
   return fixedLines.join('\n')
 }
 
-const toJSON = (error: Error0) => {
-  const result = error.toJSON()
-  result.stack = fixStack(error.stack)
-  return result
-}
-
-describe('error0', () => {
-  it('simple', () => {
-    const error0 = new Error0('test')
-    expect(error0).toBeInstanceOf(Error0)
-    expect(error0).toMatchInlineSnapshot(`[Error0: test]`)
-    expect(toJSON(error0)).toMatchInlineSnapshot(`
-      {
-        "__I_AM_ERROR_0": true,
-        "anyMessage": undefined,
-        "cause": undefined,
-        "clientMessage": undefined,
-        "code": undefined,
-        "expected": false,
-        "httpStatus": undefined,
-        "message": "test",
-        "meta": {},
-        "stack": 
-      "Error0: test
-          at <anonymous> (...)"
-      ,
-        "tag": undefined,
-      }
-    `)
-  })
-
-  it('full', () => {
-    const input = {
-      message: 'my message',
-      tag: 'tag1',
-      code: 'code1',
-      httpStatus: 400,
-      expected: true,
-      clientMessage: 'human message 1',
-      cause: new Error('original message'),
-      meta: {
-        reqDurationMs: 1,
-        userId: 'user1',
+describe('Error0', () => {
+  const statusExtension = Error0.extension()
+    .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
       },
-    }
-    const error1 = new Error0(input)
-    const error2 = new Error0(input.message, input)
-    expect(toJSON(error1)).toMatchObject(toJSON(error2))
-    expect(toJSON(error1)).toMatchInlineSnapshot(`
-      {
-        "__I_AM_ERROR_0": true,
-        "anyMessage": undefined,
-        "cause": [Error: original message],
-        "clientMessage": "human message 1",
-        "code": "code1",
-        "expected": true,
-        "httpStatus": 400,
-        "message": "my message",
-        "meta": {
-          "reqDurationMs": 1,
-          "userId": "user1",
-        },
-        "stack": 
-      "Error0: my message
-          at <anonymous> (...)
-
-      Error: original message
-          at <anonymous> (...)"
-      ,
-        "tag": "tag1",
-      }
-    `)
-  })
-
-  it('cause error default', () => {
-    const errorDefault = new Error('original message')
-    const error0 = new Error0('my message', { cause: errorDefault })
-    expect(error0).toBeInstanceOf(Error0)
-    expect(error0).toMatchInlineSnapshot(`[Error0: my message]`)
-    expect(toJSON(error0)).toMatchInlineSnapshot(`
-      {
-        "__I_AM_ERROR_0": true,
-        "anyMessage": undefined,
-        "cause": [Error: original message],
-        "clientMessage": undefined,
-        "code": undefined,
-        "expected": false,
-        "httpStatus": undefined,
-        "message": "my message",
-        "meta": {},
-        "stack": 
-      "Error0: my message
-          at <anonymous> (...)
-
-      Error: original message
-          at <anonymous> (...)"
-      ,
-        "tag": undefined,
+      serialize: (value) => value,
+    })
+    .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),
   })
 
-  it('cause strange thing', () => {
-    const error0 = new Error0('my message', { cause: 'strange thing' })
-    expect(error0).toMatchInlineSnapshot(`[Error0: my message]`)
-    expect(toJSON(error0)).toMatchInlineSnapshot(`
-      {
-        "__I_AM_ERROR_0": true,
-        "anyMessage": undefined,
-        "cause": "strange thing",
-        "clientMessage": undefined,
-        "code": undefined,
-        "expected": false,
-        "httpStatus": undefined,
-        "message": "my message",
-        "meta": {},
-        "stack": 
-      "Error0: my message
+  it('simple', () => {
+    const error = new Error0('test')
+    expect(error).toBeInstanceOf(Error0)
+    expect(error).toBeInstanceOf(Error)
+    expect(error).toMatchInlineSnapshot(`[Error0: test]`)
+    expect(error.message).toBe('test')
+    expect(error.stack).toBeDefined()
+    expect(fixStack(error.stack)).toMatchInlineSnapshot(`
+      "Error0: test
           at <anonymous> (...)"
-      ,
-        "tag": undefined,
-      }
     `)
   })
 
-  it('floats and overrides', () => {
-    const error01 = new Error0('first', {
-      tag: 'tag1',
-      clientMessage: 'human message 1',
-      meta: {
-        reqDurationMs: 1,
-        userId: 'user1',
-      },
-    })
-    const error02 = new Error0('second', {
-      tag: 'tag2',
-      code: 'code2',
-      cause: error01,
-      meta: {
-        reqDurationMs: 1,
-        ideaId: 'idea1',
-        other: {
-          x: 1,
-        },
+  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,
     })
-    expect(error01).toBeInstanceOf(Error0)
-    expect(toJSON(error02)).toMatchInlineSnapshot(`
-      {
-        "__I_AM_ERROR_0": true,
-        "anyMessage": undefined,
-        "cause": [Error0: first],
-        "clientMessage": "human message 1",
-        "code": "code2",
-        "expected": false,
-        "httpStatus": undefined,
-        "message": "second",
-        "meta": {
-          "ideaId": "idea1",
-          "other": {
-            "x": 1,
-          },
-          "reqDurationMs": 1,
-          "userId": "user1",
-        },
-        "stack": 
-      "Error0: second
-          at <anonymous> (...)
-
-      Error0: first
+    const error = new AppError('test', { status: 400 })
+    expect(error).toBeInstanceOf(AppError)
+    expect(error).toBeInstanceOf(Error0)
+    expect(error).toBeInstanceOf(Error)
+    expect(error.status).toBe(400)
+    expect(error).toMatchInlineSnapshot(`[Error0: test]`)
+    expect(error.stack).toBeDefined()
+    expect(fixStack(error.stack)).toMatchInlineSnapshot(`
+      "Error0: test
           at <anonymous> (...)"
-      ,
-        "tag": "tag2",
-      }
     `)
+    expectTypeOf<typeof AppError>().toExtend<ClassError0>()
   })
 
-  it('unknown error', () => {
-    const error0 = new Error0({})
-    expect(toJSON(error0)).toMatchInlineSnapshot(`
-      {
-        "__I_AM_ERROR_0": true,
-        "anyMessage": undefined,
-        "cause": undefined,
-        "clientMessage": undefined,
-        "code": undefined,
-        "expected": false,
-        "httpStatus": undefined,
-        "message": "Unknown error",
-        "meta": {},
-        "stack": 
-      "Error0: Unknown error
-          at <anonymous> (...)"
-      ,
-        "tag": undefined,
-      }
-    `)
-    const error1 = new Error0('test')
-    expect(error1.message).toBe('test')
-    const error2 = new Error0({ cause: error1 })
-    expect(toJSON(error2)).toMatchInlineSnapshot(`
-      {
-        "__I_AM_ERROR_0": true,
-        "anyMessage": undefined,
-        "cause": [Error0: test],
-        "clientMessage": undefined,
-        "code": undefined,
-        "expected": false,
-        "httpStatus": undefined,
-        "message": "Unknown error",
-        "meta": {},
-        "stack": 
-      "Error0: Unknown error
-          at <anonymous> (...)
-
-      Error0: test
-          at <anonymous> (...)"
-      ,
-        "tag": undefined,
-      }
-    `)
-    expect(fixStack(error2.stack)).toMatchInlineSnapshot(`
-      "Error0: Unknown error
-          at <anonymous> (...)
-
-      Error0: test
+  it('with defined extension', () => {
+    const AppError = Error0.extend(statusExtension)
+    const error = new AppError('test', { status: 400 })
+    expect(error).toBeInstanceOf(AppError)
+    expect(error).toBeInstanceOf(Error0)
+    expect(error).toBeInstanceOf(Error)
+    expect(error.status).toBe(400)
+    expect(error).toMatchInlineSnapshot(`[Error0: test]`)
+    expect(error.stack).toBeDefined()
+    expect(fixStack(error.stack)).toMatchInlineSnapshot(`
+      "Error0: test
           at <anonymous> (...)"
     `)
   })
 
-  it('input error default', () => {
-    const errorDefault = new Error('default error')
-    const error0 = new Error0(errorDefault)
-    expect(toJSON(error0)).toMatchInlineSnapshot(`
-      {
-        "__I_AM_ERROR_0": true,
-        "anyMessage": undefined,
-        "cause": [Error: default error],
-        "clientMessage": undefined,
-        "code": undefined,
-        "expected": false,
-        "httpStatus": undefined,
-        "message": "Unknown error",
-        "meta": {},
-        "stack": 
-      "Error0: Unknown error
-          at <anonymous> (...)
-
-      Error: default error
-          at <anonymous> (...)"
-      ,
-        "tag": undefined,
-      }
-    `)
-    expect(fixStack(error0.stack)).toMatchInlineSnapshot(`
-      "Error0: Unknown error
-          at <anonymous> (...)
-
-      Error: default error
-          at <anonymous> (...)"
-    `)
+  it('twice extended Error0 extends previous by types', () => {
+    const AppError1 = Error0.extend(statusExtension)
+    const AppError2 = AppError1.extend(codeExtension)
+    const error1 = new AppError1('test', { status: 400 })
+    const error2 = new AppError2('test', { status: 400, code: 'NOT_FOUND' })
+    expect(error1.status).toBe(400)
+    expect(error2.status).toBe(400)
+    expect(error2.code).toBe('NOT_FOUND')
+    expectTypeOf<typeof error2.status>().toEqualTypeOf<number | undefined>()
+    expectTypeOf<typeof error2.code>().toEqualTypeOf<'NOT_FOUND' | 'BAD_REQUEST' | 'UNAUTHORIZED' | undefined>()
+    expectTypeOf<typeof AppError1>().toExtend<ClassError0>()
+    expectTypeOf<typeof AppError2>().toExtend<ClassError0>()
+    expectTypeOf<typeof AppError2>().toExtend<typeof AppError1>()
+    expectTypeOf<typeof AppError1>().not.toExtend<typeof AppError2>()
   })
 
-  it('input error0 itself', () => {
-    const error = new Error0('error0 error')
-    const error0 = new Error0(error)
-    expect(toJSON(error0)).toMatchInlineSnapshot(`
-      {
-        "__I_AM_ERROR_0": true,
-        "anyMessage": undefined,
-        "cause": [Error0: error0 error],
-        "clientMessage": undefined,
-        "code": undefined,
-        "expected": false,
-        "httpStatus": undefined,
-        "message": "Unknown error",
-        "meta": {},
-        "stack": 
-      "Error0: Unknown error
-          at <anonymous> (...)
-
-      Error0: error0 error
-          at <anonymous> (...)"
-      ,
-        "tag": undefined,
-      }
-    `)
-    expect(fixStack(error0.stack)).toMatchInlineSnapshot(`
-      "Error0: Unknown error
-          at <anonymous> (...)
-
-      Error0: error0 error
+  it('can have cause', () => {
+    const AppError = Error0.extend(statusExtension)
+    const anotherError = new Error('another error')
+    const error = new AppError('test', { status: 400, cause: anotherError })
+    expect(error.status).toBe(400)
+    expect(error).toMatchInlineSnapshot(`[Error0: test]`)
+    expect(error.stack).toBeDefined()
+    expect(fixStack(error.stack)).toMatchInlineSnapshot(`
+      "Error0: test
           at <anonymous> (...)"
     `)
+    expect(Error0.causes(error)).toEqual([error, anotherError])
   })
 
-  it('keep stack trace', () => {
-    const errorDefault = new Error('default error')
-    const error01 = new Error0('first', {
-      tag: 'tag1',
-      clientMessage: 'human message 1',
-      cause: errorDefault,
-    })
-    const error02 = new Error0('second', {
-      tag: 'tag2',
-      code: 'code2',
-      cause: error01,
-    })
-    expect(fixStack(errorDefault.stack)).toMatchInlineSnapshot(`
-      "Error: default error
-          at <anonymous> (...)"
-    `)
-    expect(fixStack(error01.stack)).toMatchInlineSnapshot(`
-      "Error0: first
-          at <anonymous> (...)
-
-      Error: default error
-          at <anonymous> (...)"
-    `)
-    expect(fixStack(error02.stack)).toMatchInlineSnapshot(`
-      "Error0: second
-          at <anonymous> (...)
-
-      Error0: first
-          at <anonymous> (...)
-
-      Error: default error
-          at <anonymous> (...)"
-    `)
+  it('can have many causes', () => {
+    const AppError = Error0.extend(statusExtension)
+    const anotherError = new Error('another error')
+    const error1 = new AppError('test1', { status: 400, cause: anotherError })
+    const error2 = new AppError('test2', { status: 400, cause: error1 })
+    expect(error1.status).toBe(400)
+    expect(error2.status).toBe(400)
+    expect(Error0.causes(error2)).toEqual([error2, error1, anotherError])
   })
 
-  it('expected', () => {
-    const error0 = new Error0({
-      expected: true,
-    })
-    expect(error0.expected).toBe(true)
+  it('properties floating', () => {
+    const AppError = Error0.extend(statusExtension).extend(codeExtension)
+    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 })
+    expect(error1.status).toBe(400)
+    expect(error1.code).toBe(undefined)
+    expect(error2.status).toBe(400)
+    expect(error2.code).toBe('NOT_FOUND')
+    expect(Error0.causes(error2)).toEqual([error2, error1, anotherError])
+  })
 
-    const error1 = new Error0({
-      expected: false,
+  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
+      },
+      serialize: () => undefined,
     })
-    expect(error1.expected).toBe(false)
+    const error = new AppError('test', { status: 401, code: 'secret' })
+    const json = AppError.serialize(error) as Record<string, unknown>
+    expect(json.status).toBe(401)
+    expect('code' in json).toBe(false)
+  })
 
-    const error3 = new Error0({
-      expected: true,
-      cause: error0,
-    })
-    expect(error3.expected).toBe(true)
+  it('serialize keeps stack by default without stack extension', () => {
+    const AppError = Error0.extend(statusExtension)
+    const error = new AppError('test', { status: 500 })
+    const json = AppError.serialize(error) as Record<string, unknown>
+    expect(json.stack).toBe(error.stack)
+  })
 
-    const error4 = new Error0({
-      expected: false,
-      cause: error0,
+  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,
     })
-    expect(error4.expected).toBe(false)
+    const error = new AppError('test')
+    const json = AppError.serialize(error) as Record<string, unknown>
+    expect('stack' in json).toBe(false)
+  })
 
-    const error5 = new Error0({
-      expected: true,
-      cause: error1,
-    })
-    expect(error5.expected).toBe(false)
+  it('.serialize() -> .from() roundtrip keeps extension values', () => {
+    const AppError = Error0.extend(statusExtension).extend(codeExtension)
+    const error = new AppError('test', { status: 409, code: 'NOT_FOUND' })
+    const json = AppError.serialize(error, false)
+    const recreated = AppError.from(json)
+    expect(recreated).toBeInstanceOf(AppError)
+    expect(recreated.status).toBe(409)
+    expect(recreated.code).toBe('NOT_FOUND')
+    expect(AppError.serialize(recreated, false)).toEqual(json)
+  })
 
-    const error6 = new Error0({
-      expected: false,
-      cause: error1,
-    })
-    expect(error6.expected).toBe(false)
+  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('extends self', () => {
-    const error7 = new e0s.Expected('expected error')
-    expect(e0s.Expected.defaultExpected).toBe(true)
-    expect(error7.expected).toBe(true)
-    expect(error7).toBeInstanceOf(e0s.Expected)
-    expect(error7).toBeInstanceOf(Error0)
-    expect(toJSON(error7)).toMatchInlineSnapshot(`
-      {
-        "__I_AM_ERROR_0": true,
-        "anyMessage": undefined,
-        "cause": undefined,
-        "clientMessage": undefined,
-        "code": undefined,
-        "expected": true,
-        "httpStatus": undefined,
-        "message": "expected error",
-        "meta": {},
-        "stack": 
-      "Error0: expected error
-          at <anonymous> (...)"
-      ,
-        "tag": undefined,
-      }
-    `)
+  it('serialize can hide props for public output', () => {
+    const AppError = Error0.extend(statusExtension).extend(codeExtension)
+    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>
+    expect(privateJson.code).toBe('NOT_FOUND')
+    expect('code' in publicJson).toBe(false)
   })
 
-  it('extend collection', () => {
-    const e0s1 = Error0.extendCollection(e0s, {
-      defaultMessage: 'nested error',
-      defaultMeta: {
-        tagPrefix: 'nested',
-      },
+  it('by default error0 created from another error has same message', () => {
+    const schema = z.object({
+      x: z.string(),
     })
-    const error0 = new e0s1.Default('nested error')
-    expect(error0).toBeInstanceOf(e0s1.Default)
-    expect(error0).toBeInstanceOf(e0s.Default)
-    expect(error0).toBeInstanceOf(Error0)
-    expect(toJSON(error0)).toMatchInlineSnapshot(`
-      {
-        "__I_AM_ERROR_0": true,
-        "anyMessage": undefined,
-        "cause": undefined,
-        "clientMessage": undefined,
-        "code": undefined,
-        "expected": false,
-        "httpStatus": undefined,
-        "message": "nested error",
-        "meta": {
-          "tagPrefix": "nested",
-        },
-        "stack": 
-      "Error0: nested error
-          at <anonymous> (...)"
-      ,
-        "tag": "nested:nested",
-      }
-    `)
-
-    const error02 = new e0s1.Expected('nested error 1')
-    expect(error02).toBeInstanceOf(e0s1.Expected)
-    expect(error02).toBeInstanceOf(e0s.Expected)
-    expect(error02).toBeInstanceOf(Error0)
-    expect(error02.expected).toBe(true)
-    expect(toJSON(error02)).toMatchInlineSnapshot(`
-      {
-        "__I_AM_ERROR_0": true,
-        "anyMessage": undefined,
-        "cause": undefined,
-        "clientMessage": undefined,
-        "code": undefined,
-        "expected": true,
-        "httpStatus": undefined,
-        "message": "nested error 1",
-        "meta": {
-          "tagPrefix": "nested",
-        },
-        "stack": 
-      "Error0: nested error 1
-          at <anonymous> (...)"
-      ,
-        "tag": "nested:nested",
-      }
-    `)
+    const parseResult = schema.safeParse({ x: 123 })
+    const parsedError = parseResult.error
+    assert.ok(parsedError)
+    const error = Error0.from(parsedError)
+    expect(error.message).toBe(parsedError.message)
   })
 
-  it('cause zod error', () => {
-    const zodError = z.object({ x: z.number() }).safeParse('test').error
-    if (!zodError) {
-      throw new Error('zodError is undefined')
-    }
-    expect(zodError).toBeInstanceOf(ZodError)
-    const error0 = new Error0(zodError)
-    expect(error0.zodError).toBe(zodError)
-    expect(error0.message).toBe('Unknown error')
+  it('refine 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) => {
+        if (error.cause instanceof ZodError) {
+          error.status = 422
+          error.code = 'NOT_FOUND'
+          error.message = `Validation Error: ${error.message}`
+        }
+      })
+    const error = AppError.from(parsedError)
+    expect(error.message).toBe(`Validation Error: ${parsedError.message}`)
+    expect(error.status).toBe(422)
+    expect(error.code).toBe('NOT_FOUND')
+    const error1 = new AppError('test', { cause: parsedError })
+    expect(error1.message).toBe('test')
+    expect(error1.status).toBe(undefined)
+    expect(error1.code).toBe(undefined)
   })
 
-  it('from zod error', () => {
-    const zodError = z.object({ x: z.number() }).safeParse('test').error
-    if (!zodError) {
-      throw new Error('zodError is undefined')
-    }
-    expect(zodError).toBeInstanceOf(ZodError)
-    const error0 = Error0.from(zodError)
-    expect(error0.zodError).toBe(zodError)
-    expect(error0.message).toMatchInlineSnapshot(`
-      "Zod Validation Error: [
-        {
-          "expected": "object",
-          "code": "invalid_type",
-          "path": [],
-          "message": "Invalid input: expected object, received string"
+  it('refine message and other props via return output values from extension', () => {
+    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) => {
+        if (error.cause instanceof ZodError) {
+          error.message = `Validation Error: ${error.message}`
+          return {
+            status: 422,
+            code: 'NOT_FOUND',
+          }
         }
-      ]"
-    `)
+        return undefined
+      })
+    const error = AppError.from(parsedError)
+    expect(error.message).toBe(`Validation Error: ${parsedError.message}`)
+    expect(error.status).toBe(422)
+    expect(error.code).toBe('NOT_FOUND')
+    const error1 = new AppError('test', { cause: parsedError })
+    expect(error1.message).toBe('test')
+    expect(error1.status).toBe(undefined)
+    expect(error1.code).toBe(undefined)
   })
 
-  it('from axios error', async () => {
-    function makeFakeAxiosError(): AxiosError {
-      return {
-        isAxiosError: true,
-        name: 'AxiosError',
-        message: 'Request failed with status code 400',
-        config: {}, // can be empty for test
-        toJSON: () => ({}),
-        response: {
-          status: 400,
-          statusText: 'Bad Request',
-          headers: {},
-          config: {},
-          data: {
-            error: 'Invalid input',
-            details: ['Field X is required'],
-          },
+  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
         },
-      } as AxiosError
-    }
-    const axiosError = makeFakeAxiosError()
-    if (!axiosError) {
-      throw new Error('axiosError is undefined')
-    }
-    expect(isAxiosError(axiosError)).toBe(true)
-    const error0 = Error0.from(axiosError)
-    expect(error0.axiosError).toBe(axiosError)
-    expect(error0.message).toBe('Axios Error')
-    expect(error0.meta).toMatchInlineSnapshot(`
-      {
-        "axiosData": "{"error":"Invalid input","details":["Field X is required"]}",
-        "axiosStatus": 400,
-      }
-    `)
+        serialize: (value) => value,
+      })
+      .extend('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)
   })
+
+  // 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
+  // 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', {
+  //       input: (value: string) => value,
+  //       output: (error) => {
+  //         for (const value of error.flow('userId')) {
+  //           if (typeof value === 'string') {
+  //             return value
+  //           }
+  //         }
+  //         return undefined
+  //       },
+  //       serialize: (value) => value,
+  //     })
+  //   const UserError = AppError.variant('UserError', {
+  //     userId: true,
+  //   })
+  //   const error = new UserError('test', { userId: '123', status: 400 })
+  //   expect(error).toBeInstanceOf(UserError)
+  //   expect(error).toBeInstanceOf(AppError)
+  //   expect(error).toBeInstanceOf(Error0)
+  //   expect(error).toBeInstanceOf(Error)
+  //   expect(error.userId).toBe('123')
+  //   expect(error.status).toBe(400)
+  //   expect(error.code).toBe(undefined)
+  //   expectTypeOf<typeof error.userId>().toEqualTypeOf<string>()
+  //   // @ts-expect-error
+  //   new UserError('test')
+  // })
 })