@devp0nt/error0 1.0.0-next.5 → 1.0.0-next.50

package/src/plugins/cause-serialize.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, it } from 'bun:test'
+import { Error0 } from '../index.js'
+import { causeSerializePlugin } from './cause-serialize.js'
+
+describe('causeSerializePlugin', () => {
+  const statusPlugin = Error0.plugin().use('prop', 'status', {
+    init: (input: number) => input,
+    resolve: ({ flow }) => flow.find((value) => typeof value === 'number'),
+    serialize: ({ resolved }) => resolved,
+    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: ({ resolved, isPublic }) => (isPublic ? undefined : resolved),
+    deserialize: ({ value }) =>
+      typeof value === 'string' && codes.includes(value as Code) ? (value as Code) : undefined,
+  })
+
+  it('serializes and deserializes nested Error0 causes', () => {
+    const AppError = Error0.use(statusPlugin)
+      .use(codePlugin)
+      .use(causeSerializePlugin({ hideWhenPublic: false }))
+    const deepCauseError = new AppError('deep cause')
+    const causeError = new AppError('cause', { status: 409, code: 'NOT_FOUND', cause: deepCauseError })
+    const error = new AppError('root', { status: 500, cause: causeError })
+
+    const json = AppError.serialize(error, false)
+    expect(typeof json.cause).toBe('object')
+    expect((json.cause as any).message).toBe('cause')
+    expect((json.cause as any).status).toBe(409)
+    expect((json.cause as any).code).toBe('NOT_FOUND')
+    expect((json.cause as any).cause).toBeDefined()
+    expect((json.cause as any).cause.message).toBe('deep cause')
+    expect((json.cause as any).cause.status).toBe(undefined)
+    expect((json.cause as any).cause.code).toBe(undefined)
+    expect((json.cause as any).cause.cause).toBeUndefined()
+
+    const recreated = AppError.from(json)
+    expect(recreated).toBeInstanceOf(AppError)
+    expect(recreated.cause).toBeInstanceOf(AppError)
+    expect((recreated.cause as any).status).toBe(409)
+    expect((recreated.cause as any).code).toBe('NOT_FOUND')
+    expect((recreated.cause as any).cause).toBeInstanceOf(AppError)
+    expect((recreated.cause as any).cause.message).toBe('deep cause')
+    expect((recreated.cause as any).cause.status).toBe(undefined)
+    expect((recreated.cause as any).cause.code).toBe(undefined)
+    expect((recreated.cause as any).cause.cause).toBeUndefined()
+  })
+})

package/src/plugins/cause-serialize.ts

@@ -0,0 +1,15 @@
+import { Error0 } from '../index.js'
+
+export const causeSerializePlugin = ({ hideWhenPublic = true }: { hideWhenPublic?: boolean } = {}) =>
+  Error0.plugin().cause({
+    serialize: ({ value, error, isPublic }) => {
+      if (hideWhenPublic && isPublic) {
+        return undefined
+      }
+      const ctor = error.constructor as typeof Error0
+      if (ctor.is(value)) {
+        return ctor.serialize(value, isPublic)
+      }
+      return undefined
+    },
+  })

package/src/plugins/code.test.ts

@@ -0,0 +1,27 @@
+import { describe, expect, expectTypeOf, it } from 'bun:test'
+import { Error0 } from '../index.js'
+import { codePlugin } from './code.js'
+
+describe('codePlugin', () => {
+  const codes = ['NOT_FOUND', 'BAD_REQUEST', 'UNAUTHORIZED'] as const
+
+  it('serializes and deserializes allowed codes', () => {
+    const AppError = Error0.use(codePlugin({ codes: [...codes] }))
+    const error = new AppError('test', { code: 'NOT_FOUND' })
+
+    expect(error.code).toBe('NOT_FOUND')
+    expectTypeOf<typeof error.code>().toEqualTypeOf<'NOT_FOUND' | 'BAD_REQUEST' | 'UNAUTHORIZED' | undefined>()
+
+    const json = AppError.serialize(error, false)
+    expect(json.code).toBe('NOT_FOUND')
+
+    const recreated = AppError.from(json)
+    expect(recreated.code).toBe('NOT_FOUND')
+  })
+
+  it('ignores code values outside the allowed list', () => {
+    const AppError = Error0.use(codePlugin({ codes: [...codes] }))
+    const recreated = AppError.from({ message: 'test', code: 'SOMETHING_ELSE' })
+    expect(recreated.code).toBeUndefined()
+  })
+})

package/src/plugins/code.ts

@@ -0,0 +1,12 @@
+import { Error0 } from '../index.js'
+
+export const codePlugin = <TCode extends string>({ codes }: { codes?: TCode[] } = {}) => {
+  const isCode = (value: unknown): value is TCode =>
+    typeof value === 'string' && (!codes || codes.includes(value as TCode))
+  return Error0.plugin().prop('code', {
+    init: (code: TCode) => code,
+    resolve: ({ flow }) => flow.find(Boolean),
+    serialize: ({ resolved, isPublic }) => resolved,
+    deserialize: ({ value, record }) => (isCode(value) ? value : undefined),
+  })
+}

package/src/plugins/expected.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, it } from 'bun:test'
+import { Error0 } from '../index.js'
+import { expectedPlugin } from './expected.js'
+
+describe('expectedPlugin', () => {
+  const statusPlugin = Error0.plugin().use('prop', 'status', {
+    init: (input: number) => input,
+    resolve: ({ flow }) => flow.find((value) => typeof value === 'number'),
+    serialize: ({ resolved }) => resolved,
+    deserialize: ({ value }) => (typeof value === 'number' ? value : undefined),
+  })
+
+  it('can be used to control error tracker behavior', () => {
+    const AppError = Error0.use(statusPlugin).use(expectedPlugin({ hideWhenPublic: 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(false)
+    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)
+  })
+
+  it('resolves to false when any cause has false', () => {
+    const AppError = Error0.use(expectedPlugin({ hideWhenPublic: false }))
+    const root = new AppError('root', { expected: true })
+    const middle = new AppError('middle', { expected: false, cause: root })
+    const leaf = new AppError('leaf', { expected: false, cause: middle })
+    expect(leaf.expected).toBe(false)
+    expect(leaf.isExpected()).toBe(false)
+  })
+
+  it('treats undefined expected as unexpected', () => {
+    const AppError = Error0.use(expectedPlugin({ hideWhenPublic: false }))
+    const error = new AppError('without expected')
+    expect(error.expected).toBe(false)
+    expect(error.isExpected()).toBe(false)
+  })
+})

package/src/plugins/expected.ts

@@ -0,0 +1,31 @@
+import { Error0 } from '../index.js'
+
+const isExpected = (flow: unknown[]) => {
+  let expected = false
+  for (const value of flow) {
+    if (value === false) {
+      return false
+    }
+    if (value === true) {
+      expected = true
+    }
+  }
+  return expected
+}
+
+export const expectedPlugin = ({ hideWhenPublic = true }: { hideWhenPublic?: boolean } = {}) =>
+  Error0.plugin()
+    .prop('expected', {
+      init: (input: boolean) => input,
+      resolve: ({ flow }) => isExpected(flow),
+      serialize: ({ resolved, isPublic }) => {
+        if (hideWhenPublic && isPublic) {
+          return undefined
+        }
+        return resolved
+      },
+      deserialize: ({ value }) => (typeof value === 'boolean' ? value : undefined),
+    })
+    .method('isExpected', (error) => {
+      return isExpected(error.flow('expected'))
+    })

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: ({ resolved }) => resolved,
+    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: ({ resolved, isPublic }) => (isPublic ? undefined : resolved),
+    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,19 @@
+import { Error0 } from '../index.js'
+
+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

@@ -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,59 @@
+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 = ({ hideWhenPublic = true }: { hideWhenPublic?: boolean } = {}) =>
+  Error0.plugin().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: ({ 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

@@ -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: ({ resolved }) => resolved,
+    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: ({ 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 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,20 @@
+import { Error0 } from '../index.js'
+
+export const stackMergePlugin = ({
+  hideWhenPublic = true,
+  delimiter = '\n',
+}: { hideWhenPublic?: boolean; delimiter?: string } = {}) =>
+  Error0.plugin().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/status.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, expectTypeOf, it } from 'bun:test'
+import { Error0 } from '../index.js'
+import { statusPlugin } from './status.js'
+
+describe('statusPlugin', () => {
+  const statuses = {
+    BAD_REQUEST: 400,
+    UNAUTHORIZED: 401,
+    NOT_FOUND: 404,
+  } as const
+
+  it('maps status keys to numeric values', () => {
+    const AppError = Error0.use(statusPlugin({ statuses }))
+    const error = new AppError('test', { status: 'NOT_FOUND' })
+
+    expectTypeOf<typeof error.status>().toEqualTypeOf<number | undefined>()
+    expect(error.status).toBe(404)
+
+    const json = AppError.serialize(error, false)
+    expect(json.status).toBe(404)
+  })
+
+  it('accepts numeric status values when no statuses map is provided', () => {
+    const AppError = Error0.use(statusPlugin())
+    const error = new AppError('test', { status: 500 })
+    expect(error.status).toBe(500)
+  })
+
+  it('if status number not in list, it is not converts to undefined by default', () => {
+    const AppError = Error0.use(statusPlugin({ statuses }))
+    const error = new AppError('test', { status: 999 })
+    expect(error.status).toBe(999)
+  })
+
+  it('if status number not in list, it converts to undefined if strict is true', () => {
+    const AppError = Error0.use(statusPlugin({ statuses, strict: true }))
+    const error = new AppError('test', { status: 999 })
+    expect(error.status).toBeUndefined()
+  })
+
+  it('not allowed incorrect status name', () => {
+    const AppError = Error0.use(statusPlugin({ statuses }))
+    // @ts-expect-error - incorrect status name
+    const error = new AppError('test', { status: 'SOMETHING_ELSE' })
+    expect(error.status).toBeUndefined()
+  })
+
+  it('not allowed status name if statuses not provided', () => {
+    const AppError = Error0.use(statusPlugin())
+    // @ts-expect-error - incorrect status name
+    const error = new AppError('test', { status: 'SOMETHING_ELSE' })
+    expect(error.status).toBeUndefined()
+  })
+})

package/src/plugins/status.ts

@@ -0,0 +1,29 @@
+import { Error0 } from '../index.js'
+
+export const statusPlugin = <TStatuses extends Record<string, number> = Record<never, number>>({
+  statuses,
+  strict = false,
+}: { statuses?: TStatuses; strict?: boolean } = {}) => {
+  const statusValues = statuses ? Object.values(statuses) : undefined
+  const isStatusValue = (value: unknown): value is number =>
+    typeof value === 'number' && (!statusValues || !strict || statusValues.includes(value))
+  const normalizeStatusValue = (value: unknown): number | undefined => {
+    return isStatusValue(value) ? value : undefined
+  }
+  const convertStatusValue = (value: number | string): number | undefined => {
+    if (typeof value === 'number') {
+      return normalizeStatusValue(value)
+    }
+    if (statuses && value in statuses) {
+      return statuses[value as keyof TStatuses]
+    }
+    return undefined
+  }
+
+  return Error0.plugin().prop('status', {
+    init: (status: number | Extract<keyof TStatuses, string>) => convertStatusValue(status),
+    resolve: ({ flow }) => flow.find(Boolean),
+    serialize: ({ resolved }) => resolved,
+    deserialize: ({ value }) => (typeof value === 'number' ? value : undefined),
+  })
+}

package/src/plugins/tags.test.ts

@@ -0,0 +1,74 @@
+import { describe, expect, expectTypeOf, it } from 'bun:test'
+import { Error0 } from '../index.js'
+import { tagsPlugin } from './tags.js'
+
+describe('tagsPlugin', () => {
+  const tags = ['api', 'db', 'retry'] as const
+
+  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.tags).toEqual(['api', 'retry', 'db'])
+    expectTypeOf(leaf.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)
+  })
+
+  it('supports hasTag for single, some, and every checks', () => {
+    const AppError = Error0.use(tagsPlugin())
+    const root = new AppError('root', { tags: ['db', 'retry'] })
+    const leaf = new AppError('leaf', { tags: ['api'], cause: root })
+
+    expect(AppError.hasTag(leaf, 'db')).toBe(true)
+    expect(leaf.hasTag('db')).toBe(true)
+    expect(leaf.hasTag('unknown')).toBe(false)
+    expect(leaf.hasTag(['api', 'db'], 'some')).toBe(true)
+    expect(leaf.hasTag(['api', 'db'], 'every')).toBe(true)
+    expect(leaf.hasTag(['api', 'unknown'], 'every')).toBe(false)
+  })
+
+  it('filters tags not in the allow-list when strict is true', () => {
+    const AppError = Error0.use(tagsPlugin({ tags: [...tags], strict: true }))
+    const recreated = AppError.from({
+      name: 'Error0',
+      message: 'test',
+      tags: ['db', 'invalid', 123],
+    })
+    expect(recreated.tags).toEqual(['db'])
+  })
+
+  it('keeps all string tags when strict is false', () => {
+    const AppError = Error0.use(tagsPlugin({ tags: [...tags], strict: false }))
+    const recreated = AppError.from({
+      name: 'Error0',
+      message: 'test',
+      tags: ['db', 'custom', 123],
+    })
+
+    expect(recreated.tags).toEqual(['db', 'custom'])
+  })
+
+  it('enforces typed hasTag inputs when allow-list is provided', () => {
+    const AppError = Error0.use(tagsPlugin({ tags }))
+    const error = new AppError('test', { tags: ['api', 'db'] })
+
+    expectTypeOf(error.hasTag('api')).toEqualTypeOf<boolean>()
+    expectTypeOf(error.hasTag(['api', 'db'], 'every')).toEqualTypeOf<boolean>()
+    expectTypeOf(error.hasTag(['api', 'retry'], 'some')).toEqualTypeOf<boolean>()
+
+    // @ts-expect-error - unknown tag is not part of allow-list
+    error.hasTag('custom')
+    // @ts-expect-error - array checks require policy argument
+    error.hasTag(['api', 'db'])
+    // @ts-expect-error - unsupported policy
+    error.hasTag(['api', 'db'], 'all')
+  })
+})

package/src/plugins/tags.ts

@@ -0,0 +1,51 @@
+import { Error0 } from '../index.js'
+
+export const tagsPlugin = <TTag extends string>({
+  hideWhenPublic = true,
+  tags,
+  strict = true,
+}: { hideWhenPublic?: boolean; tags?: TTag[] | readonly TTag[]; strict?: boolean } = {}) => {
+  function hasTag(error: Error0, tag: TTag): boolean
+  function hasTag(error: Error0, tag: TTag[], policy: 'every' | 'some'): boolean
+  function hasTag(error: Error0, tag: TTag | TTag[], policy?: 'every' | 'some'): boolean {
+    const tags = (error as any).tags as string[] | undefined
+    if (!tags) {
+      return false
+    }
+    if (Array.isArray(tag)) {
+      if (policy === 'every') {
+        return tag.every((item) => tags.includes(item))
+      }
+      return tag.some((item) => tags.includes(item))
+    }
+    return tags.includes(tag)
+  }
+  const isTag = (value: unknown): value is TTag =>
+    typeof value === 'string' && (!tags || !strict || tags.includes(value as TTag))
+  return Error0.plugin()
+    .prop('tags', {
+      init: (input: string[]) => input,
+      resolve: ({ flow }) => {
+        const merged: string[] = []
+        for (const value of flow) {
+          if (Array.isArray(value)) {
+            merged.push(...value)
+          }
+        }
+        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) => isTag(item))
+      },
+    })
+    .method('hasTag', hasTag)
+}