@owlmeans/error 0.1.18-rc.8 → 0.1.18

package/src/utils.ts

@@ -1,6 +1,28 @@
-import { ResilientError } from './resilient.js'
+import { ResilientError } from './errors.js'
 import type { Converter, ResilientErrorConstructor } from './types.js'
 
+const unmarshal = <T extends ResilientError = ResilientError>(errorClass: ResilientErrorConstructor) =>
+  (err: Error): T => {
+    if (err instanceof errorClass) {
+      return err as T
+    }
+    const fields = err.message.split(ResilientError.separator, 4)
+    if (fields.length < 2) {
+      throw SyntaxError('Invalid marshaled error')
+    }
+    const [type, message, stack, incidentId] = fields
+    // The base constructor takes (type, message, stack); subclasses take (message, stack).
+    // Keeping the base's wire type in place avoids shifting a plain Error's message into `type`.
+    const error = errorClass === ResilientError
+      ? new errorClass(type, message, stack)
+      : new errorClass(message, stack)
+    error.type = type
+    error.message = message
+    error.incidentId = incidentId
+    error.finalizeUnmarshal()
+    return error as T
+  }
+
 export const createErrorConverter = (
   resilientErrorClass: ResilientErrorConstructor,
   errorClass?: ErrorConstructor
@@ -13,23 +35,3 @@ export const createErrorConverter = (
     unmarshal: unmarshal(resilientErrorClass)
   }
 }
-
-export const unmarshal = <T extends ResilientError = ResilientError>(errorClass: ResilientErrorConstructor) =>
-  (err: Error): T => {
-    if (err instanceof errorClass) {
-      return err as T
-    }
-    const args = err.message.split(ResilientError.separator, 3) as [string, string, string?]
-    if (args.length < 2) {
-      throw SyntaxError('Invalid marshaled error')
-    }
-
-    if (args[0] === errorClass.typeName) {
-      args.shift()
-    }
-
-    const error = new errorClass(...args)
-    error.message = args[0]
-    error.finalizeUnmarshal()
-    return error as T
-  }

package/tests/copies.spec.ts

@@ -0,0 +1,138 @@
+import { afterAll, beforeAll, describe, expect, test } from 'bun:test'
+import { cpSync, mkdtempSync, rmSync, symlinkSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join, resolve } from 'node:path'
+
+type Lib = typeof import('../src/index.js')
+
+/**
+ * Two module instances of this package in one process — what `bun --preserve-symlinks` produces
+ * when a linked workspace reaches `@owlmeans/error` through two `node_modules` paths.
+ *
+ * The sources are copied to two directories, so every module of the package (not only the entry)
+ * is loaded twice. `@owlmeans/i18n` resolves through a `node_modules` link to the workspace root.
+ */
+const loadTwice = async (): Promise<{ root: string, a: Lib, b: Lib }> => {
+  const root = mkdtempSync(join(tmpdir(), 'owlmeans-error-copies-'))
+  const workspaceModules = resolve(import.meta.dir, '../../../node_modules')
+  for (const name of ['a', 'b']) {
+    cpSync(resolve(import.meta.dir, '../src'), join(root, name, 'src'), { recursive: true })
+    symlinkSync(workspaceModules, join(root, name, 'node_modules'))
+  }
+  const a = await import(join(root, 'a', 'src', 'index.ts')) as Lib
+  const b = await import(join(root, 'b', 'src', 'index.ts')) as Lib
+
+  return { root, a, b }
+}
+
+/** The same family declared by each copy, the way two copies of one package declare it. */
+const familyOf = (lib: Lib) => {
+  class CopyApiError extends lib.ResilientError {
+    public static override typeName = 'CopyTestApiError'
+
+    constructor(message: string = 'error') {
+      super(CopyApiError.typeName, `copy-api:${message}`)
+    }
+  }
+
+  class CopyAuthFailed extends CopyApiError {
+    public static override typeName = 'CopyTestAuthFailedError'
+
+    constructor(message: string = 'error') {
+      super(`auth:${message}`)
+      this.type = CopyAuthFailed.typeName
+    }
+  }
+
+  class CopyAccess extends CopyApiError {
+    public static override typeName = 'CopyTestAccessError'
+
+    constructor(message: string = 'error') {
+      super(`access:${message}`)
+      this.type = CopyAccess.typeName
+    }
+  }
+
+  lib.ResilientError.registerErrorClass(CopyApiError)
+  lib.ResilientError.registerErrorClass(CopyAuthFailed)
+  lib.ResilientError.registerErrorClass(CopyAccess)
+
+  return { CopyApiError, CopyAuthFailed, CopyAccess }
+}
+
+describe('duplicate module copies behave as one', () => {
+  let root = ''
+  let a: Lib
+  let b: Lib
+  let A: ReturnType<typeof familyOf>
+  let B: ReturnType<typeof familyOf>
+
+  beforeAll(async () => {
+    ({ root, a, b } = await loadTwice())
+    A = familyOf(a)
+    B = familyOf(b)
+  })
+
+  afterAll(() => {
+    if (root !== '') {
+      rmSync(root, { recursive: true, force: true })
+    }
+  })
+
+  test('the two copies are distinct module instances sharing one registry', () => {
+    expect(a.ResilientError).not.toBe(b.ResilientError)
+    expect(a.ResilientError.converters).toBe(b.ResilientError.converters)
+    const catchAll = Symbol.for('@owlmeans/error:catch-all')
+    expect(b.ResilientError.converters.filter(converter => (converter as any)[catchAll] === true)).toHaveLength(1)
+  })
+
+  test('an error thrown by copy A is ensured as-is and marshalled with its type by copy B', () => {
+    const thrown = new A.CopyAuthFailed('no-guard')
+
+    expect(b.ResilientError.ensure(thrown)).toBe(thrown)
+    expect(b.isResilientError(thrown)).toBe(true)
+    const wire = b.ResilientError.marshal(b.ResilientError.ensure(thrown)).message
+    expect(wire.split(b.SEPARATOR).slice(0, 2)).toEqual(['CopyTestAuthFailedError', 'copy-api:auth:no-guard'])
+
+    const rebuilt = b.ResilientError.ensure(wire)
+    // The last registration of the type name wins — copy B registered after copy A.
+    expect(rebuilt.constructor).toBe(B.CopyAuthFailed)
+    expect(rebuilt).toBeInstanceOf(A.CopyAuthFailed)
+    expect(rebuilt.type).toBe('CopyTestAuthFailedError')
+    expect(rebuilt.message).toBe('copy-api:auth:no-guard')
+  })
+
+  test('a class registered by one copy only is rebuilt by the other', () => {
+    class OnlyInA extends a.ResilientError {
+      public static override typeName = 'CopyTestOnlyInA'
+
+      constructor(message: string = 'error') {
+        super(OnlyInA.typeName, `only-a:${message}`)
+      }
+    }
+    a.ResilientError.registerErrorClass(OnlyInA)
+
+    const rebuilt = b.ResilientError.ensure(new OnlyInA('x').marshal().message)
+    expect(rebuilt).toBeInstanceOf(OnlyInA)
+    expect(rebuilt.message).toBe('only-a:x')
+  })
+
+  test('instanceof across copies matches the class and its ancestors, never a sibling or a parent', () => {
+    const thrown = new A.CopyAuthFailed('x')
+    expect(thrown instanceof B.CopyAuthFailed).toBe(true)
+    expect(thrown instanceof B.CopyApiError).toBe(true)
+    expect(thrown instanceof b.ResilientError).toBe(true)
+    expect(thrown instanceof B.CopyAccess).toBe(false)
+    expect(new A.CopyApiError('x') instanceof B.CopyAuthFailed).toBe(false)
+
+    // A subclass without a type name of its own is matched natively only.
+    class Unnamed extends B.CopyAuthFailed { }
+    expect(new A.CopyAuthFailed('x') instanceof Unnamed).toBe(false)
+    expect(new Unnamed('x') instanceof A.CopyAuthFailed).toBe(true)
+
+    // Shape alone is not a resilient error: the brand is.
+    const lookalike = Object.assign(new Error('x'), { type: 'CopyTestAuthFailedError', marshal: () => new Error('x') })
+    expect(lookalike instanceof b.ResilientError).toBe(false)
+    expect(b.ResilientError.ensure(lookalike)).not.toBe(lookalike)
+  })
+})

package/tests/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "extends": [
+    "@owlmeans/dep-config/tsconfig.base.json",
+    "@owlmeans/dep-config/tsconfig.node.json"
+  ],
+  "compilerOptions": {
+    "types": [
+      "bun"
+    ],
+    "rootDir": "../",
+    "noEmit": true
+  },
+  "include": [
+    "./**/*",
+    "../src/**/*"
+  ]
+}

package/tsconfig.json

@@ -6,5 +6,5 @@
     "rootDir": "./src/",
     "outDir": "./build/"
   },
-  "exclude": ["./dist/**/*", "./build/**/*", "./*.ts"]
+  "exclude": ["./dist/**/*", "./build/**/*", "./tests/**/*", "./*.ts"]
 }

package/src/resilient.ts

@@ -1,81 +0,0 @@
-import { RESILENT_ERROR, SEPARATOR } from './consts.js'
-import type { Converter, ResilientErrorConstructor } from './types.js'
-import { createErrorConverter } from './utils.js'
-
-export class ResilientError extends Error {
-  public static separator: string = SEPARATOR
-
-  public static typeName: string = RESILENT_ERROR
-
-  public static converters: Converter[] = []
-
-  public static registerErrorClass(resilientErrorClass: ResilientErrorConstructor, errorClass?: ErrorConstructor): Converter {
-    const converter = createErrorConverter(resilientErrorClass, errorClass)
-    this.converters.push(converter)
-
-    return converter
-  }
-
-  public static ensure(err: Error | string, throwOnUnknown?: boolean): ResilientError {
-    err = typeof err === 'string' ? new Error(err) : err
-    if (err instanceof ResilientError) {
-      return err
-    }
-
-    // We don't proceed SyntaxError - system should crash in this case
-    if (err instanceof SyntaxError) {
-      throw err
-    }
-
-    // Umarshal marhalled error that is wrapepd to ordinary error
-    const unmarhaller = this.converters.toReversed().find(converter => converter.isMarshaled(err))
-    if (unmarhaller != null) {
-      return unmarhaller.unmarshal(err)
-    }
-
-    // Convert object of Error subtypes to ResilientError subtype
-    const converter = this.converters.find(converter => converter.match(err))
-    if (converter != null) {
-      return converter.convert(err)
-    }
-
-    if (throwOnUnknown === true) {
-      throw err
-    }
-
-    return new ResilientError(this.typeName, err.message, err.stack)
-  }
-
-  public static marshal(err: Error): Error {
-    if (err instanceof ResilientError) {
-      return new Error([err.type, err.message, err.oiriginalStack].join(this.separator))
-    }
-
-    return new Error([this.typeName, err.message, err.stack].join(this.separator))
-  }
-
-  public type: string = RESILENT_ERROR
-
-  public oiriginalStack?: string
-
-  constructor(type: string, message: string, stack?: string) {
-    super(message)
-    this.type = type
-    if (stack != null) {
-      this.oiriginalStack = stack
-    } else {
-      this.oiriginalStack = this.stack
-    }
-  }
-
-  marshal(): Error {
-    return ResilientError.marshal(this)
-  }
-
-  finalizeUnmarshal(): void { }
-}
-
-ResilientError.converters.push({
-  ...createErrorConverter(ResilientError as ResilientErrorConstructor),
-  match: () => true
-})