@travetto/runtime 7.0.0-rc.1 → 7.0.0-rc.3

package/README.md

@@ -19,6 +19,7 @@ Runtime is the foundation of all [Travetto](https://travetto.dev) applications.
    *  Standard Error Support
    *  Console Management
    *  Resource Access
+   *  JSON Utilities
    *  Common Utilities
    *  Time Utilities
    *  Process Execution
@@ -38,8 +39,6 @@ class $Runtime {
   get env(): string | undefined;
   /** Are we in development mode */
   get production(): boolean;
-  /** Is the app in dynamic mode? */
-  get dynamic(): boolean;
   /** Get debug value */
   get debug(): false | string;
   /** Manifest main */
@@ -51,11 +50,11 @@ class $Runtime {
   /** Main source path */
   get mainSourcePath(): string;
   /** Produce a workspace relative path */
-  workspaceRelative(...rel: string[]): string;
+  workspaceRelative(...parts: string[]): string;
   /** Strip off the workspace path from a file */
   stripWorkspacePath(full: string): string;
   /** Produce a workspace path for tooling, with '@' being replaced by node_module/name folder */
-  toolPath(...rel: string[]): string;
+  toolPath(...parts: string[]): string;
   /** Resolve single module path */
   modulePath(modulePath: string, overrides?: Record<string, string>): string;
   /** Resolve resource paths */
@@ -95,10 +94,6 @@ interface EnvData {
      * Special role to run as, used to access additional files from the manifest during runtime.  
      */
     TRV_ROLE: Role;
-    /** 
-     * Whether or not to run the program in dynamic mode, allowing for real-time updates  
-     */
-    TRV_DYNAMIC: boolean;
     /** 
      * The folders to use for resource lookup
      */
@@ -145,9 +140,9 @@ export class EnvProp<T> {
   /** Remove value */
   clear(): void;
   /** Export value */
-  export(val?: T | undefined | null): Record<string, string>;
+  export(value?: T | undefined | null): Record<string, string>;
   /** Read value as string */
-  get val(): string | undefined;
+  get value(): string | undefined;
   /** Read value as list */
   get list(): string[] | undefined;
   /** Read value as object */
@@ -204,8 +199,8 @@ export function work() {
 
   try {
     1 / 0;
-  } catch (err) {
-    console.error('Divide by zero', { error: err });
+  } catch (error) {
+    console.error('Divide by zero', { error });
   }
   console.debug('End Work');
 }
@@ -225,12 +220,12 @@ function work() {
     try {
         1 / 0;
     }
-    catch (err) {
-        Δconsole.log({ level: "error", import: mod_1, line: 7, scope: "work", args: ['Divide by zero', { error: err }] });
+    catch (error) {
+        Δconsole.log({ level: "error", import: mod_1, line: 7, scope: "work", args: ['Divide by zero', { error }] });
     }
     Δconsole.log({ level: "debug", import: mod_1, line: 9, scope: "work", args: ['End Work'] });
 }
-Δfunction.registerFunction(work, mod_1, { hash: 1030247697, lines: [1, 10, 2] });
+Δfunction.registerFunction(work, mod_1, { hash: 159357293, lines: [1, 10, 2] });
 ```
 
 #### Filtering Debug
@@ -258,9 +253,18 @@ $ DEBUG=express:*,@travetto/web npx trv run web
 ## Resource Access
 The primary access patterns for resources, is to directly request a file, and to resolve that file either via file-system look up or leveraging the [Manifest](https://github.com/travetto/travetto/tree/main/module/manifest#readme "Support for project indexing, manifesting, along with file watching")'s data for what resources were found at manifesting time.
 
-The [FileLoader](https://github.com/travetto/travetto/tree/main/module/runtime/src/file-loader.ts#L11) allows for accessing information about the resources, and subsequently reading the file as text/binary or to access the resource as a `Readable` stream.  If a file is not found, it will throw an [AppError](https://github.com/travetto/travetto/tree/main/module/runtime/src/error.ts#L26) with a category of 'notfound'.  
+The [FileLoader](https://github.com/travetto/travetto/tree/main/module/runtime/src/file-loader.ts#L12) allows for accessing information about the resources, and subsequently reading the file as text/binary or to access the resource as a `Readable` stream.  If a file is not found, it will throw an [AppError](https://github.com/travetto/travetto/tree/main/module/runtime/src/error.ts#L26) with a category of 'notfound'.  
+
+The [FileLoader](https://github.com/travetto/travetto/tree/main/module/runtime/src/file-loader.ts#L12) also supports tying itself to [Env](https://github.com/travetto/travetto/tree/main/module/runtime/src/env.ts#L114)'s `TRV_RESOURCES` information on where to attempt to find a requested resource.
+
+## JSON Utilities
+The framework provides utilities for working with JSON data.  This module provides methods for reading and writing JSON files, as well as serializing and deserializing JSON data.  It also provides support for working with Base64 encoded data for web safe transfer.  The primary goal is ease of use, but also a centralized location for performance and security improvements over time.
 
-The [FileLoader](https://github.com/travetto/travetto/tree/main/module/runtime/src/file-loader.ts#L11) also supports tying itself to [Env](https://github.com/travetto/travetto/tree/main/module/runtime/src/env.ts#L114)'s `TRV_RESOURCES` information on where to attempt to find a requested resource.
+   *  `parseSafe(input: string | Buffer)` parses JSON safely from a string or Buffer.
+   *  `stringifyBase64(value: any)` encodes a JSON value as a base64 encoded string.
+   *  `parseBase64(input: string)` decodes a JSON value from a base64 encoded string.
+   *  `readFile(file: string)` reads a JSON file asynchronously.
+   *  `readFileSync(file: string, onMissing?: any)` reads a JSON file synchronously.
 
 ## Common Utilities
 Common utilities used throughout the framework. Currently [Util](https://github.com/travetto/travetto/tree/main/module/runtime/src/util.ts#L12) includes:
@@ -271,7 +275,7 @@ Common utilities used throughout the framework. Currently [Util](https://github.
 
 **Code: Sample makeTemplate Usage**
 ```typescript
-const tpl = makeTemplate((name: 'age'|'name', val) => `**${name}: ${val}**`); 
+const tpl = makeTemplate((name: 'age'|'name', value) => `**${name}: ${value}**`); 
 tpl`{{age:20}} {{name: 'bob'}}</>;
 // produces
 '**age: 20** **name: bob**'
@@ -287,7 +291,7 @@ export class TimeUtil {
    * Test to see if a string is valid for relative time
    * @param val
    */
-  static isTimeSpan(val: string): val is TimeSpan;
+  static isTimeSpan(value: string): value is TimeSpan;
   /**
    * Returns time units convert to ms
    * @param amount Number of units to extend
@@ -323,7 +327,7 @@ export class TimeUtil {
 ```
 
 ## Process Execution
-[ExecUtil](https://github.com/travetto/travetto/tree/main/module/runtime/src/exec.ts#L43) exposes `getResult` as a means to wrap [child_process](https://nodejs.org/api/child_process.html)'s process object.  This wrapper allows for a promise-based resolution of the subprocess with the ability to capture the stderr/stdout.
+[ExecUtil](https://github.com/travetto/travetto/tree/main/module/runtime/src/exec.ts#L40) exposes `getResult` as a means to wrap [child_process](https://nodejs.org/api/child_process.html)'s process object.  This wrapper allows for a promise-based resolution of the subprocess with the ability to capture the stderr/stdout.
 
 A simple example would be:
 

package/__index__.ts

@@ -9,6 +9,7 @@ export * from './src/exec.ts';
 export * from './src/env.ts';
 export * from './src/file-loader.ts';
 export * from './src/function.ts';
+export * from './src/json.ts';
 export * from './src/manifest-index.ts';
 export * from './src/queue.ts';
 export * from './src/resources.ts';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/runtime",
-  "version": "7.0.0-rc.1",
+  "version": "7.0.0-rc.3",
   "description": "Runtime for travetto applications.",
   "keywords": [
     "console-manager",
@@ -25,12 +25,12 @@
     "directory": "module/runtime"
   },
   "dependencies": {
-    "@travetto/manifest": "^7.0.0-rc.0",
+    "@travetto/manifest": "^7.0.0-rc.2",
     "@types/debug": "^4.1.12",
     "debug": "^4.4.3"
   },
   "peerDependencies": {
-    "@travetto/transformer": "^7.0.0-rc.1"
+    "@travetto/transformer": "^7.0.0-rc.3"
   },
   "peerDependenciesMeta": {
     "@travetto/transformer": {

package/src/binary.ts

@@ -24,27 +24,27 @@ export class BinaryUtil {
   /** Is ReadableStream */
   static isReadableStream = hasFunction<ReadableStream>('pipeTo');
   /** Is Async Iterable */
-  static isAsyncIterable = (v: unknown): v is AsyncIterable<unknown> =>
-    !!v && (typeof v === 'object' || typeof v === 'function') && Symbol.asyncIterator in v;
+  static isAsyncIterable = (value: unknown): value is AsyncIterable<unknown> =>
+    !!value && (typeof value === 'object' || typeof value === 'function') && Symbol.asyncIterator in value;
 
   /**
-   * Is src a binary type
+   * Is value a binary type
    */
-  static isBinaryType(src: unknown): boolean {
-    return src instanceof Blob || Buffer.isBuffer(src) || this.isReadable(src) ||
-      this.isArrayBuffer(src) || this.isReadableStream(src) || this.isAsyncIterable(src);
+  static isBinaryType(value: unknown): boolean {
+    return value instanceof Blob || Buffer.isBuffer(value) || this.isReadable(value) ||
+      this.isArrayBuffer(value) || this.isReadableStream(value) || this.isAsyncIterable(value);
   }
 
   /**
-   * Generate a proper sha512 hash from a src value
-   * @param src The seed value to build the hash from
-   * @param len The optional length of the hash to generate
+   * Generate a proper sha512 hash from an input value
+   * @param input The seed value to build the hash from
+   * @param length The optional length of the hash to generate
    */
-  static hash(src: string, len: number = -1): string {
+  static hash(input: string, length: number = -1): string {
     const hash = crypto.createHash('sha512');
-    hash.update(src);
+    hash.update(input);
     const digest = hash.digest('hex');
-    return len > 0 ? digest.substring(0, len) : digest;
+    return length > 0 ? digest.substring(0, length) : digest;
   }
 
   /**
@@ -88,7 +88,7 @@ export class BinaryUtil {
   static readableBlob(input: () => (Readable | Promise<Readable>), metadata: BlobMeta = {}): Blob | File {
     const go = (): Readable => {
       const stream = new PassThrough();
-      Promise.resolve(input()).then(v => v.pipe(stream), (err) => stream.destroy(err));
+      Promise.resolve(input()).then(readable => readable.pipe(stream), (error) => stream.destroy(error));
       return stream;
     };
 
@@ -102,7 +102,7 @@ export class BinaryUtil {
       stream: { value: () => ReadableStream.from(go()) },
       arrayBuffer: { value: () => toArrayBuffer(go()) },
       text: { value: () => toText(go()) },
-      bytes: { value: () => toArrayBuffer(go()).then(v => new Uint8Array(v)) },
+      bytes: { value: () => toArrayBuffer(go()).then(buffer => new Uint8Array(buffer)) },
       [BlobMetaSymbol]: { value: metadata }
     });
   }

package/src/console.ts

@@ -27,10 +27,10 @@ export interface ConsoleEvent {
  * @concrete
  */
 export interface ConsoleListener {
-  log(ev: ConsoleEvent): void;
+  log(event: ConsoleEvent): void;
 }
 
-const DEBUG_OG = { formatArgs: debug.formatArgs, log: debug.log };
+const DEBUG_HANDLE = { formatArgs: debug.formatArgs, log: debug.log };
 
 /**
  * Provides a general abstraction against the console.* methods to allow for easier capture and redirection.
@@ -50,7 +50,7 @@ class $ConsoleManager implements ConsoleListener {
   /**
    * List of logging filters
    */
-  #filters: Partial<Record<ConsoleEvent['level'], (x: ConsoleEvent) => boolean>> = {};
+  #filters: Partial<Record<ConsoleEvent['level'], (event: ConsoleEvent) => boolean>> = {};
 
   constructor(listener: ConsoleListener) {
     this.set(listener);
@@ -66,8 +66,8 @@ class $ConsoleManager implements ConsoleListener {
   filter(level: ConsoleEvent['level'], filter?: boolean | ((ctx: ConsoleEvent) => boolean)): void {
     if (filter !== undefined) {
       if (typeof filter === 'boolean') {
-        const v = filter;
-        filter = (): boolean => v;
+        const filterValue = filter;
+        filter = (): boolean => filterValue;
       }
       this.#filters[level] = filter;
     } else {
@@ -90,8 +90,8 @@ class $ConsoleManager implements ConsoleListener {
         args: [util.format(...args)], line: 0, timestamp: new Date()
       });
     } else {
-      debug.formatArgs = DEBUG_OG.formatArgs;
-      debug.log = DEBUG_OG.log;
+      debug.formatArgs = DEBUG_HANDLE.formatArgs;
+      debug.log = DEBUG_HANDLE.log;
     }
   }
 
@@ -111,18 +111,18 @@ class $ConsoleManager implements ConsoleListener {
   /**
    * Handle direct call in lieu of the console.* commands
    */
-  log(ev: ConsoleEvent & { import?: [string, string] }): void {
-    const outEv = {
-      ...ev,
+  log(event: ConsoleEvent & { import?: [string, string] }): void {
+    const result = {
+      ...event,
       timestamp: new Date(),
-      module: ev.module ?? ev.import?.[0],
-      modulePath: ev.modulePath ?? ev.import?.[1]
+      module: event.module ?? event.import?.[0],
+      modulePath: event.modulePath ?? event.import?.[1]
     };
 
-    if (this.#filters[outEv.level] && !this.#filters[outEv.level]!(outEv)) {
+    if (this.#filters[result.level] && !this.#filters[result.level]!(result)) {
       return; // Do nothing
     } else {
-      return this.#listener.log(outEv);
+      return this.#listener.log(result);
     }
   }
 
@@ -141,5 +141,5 @@ class $ConsoleManager implements ConsoleListener {
   }
 }
 
-export const ConsoleManager = new $ConsoleManager({ log(ev): void { console![ev.level](...ev.args); } });
+export const ConsoleManager = new $ConsoleManager({ log(event): void { console![event.level](...event.args); } });
 export const log = ConsoleManager.log.bind(ConsoleManager);

package/src/context.ts

@@ -7,6 +7,7 @@ import { Env } from './env.ts';
 import { RuntimeIndex } from './manifest-index.ts';
 import { describeFunction } from './function.ts';
 import { castTo } from './types.ts';
+import { JSONUtil } from './json.ts';
 
 /** Constrained version of {@type ManifestContext} */
 class $Runtime {
@@ -28,7 +29,7 @@ class $Runtime {
 
   /** Get env name, with support for the default env */
   get env(): string | undefined {
-    return Env.TRV_ENV.val || (!this.production ? this.#idx.manifest.workspace.defaultEnv : undefined);
+    return Env.TRV_ENV.value || (!this.production ? this.#idx.manifest.workspace.defaultEnv : undefined);
   }
 
   /** Are we in development mode */
@@ -36,15 +37,10 @@ class $Runtime {
     return process.env.NODE_ENV === 'production';
   }
 
-  /** Is the app in dynamic mode? */
-  get dynamic(): boolean {
-    return Env.TRV_DYNAMIC.isTrue;
-  }
-
   /** Get debug value */
   get debug(): false | string {
-    const val = Env.DEBUG.val ?? '';
-    return (!val && this.production) || Env.DEBUG.isFalse ? false : val;
+    const value = Env.DEBUG.value ?? '';
+    return (!value && this.production) || Env.DEBUG.isFalse ? false : value;
   }
 
   /** Manifest main */
@@ -68,8 +64,8 @@ class $Runtime {
   }
 
   /** Produce a workspace relative path */
-  workspaceRelative(...rel: string[]): string {
-    return path.resolve(this.workspace.path, ...rel);
+  workspaceRelative(...parts: string[]): string {
+    return path.resolve(this.workspace.path, ...parts);
   }
 
   /** Strip off the workspace path from a file */
@@ -78,23 +74,23 @@ class $Runtime {
   }
 
   /** Produce a workspace path for tooling, with '@' being replaced by node_module/name folder */
-  toolPath(...rel: string[]): string {
-    rel = rel.flatMap(x => x === '@' ? ['node_modules', this.#idx.manifest.main.name] : [x]);
-    return path.resolve(this.workspace.path, this.#idx.manifest.build.toolFolder, ...rel);
+  toolPath(...parts: string[]): string {
+    parts = parts.flatMap(part => part === '@' ? ['node_modules', this.#idx.manifest.main.name] : [part]);
+    return path.resolve(this.workspace.path, this.#idx.manifest.build.toolFolder, ...parts);
   }
 
   /** Resolve single module path */
   modulePath(modulePath: string, overrides?: Record<string, string>): string {
     const combined = { ...this.#resourceOverrides, ...overrides };
     const [base, sub] = (combined[modulePath] ?? modulePath)
-      .replace(/^([^#]*)(#|$)/g, (_, v, r) => `${this.#moduleAliases[v] ?? v}${r}`)
+      .replace(/^([^#]*)(#|$)/g, (_, module, relativePath) => `${this.#moduleAliases[module] ?? module}${relativePath}`)
       .split('#');
     return path.resolve(this.#idx.getModule(base)?.sourcePath ?? base, sub ?? '.');
   }
 
   /** Resolve resource paths */
   resourcePaths(paths: string[] = []): string[] {
-    return [...new Set([...paths, ...Env.TRV_RESOURCES.list ?? [], '@#resources', '@@#resources'].map(v => this.modulePath(v)))];
+    return [...new Set([...paths, ...Env.TRV_RESOURCES.list ?? [], '@#resources', '@@#resources'].map(module => this.modulePath(module)))];
   }
 
   /** Get source for function */
@@ -118,10 +114,10 @@ class $Runtime {
       throw new Error(`Unable to find ${imp}, not in the manifest`);
     } else if (imp.endsWith('.json')) {
       imp = this.#idx.getFromImport(imp)?.sourceFile ?? imp;
-      return fs.readFile(imp, 'utf8').then(JSON.parse);
+      return fs.readFile(imp, 'utf8').then(JSONUtil.parseSafe<T>);
     }
 
-    if (!ManifestModuleUtil.SOURCE_EXT_RE.test(imp)) {
+    if (!ManifestModuleUtil.SOURCE_EXT_REGEX.test(imp)) {
       if (imp.startsWith('@')) {
         if (/[/].*?[/]/.test(imp)) {
           imp = `${imp}.ts`;
@@ -132,16 +128,16 @@ class $Runtime {
     }
 
     imp = ManifestModuleUtil.withOutputExtension(imp);
-    const res = await import(imp);
-    if (res?.default?.default) {
+    const imported = await import(imp);
+    if (imported?.default?.default) {
       // Unpack default.default, typescript does this in a way that requires recreating the whole object
-      const def = res?.default?.default;
+      const def = imported?.default?.default;
       return Object.defineProperties(castTo({}), {
-        ...Object.getOwnPropertyDescriptors(res),
+        ...Object.getOwnPropertyDescriptors(imported),
         default: { get: () => def, configurable: false }
       });
     }
-    return res;
+    return imported;
   }
 }
 

package/src/env.ts

@@ -9,12 +9,12 @@ export class EnvProp<T> {
   readonly key: string;
   constructor(key: string) { this.key = key; }
 
-  /** Set value according to prop type */
-  set(val: T | undefined | null): void {
-    if (val === undefined || val === null) {
+  /** Set value according to type */
+  set(value: T | undefined | null): void {
+    if (value === undefined || value === null) {
       delete process.env[this.key];
     } else {
-      process.env[this.key] = Array.isArray(val) ? `${val.join(',')}` : `${val}`;
+      process.env[this.key] = Array.isArray(value) ? `${value.join(',')}` : `${value}`;
     }
   }
 
@@ -24,36 +24,36 @@ export class EnvProp<T> {
   }
 
   /** Export value */
-  export(val?: T | undefined | null): Record<string, string> {
+  export(value?: T | undefined | null): Record<string, string> {
     let out: string;
     if (arguments.length === 0) { // If nothing passed in
-      out = `${this.val}`;
-    } else if (val === undefined || val === null) {
+      out = `${this.value}`;
+    } else if (value === undefined || value === null) {
       out = '';
-    } else if (Array.isArray(val)) {
-      out = val.join(',');
-    } else if (typeof val === 'object') {
-      out = Object.entries(val).map(([k, v]) => `${k}=${v}`).join(',');
+    } else if (Array.isArray(value)) {
+      out = value.join(',');
+    } else if (typeof value === 'object') {
+      out = Object.entries(value).map(([key, keyValue]) => `${key}=${keyValue}`).join(',');
     } else {
-      out = `${val}`;
+      out = `${value}`;
     }
     return { [this.key]: out };
   }
 
   /** Read value as string */
-  get val(): string | undefined { return process.env[this.key] || undefined; }
+  get value(): string | undefined { return process.env[this.key] || undefined; }
 
   /** Read value as list */
   get list(): string[] | undefined {
-    const val = this.val;
-    return (val === undefined || val === '') ?
-      undefined : val.split(/[, ]+/g).map(x => x.trim()).filter(x => !!x);
+    const value = this.value;
+    return (value === undefined || value === '') ?
+      undefined : value.split(/[, ]+/g).map(item => item.trim()).filter(item => !!item);
   }
 
   /** Read value as object */
   get object(): Record<string, string> | undefined {
     const items = this.list;
-    return items ? Object.fromEntries(items.map(x => x.split(/[:=]/g))) : undefined;
+    return items ? Object.fromEntries(items.map(item => item.split(/[:=]/g))) : undefined;
   }
 
   /** Add values to list */
@@ -63,35 +63,35 @@ export class EnvProp<T> {
 
   /** Read value as int  */
   get int(): number | undefined {
-    const vi = parseInt(this.val ?? '', 10);
-    return Number.isNaN(vi) ? undefined : vi;
+    const parsed = parseInt(this.value ?? '', 10);
+    return Number.isNaN(parsed) ? undefined : parsed;
   }
 
   /** Read value as boolean */
   get bool(): boolean | undefined {
-    const val = this.val;
-    return (val === undefined || val === '') ? undefined : IS_TRUE.test(val);
+    const value = this.value;
+    return (value === undefined || value === '') ? undefined : IS_TRUE.test(value);
   }
 
   /** Determine if the underlying value is truthy */
   get isTrue(): boolean {
-    return IS_TRUE.test(this.val ?? '');
+    return IS_TRUE.test(this.value ?? '');
   }
 
   /** Determine if the underlying value is falsy */
   get isFalse(): boolean {
-    return IS_FALSE.test(this.val ?? '');
+    return IS_FALSE.test(this.value ?? '');
   }
 
   /** Determine if the underlying value is set */
   get isSet(): boolean {
-    const val = this.val;
-    return val !== undefined && val !== '';
+    const value = this.value;
+    return value !== undefined && value !== '';
   }
 }
 
 type AllType = {
-  [K in keyof EnvData]: Pick<EnvProp<EnvData[K]>, 'key' | 'export' | 'val' | 'set' | 'clear' | 'isSet' |
+  [K in keyof EnvData]: Pick<EnvProp<EnvData[K]>, 'key' | 'export' | 'value' | 'set' | 'clear' | 'isSet' |
     (EnvData[K] extends unknown[] ? 'list' | 'add' : never) |
     (Extract<EnvData[K], object> extends never ? never : 'object') |
     (Extract<EnvData[K], number> extends never ? never : 'int') |
@@ -101,10 +101,10 @@ type AllType = {
 
 function delegate<T extends object>(base: T): AllType & T {
   return new Proxy(castTo(base), {
-    get(target, prop): unknown {
-      return typeof prop !== 'string' ? undefined :
-        (prop in base ? base[castKey(prop)] :
-          target[castKey<typeof target>(prop)] ??= castTo(new EnvProp(prop))
+    get(target, property): unknown {
+      return typeof property !== 'string' ? undefined :
+        (property in base ? base[castKey(property)] :
+          target[castKey<typeof target>(property)] ??= castTo(new EnvProp(property))
         );
     }
   });

package/src/error.ts

@@ -28,14 +28,14 @@ export class AppError<T = Record<string, unknown> | undefined> extends Error {
   static defaultCategory?: ErrorCategory;
 
   /** Convert from JSON object */
-  static fromJSON(e: unknown): AppError | undefined {
-    if (!!e && typeof e === 'object' &&
-      ('message' in e && typeof e.message === 'string') &&
-      ('category' in e && typeof e.category === 'string') &&
-      ('type' in e && typeof e.type === 'string') &&
-      ('at' in e && typeof e.at === 'string')
+  static fromJSON(error: unknown): AppError | undefined {
+    if (!!error && typeof error === 'object' &&
+      ('message' in error && typeof error.message === 'string') &&
+      ('category' in error && typeof error.category === 'string') &&
+      ('type' in error && typeof error.type === 'string') &&
+      ('at' in error && typeof error.at === 'string')
     ) {
-      return new AppError(e.message, castTo<AppErrorOptions<Record<string, unknown>>>(e));
+      return new AppError(error.message, castTo<AppErrorOptions<Record<string, unknown>>>(error));
     }
   }
 
@@ -50,21 +50,21 @@ export class AppError<T = Record<string, unknown> | undefined> extends Error {
    * @param message The error message
    */
   constructor(
-    ...[message, opts]:
+    ...[message, options]:
       T extends undefined ? ([string] | [string, AppErrorOptions<T>]) : [string, AppErrorOptions<T>]
   ) {
-    super(message, opts?.cause ? { cause: opts.cause } : undefined);
-    this.type = opts?.type ?? this.constructor.name;
-    this.details = opts?.details!;
-    this.category = opts?.category ?? castTo<typeof AppError>(this.constructor).defaultCategory ?? 'general';
-    this.at = new Date(opts?.at ?? Date.now()).toISOString();
+    super(message, options?.cause ? { cause: options.cause } : undefined);
+    this.type = options?.type ?? this.constructor.name;
+    this.details = options?.details!;
+    this.category = options?.category ?? castTo<typeof AppError>(this.constructor).defaultCategory ?? 'general';
+    this.at = new Date(options?.at ?? Date.now()).toISOString();
   }
 
   /**
    * Serializes an error to a basic object
    */
   toJSON(): AppErrorOptions<T> & { message: string } {
-    const res: AppErrorOptions<unknown> = {
+    const options: AppErrorOptions<unknown> = {
       category: this.category,
       ...(this.cause ? { cause: `${this.cause}` } : undefined),
       type: this.type,
@@ -73,6 +73,6 @@ export class AppError<T = Record<string, unknown> | undefined> extends Error {
     };
 
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return { message: this.message, ...res as AppErrorOptions<T> };
+    return { message: this.message, ...options as AppErrorOptions<T> };
   }
 }