@devp0nt/error0 1.0.0-next.55 → 1.0.0-next.57

package/src/plugins/status.ts

@@ -1,35 +0,0 @@
-import { Error0 } from '../index.js'
-
-export const statusPlugin = <TStatuses extends Record<string, number> = Record<never, number>>({
-  isPublic = false,
-  statuses,
-  strict = false,
-}: { isPublic?: boolean; 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, isPublic: _isPublic }) => {
-      if (!isPublic && _isPublic) {
-        return undefined
-      }
-      return resolved
-    },
-    deserialize: ({ value }) => (typeof value === 'number' ? value : undefined),
-  })
-}

package/src/plugins/tags.test.ts

@@ -1,72 +0,0 @@
-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 - unsupported policy
-    error.hasTag(['api', 'db'], 'all')
-  })
-})

package/src/plugins/tags.ts

@@ -1,63 +0,0 @@
-import { Error0 } from '../index.js'
-
-export const tagsPlugin = <TTag extends string>({
-  isPublic = false,
-  tags,
-  strict = true,
-}: { isPublic?: 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: _isPublic }) => {
-        if (!isPublic && _isPublic) {
-          return undefined
-        }
-        return resolved
-      },
-      deserialize: ({ value }) => {
-        if (!Array.isArray(value)) {
-          return undefined
-        }
-        return value.filter((item) => isTag(item))
-      },
-    })
-    .method('hasTag', (error, tag: TTag | TTag[], policy: 'every' | 'some' = 'every'): boolean => {
-      const tags = error.tags
-      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)
-    })
-}