@dxos/errors 0.8.4-main.fd6878d → 0.8.4-main.fffef41

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/errors",
-  "version": "0.8.4-main.fd6878d",
+  "version": "0.8.4-main.fffef41",
   "description": "Error definitions",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",

package/src/base.ts

@@ -2,12 +2,14 @@
 // Copyright 2025 DXOS.org
 //
 
-export type BaseErrorOptions = {
+/**
+ * Options for creating a BaseError.
+ */
+export type BaseErrorOptions = ErrorOptions & {
   /**
-   * The cause of the error.
-   * An instance of Error.
+   * Override base message.
    */
-  cause?: unknown;
+  message?: string;
 
   /**
    * Structured details about the error.
@@ -21,56 +23,61 @@ export type BaseErrorOptions = {
 export class BaseError<Code extends string = string> extends Error {
   /**
    * Primary way of defining new error classes.
-   *
-   * Expample:
-   *
-   * ```ts
-   * export class AiInputPreprocessingError extends BaseError.extend('AI_INPUT_PREPROCESSING_ERROR') {}
-   * ```
+   * Extended class may specialize constructor for required context params.
+   * @param code - Error code.
+   * @param message - Default error message.
    */
-  static extend<Code extends string>(code: Code) {
-    return class extends BaseError<Code> {
+  static extend<Code extends string = string>(code: Code, message?: string) {
+    return class ExtendedError extends BaseError<Code> {
       static code = code;
 
       static is(error: unknown): error is BaseError {
         return typeof error === 'object' && error !== null && 'code' in error && error.code === code;
       }
 
-      static wrap(message: string, options?: Omit<BaseErrorOptions, 'cause'>) {
-        return (error: unknown) => new this(message, { ...options, cause: error });
+      static wrap(
+        options?: Omit<BaseErrorOptions, 'cause'> & { ifTypeDiffers?: boolean },
+      ): (error: unknown) => ExtendedError {
+        const wrapFn = (error: unknown) => {
+          if (options?.ifTypeDiffers === true && this.is(error)) {
+            return error as ExtendedError;
+          }
+          const newError: ExtendedError = new this({ message, ...options, cause: error });
+          Error.captureStackTrace(newError, wrapFn); // Position stack-trace to start from the caller of `wrap`.
+          return newError;
+        };
+        return wrapFn;
       }
 
-      constructor(message: string, options?: BaseErrorOptions) {
-        super(code, message, options);
+      constructor(options?: BaseErrorOptions) {
+        super(code, { message: options?.message ?? message, ...options });
       }
     };
   }
 
-  #code: Code;
-  #context: Record<string, unknown>;
+  // NOTE: Errors go through odd transformations and the private fields seem to break.
+  code: Code;
+  context: Record<string, unknown>;
 
-  constructor(code: Code, message: string, options?: BaseErrorOptions) {
-    super(message, options);
+  constructor(code: Code, options?: BaseErrorOptions) {
+    super(options?.message, { cause: options?.cause });
 
-    this.#code = code;
-    this.#context = options?.context ?? {};
+    this.code = code;
+    this.context = options?.context ?? {};
     Object.setPrototypeOf(this, new.target.prototype);
   }
 
   override get name() {
-    return this.#code;
+    return this.code;
   }
 
-  get code(): Code {
-    return this.#code;
+  /** Fallback message. */
+  override get message() {
+    return this.constructor.name;
   }
 
   // For effect error matching.
   get _tag(): Code {
-    return this.#code;
-  }
-
-  get context() {
-    return this.#context;
+    return this.code;
   }
 }

package/src/errors.test.ts

@@ -4,11 +4,12 @@
 
 import { describe, expect, test } from 'vitest';
 
+import { BaseError, type BaseErrorOptions } from './base';
 import { SystemError } from './errors';
 
 describe('errors', () => {
   test('error code and message, cause', () => {
-    const error = new SystemError('Test message', { cause: new Error('Test cause'), context: { a: 1, b: 2 } });
+    const error = new SystemError({ message: 'Test message', cause: new Error('Test cause'), context: { a: 1, b: 2 } });
     expect(error).toBeInstanceOf(SystemError);
     expect(error).toBeInstanceOf(SystemError);
     expect(error.code).toBe(SystemError.code);
@@ -24,19 +25,37 @@ describe('errors', () => {
       expect.fail('Expected error to be thrown');
     } catch (error: any) {
       expect(error).toBeInstanceOf(SystemError);
-      expect(String(error)).toEqual('SYSTEM_ERROR: Test message');
+      expect(String(error)).toEqual('SYSTEM: Test message');
       const stackLines = error.stack!.split('\n');
-      expect(stackLines?.[0]).toEqual('SYSTEM_ERROR: Test message');
+      expect(stackLines?.[0]).toEqual('SYSTEM: Test message');
       expect(stackLines?.[1]).toMatch(/^ {4}at two \(.*$/);
       expect(stackLines?.[2]).toMatch(/^ {4}at one \(.*$/);
     }
   });
+
+  test('custom message', () => {
+    class CustomError extends BaseError.extend('CUSTOM', 'Custom message') {
+      constructor(value: number, options?: Omit<BaseErrorOptions, 'context'>) {
+        super({ context: { value }, ...options });
+      }
+    }
+
+    const error = new CustomError(1);
+    expect(error).toBeInstanceOf(CustomError);
+    expect(error.message).toBe('Custom message');
+    expect(error.context).toEqual({ value: 1 });
+  });
+
+  test('is', () => {
+    const error = new SystemError({ message: 'Test message' });
+    expect(SystemError.is(error)).toBe(true);
+  });
 });
 
 const throwError = () => {
   const one = () => {
     const two = () => {
-      throw new SystemError('Test message');
+      throw new SystemError({ message: 'Test message' });
     };
     two();
   };

package/src/errors.ts

@@ -4,14 +4,14 @@
 
 import { BaseError } from './base';
 
-export class TimeoutError extends BaseError.extend('TIMEOUT') {}
+export class ApiError extends BaseError.extend('API', 'API error') {}
 
-export class AbortedError extends BaseError.extend('ABORTED') {}
+export class SystemError extends BaseError.extend('SYSTEM', 'System error') {}
 
-export class UnimplementedError extends BaseError.extend('UNIMPLEMENTED') {}
+export class InternalError extends BaseError.extend('INTERNAL', 'Internal error') {}
 
-export class ApiError extends BaseError.extend('API_ERROR') {}
+export class TimeoutError extends BaseError.extend('TIMEOUT', 'Timeout') {}
 
-export class SystemError extends BaseError.extend('SYSTEM_ERROR') {}
+export class AbortedError extends BaseError.extend('ABORTED', 'Aborted') {}
 
-export class InternalError extends BaseError.extend('INTERNAL_ERROR') {}
+export class NotImplementedError extends BaseError.extend('NOT_IMPLEMENTED', 'Not implemented') {}