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

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

@@ -0,0 +1,32 @@
+import { describe, expect, it } from 'bun:test'
+import { Error0 } from '../index.js'
+import { messageMergePlugin } from './message-merge.js'
+
+describe('messageMergePlugin', () => {
+  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 message across causes in one serialized value', () => {
+    const AppError = Error0.use(statusPlugin).use(codePlugin).use(messageMergePlugin)
+    const error1 = new AppError('test1', { status: 400, code: 'NOT_FOUND' })
+    const error2 = new AppError('test2', { status: 401, cause: error1 })
+    expect(error1.message).toBe('test1')
+    expect(error2.message).toBe('test2')
+    expect(error1.serialize().message).toBe('test1')
+    expect(error2.serialize().message).toBe('test2: test1')
+  })
+})

package/src/plugins/message-merge.ts

@@ -0,0 +1,15 @@
+import { Error0 } from '../index.js'
+
+export const messageMergePlugin = Error0.plugin().use('message', {
+  serialize: ({ error }) => {
+    return (
+      error
+        .causes()
+        .map((cause) => {
+          return cause instanceof Error ? cause.message : undefined
+        })
+        .filter((value): value is string => typeof value === 'string')
+        .join(': ') || 'Unknown error'
+    )
+  },
+})

package/src/plugins/meta.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it } from 'bun:test'
+import { Error0 } from '../index.js'
+import { metaPlugin } from './meta.js'
+
+describe('metaPlugin', () => {
+  it('merges meta across causes into current error', () => {
+    const AppError = Error0.use(metaPlugin)
+    const root = new AppError('root', { meta: { requestId: 'r1', source: 'db' } })
+    const leaf = new AppError('leaf', { meta: { route: '/ideas', source: 'api' }, cause: root })
+    expect(leaf.resolve().meta).toEqual({
+      requestId: 'r1',
+      source: 'api',
+      route: '/ideas',
+    })
+  })
+
+  it('serializes meta only for private output and keeps json-safe values', () => {
+    const AppError = Error0.use(metaPlugin)
+    const error = new AppError('test', {
+      meta: {
+        ok: true,
+        nested: { id: 1 },
+        skip: () => 'x',
+      },
+    })
+    expect(AppError.serialize(error, false).meta).toEqual({
+      ok: true,
+      nested: { id: 1 },
+    })
+    expect('meta' in AppError.serialize(error, true)).toBe(false)
+  })
+})

package/src/plugins/meta.ts

@@ -0,0 +1,53 @@
+import { Error0 } from '../index.js'
+
+type Json = null | boolean | number | string | Json[] | { [key: string]: Json }
+
+const toJsonSafe = (input: unknown): Json | undefined => {
+  if (input === null) {
+    return null
+  }
+  if (typeof input === 'string' || typeof input === 'number' || typeof input === 'boolean') {
+    return input
+  }
+  if (Array.isArray(input)) {
+    return input.map((value) => toJsonSafe(value)) as Json[]
+  }
+  if (typeof input === 'object') {
+    const output: Record<string, Json> = {}
+    for (const [key, value] of Object.entries(input as Record<string, unknown>)) {
+      const jsonValue = toJsonSafe(value)
+      if (jsonValue !== undefined) {
+        output[key] = jsonValue
+      }
+    }
+    return output
+  }
+  return undefined
+}
+
+const isMetaRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null && !Array.isArray(value)
+
+export const metaPlugin = Error0.plugin().use('prop', 'meta', {
+  init: (input: Record<string, unknown>) => input,
+  resolve: ({ flow }) => {
+    const values = flow.filter(isMetaRecord)
+    if (values.length === 0) {
+      return undefined
+    }
+
+    // Merge cause meta into the current error; nearer errors win on conflicts.
+    const merged: Record<string, unknown> = {}
+    for (const value of [...values].reverse()) {
+      Object.assign(merged, value)
+    }
+    return merged
+  },
+  serialize: ({ value, isPublic }) => (isPublic ? undefined : toJsonSafe(value)),
+  deserialize: ({ value }) => {
+    if (!isMetaRecord(value)) {
+      return undefined
+    }
+    return value
+  },
+})

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')
+  },
+})