@travetto/runtime 7.0.0-rc.5 → 7.0.1

package/README.md

@@ -267,7 +267,7 @@ The framework provides utilities for working with JSON data.  This module provid
    *  `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:
+Common utilities used throughout the framework. Currently [Util](https://github.com/travetto/travetto/tree/main/module/runtime/src/util.ts#L11) includes:
    *  `uuid(len: number)` generates a simple uuid for use within the application.
    *  `allowDenyMatcher(rules[])` builds a matching function that leverages the rules as an allow/deny list, where order of the rules matters.  Negative rules are prefixed by '!'.
    *  `hash(text: string, size?: number)` produces a full sha512 hash.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/runtime",
-  "version": "7.0.0-rc.5",
+  "version": "7.0.1",
   "type": "module",
   "description": "Runtime for travetto applications.",
   "keywords": [
@@ -26,12 +26,12 @@
     "directory": "module/runtime"
   },
   "dependencies": {
-    "@travetto/manifest": "^7.0.0-rc.3",
+    "@travetto/manifest": "^7.0.0",
     "@types/debug": "^4.1.12",
     "debug": "^4.4.3"
   },
   "peerDependencies": {
-    "@travetto/transformer": "^7.0.0-rc.4"
+    "@travetto/transformer": "^7.0.1"
   },
   "peerDependenciesMeta": {
     "@travetto/transformer": {

package/src/exec.ts

@@ -39,6 +39,34 @@ type ExecutionBaseResult = Omit<ExecutionResult, 'stdout' | 'stderr'>;
  */
 export class ExecUtil {
 
+  /**
+   * Defer control to subprocess execution, mainly used for nested execution
+   */
+  static async deferToSubprocess(child: ChildProcess, relayInterrupt: boolean = true): Promise<ExecutionResult> {
+    if (!relayInterrupt) {
+      process.removeAllListeners('SIGINT'); // Remove any existing listeners
+      process.on('SIGINT', () => { }); // Prevents SIGINT from killing parent process, the child will handle
+    }
+
+    child.on('message', value => process.send?.(value));
+
+    const interrupt = (): void => { child?.kill('SIGINT'); };
+    const toMessage = (value: unknown): void => { child?.send(value!); };
+
+    // Proxy kill requests
+    process.on('message', toMessage);
+
+    if (relayInterrupt) {
+      process.on('SIGINT', interrupt);
+    }
+
+    const result = await ExecUtil.getResult(child, { catch: true });
+    process.exitCode = child.exitCode;
+    process.off('message', toMessage);
+    process.off('SIGINT', interrupt);
+    return result;
+  }
+
   /**
    * Take a child process, and some additional options, and produce a promise that
    * represents the entire execution.  On successful completion the promise will resolve, and

package/src/util.ts

@@ -2,7 +2,6 @@ import crypto from 'node:crypto';
 import timers from 'node:timers/promises';
 
 import { castTo } from './types.ts';
-import { AppError } from './error.ts';
 
 type MapFn<T, U> = (value: T, i: number) => U | Promise<U>;
 
@@ -119,28 +118,4 @@ export class Util {
       return () => true;
     }
   }
-
-  /**
-   * Retry an operation, with a custom conflict handler
-   * @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>(
-    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 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
-        }
-      }
-    }
-
-    throw new AppError(`Operation failed after ${maxTries} attempts`);
-  }
 }

package/src/watch.ts

@@ -1,86 +1,136 @@
-import { ManifestModuleUtil, type ChangeEventType, type ManifestModuleFileType } from '@travetto/manifest';
+import { ChildProcess } from 'node:child_process';
 
-import { RuntimeIndex } from './manifest-index.ts';
-import { ShutdownManager } from './shutdown.ts';
-import { Util } from './util.ts';
+import type { CompilerEventPayload, CompilerEventType } from '@travetto/compiler/support/types.ts';
 
-type WatchEvent = { file: string, action: ChangeEventType, output: string, module: string, import: string, time: number };
+import { AppError } from './error';
+import { Util } from './util';
+import { RuntimeIndex } from './manifest-index';
+import { ShutdownManager } from './shutdown';
+import { castTo } from './types';
 
-type WatchCompilerOptions = {
-  /**
-   * Restart the watch loop on compiler exit
-   */
-  restartOnCompilerExit?: boolean;
-  /**
-   * Run on restart
-   */
-  onRestart?: () => void;
+type RetryRunState = {
+  iteration: number;
+  startTime: number;
+  errorIterations: number;
+  result?: 'error' | 'restart' | 'stop';
 };
 
-export async function* watchCompiler(config?: WatchCompilerOptions): AsyncIterable<WatchEvent> {
-  // Load at runtime
-  const { CompilerClient } = await import('@travetto/compiler/support/server/client.ts');
-
-  const client = new CompilerClient(RuntimeIndex.manifest, {
-    warn(message, ...args): void { console.error('warn', message, ...args); },
-    debug(message, ...args): void { console.error('debug', message, ...args); },
-    error(message, ...args): void { console.error('error', message, ...args); },
-    info(message, ...args): void { console.error('info', message, ...args); },
-  });
-
-  const controller = new AbortController();
-  const remove = ShutdownManager.onGracefulShutdown(async () => controller.abort());
-
-  const maxIterations = 10;
-  const maxWindow = 10 * 1000;
-  const iterations: number[] = [];
-  let iterationsExhausted = false;
-
-  while (
-    !controller.signal.aborted &&
-    !iterationsExhausted &&
-    (config?.restartOnCompilerExit || iterations.length === 0)
-  ) {
-    if (iterations.length) { // Wait on next iteration
-      await Util.nonBlockingTimeout(10);
-    }
+type RetryRunConfig = {
+  maxRetries: number;
+  maxRetryWindow: number;
+  signal?: AbortSignal;
+  onRetry: (state: RetryRunState, config: RetryRunConfig) => (unknown | Promise<unknown>);
+};
 
-    await client.waitForState(['compile-end', 'watch-start'], undefined, controller.signal);
+/**
+ * Utilities for watching resources
+ */
+export class WatchUtil {
 
-    if (!await client.isWatching()) { // If we get here, without a watch
-      await Util.nonBlockingTimeout(maxWindow / (maxIterations * 2));
-    } else {
-      if (iterations.length) {
-        config?.onRestart?.();
-      }
-      yield* client.fetchEvents('change', { signal: controller.signal, enforceIteration: true });
-    }
+  static #RESTART_EXIT_CODE = 200;
 
-    iterations.push(Date.now());
-    if (iterations.length >= maxIterations) {
-      iterationsExhausted = (Date.now() - iterations[0]) > maxWindow;
-      iterations.shift();
-    }
+  /** Convert exit code to a result type  */
+  static exitCodeToResult(code: number): RetryRunState['result'] {
+    return code === this.#RESTART_EXIT_CODE ? 'restart' : code > 0 ? 'error' : 'stop';
   }
 
-  remove();
-}
+  /** Exit with a restart exit code */
+  static exitWithRestart(): void {
+    process.exit(this.#RESTART_EXIT_CODE);
+  }
 
-export function listenForSourceChanges(onChange: () => void, debounceDelay = 10): void {
-  let timeout: ReturnType<typeof setTimeout> | undefined;
+  /** Listen for restart signals */
+  static listenForRestartSignal(): void {
+    const listener = (event: unknown): void => {
+      if (event === 'WATCH_RESTART') { this.exitWithRestart(); }
+    };
+    process.on('message', listener);
+    ShutdownManager.onGracefulShutdown(() => { process.removeListener('message', listener); });
+  }
 
-  const validFileTypes = new Set<ManifestModuleFileType>(['ts', 'js', 'package-json', 'typings']);
+  /** Trigger a restart signal to a subprocess */
+  static triggerRestartSignal(subprocess?: ChildProcess): void {
+    subprocess?.connected && subprocess.send?.('WATCH_RESTART');
+  }
 
-  function send(): void {
-    clearTimeout(timeout);
-    timeout = setTimeout(onChange, debounceDelay);
+  /** Compute the delay before restarting */
+  static computeRestartDelay(state: RetryRunState, config: RetryRunConfig): number {
+    return state.result === 'error'
+      ? config.maxRetryWindow / (config.maxRetries + 1)
+      : 10;
   }
 
-  (async function (): Promise<void> {
-    for await (const item of watchCompiler({ restartOnCompilerExit: true, onRestart: send })) {
-      if (validFileTypes.has(ManifestModuleUtil.getFileType(item.file)) && RuntimeIndex.findModuleForArbitraryFile(item.file)) {
-        send();
+  /**
+   * Run with restart capability
+   */
+  static async runWithRetry(run: (state: RetryRunState & { signal: AbortSignal }) => Promise<RetryRunState['result']>, options?: Partial<RetryRunConfig>): Promise<void> {
+    const controller = new AbortController();
+    const cleanup = ShutdownManager.onGracefulShutdown(() => controller.abort());
+    let retryExhausted = false;
+
+    const state: RetryRunState = {
+      iteration: 0,
+      errorIterations: 0,
+      startTime: Date.now()
+    };
+
+    const config: RetryRunConfig = {
+      maxRetryWindow: 10 * 1000,
+      maxRetries: 10,
+      onRetry: () => Util.nonBlockingTimeout(this.computeRestartDelay(state, config)),
+      ...options,
+    };
+
+
+    while (!controller.signal.aborted && !retryExhausted) {
+      if (state.iteration > 0) {
+        await config.onRetry(state, config);
+      }
+
+      state.result = await run({ ...state, signal: controller.signal }).catch(() => 'error' as const);
+      switch (state.result) {
+        case 'stop': controller.abort(); break;
+        case 'error': state.errorIterations += 1; break;
+        case 'restart': {
+          state.startTime = Date.now();
+          state.errorIterations = 0;
+        }
       }
+
+      retryExhausted = (state.errorIterations >= config.maxRetries) || (Date.now() - state.startTime >= config.maxRetryWindow);
+      state.iteration += 1;
+    }
+
+    if (retryExhausted) {
+      throw new AppError(`Operation failed after ${state.errorIterations} attempts`);
     }
-  })();
+
+    cleanup?.();
+  }
+
+  /**  Watch compiler events  */
+  static async watchCompilerEvents<K extends CompilerEventType, T extends CompilerEventPayload<K>>(
+    type: K,
+    onChange: (input: T) => unknown,
+    filter?: (input: T) => boolean,
+    options?: Partial<RetryRunConfig>,
+  ): Promise<void> {
+    const { CompilerClient } = await import('@travetto/compiler/support/server/client.ts');
+    const client = new CompilerClient(RuntimeIndex.manifest, console);
+
+    return this.runWithRetry(async ({ signal }) => {
+      await client.waitForState(['compile-end', 'watch-start'], undefined, signal);
+
+      if (!await client.isWatching()) { // If we get here, without a watch
+        return 'error';
+      } else {
+        for await (const event of client.fetchEvents(type, { signal, enforceIteration: true })) {
+          if (!filter || filter(castTo(event))) {
+            await onChange(castTo(event));
+          }
+        }
+        return 'restart';
+      }
+    }, options);
+  }
 }