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

package/dist/esm/plugins/tags.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/plugins/tags.ts"],"sourcesContent":["import { Error0 } from '../index.js'\n\nexport const tagsPlugin = ({ hideWhenPublic = true }: { hideWhenPublic?: boolean } = {}) =>\n  Error0.plugin().use('prop', 'tags', {\n    init: (input: string[]) => input,\n    resolve: ({ flow }) => {\n      const merged: string[] = []\n      for (const value of flow) {\n        if (Array.isArray(value)) {\n          merged.push(...value.filter((item): item is string => typeof item === 'string'))\n        }\n      }\n      return merged.length > 0 ? Array.from(new Set(merged)) : undefined\n    },\n    serialize: ({ resolved, isPublic }) => {\n      if (hideWhenPublic && isPublic) {\n        return undefined\n      }\n      return resolved\n    },\n    deserialize: ({ value }) => {\n      if (!Array.isArray(value)) {\n        return undefined\n      }\n      return value.filter((item): item is string => typeof item === 'string')\n    },\n  })\n"],"mappings":"AAAA,SAAS,cAAc;AAEhB,MAAM,aAAa,CAAC,EAAE,iBAAiB,KAAK,IAAkC,CAAC,MACpF,OAAO,OAAO,EAAE,IAAI,QAAQ,QAAQ;AAAA,EAClC,MAAM,CAAC,UAAoB;AAAA,EAC3B,SAAS,CAAC,EAAE,KAAK,MAAM;AACrB,UAAM,SAAmB,CAAC;AAC1B,eAAW,SAAS,MAAM;AACxB,UAAI,MAAM,QAAQ,KAAK,GAAG;AACxB,eAAO,KAAK,GAAG,MAAM,OAAO,CAAC,SAAyB,OAAO,SAAS,QAAQ,CAAC;AAAA,MACjF;AAAA,IACF;AACA,WAAO,OAAO,SAAS,IAAI,MAAM,KAAK,IAAI,IAAI,MAAM,CAAC,IAAI;AAAA,EAC3D;AAAA,EACA,WAAW,CAAC,EAAE,UAAU,SAAS,MAAM;AACrC,QAAI,kBAAkB,UAAU;AAC9B,aAAO;AAAA,IACT;AACA,WAAO;AAAA,EACT;AAAA,EACA,aAAa,CAAC,EAAE,MAAM,MAAM;AAC1B,QAAI,CAAC,MAAM,QAAQ,KAAK,GAAG;AACzB,aAAO;AAAA,IACT;AACA,WAAO,MAAM,OAAO,CAAC,SAAyB,OAAO,SAAS,QAAQ;AAAA,EACxE;AACF,CAAC;","names":[]}
+{"version":3,"sources":["../../../src/plugins/tags.ts"],"sourcesContent":["import { Error0 } from '../index.js'\n\nexport const tagsPlugin = <TTag extends string>({\n  hideWhenPublic = true,\n  tags,\n  strict = true,\n}: { hideWhenPublic?: boolean; tags?: TTag[] | readonly TTag[]; strict?: boolean } = {}) => {\n  function hasTag(error: Error0, tag: TTag): boolean\n  function hasTag(error: Error0, tag: TTag[], policy: 'every' | 'some'): boolean\n  function hasTag(error: Error0, tag: TTag | TTag[], policy?: 'every' | 'some'): boolean {\n    const tags = (error as any).tags as string[] | undefined\n    if (!tags) {\n      return false\n    }\n    if (Array.isArray(tag)) {\n      if (policy === 'every') {\n        return tag.every((item) => tags.includes(item))\n      }\n      return tag.some((item) => tags.includes(item))\n    }\n    return tags.includes(tag)\n  }\n  const isTag = (value: unknown): value is TTag =>\n    typeof value === 'string' && (!tags || !strict || tags.includes(value as TTag))\n  return Error0.plugin()\n    .prop('tags', {\n      init: (input: string[]) => input,\n      resolve: ({ flow }) => {\n        const merged: string[] = []\n        for (const value of flow) {\n          if (Array.isArray(value)) {\n            merged.push(...value)\n          }\n        }\n        return merged.length > 0 ? Array.from(new Set(merged)) : undefined\n      },\n      serialize: ({ resolved, isPublic }) => {\n        if (hideWhenPublic && isPublic) {\n          return undefined\n        }\n        return resolved\n      },\n      deserialize: ({ value }) => {\n        if (!Array.isArray(value)) {\n          return undefined\n        }\n        return value.filter((item) => isTag(item))\n      },\n    })\n    .method('hasTag', hasTag)\n}\n"],"mappings":"AAAA,SAAS,cAAc;AAEhB,MAAM,aAAa,CAAsB;AAAA,EAC9C,iBAAiB;AAAA,EACjB;AAAA,EACA,SAAS;AACX,IAAqF,CAAC,MAAM;AAG1F,WAAS,OAAO,OAAe,KAAoB,QAAoC;AACrF,UAAMA,QAAQ,MAAc;AAC5B,QAAI,CAACA,OAAM;AACT,aAAO;AAAA,IACT;AACA,QAAI,MAAM,QAAQ,GAAG,GAAG;AACtB,UAAI,WAAW,SAAS;AACtB,eAAO,IAAI,MAAM,CAAC,SAASA,MAAK,SAAS,IAAI,CAAC;AAAA,MAChD;AACA,aAAO,IAAI,KAAK,CAAC,SAASA,MAAK,SAAS,IAAI,CAAC;AAAA,IAC/C;AACA,WAAOA,MAAK,SAAS,GAAG;AAAA,EAC1B;AACA,QAAM,QAAQ,CAAC,UACb,OAAO,UAAU,aAAa,CAAC,QAAQ,CAAC,UAAU,KAAK,SAAS,KAAa;AAC/E,SAAO,OAAO,OAAO,EAClB,KAAK,QAAQ;AAAA,IACZ,MAAM,CAAC,UAAoB;AAAA,IAC3B,SAAS,CAAC,EAAE,KAAK,MAAM;AACrB,YAAM,SAAmB,CAAC;AAC1B,iBAAW,SAAS,MAAM;AACxB,YAAI,MAAM,QAAQ,KAAK,GAAG;AACxB,iBAAO,KAAK,GAAG,KAAK;AAAA,QACtB;AAAA,MACF;AACA,aAAO,OAAO,SAAS,IAAI,MAAM,KAAK,IAAI,IAAI,MAAM,CAAC,IAAI;AAAA,IAC3D;AAAA,IACA,WAAW,CAAC,EAAE,UAAU,SAAS,MAAM;AACrC,UAAI,kBAAkB,UAAU;AAC9B,eAAO;AAAA,MACT;AACA,aAAO;AAAA,IACT;AAAA,IACA,aAAa,CAAC,EAAE,MAAM,MAAM;AAC1B,UAAI,CAAC,MAAM,QAAQ,KAAK,GAAG;AACzB,eAAO;AAAA,MACT;AACA,aAAO,MAAM,OAAO,CAAC,SAAS,MAAM,IAAI,CAAC;AAAA,IAC3C;AAAA,EACF,CAAC,EACA,OAAO,UAAU,MAAM;AAC5B;","names":["tags"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devp0nt/error0",
-  "version": "1.0.0-next.49",
+  "version": "1.0.0-next.50",
   "license": "MIT",
   "author": {
     "name": "Sergei Dmitriev",

package/src/index.test.ts

@@ -683,15 +683,61 @@ describe('Error0', () => {
     expect(elapsedMs).toBeLessThan(budgetMs)
   })
 
+  it('class can be created extended from Error0', () => {
+    class MyError extends Error0.use(statusPlugin).use(codePlugin) {
+      isStatusAndCode(status: number, code: string): boolean {
+        return this.status === status && this.code === code
+      }
+    }
+    const error = new MyError('test', { status: 400, code: 'NOT_FOUND' })
+    expect(error.isStatusAndCode(400, 'NOT_FOUND')).toBe(true)
+    expect(error.isStatusAndCode(400, 'BAD_REQUEST')).toBe(false)
+    expect(error.name).toBe('Error0')
+    expectTypeOf<typeof MyError>().toExtend<ClassError0>()
+  })
+
   it('Error0 assignable to LikeError0', () => {
-    type LikeError0 = {
-      from: (error: unknown) => Error
-      serialize: (error: Error) => Record<string, unknown>
+    class MyError extends Error {
+      status?: number
+      code?: string
+      constructor(message: string, options: { cause?: unknown; status?: number; code?: string }) {
+        super(message, { cause: options.cause })
+        this.status = options.status
+        this.code = options.code
+      }
+
+      static from(error: unknown): MyError {
+        if (error instanceof MyError) {
+          return error
+        }
+        const object = typeof error === 'object' && error !== null ? (error as Record<string, unknown>) : {}
+        const message =
+          typeof object.message === 'string' ? object.message : typeof error === 'string' ? error : 'Unknown error'
+        const status = typeof object.status === 'number' ? object.status : undefined
+        const code = typeof object.code === 'string' ? object.code : undefined
+        return new MyError(message, {
+          cause: error,
+          status,
+          code,
+        })
+      }
+
+      static serialize(error: MyError): Record<string, unknown> {
+        return {
+          message: error.message,
+          status: error.status,
+          code: error.code,
+        }
+      }
     }
-    expectTypeOf<typeof Error0>().toExtend<LikeError0>()
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    const AppError = Error0.use(statusPlugin)
-    expectTypeOf<typeof AppError>().toExtend<LikeError0>()
+
+    type LikeError0<TError> = {
+      new (message: string, options: { cause?: unknown; status?: number; code?: string }): TError
+      from: (error: unknown) => TError
+      serialize: (error: TError) => Record<string, unknown>
+    }
+    expectTypeOf<typeof MyError>().toExtend<LikeError0<MyError>>()
+    expectTypeOf<typeof Error0>().toExtend<typeof MyError>()
   })
 
   // we will have no variants

package/src/index.ts

@@ -66,6 +66,7 @@ export type ErrorPluginMethodFn<TOutputValue, TArgs extends unknown[] = unknown[
   error: TError,
   ...args: TArgs
 ) => TOutputValue
+type ErrorPluginAnyMethodFn = (error: any, ...args: any[]) => any
 export type ErrorPluginAdaptResult<TOutputProps extends Record<string, unknown>> = Partial<TOutputProps> | undefined
 export type ErrorPluginAdaptFn<
   TError extends Error0 = Error0,
@@ -89,13 +90,10 @@ export type ErrorPluginMessageSerialize<TError extends Error0> = (options: {
   isPublic: boolean
 }) => unknown
 export type ErrorPluginMessage<TError extends Error0 = Error0> = { serialize: ErrorPluginMessageSerialize<TError> }
-type ErrorMethodRecord = {
-  args: unknown[]
-  output: unknown
-}
+type ErrorMethodRecord = { fn: ErrorPluginAnyMethodFn }
 
 export type ErrorPluginProps = { [key: string]: ErrorPluginPropOptions<any, any> }
-export type ErrorPluginMethods = { [key: string]: ErrorPluginMethodFn<any, any[]> }
+export type ErrorPluginMethods = { [key: string]: ErrorPluginAnyMethodFn }
 
 export type ErrorPlugin<
   TProps extends ErrorPluginProps = Record<never, never>,
@@ -118,9 +116,8 @@ type AddPropToPluginProps<
 type AddMethodToPluginMethods<
   TMethods extends ErrorPluginMethods,
   TKey extends string,
-  TArgs extends unknown[],
-  TOutputValue,
-> = TMethods & Record<TKey, ErrorPluginMethodFn<TOutputValue, TArgs>>
+  TMethod extends ErrorPluginAnyMethodFn,
+> = TMethods & Record<TKey, TMethod>
 type PluginOutputProps<TProps extends ErrorPluginProps> = {
   [TKey in keyof TProps]: TProps[TKey] extends ErrorPluginPropOptions<any, any, any, infer TResolveValue>
     ? TResolveValue
@@ -160,24 +157,80 @@ type ErrorOwnMethods<TPluginsMap extends ErrorPluginsMap> = {
 type ErrorResolveMethods<TPluginsMap extends ErrorPluginsMap> = {
   resolve: () => ErrorResolvedProps<TPluginsMap>
 }
+type BindInstanceMethod<TMethod> = TMethod extends {
+  (error: any, ...args: infer TArgs1): infer TOutput1
+  (error: any, ...args: infer TArgs2): infer TOutput2
+  (error: any, ...args: infer TArgs3): infer TOutput3
+  (error: any, ...args: infer TArgs4): infer TOutput4
+}
+  ? {
+      (...args: TArgs1): TOutput1
+      (...args: TArgs2): TOutput2
+      (...args: TArgs3): TOutput3
+      (...args: TArgs4): TOutput4
+    }
+  : TMethod extends {
+        (error: any, ...args: infer TArgs1): infer TOutput1
+        (error: any, ...args: infer TArgs2): infer TOutput2
+        (error: any, ...args: infer TArgs3): infer TOutput3
+      }
+    ? {
+        (...args: TArgs1): TOutput1
+        (...args: TArgs2): TOutput2
+        (...args: TArgs3): TOutput3
+      }
+    : TMethod extends {
+          (error: any, ...args: infer TArgs1): infer TOutput1
+          (error: any, ...args: infer TArgs2): infer TOutput2
+        }
+      ? {
+          (...args: TArgs1): TOutput1
+          (...args: TArgs2): TOutput2
+        }
+      : TMethod extends (error: any, ...args: infer TArgs) => infer TOutput
+        ? (...args: TArgs) => TOutput
+        : never
+type BindStaticMethod<TMethod> = TMethod extends {
+  (error: any, ...args: infer TArgs1): infer TOutput1
+  (error: any, ...args: infer TArgs2): infer TOutput2
+  (error: any, ...args: infer TArgs3): infer TOutput3
+  (error: any, ...args: infer TArgs4): infer TOutput4
+}
+  ? {
+      (error: unknown, ...args: TArgs1): TOutput1
+      (error: unknown, ...args: TArgs2): TOutput2
+      (error: unknown, ...args: TArgs3): TOutput3
+      (error: unknown, ...args: TArgs4): TOutput4
+    }
+  : TMethod extends {
+        (error: any, ...args: infer TArgs1): infer TOutput1
+        (error: any, ...args: infer TArgs2): infer TOutput2
+        (error: any, ...args: infer TArgs3): infer TOutput3
+      }
+    ? {
+        (error: unknown, ...args: TArgs1): TOutput1
+        (error: unknown, ...args: TArgs2): TOutput2
+        (error: unknown, ...args: TArgs3): TOutput3
+      }
+    : TMethod extends {
+          (error: any, ...args: infer TArgs1): infer TOutput1
+          (error: any, ...args: infer TArgs2): infer TOutput2
+        }
+      ? {
+          (error: unknown, ...args: TArgs1): TOutput1
+          (error: unknown, ...args: TArgs2): TOutput2
+        }
+      : TMethod extends (error: any, ...args: infer TArgs) => infer TOutput
+        ? (error: unknown, ...args: TArgs) => TOutput
+        : never
 type ErrorMethods<TPluginsMap extends ErrorPluginsMap> = {
-  [TKey in keyof TPluginsMap['methods']]: TPluginsMap['methods'][TKey] extends {
-    args: infer TArgs extends unknown[]
-    output: infer TOutput
-  }
-    ? (...args: TArgs) => TOutput
-    : never
+  [TKey in keyof TPluginsMap['methods']]: BindInstanceMethod<TPluginsMap['methods'][TKey]['fn']>
 }
 export type ErrorResolved<TPluginsMap extends ErrorPluginsMap> = ErrorResolvedProps<TPluginsMap> &
   ErrorMethods<TPluginsMap>
 
 type ErrorStaticMethods<TPluginsMap extends ErrorPluginsMap> = {
-  [TKey in keyof TPluginsMap['methods']]: TPluginsMap['methods'][TKey] extends {
-    args: infer TArgs extends unknown[]
-    output: infer TOutput
-  }
-    ? (error: unknown, ...args: TArgs) => TOutput
-    : never
+  [TKey in keyof TPluginsMap['methods']]: BindStaticMethod<TPluginsMap['methods'][TKey]['fn']>
 }
 
 type EmptyPluginsMap = {
@@ -214,12 +267,11 @@ type PluginPropsMapOf<TPlugin extends ErrorPlugin> = {
     : never
 }
 type PluginMethodsMapOf<TPlugin extends ErrorPlugin> = {
-  [TKey in keyof NonNullable<TPlugin['methods']>]: NonNullable<TPlugin['methods']>[TKey] extends (
-    error: Error0,
-    ...args: infer TArgs extends unknown[]
-  ) => infer TOutput
-    ? { args: TArgs; output: TOutput }
-    : never
+  [TKey in keyof NonNullable<TPlugin['methods']>]: {
+    fn: NonNullable<TPlugin['methods']>[TKey] extends ErrorPluginAnyMethodFn
+      ? NonNullable<TPlugin['methods']>[TKey]
+      : never
+  }
 }
 type ErrorPluginsMapOfPlugin<TPlugin extends ErrorPlugin> = {
   props: PluginPropsMapOf<TPlugin>
@@ -242,12 +294,8 @@ type ExtendErrorPluginsMapWithProp<
 type ExtendErrorPluginsMapWithMethod<
   TMap extends ErrorPluginsMap,
   TKey extends string,
-  TArgs extends unknown[],
-  TOutputValue,
-> = ExtendErrorPluginsMap<
-  TMap,
-  ErrorPlugin<Record<never, never>, Record<TKey, ErrorPluginMethodFn<TOutputValue, TArgs>>>
->
+  TMethod extends ErrorPluginAnyMethodFn,
+> = ExtendErrorPluginsMap<TMap, ErrorPlugin<Record<never, never>, Record<TKey, TMethod>>>
 
 type PluginsMapOf<TClass> = TClass extends { __pluginsMap?: infer TPluginsMap }
   ? TPluginsMap extends ErrorPluginsMap
@@ -312,10 +360,10 @@ export class PluginError0<
     return this.use('prop', key, value)
   }
 
-  method<TKey extends string, TArgs extends unknown[], TOutputValue>(
+  method<TKey extends string, TMethod extends (error: BuilderError0<TProps, TMethods>, ...args: any[]) => any>(
     key: TKey,
-    value: ErrorPluginMethodFn<TOutputValue, TArgs, BuilderError0<TProps, TMethods>>,
-  ): PluginError0<TProps, AddMethodToPluginMethods<TMethods, TKey, TArgs, TOutputValue>> {
+    value: TMethod,
+  ): PluginError0<TProps, AddMethodToPluginMethods<TMethods, TKey, TMethod>> {
     return this.use('method', key, value)
   }
 
@@ -347,11 +395,11 @@ export class PluginError0<
     key: TKey,
     value: ErrorPluginPropOptions<TInputValue, TOutputValue, BuilderError0<TProps, TMethods>, TResolveValue>,
   ): PluginError0<AddPropToPluginProps<TProps, TKey, TInputValue, TOutputValue, TResolveValue>, TMethods>
-  use<TKey extends string, TArgs extends unknown[], TOutputValue>(
+  use<TKey extends string, TMethod extends (error: BuilderError0<TProps, TMethods>, ...args: any[]) => any>(
     kind: 'method',
     key: TKey,
-    value: ErrorPluginMethodFn<TOutputValue, TArgs, BuilderError0<TProps, TMethods>>,
-  ): PluginError0<TProps, AddMethodToPluginMethods<TMethods, TKey, TArgs, TOutputValue>>
+    value: TMethod,
+  ): PluginError0<TProps, AddMethodToPluginMethods<TMethods, TKey, TMethod>>
   use(
     kind: 'adapt',
     value: ErrorPluginAdaptFn<BuilderError0<TProps, TMethods>, PluginOutputProps<TProps>>,
@@ -460,10 +508,10 @@ export type ClassError0<TPluginsMap extends ErrorPluginsMap = EmptyPluginsMap> =
   //   key: TKey,
   //   value: ErrorPluginPropOptions<TInputValue, TOutputValue, ErrorInstanceOfMap<TPluginsMap>, TResolveValue>,
   // ) => ClassError0<ExtendErrorPluginsMapWithProp<TPluginsMap, TKey, TInputValue, TOutputValue, TResolveValue>>
-  // method: <TKey extends string, TArgs extends unknown[], TOutputValue>(
+  // method: <TKey extends string, TMethod extends (error: ErrorInstanceOfMap<TPluginsMap>, ...args: any[]) => any>(
   //   key: TKey,
-  //   value: ErrorPluginMethodFn<TOutputValue, TArgs, ErrorInstanceOfMap<TPluginsMap>>,
-  // ) => ClassError0<ExtendErrorPluginsMapWithMethod<TPluginsMap, TKey, TArgs, TOutputValue>>
+  //   value: TMethod,
+  // ) => ClassError0<ExtendErrorPluginsMapWithMethod<TPluginsMap, TKey, TMethod>>
   // adapt: (
   //   value: ErrorPluginAdaptFn<ErrorInstanceOfMap<TPluginsMap>, ErrorResolvedProps<TPluginsMap>>,
   // ) => ClassError0<TPluginsMap>
@@ -483,11 +531,11 @@ export type ClassError0<TPluginsMap extends ErrorPluginsMap = EmptyPluginsMap> =
       key: TKey,
       value: ErrorPluginPropOptions<TInputValue, TOutputValue, ErrorInstanceOfMap<TPluginsMap>, TResolveValue>,
     ): ClassError0<ExtendErrorPluginsMapWithProp<TPluginsMap, TKey, TInputValue, TOutputValue, TResolveValue>>
-    <TKey extends string, TArgs extends unknown[], TOutputValue>(
+    <TKey extends string, TMethod extends (error: ErrorInstanceOfMap<TPluginsMap>, ...args: any[]) => any>(
       kind: 'method',
       key: TKey,
-      value: ErrorPluginMethodFn<TOutputValue, TArgs, ErrorInstanceOfMap<TPluginsMap>>,
-    ): ClassError0<ExtendErrorPluginsMapWithMethod<TPluginsMap, TKey, TArgs, TOutputValue>>
+      value: TMethod,
+    ): ClassError0<ExtendErrorPluginsMapWithMethod<TPluginsMap, TKey, TMethod>>
     (
       kind: 'adapt',
       value: ErrorPluginAdaptFn<ErrorInstanceOfMap<TPluginsMap>, ErrorResolvedProps<TPluginsMap>>,
@@ -648,29 +696,17 @@ export class Error0 extends Error {
 
   private static readonly isOwnProperty = (object: object, key: string): boolean => {
     const ownStore = this._getOwnStore(object)
-    if (ownStore && Object.prototype.hasOwnProperty.call(ownStore, key)) {
-      return true
+    if (ownStore) {
+      return Object.prototype.hasOwnProperty.call(ownStore, key)
     }
-    const d = Object.getOwnPropertyDescriptor(object, key)
-    if (!d) return false
-    if (typeof d.get === 'function' || typeof d.set === 'function') {
-      if ('name' in object && object.name === 'Error0') {
-        return false
-      } else {
-        return true
-      }
-    }
-    return true
+    return !!Object.getOwnPropertyDescriptor(object, key)
   }
   private static _ownByKey(error: object, key: string): unknown {
     const ownStore = this._getOwnStore(error)
-    if (ownStore && Object.prototype.hasOwnProperty.call(ownStore, key)) {
+    if (ownStore) {
       return ownStore[key]
     }
-    if (this.isOwnProperty(error, key)) {
-      return (error as Record<string, unknown>)[key]
-    }
-    return undefined
+    return (error as Record<string, unknown>)[key]
   }
   private static _flowByKey(error: object, key: string): unknown[] {
     const causes = this.causes(error, true)
@@ -963,11 +999,11 @@ export class Error0 extends Error {
   //   return this.use('prop', key, value)
   // }
 
-  // static method<TThis extends typeof Error0, TKey extends string, TArgs extends unknown[], TOutputValue>(
+  // static method<TThis extends typeof Error0, TKey extends string, TMethod extends (error: ErrorInstanceOfMap<PluginsMapOf<TThis>>, ...args: any[]) => any>(
   //   this: TThis,
   //   key: TKey,
-  //   value: ErrorPluginMethodFn<TOutputValue, TArgs, ErrorInstanceOfMap<PluginsMapOf<TThis>>>,
-  // ): ClassError0<ExtendErrorPluginsMapWithMethod<PluginsMapOf<TThis>, TKey, TArgs, TOutputValue>> {
+  //   value: TMethod,
+  // ): ClassError0<ExtendErrorPluginsMapWithMethod<PluginsMapOf<TThis>, TKey, TMethod>> {
   //   return this.use('method', key, value)
   // }
 
@@ -1008,12 +1044,16 @@ export class Error0 extends Error {
     key: TKey,
     value: ErrorPluginPropOptions<TInputValue, TOutputValue, ErrorInstanceOfMap<PluginsMapOf<TThis>>, TResolveValue>,
   ): ClassError0<ExtendErrorPluginsMapWithProp<PluginsMapOf<TThis>, TKey, TInputValue, TOutputValue, TResolveValue>>
-  static use<TThis extends typeof Error0, TKey extends string, TArgs extends unknown[], TOutputValue>(
+  static use<
+    TThis extends typeof Error0,
+    TKey extends string,
+    TMethod extends (error: ErrorInstanceOfMap<PluginsMapOf<TThis>>, ...args: any[]) => any,
+  >(
     this: TThis,
     kind: 'method',
     key: TKey,
-    value: ErrorPluginMethodFn<TOutputValue, TArgs, ErrorInstanceOfMap<PluginsMapOf<TThis>>>,
-  ): ClassError0<ExtendErrorPluginsMapWithMethod<PluginsMapOf<TThis>, TKey, TArgs, TOutputValue>>
+    value: TMethod,
+  ): ClassError0<ExtendErrorPluginsMapWithMethod<PluginsMapOf<TThis>, TKey, TMethod>>
   static use<TThis extends typeof Error0>(
     this: TThis,
     kind: 'adapt',

package/src/plugins/cause-serialize.ts

@@ -1,7 +1,7 @@
 import { Error0 } from '../index.js'
 
 export const causeSerializePlugin = ({ hideWhenPublic = true }: { hideWhenPublic?: boolean } = {}) =>
-  Error0.plugin().use('cause', {
+  Error0.plugin().cause({
     serialize: ({ value, error, isPublic }) => {
       if (hideWhenPublic && 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.ts

@@ -15,7 +15,7 @@ const isExpected = (flow: unknown[]) => {
 
 export const expectedPlugin = ({ hideWhenPublic = true }: { hideWhenPublic?: boolean } = {}) =>
   Error0.plugin()
-    .use('prop', 'expected', {
+    .prop('expected', {
       init: (input: boolean) => input,
       resolve: ({ flow }) => isExpected(flow),
       serialize: ({ resolved, isPublic }) => {
@@ -26,6 +26,6 @@ export const expectedPlugin = ({ hideWhenPublic = true }: { hideWhenPublic?: boo
       },
       deserialize: ({ value }) => (typeof value === 'boolean' ? value : undefined),
     })
-    .use('method', 'isExpected', (error) => {
+    .method('isExpected', (error) => {
       return isExpected(error.flow('expected'))
     })

package/src/plugins/meta.ts

@@ -29,7 +29,7 @@ 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().use('prop', 'meta', {
+  Error0.plugin().prop('meta', {
     init: (input: Record<string, unknown>) => input,
     resolve: ({ flow }) => {
       const values = flow.filter(isMetaRecord)

package/src/plugins/stack-merge.ts

@@ -4,7 +4,7 @@ export const stackMergePlugin = ({
   hideWhenPublic = true,
   delimiter = '\n',
 }: { hideWhenPublic?: boolean; delimiter?: string } = {}) =>
-  Error0.plugin().use('stack', {
+  Error0.plugin().stack({
     serialize: ({ error, isPublic }) => {
       if (hideWhenPublic && isPublic) {
         return undefined

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

@@ -3,12 +3,14 @@ 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.resolve().tags).toEqual(['api', 'retry', 'db'])
-    expectTypeOf(leaf.resolve().tags).toEqualTypeOf<string[] | undefined>()
+    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>>()
   })
@@ -19,4 +21,54 @@ describe('tagsPlugin', () => {
     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')
+  })
 })