@dxos/errors 0.8.4-main.66e292d → 0.8.4-main.69d29f4

package/package.json

@@ -1,12 +1,16 @@
 {
   "name": "@dxos/errors",
-  "version": "0.8.4-main.66e292d",
+  "version": "0.8.4-main.69d29f4",
   "description": "Error definitions",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dxos/dxos"
+  },
   "license": "MIT",
   "author": "DXOS.org",
-  "sideEffects": true,
+  "sideEffects": false,
   "type": "module",
   "exports": {
     ".": {

package/src/base.ts

@@ -20,19 +20,19 @@ export type BaseErrorOptions = ErrorOptions & {
 /**
  * Base class for all DXOS errors.
  */
-export class BaseError<Code extends string = string> extends Error {
+export class BaseError<Name extends string = string> extends Error {
   /**
    * Primary way of defining new error classes.
    * Extended class may specialize constructor for required context params.
-   * @param code - Error code.
+   * @param name - Error name.
    * @param message - Default error message.
    */
-  static extend<Code extends string = string>(code: Code, message?: string) {
-    return class ExtendedError extends BaseError<Code> {
-      static code = code;
+  static extend<Name extends string = string>(name: Name, message?: string) {
+    return class ExtendedError extends BaseError<Name> {
+      static override name: Name = name;
 
       static is(error: unknown): error is BaseError {
-        return typeof error === 'object' && error !== null && 'code' in error && error.code === code;
+        return typeof error === 'object' && error !== null && 'name' in error && error.name === name;
       }
 
       static wrap(
@@ -50,34 +50,30 @@ export class BaseError<Code extends string = string> extends Error {
       }
 
       constructor(options?: BaseErrorOptions) {
-        super(code, { message: options?.message ?? message, ...options });
+        super(name, { message: options?.message ?? message, ...options });
       }
     };
   }
 
   // NOTE: Errors go through odd transformations and the private fields seem to break.
-  code: Code;
+  override name: Name;
   context: Record<string, unknown>;
 
-  constructor(code: Code, options?: BaseErrorOptions) {
+  constructor(name: Name, options?: BaseErrorOptions) {
     super(options?.message, { cause: options?.cause });
 
-    this.code = code;
+    this.name = name;
     this.context = options?.context ?? {};
     Object.setPrototypeOf(this, new.target.prototype);
   }
 
-  override get name() {
-    return this.code;
-  }
-
   /** Fallback message. */
   override get message() {
     return this.constructor.name;
   }
 
   // For effect error matching.
-  get _tag(): Code {
-    return this.code;
+  get _tag(): Name {
+    return this.name;
   }
 }

package/src/errors.test.ts

@@ -12,7 +12,8 @@ describe('errors', () => {
     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);
+    expect(error.name).toBe(SystemError.name);
+    expect(error._tag).toBe(SystemError.name);
     expect(error.message).toBe('Test message');
     expect(error.cause).toBeInstanceOf(Error);
     expect((error.cause as Error).message).toBe('Test cause');
@@ -25,16 +26,16 @@ describe('errors', () => {
       expect.fail('Expected error to be thrown');
     } catch (error: any) {
       expect(error).toBeInstanceOf(SystemError);
-      expect(String(error)).toEqual('SYSTEM: Test message');
+      expect(String(error)).toEqual('SystemError: Test message');
       const stackLines = error.stack!.split('\n');
-      expect(stackLines?.[0]).toEqual('SYSTEM: Test message');
+      expect(stackLines?.[0]).toEqual('SystemError: 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') {
+    class CustomError extends BaseError.extend('CustomError', 'Custom message') {
       constructor(value: number, options?: Omit<BaseErrorOptions, 'context'>) {
         super({ context: { value }, ...options });
       }

package/src/errors.ts

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