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

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

@@ -0,0 +1,64 @@
+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: ({ value }) => value,
+    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: ({ value, isPublic }) => (isPublic ? undefined : value),
+    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()
+  })
+
+  it('by default serializes stack of this error only', () => {
+    const AppError = Error0.use(statusPlugin).use(codePlugin).use(stackMergePlugin)
+    const error = new AppError('test', { status: 400, code: 'NOT_FOUND' })
+    const json = AppError.serialize(error, false)
+    expect(json.stack).toBe(error.stack)
+  })
+})

package/src/plugins/stack-merge.ts

@@ -0,0 +1,16 @@
+import { Error0 } from '../index.js'
+
+export const stackMergePlugin = Error0.plugin().use('stack', {
+  serialize: ({ error, isPublic }) => {
+    if (isPublic) {
+      return undefined
+    }
+    return error
+      .causes()
+      .map((cause) => {
+        return cause instanceof Error ? cause.stack : undefined
+      })
+      .filter((value): value is string => typeof value === 'string')
+      .join('\n')
+  },
+})

package/src/plugins/tags.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, expectTypeOf, it } from 'bun:test'
+import { Error0 } from '../index.js'
+import { tagsPlugin } from './tags.js'
+
+describe('tagsPlugin', () => {
+  it('merges and deduplicates tags across causes', () => {
+    const AppError = Error0.use(tagsPlugin)
+    const root = new AppError('root', { tags: ['db', 'retry'] })
+    const leaf = new AppError('leaf', { tags: ['api', 'retry'], cause: root })
+    expect(leaf.resolve().tags).toEqual(['api', 'retry', 'db'])
+    expectTypeOf(leaf.resolve().tags).toEqualTypeOf<string[] | undefined>()
+    expectTypeOf(leaf.own('tags')).toEqualTypeOf<string[] | undefined>()
+    expectTypeOf(leaf.flow('tags')).toEqualTypeOf<Array<string[] | undefined>>()
+  })
+
+  it('serializes tags only for private output', () => {
+    const AppError = Error0.use(tagsPlugin)
+    const error = new AppError('test', { tags: ['internal'] })
+    expect(AppError.serialize(error, false).tags).toEqual(['internal'])
+    expect('tags' in AppError.serialize(error, true)).toBe(false)
+  })
+})

package/src/plugins/tags.ts

@@ -0,0 +1,21 @@
+import { Error0 } from '../index.js'
+
+export const tagsPlugin = Error0.plugin().use('prop', 'tags', {
+  init: (input: string[]) => input,
+  resolve: ({ flow }) => {
+    const merged: string[] = []
+    for (const value of flow) {
+      if (Array.isArray(value)) {
+        merged.push(...value.filter((item): item is string => typeof item === 'string'))
+      }
+    }
+    return merged.length > 0 ? Array.from(new Set(merged)) : undefined
+  },
+  serialize: ({ value, isPublic }) => (isPublic ? undefined : value),
+  deserialize: ({ value }) => {
+    if (!Array.isArray(value)) {
+      return undefined
+    }
+    return value.filter((item): item is string => typeof item === 'string')
+  },
+})