@travetto/compiler 4.0.2 → 4.0.4

package/README.md

@@ -31,6 +31,7 @@ The compiler cli supports the following operations:
    *  `clean` - Clean out the output and compiler caches
    *  `info` - Retrieve the compiler information, if running
    *  `event <log|progress|state>` - Watch events in realtime as newline delimited JSON
+   *  `exec <file> [...args]` - Allow for compiling and executing an entrypoint file
    *  `manifest --prod [output]` - Generate the project manifest
 In addition to the normal output, the compiler supports an environment variable `TRV_BUILD` that supports the following values: `debug`, `info`, `warn` or `none`.  This provides different level of logging during the build process which is helpful to diagnose any odd behaviors.  When invoking an unknown command (e.g. `<other>` from above), the default level is `warn`.  Otherwise the default logging level is `info`.
 

package/bin/trvc.js

@@ -14,6 +14,7 @@ const help = () => [
   ' * clean                      - Clean out the output and compiler caches',
   ' * info                       - Retrieve the compiler information, if running',
   ' * event <log|progress|state> - Watch events in realtime as newline delimited JSON',
+  ' * exec <file> [...args]      - Allow for compiling and executing an entrypoint file',
   ' * manifest --prod [output]   - Generate the project manifest',
 ].join('\n');
 
@@ -35,6 +36,7 @@ getEntry().then(async (ops) => {
     });
     case 'clean': return ops.clean();
     case 'manifest': return ops.manifest(args[0], flags.some(x => x === '--prod'));
+    case 'exec': return ops.getLoader().then(v => v(args[0], all.slice(1)));
     case 'start':
     case 'watch': return ops.watch();
     case 'build': return ops.build();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/compiler",
-  "version": "4.0.2",
+  "version": "4.0.4",
   "description": "The compiler infrastructure for the Travetto framework",
   "keywords": [
     "compiler",
@@ -31,12 +31,12 @@
   },
   "dependencies": {
     "@parcel/watcher": "^2.4.0",
-    "@travetto/manifest": "^4.0.0",
-    "@travetto/transformer": "^4.0.1",
+    "@travetto/manifest": "^4.0.1",
+    "@travetto/transformer": "^4.0.2",
     "@types/node": "^20.11.16"
   },
   "peerDependencies": {
-    "@travetto/cli": "^4.0.3"
+    "@travetto/cli": "^4.0.4"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {

package/src/compiler.ts

@@ -1,4 +1,3 @@
-import timers from 'node:timers/promises';
 import fs from 'node:fs/promises';
 import { setMaxListeners } from 'node:events';
 
@@ -11,6 +10,7 @@ import { CompileEmitEvent, CompileEmitter } from './types';
 import { EventUtil } from './event';
 
 import { IpcLogger } from '../support/log';
+import { CommonUtil } from '../support/util';
 
 const log = new IpcLogger({ level: 'debug' });
 
@@ -82,7 +82,7 @@ export class Compiler {
     process.removeAllListeners('disconnect');
     process.removeAllListeners('message');
     this.#ctrl.abort();
-    setTimeout(() => process.exit(), 1000).unref(); // Allow upto 1s to shutdown gracefully
+    CommonUtil.nonBlockingTimeout(1000).then(() => process.exit()); // Allow upto 1s to shutdown gracefully
   }
 
   /**
@@ -113,7 +113,7 @@ export class Compiler {
     }
     EventUtil.sendEvent('progress', { total: files.length, idx: files.length, message: 'Complete', operation: 'compile', complete: true });
 
-    await timers.setTimeout(1);
+    await CommonUtil.queueMacroTask();
 
     log.debug(`Compiled ${i} files`);
   }

package/support/entry.trvc.ts

@@ -91,7 +91,7 @@ export const main = (ctx: ManifestContext) => {
     },
 
     /** Build and return a loader */
-    async getLoader(): Promise<(mod: string) => Promise<unknown>> {
+    async getLoader(): Promise<(mod: string, args?: string[]) => Promise<unknown>> {
       Log.initLevel('none');
       if (!(await client.isWatching())) { // Short circuit if we can
         Log.initLevel('error');

package/support/server/client.ts

@@ -6,6 +6,7 @@ import { ManifestContext } from '@travetto/manifest';
 
 import type { CompilerEvent, CompilerEventType, CompilerServerInfo, CompilerStateType } from '../types';
 import type { LogShape } from '../log';
+import { CommonUtil } from '../util';
 import { ProcessHandle } from './process-handle';
 
 type FetchEventsConfig<T> = {
@@ -14,6 +15,12 @@ type FetchEventsConfig<T> = {
   enforceIteration?: boolean;
 };
 
+const streamAgent = new Agent({
+  keepAlive: true,
+  keepAliveMsecs: 10000,
+  timeout: 1000 * 60 * 60 * 24
+});
+
 /**
  * Compiler Client Operations
  */
@@ -37,23 +44,26 @@ export class CompilerClient {
     return this.#url;
   }
 
-  async #fetch(rel: string, opts?: RequestInit & { timeout?: number }, logTimeout = true): Promise<Response> {
+  async #fetch(rel: string, opts?: RequestInit & { timeout?: number }, logTimeout = true): Promise<{ ok: boolean, text: string }> {
     const ctrl = new AbortController();
+    const timeoutCtrl = new AbortController();
+
     opts?.signal?.addEventListener('abort', () => ctrl.abort());
-    const timeoutId = setTimeout(() => {
-      logTimeout && this.#log.error(`Timeout on request to ${this.#url}${rel}`);
-      ctrl.abort('TIMEOUT');
-    }, opts?.timeout ?? 100).unref();
-    try {
-      return await fetch(`${this.#url}${rel}`, { ...opts, signal: ctrl.signal });
-    } finally {
-      clearTimeout(timeoutId);
-    }
+    timers.setTimeout(opts?.timeout ?? 100, undefined, { ref: false, signal: timeoutCtrl.signal })
+      .then(() => {
+        logTimeout && this.#log.error(`Timeout on request to ${this.#url}${rel}`);
+        ctrl.abort('TIMEOUT');
+      })
+      .catch(() => { });
+    const res = await fetch(`${this.#url}${rel}`, { ...opts, signal: ctrl.signal });
+    const out = { ok: res.ok, text: await res.text() };
+    timeoutCtrl.abort();
+    return out;
   }
 
   /** Get server information, if server is running */
   info(): Promise<CompilerServerInfo | undefined> {
-    return this.#fetch('/info', { timeout: 200 }, false).then(v => v.json(), () => undefined)
+    return this.#fetch('/info', { timeout: 200 }, false).then(v => JSON.parse(v.text), () => undefined)
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       .then(v => v as CompilerServerInfo);
   }
@@ -110,22 +120,16 @@ export class CompilerClient {
       const quit = (): void => ctrl.abort();
       try {
         signal.addEventListener('abort', quit);
-        const res = await new Promise<http.IncomingMessage>(resolve => {
-          http.get(`${this.#url}/event/${type}`, {
-            agent: new Agent({
-              keepAlive: true,
-              keepAliveMsecs: 10000,
-              timeout: 1000 * 60 * 60 * 24
-            }),
-            signal: ctrl.signal
-          }, res => resolve(res))
-        });
-
-        for await (const line of rl.createInterface(res)) {
+        const response = await new Promise<http.IncomingMessage>((resolve, reject) =>
+          http.get(`${this.#url}/event/${type}`, { agent: streamAgent, signal: ctrl.signal }, resolve)
+            .on('error', reject)
+        );
+
+        for await (const line of rl.createInterface(response)) {
           if (line.trim().charAt(0) === '{') {
             const val = JSON.parse(line);
             if (cfg.until?.(val)) {
-              await timers.setTimeout(1);
+              await CommonUtil.queueMacroTask();
               ctrl.abort();
             }
             yield val;
@@ -136,7 +140,7 @@ export class CompilerClient {
       }
       signal.removeEventListener('abort', quit);
 
-      await timers.setTimeout(1);
+      await CommonUtil.queueMacroTask();
 
       info = await this.info();
 

package/support/server/process-handle.ts

@@ -1,9 +1,9 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import timers from 'node:timers/promises';
 
 import type { ManifestContext } from '@travetto/manifest';
 import { Log, Logger } from '../log';
+import { CommonUtil } from '../util';
 
 export class ProcessHandle {
 
@@ -56,7 +56,7 @@ export class ProcessHandle {
       if (!await this.isRunning()) {
         return true;
       }
-      await timers.setTimeout(100);
+      await CommonUtil.nonBlockingTimeout(100);
     }
     try {
       this.#log.debug('Force Killing', pid);

package/support/server/server.ts

@@ -77,7 +77,7 @@ export class CompilerServer {
         .on('close', () => log.debug('Server close event'));
 
       const url = new URL(this.#url);
-      setTimeout(() => this.#server.listen(+url.port, url.hostname), 1); // Run async
+      CommonUtil.queueMacroTask().then(() => this.#server.listen(+url.port, url.hostname)); // Run async
     });
 
     if (output === 'retry') {
@@ -86,7 +86,7 @@ export class CompilerServer {
       }
       log.info('Waiting for build to finish, before retrying');
       // Let the server finish
-      await this.#client.waitForState(['close'], 'Server closed', this.signal);
+      await this.#client.waitForState(['closed'], 'Server closed', this.signal);
       return this.#tryListen(attempt + 1);
     } else if (output === 'ok') {
       await this.#handle.server.writePid(this.info.serverPid);
@@ -121,7 +121,7 @@ export class CompilerServer {
   async #disconnectActive(): Promise<void> {
     log.info('Server disconnect requested');
     this.info.iteration = Date.now();
-    await new Promise(r => setTimeout(r, 20));
+    await CommonUtil.nonBlockingTimeout(20);
     for (const el of Object.values(this.#listeners)) {
       try { el.res.end(); } catch { }
     }
@@ -204,9 +204,9 @@ export class CompilerServer {
 
     try {
       await new Promise((resolve, reject) => {
-        setTimeout(reject, 2000).unref(); // 2s max wait
+        CommonUtil.nonBlockingTimeout(2000).then(reject); // Wait 2s max
         this.#server.close(resolve);
-        this.#emitEvent({ type: 'state', payload: { state: 'close' } });
+        this.#emitEvent({ type: 'state', payload: { state: 'closed' } });
         setImmediate(() => {
           this.#server.closeAllConnections();
           this.#shutdown.abort();

package/support/types.ts

@@ -1,6 +1,6 @@
 export type CompilerMode = 'build' | 'watch';
 
-export type CompilerStateType = 'startup' | 'init' | 'compile-start' | 'compile-end' | 'watch-start' | 'watch-end' | 'reset' | 'close';
+export type CompilerStateType = 'startup' | 'init' | 'compile-start' | 'compile-end' | 'watch-start' | 'watch-end' | 'reset' | 'closed';
 export type CompilerChangeEvent = { file: string, action: 'create' | 'update' | 'delete', output: string, module: string, time: number };
 export type CompilerLogLevel = 'info' | 'debug' | 'warn' | 'error';
 export type CompilerLogEvent = { level: CompilerLogLevel, message: string, time?: number, args?: unknown[], scope?: string };

package/support/util.ts

@@ -1,5 +1,6 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
+import timers from 'node:timers/promises';
 import { setMaxListeners } from 'node:events';
 
 import type { ManifestContext } from '@travetto/manifest';
@@ -95,11 +96,28 @@ export class CommonUtil {
    * Create a module loader given a context, and assuming build is complete
    * @param ctx
    */
-  static moduleLoader(ctx: ManifestContext): (mod: string) => Promise<unknown> {
-    return (mod) => {
+  static moduleLoader(ctx: ManifestContext): (mod: string, args?: string[]) => Promise<unknown> {
+    return (mod, args) => {
       const outputRoot = path.resolve(ctx.workspace.path, ctx.build.outputFolder);
       process.env.TRV_MANIFEST = path.resolve(outputRoot, 'node_modules', ctx.main.name); // Setup for running
+      if (args) {
+        process.argv = [process.argv0, mod, ...args];
+      }
       return import(path.join(outputRoot, 'node_modules', mod)); // Return function to run import on a module
     };
   }
+
+  /**
+   * Non-blocking timeout, that is cancellable
+   */
+  static nonBlockingTimeout(time: number): Promise<void> {
+    return timers.setTimeout(time, undefined, { ref: false }).catch(() => { });
+  }
+
+  /**
+   * Queue new macrotask
+   */
+  static queueMacroTask(): Promise<void> {
+    return timers.setImmediate(undefined);
+  }
 }