@travetto/runtime 7.1.2 → 7.1.4

package/README.md

@@ -51,8 +51,6 @@ class $Runtime {
   get monoRoot(): boolean;
   /** Main source path */
   get mainSourcePath(): string;
-  /** Get trv entrypoint */
-  get trvEntryPoint(): string;
   /** Produce a workspace relative path */
   workspaceRelative(...parts: string[]): string;
   /** Strip off the workspace path from a file */
@@ -69,6 +67,8 @@ class $Runtime {
   getImport(handle: Function): string;
   /** Import from a given path */
   async importFrom<T = unknown>(location?: string): Promise<T>;
+  /** Get an install command for a given npm module */
+  getInstallCommand(pkg: string, production = false): string;
 }
 ```
 
@@ -323,7 +323,7 @@ export class TimeUtil {
 ```
 
 ## Process Execution
-[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.
+[ExecUtil](https://github.com/travetto/travetto/tree/main/module/runtime/src/exec.ts#L41) 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/runtime",
-  "version": "7.1.2",
+  "version": "7.1.4",
   "type": "module",
   "description": "Runtime for travetto applications.",
   "keywords": [
@@ -26,12 +26,12 @@
     "directory": "module/runtime"
   },
   "dependencies": {
-    "@travetto/manifest": "^7.1.1",
+    "@travetto/manifest": "^7.1.3",
     "@types/debug": "^4.1.12",
     "debug": "^4.4.3"
   },
   "peerDependencies": {
-    "@travetto/transformer": "^7.1.1"
+    "@travetto/transformer": "^7.1.3"
   },
   "peerDependenciesMeta": {
     "@travetto/transformer": {

package/src/context.ts

@@ -68,11 +68,6 @@ class $Runtime {
     return this.#idx.mainModule.sourcePath;
   }
 
-  /** Get trv entrypoint */
-  get trvEntryPoint(): string {
-    return this.workspaceRelative('node_modules', '.bin', 'trv');
-  }
-
   /** Produce a workspace relative path */
   workspaceRelative(...parts: string[]): string {
     return path.resolve(this.workspace.path, ...parts);
@@ -141,6 +136,15 @@ class $Runtime {
     const imported = await import(location);
     return imported;
   }
+
+  /** Get an install command for a given npm module */
+  getInstallCommand(pkg: string, production = false): string {
+    switch (this.workspace.manager) {
+      case 'npm': return `npm install ${production ? '' : '--save-dev '}${pkg}`;
+      case 'yarn': return `yarn add ${production ? '' : '--dev '}${pkg}`;
+      case 'pnpm': return `pnpm add ${production ? '' : '--dev '}${pkg}`;
+    }
+  }
 }
 
 export const Runtime = new $Runtime(RuntimeIndex, Env.TRV_RESOURCE_OVERRIDES.object);

package/src/exec.ts

@@ -1,8 +1,9 @@
-import { type ChildProcess } from 'node:child_process';
+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';
+import { RuntimeIndex } from './manifest-index.ts';
 
 const ResultSymbol = Symbol();
 
@@ -39,24 +40,6 @@ type ExecutionBaseResult = Omit<ExecutionResult, 'stdout' | 'stderr'>;
  */
 export class ExecUtil {
 
-  /**
-   * Defer control to subprocess execution, mainly used for nested execution
-   */
-  static async deferToSubprocess(child: ChildProcess): Promise<ExecutionResult> {
-    const messageToChild = (value: unknown): void => { child.send(value!); };
-    const messageToParent = (value: unknown): void => { process.send?.(value); };
-
-    try {
-      process.on('message', messageToChild);
-      child.on('message', messageToParent);
-      const result = await this.getResult(child, { catch: true });
-      process.exitCode = child.exitCode;
-      return result;
-    } finally {
-      process.off('message', messageToChild);
-    }
-  }
-
   /**
    * 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
@@ -128,4 +111,9 @@ export class ExecUtil {
       await handler(item);
     }
   }
+
+  /** Spawn a package command */
+  static spawnPackageCommand(cmd: string, args: string[], config: SpawnOptions = {}): ChildProcess {
+    return spawn(process.argv0, [RuntimeIndex.resolvePackageCommand(cmd), ...args], config);
+  }
 }

package/src/shutdown.ts

@@ -11,8 +11,7 @@ const REASON_TO_CODE = new Map<ShutdownReason, number>(MAPPING);
 const CODE_TO_REASON = new Map<number, ShutdownReason>(MAPPING.map(([k, v]) => [v, k]));
 
 type Handler = (event: Event) => unknown;
-type ShutdownSignal = 'SIGINT' | 'SIGTERM' | 'SIGUSR2' | string | undefined;
-type ShutdownEvent = { signal?: ShutdownSignal, reason?: ShutdownReason | number, exit?: boolean };
+type ShutdownEvent = { reason?: ShutdownReason, mode?: 'exit' | 'interrupt' };
 
 const isShutdownEvent = (event: unknown): event is ShutdownEvent =>
   typeof event === 'object' && event !== null && 'type' in event && event.type === 'shutdown';
@@ -36,11 +35,12 @@ export class ShutdownManager {
   static {
     this.#controller.signal.addEventListener = (_: 'abort', listener: Handler): void => { this.#registered.add(listener); };
     this.#controller.signal.removeEventListener = (_: 'abort', listener: Handler): void => { this.#registered.delete(listener); };
-    process
-      .on('message', event => { isShutdownEvent(event) && this.shutdown(event); })
-      .on('SIGINT', () => this.shutdown({ signal: 'SIGINT' }))
-      .on('SIGUSR2', () => this.shutdown({ signal: 'SIGUSR2' }))
-      .on('SIGTERM', () => this.shutdown({ signal: 'SIGTERM' }));
+    try {
+      process
+        .on('message', event => { isShutdownEvent(event) && this.shutdown(event); })
+        .on('SIGINT', () => this.shutdown({ mode: 'interrupt' }))
+        .on('SIGTERM', () => this.shutdown());
+    } catch { }
   }
 
   static get signal(): AbortSignal {
@@ -66,29 +66,24 @@ export class ShutdownManager {
   /**
    * Shutdown the application gracefully
    */
-  static async shutdown(event?: ShutdownEvent): Promise<void> {
-    if ((event?.signal === 'SIGINT' && this.#shouldIgnoreInterrupt) || this.#controller.signal.aborted) {
+  static async shutdown({ reason = 'quit', mode = undefined }: ShutdownEvent = {}): Promise<void> {
+    if ((mode === 'interrupt' && this.#shouldIgnoreInterrupt) || this.#controller.signal.aborted) {
       return;
     }
 
     process // Allow shutdown if anything is still listening
       .removeAllListeners('message')
       .removeAllListeners('SIGINT')
-      .removeAllListeners('SIGTERM')
-      .removeAllListeners('SIGUSR2');
+      .removeAllListeners('SIGTERM');
 
-    if (event?.signal === 'SIGINT' && process.stdout.isTTY) {
+    if (mode === 'interrupt' && process.stdout.isTTY) {
       process.stdout.write('\n');
     }
 
-    if (event?.reason !== undefined) {
-      const { reason } = event;
-      process.exitCode = (typeof reason === 'string' ? REASON_TO_CODE.get(reason) : reason);
-    }
+    process.exitCode ??= REASON_TO_CODE.get(reason);
 
     const timeout = TimeUtil.fromValue(Env.TRV_SHUTDOWN_WAIT.value) ?? 2000;
-    const context = { ...event, pid: process.pid, timeout, pending: this.#registered.size };
-
+    const context = { reason, mode, pid: process.pid, timeout, pending: this.#registered.size };
     this.#controller.abort('Shutdown started');
     console.debug('Shutdown started', context);
 
@@ -103,7 +98,7 @@ export class ShutdownManager {
       console.warn('Shutdown timed out', context);
     }
 
-    if (event?.exit) {
+    if (mode === 'exit') {
       process.exit();
     }
   }