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

package/dist/esm/plugins/status.d.ts

@@ -1,6 +1,7 @@
 import { PluginError0, ErrorPluginPropOptions, Error0 } from '../index.js';
 
-declare const statusPlugin: <TStatuses extends Record<string, number> = Record<never, number>>({ statuses, strict, }?: {
+declare const statusPlugin: <TStatuses extends Record<string, number> = Record<never, number>>({ isPublic, statuses, strict, }?: {
+    isPublic?: boolean;
     statuses?: TStatuses;
     strict?: boolean;
 }) => PluginError0<Record<never, never> & Record<"status", ErrorPluginPropOptions<number | Extract<keyof TStatuses, string>, number | undefined, Error0, number | undefined>>, Record<never, never>>;

package/dist/esm/plugins/status.js

@@ -1,5 +1,6 @@
 import { Error0 } from "../index.js";
 const statusPlugin = ({
+  isPublic = false,
   statuses,
   strict = false
 } = {}) => {
@@ -20,7 +21,12 @@ const statusPlugin = ({
   return Error0.plugin().prop("status", {
     init: (status) => convertStatusValue(status),
     resolve: ({ flow }) => flow.find(Boolean),
-    serialize: ({ resolved }) => resolved,
+    serialize: ({ resolved, isPublic: _isPublic }) => {
+      if (!isPublic && _isPublic) {
+        return void 0;
+      }
+      return resolved;
+    },
     deserialize: ({ value }) => typeof value === "number" ? value : void 0
   });
 };

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/plugins/status.ts"],"sourcesContent":["import { Error0 } from '../index.js'\n\nexport const statusPlugin = <TStatuses extends Record<string, number> = Record<never, number>>({\n  statuses,\n  strict = false,\n}: { statuses?: TStatuses; strict?: boolean } = {}) => {\n  const statusValues = statuses ? Object.values(statuses) : undefined\n  const isStatusValue = (value: unknown): value is number =>\n    typeof value === 'number' && (!statusValues || !strict || statusValues.includes(value))\n  const normalizeStatusValue = (value: unknown): number | undefined => {\n    return isStatusValue(value) ? value : undefined\n  }\n  const convertStatusValue = (value: number | string): number | undefined => {\n    if (typeof value === 'number') {\n      return normalizeStatusValue(value)\n    }\n    if (statuses && value in statuses) {\n      return statuses[value as keyof TStatuses]\n    }\n    return undefined\n  }\n\n  return Error0.plugin().prop('status', {\n    init: (status: number | Extract<keyof TStatuses, string>) => convertStatusValue(status),\n    resolve: ({ flow }) => flow.find(Boolean),\n    serialize: ({ resolved }) => resolved,\n    deserialize: ({ value }) => (typeof value === 'number' ? value : undefined),\n  })\n}\n"],"mappings":"AAAA,SAAS,cAAc;AAEhB,MAAM,eAAe,CAAmE;AAAA,EAC7F;AAAA,EACA,SAAS;AACX,IAAgD,CAAC,MAAM;AACrD,QAAM,eAAe,WAAW,OAAO,OAAO,QAAQ,IAAI;AAC1D,QAAM,gBAAgB,CAAC,UACrB,OAAO,UAAU,aAAa,CAAC,gBAAgB,CAAC,UAAU,aAAa,SAAS,KAAK;AACvF,QAAM,uBAAuB,CAAC,UAAuC;AACnE,WAAO,cAAc,KAAK,IAAI,QAAQ;AAAA,EACxC;AACA,QAAM,qBAAqB,CAAC,UAA+C;AACzE,QAAI,OAAO,UAAU,UAAU;AAC7B,aAAO,qBAAqB,KAAK;AAAA,IACnC;AACA,QAAI,YAAY,SAAS,UAAU;AACjC,aAAO,SAAS,KAAwB;AAAA,IAC1C;AACA,WAAO;AAAA,EACT;AAEA,SAAO,OAAO,OAAO,EAAE,KAAK,UAAU;AAAA,IACpC,MAAM,CAAC,WAAsD,mBAAmB,MAAM;AAAA,IACtF,SAAS,CAAC,EAAE,KAAK,MAAM,KAAK,KAAK,OAAO;AAAA,IACxC,WAAW,CAAC,EAAE,SAAS,MAAM;AAAA,IAC7B,aAAa,CAAC,EAAE,MAAM,MAAO,OAAO,UAAU,WAAW,QAAQ;AAAA,EACnE,CAAC;AACH;","names":[]}
+{"version":3,"sources":["../../../src/plugins/status.ts"],"sourcesContent":["import { Error0 } from '../index.js'\n\nexport const statusPlugin = <TStatuses extends Record<string, number> = Record<never, number>>({\n  isPublic = false,\n  statuses,\n  strict = false,\n}: { isPublic?: boolean; statuses?: TStatuses; strict?: boolean } = {}) => {\n  const statusValues = statuses ? Object.values(statuses) : undefined\n  const isStatusValue = (value: unknown): value is number =>\n    typeof value === 'number' && (!statusValues || !strict || statusValues.includes(value))\n  const normalizeStatusValue = (value: unknown): number | undefined => {\n    return isStatusValue(value) ? value : undefined\n  }\n  const convertStatusValue = (value: number | string): number | undefined => {\n    if (typeof value === 'number') {\n      return normalizeStatusValue(value)\n    }\n    if (statuses && value in statuses) {\n      return statuses[value as keyof TStatuses]\n    }\n    return undefined\n  }\n\n  return Error0.plugin().prop('status', {\n    init: (status: number | Extract<keyof TStatuses, string>) => convertStatusValue(status),\n    resolve: ({ flow }) => flow.find(Boolean),\n    serialize: ({ resolved, isPublic: _isPublic }) => {\n      if (!isPublic && _isPublic) {\n        return undefined\n      }\n      return resolved\n    },\n    deserialize: ({ value }) => (typeof value === 'number' ? value : undefined),\n  })\n}\n"],"mappings":"AAAA,SAAS,cAAc;AAEhB,MAAM,eAAe,CAAmE;AAAA,EAC7F,WAAW;AAAA,EACX;AAAA,EACA,SAAS;AACX,IAAoE,CAAC,MAAM;AACzE,QAAM,eAAe,WAAW,OAAO,OAAO,QAAQ,IAAI;AAC1D,QAAM,gBAAgB,CAAC,UACrB,OAAO,UAAU,aAAa,CAAC,gBAAgB,CAAC,UAAU,aAAa,SAAS,KAAK;AACvF,QAAM,uBAAuB,CAAC,UAAuC;AACnE,WAAO,cAAc,KAAK,IAAI,QAAQ;AAAA,EACxC;AACA,QAAM,qBAAqB,CAAC,UAA+C;AACzE,QAAI,OAAO,UAAU,UAAU;AAC7B,aAAO,qBAAqB,KAAK;AAAA,IACnC;AACA,QAAI,YAAY,SAAS,UAAU;AACjC,aAAO,SAAS,KAAwB;AAAA,IAC1C;AACA,WAAO;AAAA,EACT;AAEA,SAAO,OAAO,OAAO,EAAE,KAAK,UAAU;AAAA,IACpC,MAAM,CAAC,WAAsD,mBAAmB,MAAM;AAAA,IACtF,SAAS,CAAC,EAAE,KAAK,MAAM,KAAK,KAAK,OAAO;AAAA,IACxC,WAAW,CAAC,EAAE,UAAU,UAAU,UAAU,MAAM;AAChD,UAAI,CAAC,YAAY,WAAW;AAC1B,eAAO;AAAA,MACT;AACA,aAAO;AAAA,IACT;AAAA,IACA,aAAa,CAAC,EAAE,MAAM,MAAO,OAAO,UAAU,WAAW,QAAQ;AAAA,EACnE,CAAC;AACH;","names":[]}

package/dist/esm/plugins/tags.d.ts

@@ -1,7 +1,7 @@
 import { PluginError0, ErrorPluginPropOptions, Error0 } from '../index.js';
 
-declare const tagsPlugin: <TTag extends string>({ hideWhenPublic, tags, strict, }?: {
-    hideWhenPublic?: boolean;
+declare const tagsPlugin: <TTag extends string>({ isPublic, tags, strict, }?: {
+    isPublic?: boolean;
     tags?: TTag[] | readonly TTag[];
     strict?: boolean;
 }) => PluginError0<Record<never, never> & Record<"tags", ErrorPluginPropOptions<string[], string[], Error0, string[] | undefined>>, Record<never, never> & Record<"hasTag", {

package/dist/esm/plugins/tags.js

@@ -1,6 +1,6 @@
 import { Error0 } from "../index.js";
 const tagsPlugin = ({
-  hideWhenPublic = true,
+  isPublic = false,
   tags,
   strict = true
 } = {}) => {
@@ -29,8 +29,8 @@ const tagsPlugin = ({
       }
       return merged.length > 0 ? Array.from(new Set(merged)) : void 0;
     },
-    serialize: ({ resolved, isPublic }) => {
-      if (hideWhenPublic && isPublic) {
+    serialize: ({ resolved, isPublic: _isPublic }) => {
+      if (!isPublic && _isPublic) {
         return void 0;
       }
       return resolved;

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 = <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"]}
+{"version":3,"sources":["../../../src/plugins/tags.ts"],"sourcesContent":["import { Error0 } from '../index.js'\n\nexport const tagsPlugin = <TTag extends string>({\n  isPublic = false,\n  tags,\n  strict = true,\n}: { isPublic?: 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: _isPublic }) => {\n        if (!isPublic && _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,WAAW;AAAA,EACX;AAAA,EACA,SAAS;AACX,IAA+E,CAAC,MAAM;AAGpF,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,UAAU,UAAU,MAAM;AAChD,UAAI,CAAC,YAAY,WAAW;AAC1B,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.50",
+  "version": "1.0.0-next.52",
   "license": "MIT",
   "author": {
     "name": "Sergei Dmitriev",

package/src/index.test.ts

@@ -203,13 +203,20 @@ describe('Error0', () => {
     expect('code' in json).toBe(false)
   })
 
-  it('serialize keeps stack by default without stack plugin', () => {
+  it('serialize keeps stack by default without stack plugin when not public', () => {
     const AppError = Error0.use(statusPlugin)
     const error = new AppError('test', { status: 500 })
-    const json = AppError.serialize(error)
+    const json = AppError.serialize(error, false)
     expect(json.stack).toBe(error.stack)
   })
 
+  it('serialize does not keep stack when public', () => {
+    const AppError = Error0.use(statusPlugin)
+    const error = new AppError('test', { status: 500 })
+    const json = AppError.serialize(error, true)
+    expect('stack' in json).toBe(false)
+  })
+
   it('stack plugin can customize stack serialization without defining prop plugin', () => {
     const AppError = Error0.use('stack', { serialize: ({ value }) => (value ? `custom:${value}` : undefined) })
     const error = new AppError('test')

package/src/index.ts

@@ -79,11 +79,22 @@ export type ErrorPluginStackSerialize<TError extends Error0> = (options: {
 }) => unknown
 export type ErrorPluginStack<TError extends Error0 = Error0> = { serialize: ErrorPluginStackSerialize<TError> }
 export type ErrorPluginCauseSerialize<TError extends Error0> = (options: {
-  value: unknown
+  cause: unknown
   error: TError
   isPublic: boolean
+  is: (cause: unknown) => boolean
+  serialize: (cause: unknown) => Record<string, unknown>
 }) => unknown
-export type ErrorPluginCause<TError extends Error0 = Error0> = { serialize: ErrorPluginCauseSerialize<TError> }
+export type ErrorPluginCauseDeserialize = (options: {
+  cause: unknown
+  error: Record<string, unknown>
+  isSerialized: (serializedCause: unknown) => boolean
+  fromSerialized: (serializedCause: unknown) => Error0
+}) => unknown
+export type ErrorPluginCause<TError extends Error0 = Error0> = {
+  serialize: ErrorPluginCauseSerialize<TError>
+  deserialize: ErrorPluginCauseDeserialize
+}
 export type ErrorPluginMessageSerialize<TError extends Error0> = (options: {
   value: string
   error: TError
@@ -897,26 +908,18 @@ export class Error0 extends Error {
         console.error(`Error0: failed to deserialize property ${key}`, errorRecord)
       }
     }
-    // we do not serialize causes
-    // ;(recreated as unknown as { cause?: unknown }).cause = errorRecord.cause
-    if ('stack' in errorRecord) {
-      try {
-        if (typeof errorRecord.stack === 'string') {
-          recreated.stack = errorRecord.stack
-        }
-      } catch {
-        // eslint-disable-next-line no-console
-        console.error('Error0: failed to deserialize stack', errorRecord)
-      }
+    if ('stack' in errorRecord && typeof errorRecord.stack === 'string') {
+      recreated.stack = errorRecord.stack
     }
     const causePlugin = plugin.cause
-    if (causePlugin?.serialize && 'cause' in errorRecord) {
+    if (causePlugin && 'cause' in errorRecord) {
       try {
-        if (this.isSerialized(errorRecord.cause)) {
-          ;(recreated as { cause?: unknown }).cause = this._fromSerialized(errorRecord.cause)
-        } else {
-          ;(recreated as { cause?: unknown }).cause = errorRecord.cause
-        }
+        ;(recreated as { cause?: unknown }).cause = causePlugin.deserialize({
+          cause: errorRecord.cause,
+          error: errorRecord,
+          isSerialized: (serializedCause) => this.isSerialized(serializedCause),
+          fromSerialized: (serializedCause) => this._fromSerialized(serializedCause),
+        })
       } catch {
         // eslint-disable-next-line no-console
         console.error('Error0: failed to deserialize cause', errorRecord)
@@ -1098,8 +1101,13 @@ export class Error0 extends Error {
       if (typeof key === 'undefined') {
         throw new Error('Error0.use("cause", value) requires cause plugin value')
       }
-      if (typeof key !== 'object' || key === null || typeof (key as { serialize?: unknown }).serialize !== 'function') {
-        throw new Error('Error0.use("cause", value) expects { serialize: function }')
+      if (
+        typeof key !== 'object' ||
+        key === null ||
+        typeof (key as { serialize?: unknown }).serialize !== 'function' ||
+        typeof (key as { deserialize?: unknown }).deserialize !== 'function'
+      ) {
+        throw new Error('Error0.use("cause", value) expects { serialize: function, deserialize: function }')
       }
       return this._useWithPlugin({
         cause: key as ErrorPluginCause,
@@ -1166,8 +1174,6 @@ export class Error0 extends Error {
     }
     const json: Record<string, unknown> = {
       name: error0.name,
-      // we do not serialize causes, it is enough that we have floated props and adapt helper
-      // cause: error0.cause,
     }
     if (serializedMessage !== undefined) {
       json.message = serializedMessage
@@ -1206,7 +1212,7 @@ export class Error0 extends Error {
       if (stackPlugin) {
         serializedStack = stackPlugin.serialize({ value: error0.stack, error: error0, isPublic })
       } else {
-        serializedStack = error0.stack
+        serializedStack = isPublic ? undefined : error0.stack
       }
       if (serializedStack !== undefined) {
         json.stack = serializedStack
@@ -1219,9 +1225,11 @@ export class Error0 extends Error {
     if (causePlugin?.serialize) {
       try {
         const serializedCause = causePlugin.serialize({
-          value: (error0 as { cause?: unknown }).cause,
+          cause: (error0 as { cause?: unknown }).cause,
           error: error0,
           isPublic,
+          is: (cause) => this.is(cause),
+          serialize: (cause) => this.serialize(cause, isPublic),
         })
         if (serializedCause !== undefined) {
           json.cause = serializedCause

package/src/plugins/{cause-serialize.test.ts → cause.test.ts}

@@ -1,8 +1,8 @@
 import { describe, expect, it } from 'bun:test'
 import { Error0 } from '../index.js'
-import { causeSerializePlugin } from './cause-serialize.js'
+import { causePlugin } from './cause.js'
 
-describe('causeSerializePlugin', () => {
+describe('causePlugin', () => {
   const statusPlugin = Error0.plugin().use('prop', 'status', {
     init: (input: number) => input,
     resolve: ({ flow }) => flow.find((value) => typeof value === 'number'),
@@ -23,7 +23,7 @@ describe('causeSerializePlugin', () => {
   it('serializes and deserializes nested Error0 causes', () => {
     const AppError = Error0.use(statusPlugin)
       .use(codePlugin)
-      .use(causeSerializePlugin({ hideWhenPublic: false }))
+      .use(causePlugin({ isPublic: true }))
     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 })
@@ -50,4 +50,57 @@ describe('causeSerializePlugin', () => {
     expect((recreated.cause as any).cause.code).toBe(undefined)
     expect((recreated.cause as any).cause.cause).toBeUndefined()
   })
+
+  it('supports variants', () => {
+    class DbError extends Error {
+      query: string
+      constructor(message: string, options: { cause?: unknown; query: string }) {
+        super(message, { cause: options.cause })
+        this.query = options.query
+        this.name = 'DbError'
+      }
+      static serialize(error: DbError): Record<string, unknown> {
+        return {
+          message: error.message,
+          query: error.query,
+        }
+      }
+      static from(error: unknown): DbError {
+        if (error instanceof DbError) {
+          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 query = typeof object.query === 'string' ? object.query : 'NOT_FOUND'
+        return new DbError(message, { cause: error, query })
+      }
+      static isSerialized(serializedCause: unknown): boolean {
+        return (
+          typeof serializedCause === 'object' &&
+          serializedCause !== null &&
+          'query' in serializedCause &&
+          typeof serializedCause.query === 'string'
+        )
+      }
+    }
+    const AppError = Error0.use(statusPlugin)
+      .use(codePlugin)
+      .use(
+        causePlugin({
+          variants: {
+            DbError,
+          },
+        }),
+      )
+    const dbError = new DbError('test', { query: 'SELECT * FROM users' })
+    const error = new AppError('root', { status: 500, cause: dbError })
+    const json = AppError.serialize(error, false)
+    expect(json.cause).toBeDefined()
+    expect((json.cause as any).query).toBe('SELECT * FROM users')
+    const recreated = AppError.from(json)
+    expect(recreated).toBeInstanceOf(AppError)
+    expect(recreated.cause).toBeInstanceOf(DbError)
+    expect((recreated.cause as any).query).toBe('SELECT * FROM users')
+  })
 })

package/src/plugins/cause.ts

@@ -0,0 +1,45 @@
+import { Error0 } from '../index.js'
+
+type Variant = {
+  new (...args: any[]): unknown
+  [Symbol.hasInstance]: (value: any) => boolean
+  isSerialized: (serializedCause: any) => boolean
+  serialize: (error: any) => unknown
+  from: (error: any) => unknown
+}
+
+export const causePlugin = <TVariants extends Record<string, Variant> = Record<never, Variant>>({
+  isPublic = false,
+  variants = undefined,
+}: { isPublic?: boolean; variants?: TVariants } = {}) =>
+  Error0.plugin().cause({
+    serialize: ({ cause, isPublic: _isPublic, is, serialize }) => {
+      if (!isPublic && _isPublic) {
+        return undefined
+      }
+      if (variants) {
+        for (const variant of Object.values(variants)) {
+          if (cause instanceof variant) {
+            return variant.serialize(cause)
+          }
+        }
+      }
+      if (is(cause)) {
+        return serialize(cause)
+      }
+      return undefined
+    },
+    deserialize: ({ cause, fromSerialized, isSerialized }) => {
+      if (variants) {
+        for (const variant of Object.values(variants)) {
+          if (variant.isSerialized(cause)) {
+            return variant.from(cause)
+          }
+        }
+      }
+      if (isSerialized(cause)) {
+        return fromSerialized(cause)
+      }
+      return cause
+    },
+  })

package/src/plugins/code.ts

@@ -1,12 +1,20 @@
 import { Error0 } from '../index.js'
 
-export const codePlugin = <TCode extends string>({ codes }: { codes?: TCode[] } = {}) => {
+export const codePlugin = <TCode extends string>({
+  codes,
+  isPublic = false,
+}: { codes?: TCode[]; isPublic?: boolean } = {}) => {
   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,
+    serialize: ({ resolved, isPublic: _isPublic }) => {
+      if (!isPublic && _isPublic) {
+        return undefined
+      }
+      return resolved
+    },
     deserialize: ({ value, record }) => (isCode(value) ? value : undefined),
   })
 }

package/src/plugins/expected.test.ts

@@ -11,7 +11,7 @@ describe('expectedPlugin', () => {
   })
 
   it('can be used to control error tracker behavior', () => {
-    const AppError = Error0.use(statusPlugin).use(expectedPlugin({ hideWhenPublic: false }))
+    const AppError = Error0.use(statusPlugin).use(expectedPlugin({ isPublic: true }))
     const errorExpected = new AppError('test', { status: 400, expected: true })
     const errorUnexpected = new AppError('test', { status: 400, expected: false })
     const usualError = new Error('test')
@@ -30,7 +30,7 @@ describe('expectedPlugin', () => {
   })
 
   it('resolves to false when any cause has false', () => {
-    const AppError = Error0.use(expectedPlugin({ hideWhenPublic: false }))
+    const AppError = Error0.use(expectedPlugin({ isPublic: true }))
     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 })
@@ -39,9 +39,28 @@ describe('expectedPlugin', () => {
   })
 
   it('treats undefined expected as unexpected', () => {
-    const AppError = Error0.use(expectedPlugin({ hideWhenPublic: false }))
+    const AppError = Error0.use(expectedPlugin({ isPublic: true }))
     const error = new AppError('without expected')
     expect(error.expected).toBe(false)
     expect(error.isExpected()).toBe(false)
   })
+
+  it('supports override', () => {
+    const AppError = Error0.use(statusPlugin).use(
+      expectedPlugin({
+        isPublic: true,
+        override: (error) => {
+          return error.message.includes('CRITICAL') ? false : undefined
+        },
+      }),
+    )
+    const errorNonCritical = new AppError('USUAL: test', { status: 400 })
+    const errorNonCriticalExpected = new AppError('USUAL: test', { status: 400, expected: true })
+    const errorCritical = new AppError('CRITICAL: test', { status: 400 })
+    const errorCriticalExpected = new AppError('CRITICAL: test', { status: 400, expected: true })
+    expect(errorNonCritical.expected).toBe(false) // becouse expected was not provided at all
+    expect(errorNonCriticalExpected.expected).toBe(true)
+    expect(errorCritical.expected).toBe(false)
+    expect(errorCriticalExpected.expected).toBe(false)
+  })
 })

package/src/plugins/expected.ts

@@ -1,6 +1,20 @@
 import { Error0 } from '../index.js'
 
-const isExpected = (flow: unknown[]) => {
+const isExpected = ({
+  flow,
+  error,
+  override,
+}: {
+  flow: unknown[]
+  error: Error0
+  override?: (error: any) => boolean | undefined
+}) => {
+  if (override) {
+    const overridden = override(error)
+    if (overridden !== undefined) {
+      return overridden
+    }
+  }
   let expected = false
   for (const value of flow) {
     if (value === false) {
@@ -13,13 +27,16 @@ const isExpected = (flow: unknown[]) => {
   return expected
 }
 
-export const expectedPlugin = ({ hideWhenPublic = true }: { hideWhenPublic?: boolean } = {}) =>
+export const expectedPlugin = <TError extends Error0>({
+  isPublic = false,
+  override,
+}: { isPublic?: boolean; override?: (error: TError) => boolean | undefined } = {}) =>
   Error0.plugin()
     .prop('expected', {
       init: (input: boolean) => input,
-      resolve: ({ flow }) => isExpected(flow),
-      serialize: ({ resolved, isPublic }) => {
-        if (hideWhenPublic && isPublic) {
+      resolve: ({ flow, error }) => isExpected({ flow, error, override }),
+      serialize: ({ resolved, isPublic: _isPublic }) => {
+        if (isPublic && _isPublic) {
           return undefined
         }
         return resolved
@@ -27,5 +44,5 @@ export const expectedPlugin = ({ hideWhenPublic = true }: { hideWhenPublic?: boo
       deserialize: ({ value }) => (typeof value === 'boolean' ? value : undefined),
     })
     .method('isExpected', (error) => {
-      return isExpected(error.flow('expected'))
+      return isExpected({ flow: error.flow('expected'), error, override })
     })

package/src/plugins/flat-original.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, it } from 'bun:test'
+import { Error0 } from '../index.js'
+import { flatOriginalPlugin } from './flat-original.js'
+
+describe('flatOriginalPlugin', () => {
+  it('without plugin original error comes to cause', () => {
+    const usualError = new Error('another error')
+    const error = Error0.from(usualError)
+    expect(error).toBeInstanceOf(Error0)
+    expect(error).toBeInstanceOf(Error)
+    expect(error.name).toBe('Error0')
+    expect(error.cause).not.toBeInstanceOf(Error0)
+    expect(error.cause).toBeInstanceOf(Error)
+    expect(error.cause).toBe(usualError)
+    expect((error.cause as any).name).toBe('Error')
+    expect(error.causes()).toEqual([error, usualError])
+  })
+
+  it('with plugin original error becomes error0 itself', () => {
+    const usualError = new Error('another error')
+    const AppError = Error0.use(flatOriginalPlugin())
+    const error = AppError.from(usualError)
+    expect(error).toBeInstanceOf(AppError)
+    expect(error).toBeInstanceOf(Error0)
+    expect(error).toBeInstanceOf(Error)
+    expect(error.message).toBe(usualError.message)
+    expect(error.stack).toBe(usualError.stack)
+    expect(error.name).toBe('Error0')
+    expect(error.cause).toBeUndefined()
+  })
+
+  it('with plugin original error becomes error0 itself but keep it own causes', () => {
+    const causeError = new Error('cause error')
+    const usualError = new Error('another error', { cause: causeError })
+    const AppError = Error0.use(flatOriginalPlugin())
+    const error = AppError.from(usualError)
+    expect(error).toBeInstanceOf(AppError)
+    expect(error).toBeInstanceOf(Error0)
+    expect(error).toBeInstanceOf(Error)
+    expect(error.message).toBe(usualError.message)
+    expect(error.stack).toBe(usualError.stack)
+    expect(error.name).toBe('Error0')
+    expect(error.causes()).toEqual([error, causeError])
+  })
+})

package/src/plugins/flat-original.ts

@@ -0,0 +1,12 @@
+import { Error0 } from '../index.js'
+
+export const flatOriginalPlugin = ({ prefix }: { prefix?: string } = {}) => {
+  return Error0.plugin().adapt((error) => {
+    const cause = error.cause
+    if (cause instanceof Error && cause.constructor === Error) {
+      error.cause = cause.cause
+      error.message = `${prefix ?? ''}${cause.message}`
+      error.stack = cause.stack
+    }
+  })
+}

package/src/plugins/meta.ts

@@ -28,7 +28,7 @@ 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 = ({ hideWhenPublic = true }: { hideWhenPublic?: boolean } = {}) =>
+export const metaPlugin = ({ isPublic = false }: { isPublic?: boolean } = {}) =>
   Error0.plugin().prop('meta', {
     init: (input: Record<string, unknown>) => input,
     resolve: ({ flow }) => {
@@ -44,8 +44,8 @@ export const metaPlugin = ({ hideWhenPublic = true }: { hideWhenPublic?: boolean
       }
       return merged
     },
-    serialize: ({ resolved, isPublic }) => {
-      if (hideWhenPublic && isPublic) {
+    serialize: ({ resolved, isPublic: _isPublic }) => {
+      if (!isPublic && _isPublic) {
         return undefined
       }
       return toJsonSafe(resolved)

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

@@ -54,11 +54,4 @@ describe('stackMergePlugin', () => {
     `)
     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

@@ -1,12 +1,12 @@
 import { Error0 } from '../index.js'
 
 export const stackMergePlugin = ({
-  hideWhenPublic = true,
+  isPublic = false,
   delimiter = '\n',
-}: { hideWhenPublic?: boolean; delimiter?: string } = {}) =>
+}: { isPublic?: boolean; delimiter?: string } = {}) =>
   Error0.plugin().stack({
-    serialize: ({ error, isPublic }) => {
-      if (hideWhenPublic && isPublic) {
+    serialize: ({ error, isPublic: _isPublic }) => {
+      if (!isPublic && _isPublic) {
         return undefined
       }
       return error

package/src/plugins/status.ts

@@ -1,9 +1,10 @@
 import { Error0 } from '../index.js'
 
 export const statusPlugin = <TStatuses extends Record<string, number> = Record<never, number>>({
+  isPublic = false,
   statuses,
   strict = false,
-}: { statuses?: TStatuses; strict?: boolean } = {}) => {
+}: { 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))
@@ -23,7 +24,12 @@ export const statusPlugin = <TStatuses extends Record<string, number> = Record<n
   return Error0.plugin().prop('status', {
     init: (status: number | Extract<keyof TStatuses, string>) => convertStatusValue(status),
     resolve: ({ flow }) => flow.find(Boolean),
-    serialize: ({ resolved }) => resolved,
+    serialize: ({ resolved, isPublic: _isPublic }) => {
+      if (!isPublic && _isPublic) {
+        return undefined
+      }
+      return resolved
+    },
     deserialize: ({ value }) => (typeof value === 'number' ? value : undefined),
   })
 }

package/src/plugins/tags.ts

@@ -1,10 +1,10 @@
 import { Error0 } from '../index.js'
 
 export const tagsPlugin = <TTag extends string>({
-  hideWhenPublic = true,
+  isPublic = false,
   tags,
   strict = true,
-}: { hideWhenPublic?: boolean; tags?: TTag[] | readonly TTag[]; strict?: boolean } = {}) => {
+}: { 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 {
@@ -34,8 +34,8 @@ export const tagsPlugin = <TTag extends string>({
         }
         return merged.length > 0 ? Array.from(new Set(merged)) : undefined
       },
-      serialize: ({ resolved, isPublic }) => {
-        if (hideWhenPublic && isPublic) {
+      serialize: ({ resolved, isPublic: _isPublic }) => {
+        if (!isPublic && _isPublic) {
           return undefined
         }
         return resolved

package/dist/cjs/plugins/cause-serialize.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/plugins/cause-serialize.ts"],"sourcesContent":["import { Error0 } from '../index.js'\n\nexport const causeSerializePlugin = ({ hideWhenPublic = true }: { hideWhenPublic?: boolean } = {}) =>\n  Error0.plugin().cause({\n    serialize: ({ value, error, isPublic }) => {\n      if (hideWhenPublic && isPublic) {\n        return undefined\n      }\n      const ctor = error.constructor as typeof Error0\n      if (ctor.is(value)) {\n        return ctor.serialize(value, isPublic)\n      }\n      return undefined\n    },\n  })\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,eAAuB;AAEhB,MAAM,uBAAuB,CAAC,EAAE,iBAAiB,KAAK,IAAkC,CAAC,MAC9F,gBAAO,OAAO,EAAE,MAAM;AAAA,EACpB,WAAW,CAAC,EAAE,OAAO,OAAO,SAAS,MAAM;AACzC,QAAI,kBAAkB,UAAU;AAC9B,aAAO;AAAA,IACT;AACA,UAAM,OAAO,MAAM;AACnB,QAAI,KAAK,GAAG,KAAK,GAAG;AAClB,aAAO,KAAK,UAAU,OAAO,QAAQ;AAAA,IACvC;AACA,WAAO;AAAA,EACT;AACF,CAAC;","names":[]}

package/dist/cjs/plugins/cause-serialize.d.cts

@@ -1,7 +0,0 @@
-import { PluginError0 } from '../index.cjs';
-
-declare const causeSerializePlugin: ({ hideWhenPublic }?: {
-    hideWhenPublic?: boolean;
-}) => PluginError0<Record<never, never>, Record<never, never>>;
-
-export { causeSerializePlugin };