@devp0nt/error0 1.0.0-next.48 → 1.0.0-next.49

package/src/plugins/message-merge.ts

@@ -1,15 +1,19 @@
 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'
-    )
-  },
-})
+export const messageMergePlugin = ({
+  delimiter = ': ',
+  fallback = 'Unknown error',
+}: { delimiter?: string; fallback?: string } = {}) =>
+  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(delimiter) || fallback
+      )
+    },
+  })

package/src/plugins/meta.test.ts

@@ -4,7 +4,7 @@ import { metaPlugin } from './meta.js'
 
 describe('metaPlugin', () => {
   it('merges meta across causes into current error', () => {
-    const AppError = Error0.use(metaPlugin)
+    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({
@@ -15,7 +15,7 @@ describe('metaPlugin', () => {
   })
 
   it('serializes meta only for private output and keeps json-safe values', () => {
-    const AppError = Error0.use(metaPlugin)
+    const AppError = Error0.use(metaPlugin())
     const error = new AppError('test', {
       meta: {
         ok: true,

package/src/plugins/meta.ts

@@ -28,26 +28,32 @@ const toJsonSafe = (input: unknown): Json | 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
-    }
+export const metaPlugin = ({ hideWhenPublic = true }: { hideWhenPublic?: boolean } = {}) =>
+  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
-  },
-})
+      // 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: ({ resolved, isPublic }) => {
+      if (hideWhenPublic && isPublic) {
+        return undefined
+      }
+      return toJsonSafe(resolved)
+    },
+    deserialize: ({ value }) => {
+      if (!isMetaRecord(value)) {
+        return undefined
+      }
+      return value
+    },
+  })

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

@@ -18,7 +18,7 @@ describe('stackMergePlugin', () => {
   const statusPlugin = Error0.plugin().use('prop', 'status', {
     init: (input: number) => input,
     resolve: ({ flow }) => flow.find((value) => typeof value === 'number'),
-    serialize: ({ value }) => value,
+    serialize: ({ resolved }) => resolved,
     deserialize: ({ value }) => (typeof value === 'number' ? value : undefined),
   })
 
@@ -27,13 +27,13 @@ describe('stackMergePlugin', () => {
   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),
+    serialize: ({ resolved, isPublic }) => (isPublic ? undefined : resolved),
     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 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
@@ -56,7 +56,7 @@ describe('stackMergePlugin', () => {
   })
 
   it('by default serializes stack of this error only', () => {
-    const AppError = Error0.use(statusPlugin).use(codePlugin).use(stackMergePlugin)
+    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

@@ -1,16 +1,20 @@
 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')
-  },
-})
+export const stackMergePlugin = ({
+  hideWhenPublic = true,
+  delimiter = '\n',
+}: { hideWhenPublic?: boolean; delimiter?: string } = {}) =>
+  Error0.plugin().use('stack', {
+    serialize: ({ error, isPublic }) => {
+      if (hideWhenPublic && isPublic) {
+        return undefined
+      }
+      return error
+        .causes()
+        .map((cause) => {
+          return cause instanceof Error ? cause.stack : undefined
+        })
+        .filter((value): value is string => typeof value === 'string')
+        .join(delimiter)
+    },
+  })

package/src/plugins/tags.test.ts

@@ -4,7 +4,7 @@ import { tagsPlugin } from './tags.js'
 
 describe('tagsPlugin', () => {
   it('merges and deduplicates tags across causes', () => {
-    const AppError = Error0.use(tagsPlugin)
+    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'])
@@ -14,7 +14,7 @@ describe('tagsPlugin', () => {
   })
 
   it('serializes tags only for private output', () => {
-    const AppError = Error0.use(tagsPlugin)
+    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

@@ -1,21 +1,27 @@
 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'))
+export const tagsPlugin = ({ hideWhenPublic = true }: { hideWhenPublic?: boolean } = {}) =>
+  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')
-  },
-})
+      return merged.length > 0 ? Array.from(new Set(merged)) : undefined
+    },
+    serialize: ({ resolved, isPublic }) => {
+      if (hideWhenPublic && isPublic) {
+        return undefined
+      }
+      return resolved
+    },
+    deserialize: ({ value }) => {
+      if (!Array.isArray(value)) {
+        return undefined
+      }
+      return value.filter((item): item is string => typeof item === 'string')
+    },
+  })