@dxos/errors 0.8.4-main.dedc0f3 → 0.8.4-main.e098934

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/errors",
-  "version": "0.8.4-main.dedc0f3",
+  "version": "0.8.4-main.e098934",
   "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,14 +23,11 @@ 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) {
+  static extend<Code extends string = string>(code: Code, message?: string) {
     return class extends BaseError<Code> {
       static code = code;
 
@@ -36,12 +35,12 @@ export class BaseError<Code extends string = string> extends Error {
         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'>) {
+        return (error: unknown) => new this({ message, ...options, cause: error });
       }
 
-      constructor(message: string, options?: BaseErrorOptions) {
-        super(code, message, options);
+      constructor(options?: BaseErrorOptions) {
+        super(code, { message: options?.message ?? message, ...options });
       }
     };
   }
@@ -49,8 +48,8 @@ export class BaseError<Code extends string = string> extends Error {
   #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 ?? {};
@@ -61,6 +60,11 @@ export class BaseError<Code extends string = string> extends Error {
     return this.#code;
   }
 
+  /** Fallback message. */
+  override get message() {
+    return this.constructor.name;
+  }
+
   get code(): Code {
     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,16 +25,29 @@ 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('Test message');
+    const error = new SystemError({ message: 'Test message' });
     expect(SystemError.is(error)).toBe(true);
   });
 });
@@ -41,7 +55,7 @@ describe('errors', () => {
 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') {}