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

package/src/exec.ts

@@ -1,14 +1,23 @@
-import { ChildProcess } from 'node:child_process';
-import { Readable } from 'node:stream';
+import { type ChildProcess, spawn, type SpawnOptions } from 'node:child_process';
+import type { Readable } from 'node:stream';
 import { createInterface } from 'node:readline/promises';
 
-import { castTo } from './types.ts';
-
-const MINUTE = (1000 * 60);
+import { castTo, type Any } from './types.ts';
 
 const ResultSymbol = Symbol();
 
-interface ExecutionBaseResult {
+/**
+ * Result of an execution
+ */
+export interface ExecutionResult<T extends string | Buffer = string | Buffer> {
+  /**
+   * Stdout
+   */
+  stdout: T;
+  /**
+   * Stderr
+   */
+  stderr: T;
   /**
    * Exit code
    */
@@ -23,77 +32,19 @@ interface ExecutionBaseResult {
   valid: boolean;
 }
 
-/**
- * Result of an execution
- */
-export interface ExecutionResult<T extends string | Buffer = string | Buffer> extends ExecutionBaseResult {
-  /**
-   * Stdout
-   */
-  stdout: T;
-  /**
-   * Stderr
-   */
-  stderr: T;
-}
+type ExecutionBaseResult = Omit<ExecutionResult, 'stdout' | 'stderr'>;
 
 /**
  * Standard utilities for managing executions
  */
 export class ExecUtil {
 
-  static RESTART_EXIT_CODE = 200;
-
   /**
-   * Run with automatic restart support
-   * @param run The factory to produce the next running process
-   * @param maxRetriesPerMinute The number of times to allow a retry within a minute
+   * Spawn wrapper that ensures performant invocation of trv commands
    */
-  static async withRestart(
-    run: () => ChildProcess,
-    config?: { maxRetriesPerMinute?: number, relayInterrupt?: boolean }
-  ): Promise<ExecutionResult> {
-    const maxRetries = config?.maxRetriesPerMinute ?? 5;
-    const relayInterrupt = config?.relayInterrupt ?? false;
-
-    const restarts: number[] = [];
-
-    if (!relayInterrupt) {
-      process.removeAllListeners('SIGINT'); // Remove any existing listeners
-      process.on('SIGINT', () => { }); // Prevents SIGINT from killing parent process, the child will handle
-    }
-
-    for (; ;) {
-      const proc = run();
-      const interrupt = (): void => { proc.kill('SIGINT'); };
-      const toMessage = (v: unknown): void => { proc.send?.(v!); };
-
-      // Proxy kill requests
-      process.on('message', toMessage);
-      if (relayInterrupt) {
-        process.on('SIGINT', interrupt);
-      }
-      proc.on('message', v => process.send?.(v));
-
-      const result = await this.getResult(proc, { catch: true });
-      if (result.code !== this.RESTART_EXIT_CODE) {
-        return result;
-      } else {
-        if (relayInterrupt) {
-          process.off('SIGINT', interrupt);
-        }
-        process.off('message', toMessage);
-        restarts.unshift(Date.now());
-        if (restarts.length === maxRetries) {
-          if ((restarts[0] - restarts[maxRetries - 1]) <= MINUTE) {
-            console.error(`Bailing, due to ${maxRetries} restarts in under a minute`);
-            return result;
-          }
-          restarts.pop(); // Keep list short
-        }
-        console.error('Restarting...', { pid: process.pid });
-      }
-    }
+  static spawnTrv(cmd: string, args: string[], options: SpawnOptions): ChildProcess {
+    const entry = (globalThis as Any).__entry_point__ ?? process.argv.at(1);
+    return spawn(process.argv0, [entry, cmd, ...args], options);
   }
 
   /**
@@ -101,15 +52,15 @@ export class ExecUtil {
    * represents the entire execution.  On successful completion the promise will resolve, and
    * on failed completion the promise will reject.
    *
-   * @param proc The process to enhance
+   * @param subProcess The process to enhance
    * @param options The options to use to enhance the process
    */
-  static getResult(proc: ChildProcess): Promise<ExecutionResult<string>>;
-  static getResult(proc: ChildProcess, options: { catch?: boolean, binary?: false }): Promise<ExecutionResult<string>>;
-  static getResult(proc: ChildProcess, options: { catch?: boolean, binary: true }): Promise<ExecutionResult<Buffer>>;
-  static getResult<T extends string | Buffer>(proc: ChildProcess, options: { catch?: boolean, binary?: boolean } = {}): Promise<ExecutionResult<T>> {
-    const _proc: ChildProcess & { [ResultSymbol]?: Promise<ExecutionResult> } = proc;
-    const result = _proc[ResultSymbol] ??= new Promise<ExecutionResult>(resolve => {
+  static getResult(subProcess: ChildProcess): Promise<ExecutionResult<string>>;
+  static getResult(subProcess: ChildProcess, options: { catch?: boolean, binary?: false }): Promise<ExecutionResult<string>>;
+  static getResult(subProcess: ChildProcess, options: { catch?: boolean, binary: true }): Promise<ExecutionResult<Buffer>>;
+  static getResult<T extends string | Buffer>(subProcess: ChildProcess, options: { catch?: boolean, binary?: boolean } = {}): Promise<ExecutionResult<T>> {
+    const typed: ChildProcess & { [ResultSymbol]?: Promise<ExecutionResult> } = subProcess;
+    const result = typed[ResultSymbol] ??= new Promise<ExecutionResult>(resolve => {
       const stdout: Buffer[] = [];
       const stderr: Buffer[] = [];
       let done = false;
@@ -136,25 +87,25 @@ export class ExecUtil {
         );
       };
 
-      proc.stdout?.on('data', (d: string | Buffer) => stdout.push(Buffer.isBuffer(d) ? d : Buffer.from(d)));
-      proc.stderr?.on('data', (d: string | Buffer) => stderr.push(Buffer.isBuffer(d) ? d : Buffer.from(d)));
+      subProcess.stdout?.on('data', (data: string | Buffer) => stdout.push(Buffer.isBuffer(data) ? data : Buffer.from(data)));
+      subProcess.stderr?.on('data', (data: string | Buffer) => stderr.push(Buffer.isBuffer(data) ? data : Buffer.from(data)));
 
-      proc.on('error', (err: Error) =>
-        finish({ code: 1, message: err.message, valid: false }));
+      subProcess.on('error', (error: Error) =>
+        finish({ code: 1, message: error.message, valid: false }));
 
-      proc.on('close', (code: number) =>
+      subProcess.on('close', (code: number) =>
         finish({ code, valid: code === null || code === 0 }));
 
-      if (proc.exitCode !== null) { // We are already done
-        finish({ code: proc.exitCode, valid: proc.exitCode === 0 });
+      if (subProcess.exitCode !== null) { // We are already done
+        finish({ code: subProcess.exitCode, valid: subProcess.exitCode === 0 });
       }
     });
 
-    return castTo(options.catch ? result : result.then(v => {
-      if (v.valid) {
-        return v;
+    return castTo(options.catch ? result : result.then(executionResult => {
+      if (executionResult.valid) {
+        return executionResult;
       } else {
-        throw new Error(v.message);
+        throw new Error(executionResult.message);
       }
     }));
   }

package/src/file-loader.ts

@@ -4,6 +4,7 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 
 import { AppError } from './error.ts';
+import { JSONUtil } from './json.ts';
 
 /**
  * File loader that will search for files across the provided search paths
@@ -64,4 +65,12 @@ export class FileLoader {
   async readFile(relativePath: string): Promise<File> {
     return new File([await this.read(relativePath, true)], path.basename(relativePath));
   }
+
+  /**
+   * Read relative file as JSON
+   */
+  async readJSON<T>(relativePath: string): Promise<T> {
+    const location = await this.resolve(relativePath);
+    return JSONUtil.readFile<T>(location);
+  }
 }

package/src/json.ts

@@ -0,0 +1,74 @@
+import fs from 'node:fs/promises';
+import { existsSync, readFileSync } from 'node:fs';
+
+import type { Any } from './types';
+
+/**
+ * JSON Utility functions
+ */
+export class JSONUtil {
+
+  /**
+   * Parse JSON safely
+   */
+  static parseSafe<T>(input: string | Buffer, reviver?: (this: unknown, key: string, value: Any) => unknown): T {
+    if (typeof input !== 'string') {
+      input = input.toString('utf8');
+    }
+    // TODO: Ensure we aren't vulnerable to prototype pollution
+    return JSON.parse(input, reviver);
+  }
+
+  /**
+   * Encode JSON value as base64 encoded string
+   */
+  static stringifyBase64<T>(value: T | undefined): string | undefined {
+    if (value === undefined) {
+      return;
+    }
+    const text = JSON.stringify(value);
+    return Buffer.from(text, 'utf8').toString('base64');
+  }
+
+  /**
+   * Decode JSON value from base64 encoded string
+   */
+  static parseBase64<T>(input: string): T;
+  static parseBase64<T>(input?: string | undefined): T | undefined;
+  static parseBase64<T>(input?: string | undefined): T | undefined {
+    if (!input) {
+      return undefined;
+    }
+
+    let decoded = Buffer.from(input, 'base64').toString('utf8');
+
+    // Read from encoded if it happens
+    if (decoded.startsWith('%')) {
+      decoded = decodeURIComponent(decoded);
+    }
+
+    return this.parseSafe(decoded);
+  }
+
+  /**
+   * Read JSON file asynchronously
+   * @param file
+   * @returns
+   */
+  static async readFile<T>(file: string): Promise<T> {
+    const content = await fs.readFile(file, 'utf8');
+    return this.parseSafe(content);
+  }
+
+  /**
+   * Read JSON file synchronously
+   * @param file
+   */
+  static readFileSync<T>(file: string, onMissing?: T): T {
+    if (!existsSync(file) && onMissing !== undefined) {
+      return onMissing;
+    }
+    const content = readFileSync(file, 'utf8');
+    return this.parseSafe(content);
+  }
+}

package/src/queue.ts

@@ -54,9 +54,9 @@ export class AsyncQueue<X> implements AsyncIterator<X>, AsyncIterable<X> {
   /**
    * Throw an error from the queue, rejecting and terminating immediately
    */
-  async throw(e?: Error): Promise<IteratorResult<X>> {
+  async throw(error?: Error): Promise<IteratorResult<X>> {
     this.#done = true;
-    this.#ready.reject(e);
+    this.#ready.reject(error);
     return { value: undefined, done: this.#done };
   }
 }

package/src/resources.ts

@@ -15,9 +15,9 @@ class $RuntimeResources extends FileLoader {
   }
 
   override get searchPaths(): readonly string[] {
-    if (!this.#computed || this.#env !== Env.TRV_RESOURCES.val || this.#mod !== Env.TRV_MODULE.val) {
-      this.#env = Env.TRV_RESOURCES.val!;
-      this.#mod = Env.TRV_MODULE.val!;
+    if (!this.#computed || this.#env !== Env.TRV_RESOURCES.value || this.#mod !== Env.TRV_MODULE.value) {
+      this.#env = Env.TRV_RESOURCES.value!;
+      this.#mod = Env.TRV_MODULE.value!;
       this.#computed = Runtime.resourcePaths();
     }
     return this.#computed;

package/src/shutdown.ts

@@ -40,7 +40,7 @@ export class ShutdownManager {
     this.#ensureExitListeners();
     this.#handlers.push({ handler, scope });
     return () => {
-      const idx = this.#handlers.findIndex(x => x.handler === handler);
+      const idx = this.#handlers.findIndex(item => item.handler === handler);
       if (idx >= 0) {
         this.#handlers.splice(idx, 1);
       }
@@ -61,7 +61,7 @@ export class ShutdownManager {
 
     await Util.queueMacroTask(); // Force the event loop to wait one cycle
 
-    const timeout = TimeUtil.fromValue(Env.TRV_SHUTDOWN_WAIT.val) ?? 2000;
+    const timeout = TimeUtil.fromValue(Env.TRV_SHUTDOWN_WAIT.value) ?? 2000;
     const items = this.#handlers.splice(0, this.#handlers.length);
     console.debug('Graceful shutdown: started', { source, timeout, count: items.length });
     const handlers = Promise.all(items.map(async ({ scope, handler }) => {
@@ -73,8 +73,8 @@ export class ShutdownManager {
         if (scope) {
           console.debug('Stopped', { scope });
         }
-      } catch (err) {
-        console.error('Error stopping', { err, scope });
+      } catch (error) {
+        console.error('Error stopping', { error, scope });
       }
     }));
 

package/src/time.ts

@@ -22,8 +22,8 @@ export class TimeUtil {
    * Test to see if a string is valid for relative time
    * @param val
    */
-  static isTimeSpan(val: string): val is TimeSpan {
-    return TIME_PATTERN.test(val);
+  static isTimeSpan(value: string): value is TimeSpan {
+    return TIME_PATTERN.test(value);
   }
 
   /**
@@ -36,12 +36,12 @@ export class TimeUtil {
       return amount.getTime();
     } else if (typeof amount === 'string') {
       const groups: { amount?: string, unit?: TimeUnit } = amount.match(TIME_PATTERN)?.groups ?? {};
-      const amountStr = groups.amount ?? `${amount}`;
+      const amountString = groups.amount ?? `${amount}`;
       unit = groups.unit ?? unit ?? 'ms';
       if (!TIME_UNITS[unit]) {
         return NaN;
       }
-      amount = amountStr.includes('.') ? parseFloat(amountStr) : parseInt(amountStr, 10);
+      amount = amountString.includes('.') ? parseFloat(amountString) : parseInt(amountString, 10);
     }
     return amount * TIME_UNITS[unit ?? 'ms'];
   }
@@ -69,11 +69,11 @@ export class TimeUtil {
     if (value === undefined) {
       return value;
     }
-    const val = (typeof value === 'string' && /\d{1,30}[a-z]$/i.test(value)) ?
+    const result = (typeof value === 'string' && /\d{1,30}[a-z]$/i.test(value)) ?
       (this.isTimeSpan(value) ? this.asMillis(value) : undefined) :
       (typeof value === 'string' ? parseInt(value, 10) :
         (value instanceof Date ? value.getTime() : value));
-    return Number.isNaN(val) ? undefined : val;
+    return Number.isNaN(result) ? undefined : result;
   }
 
   /**
@@ -90,11 +90,11 @@ export class TimeUtil {
    * @param time Time in milliseconds
    */
   static asClock(time: number): string {
-    const s = Math.trunc(time / 1000);
+    const seconds = Math.trunc(time / 1000);
     return [
-      s > 3600 ? `${Math.trunc(s / 3600).toString().padStart(2, '0')}h` : '',
-      s > 60 ? `${Math.trunc((s % 3600) / 60).toString().padStart(2, '0')}m` : '',
-      `${(s % 60).toString().padStart(2, '0')}s`
-    ].filter(x => !!x).slice(0, 2).join(' ');
+      seconds > 3600 ? `${Math.trunc(seconds / 3600).toString().padStart(2, '0')}h` : '',
+      seconds > 60 ? `${Math.trunc((seconds % 3600) / 60).toString().padStart(2, '0')}m` : '',
+      `${(seconds % 60).toString().padStart(2, '0')}s`
+    ].filter(part => !!part).slice(0, 2).join(' ');
   }
 }

package/src/trv.d.ts

@@ -21,10 +21,6 @@ declare module "@travetto/runtime" {
      * 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
      */

package/src/types.ts

@@ -14,7 +14,7 @@ export type TypedFunction<R = Any, V = unknown> = (this: V, ...args: Any[]) => R
 
 export type MethodDescriptor<V = Any, R = Any> = TypedPropertyDescriptor<TypedFunction<R, V>>;
 export type AsyncMethodDescriptor<V = Any, R = Any> = TypedPropertyDescriptor<TypedFunction<Promise<R>, V>>;
-export type AsyncItrMethodDescriptor<V = Any, R = Any> = TypedPropertyDescriptor<TypedFunction<AsyncIterable<R>, V>>;
+export type AsyncIterableMethodDescriptor<V = Any, R = Any> = TypedPropertyDescriptor<TypedFunction<AsyncIterable<R>, V>>;
 export type ClassTDecorator<T extends Class = Class> = (target: T) => T | void;
 
 export type Primitive = number | bigint | boolean | string | Date;
@@ -34,9 +34,10 @@ type ValidPrimitiveFields<T, Z = undefined> = {
 export type RetainPrimitiveFields<T, Z = undefined> = Pick<T, ValidPrimitiveFields<T, Z>>;
 
 export const TypedObject: {
-  keys<T = unknown, K extends keyof T = keyof T & string>(o: T): K[];
+  keys<T = unknown, K extends keyof T = keyof T & string>(value: T): K[];
   fromEntries<K extends string | symbol, V>(items: ([K, V] | readonly [K, V])[]): Record<K, V>;
   entries<K extends Record<symbol | string, unknown>>(record: K): [keyof K, K[keyof K]][];
+  assign<T extends {}, U extends T>(target: T, ...sources: U[]): U;
 } & ObjectConstructor = Object;
 
 export const safeAssign = <T extends {}, U extends {}>(target: T, ...sources: U[]): T & U =>
@@ -47,6 +48,7 @@ export function castTo<T>(input: unknown): T {
   return input as T;
 }
 
+export const isClass = (input: unknown): input is Class => typeof input === 'function' && 'Ⲑid' in input;
 export const castKey = <T>(input: string | number | symbol): keyof T => castTo(input);
 export const asFull = <T>(input: Partial<T>): T => castTo(input);
 export const asConstructable = <Z = unknown>(input: Class | unknown): { constructor: Class<Z> } => castTo(input);
@@ -56,22 +58,20 @@ export function classConstruct<T>(cls: Class<T>, args: unknown[] = []): ClassIns
   return castTo(new cons(...args));
 }
 
-export const hasFunction = <T>(key: keyof T) => (o: unknown): o is T =>
-  typeof o === 'object' && o !== null && typeof o[castKey(key)] === 'function';
+export const hasFunction = <T>(key: keyof T) => (value: unknown): value is T =>
+  typeof value === 'object' && value !== null && typeof value[castKey(key)] === 'function';
 
 export const hasToJSON = hasFunction<{ toJSON(): object }>('toJSON');
 
+/**
+ * A type representing unknown type
+ */
+export class UnknownType { }
+
 export function toConcrete<T extends unknown>(): Class<T> {
   return arguments[0];
 }
 
-export function getAllEntries<V>(obj: Record<string | symbol, V>): [string | symbol, V][] {
-  return [
-    ...Object.keys(obj),
-    ...Object.getOwnPropertySymbols(obj)
-  ].map(k => [k, obj[k]] as const);
-}
-
 /**
  * Find parent class for a given class object
  */
@@ -83,7 +83,8 @@ export function getParentClass(cls: Class): Class | undefined {
 /**
  * Get the class from an instance or class
  */
-export const getClass = <T = unknown>(x: ClassInstance | Class): Class<T> => 'Ⲑid' in x ? castTo(x) : asConstructable<T>(x).constructor;
+export const getClass = <T = unknown>(value: ClassInstance | Class): Class<T> =>
+  'Ⲑid' in value ? castTo(value) : asConstructable<T>(value).constructor;
 
 /**
  * Range of bytes, inclusive

package/src/util.ts

@@ -1,10 +1,10 @@
 import crypto from 'node:crypto';
 import timers from 'node:timers/promises';
 
-import { castTo, hasToJSON } from './types.ts';
+import { castTo } from './types.ts';
 import { AppError } from './error.ts';
 
-type MapFn<T, U> = (val: T, i: number) => U | Promise<U>;
+type MapFn<T, U> = (value: T, i: number) => U | Promise<U>;
 
 /**
  * Grab bag of common utilities
@@ -38,35 +38,35 @@ export class Util {
 
   /**
    * Generate a random UUID
-   * @param len The length of the uuid to generate
+   * @param length The length of the uuid to generate
    */
-  static uuid(len: number = 32): string {
-    const bytes = crypto.randomBytes(Math.ceil(len / 2));
-    if (len === 32) { // Make valid uuid-v4
+  static uuid(length: number = 32): string {
+    const bytes = crypto.randomBytes(Math.ceil(length / 2));
+    if (length === 32) { // Make valid uuid-v4
       // eslint-disable-next-line no-bitwise
       bytes[6] = (bytes[6] & 0x0f) | 0x40;
       // eslint-disable-next-line no-bitwise
       bytes[8] = (bytes[8] & 0x3f) | 0x80;
     }
-    return bytes.toString('hex').substring(0, len);
+    return bytes.toString('hex').substring(0, length);
   }
 
   /**
    * Map an async iterable with various mapping functions
    */
-  static mapAsyncItr<T, U, V, W>(source: AsyncIterable<T>, fn1: MapFn<T, U>, fn2: MapFn<U, V>, fn3: MapFn<V, W>): AsyncIterable<W>;
-  static mapAsyncItr<T, U, V>(source: AsyncIterable<T>, fn1: MapFn<T, U>, fn2: MapFn<U, V>): AsyncIterable<V>;
-  static mapAsyncItr<T, U>(source: AsyncIterable<T>, fn: MapFn<T, U>): AsyncIterable<U>;
-  static async * mapAsyncItr<T>(source: AsyncIterable<T>, ...fns: MapFn<unknown, unknown>[]): AsyncIterable<unknown> {
+  static mapAsyncIterable<T, U, V, W>(source: AsyncIterable<T>, fn1: MapFn<T, U>, fn2: MapFn<U, V>, fn3: MapFn<V, W>): AsyncIterable<W>;
+  static mapAsyncIterable<T, U, V>(source: AsyncIterable<T>, fn1: MapFn<T, U>, fn2: MapFn<U, V>): AsyncIterable<V>;
+  static mapAsyncIterable<T, U>(source: AsyncIterable<T>, fn: MapFn<T, U>): AsyncIterable<U>;
+  static async * mapAsyncIterable<T>(input: AsyncIterable<T>, ...fns: MapFn<unknown, unknown>[]): AsyncIterable<unknown> {
     let idx = -1;
-    for await (const el of source) {
-      if (el !== undefined) {
+    for await (const item of input) {
+      if (item !== undefined) {
         idx += 1;
-        let m = el;
+        let result = item;
         for (const fn of fns) {
-          m = castTo(await fn(m, idx));
+          result = castTo(await fn(result, idx));
         }
-        yield m;
+        yield result;
       }
     }
   }
@@ -103,9 +103,9 @@ export class Util {
     cacheKey?: (...keyInput: K) => string
   ): (...input: K) => boolean {
 
-    const rawRules = (Array.isArray(rules) ? rules : rules.split(/,/g).map(x => x.trim()));
+    const rawRules = (Array.isArray(rules) ? rules : rules.split(/,/g).map(rule => rule.trim()));
     const convertedRules = rawRules.map(rule => this.#allowDenyRuleInput(rule, convert));
-    const unmatchedValue = !convertedRules.some(r => r.positive);
+    const unmatchedValue = !convertedRules.some(rule => rule.positive);
 
     if (convertedRules.length) {
       if (cacheKey) {
@@ -120,99 +120,23 @@ export class Util {
     }
   }
 
-  /**
-   * Encode JSON value as base64 encoded string
-   */
-  static encodeSafeJSON<T>(value: T | undefined): string | undefined {
-    if (value === undefined) {
-      return;
-    }
-    const res = JSON.stringify(value);
-    return Buffer.from(res, 'utf8').toString('base64');
-  }
-
-  /**
-   * Decode JSON value from base64 encoded string
-   */
-  static decodeSafeJSON<T>(input: string): T;
-  static decodeSafeJSON<T>(input?: string | undefined): T | undefined;
-  static decodeSafeJSON<T>(input?: string | undefined): T | undefined {
-    if (!input) {
-      return undefined;
-    }
-
-    let decoded = Buffer.from(input, 'base64').toString('utf8');
-
-    // Read from encoded if it happens
-    if (decoded.startsWith('%')) {
-      decoded = decodeURIComponent(decoded);
-    }
-
-    return JSON.parse(decoded, undefined);
-  }
-
-  /**
-   * Serialize to JSON
-   */
-  static serializeToJSON<T>(out: T): string {
-    return JSON.stringify(out, function (k, v) {
-      const ov = this[k];
-      if (ov && ov instanceof Error) {
-        return {
-          $: true,
-          ...hasToJSON(ov) ? ov.toJSON() : ov,
-          name: ov.name,
-          message: ov.message,
-          stack: ov.stack,
-        };
-      } else if (typeof v === 'bigint') {
-        return `${v.toString()}$n`;
-      } else {
-        return v;
-      }
-    });
-  }
-
-  /**
-   * Deserialize from JSON
-   */
-  static deserializeFromJson<T = unknown>(input: string): T {
-    return JSON.parse(input, function (k, v) {
-      if (v && typeof v === 'object' && '$' in v) {
-        const err = AppError.fromJSON(v) ?? new Error();
-        if (!(err instanceof AppError)) {
-          const { $: _, ...rest } = v;
-          Object.assign(err, rest);
-        }
-        err.message = v.message;
-        err.stack = v.stack;
-        err.name = v.name;
-        return err;
-      } else if (typeof v === 'string' && /^\d+[$]n$/.test(v)) {
-        return BigInt(v.split('$')[0]);
-      } else {
-        return v;
-      }
-    });
-  }
-
   /**
    * Retry an operation, with a custom conflict handler
-   * @param op The operation to retry
+   * @param operation The operation to retry
    * @param isHandledConflict Function to determine if the error is a handled conflict
    * @param maxTries Maximum number of retries
    */
   static async acquireWithRetry<T>(
-    op: () => T | Promise<T>,
-    prepareRetry: (err: unknown, count: number) => (void | undefined | boolean | Promise<(void | undefined | boolean)>),
+    operation: () => T | Promise<T>,
+    prepareRetry: (error: unknown, count: number) => (void | undefined | boolean | Promise<(void | undefined | boolean)>),
     maxTries = 5,
   ): Promise<T> {
     for (let i = 0; i < maxTries; i++) {
       try {
-        return await op();
-      } catch (err) {
-        if (i === maxTries - 1 || await prepareRetry(err, i) === false) {
-          throw err; // Stop retrying if we reached max tries or prepareRetry returns false
+        return await operation();
+      } catch (error) {
+        if (i === maxTries - 1 || await prepareRetry(error, i) === false) {
+          throw error; // Stop retrying if we reached max tries or prepareRetry returns false
         }
       }
     }