@travetto/compiler 8.0.0-alpha.2 → 8.0.0-alpha.21

package/src/server/client.ts

@@ -1,13 +1,13 @@
-import rl from 'node:readline/promises';
-import timers from 'node:timers/promises';
 import fs from 'node:fs/promises';
 import http, { Agent } from 'node:http';
+import rl from 'node:readline/promises';
+import timers from 'node:timers/promises';
 
 import type { ManifestContext } from '@travetto/manifest';
 
-import type { CompilerEventPayload, CompilerEventType, CompilerServerInfo, CompilerStateType } from '../types.ts';
-import type { LogShape } from '../log.ts';
 import { CommonUtil } from '../common.ts';
+import type { LogShape } from '../log.ts';
+import type { CompilerEventPayload, CompilerEventType, CompilerServerInfo, CompilerStateType } from '../types.ts';
 import { ProcessHandle } from './process-handle.ts';
 
 type FetchEventsConfig<T> = {
@@ -26,7 +26,6 @@ const streamAgent = new Agent({
  * Compiler Client Operations
  */
 export class CompilerClient {
-
   #url: string;
   #log: LogShape;
   #handle: Record<'compiler' | 'server', ProcessHandle>;
@@ -47,17 +46,18 @@ export class CompilerClient {
     return this.#url;
   }
 
-  async #fetch(urlPath: string, options?: RequestInit & { timeout?: number }, logTimeout = true): Promise<{ ok: boolean, text: string }> {
+  async #fetch(urlPath: string, options?: RequestInit & { timeout?: number }, logTimeout = true): Promise<{ ok: boolean; text: string }> {
     const controller = new AbortController();
     const timeoutController = new AbortController();
 
     options?.signal?.addEventListener('abort', () => controller.abort());
-    timers.setTimeout(options?.timeout ?? 100, undefined, { ref: false, signal: timeoutController.signal })
+    timers
+      .setTimeout(options?.timeout ?? 100, undefined, { ref: false, signal: timeoutController.signal })
       .then(() => {
         logTimeout && this.#log.error(`Timeout on request to ${this.#url}${urlPath}`);
         controller.abort('TIMEOUT');
       })
-      .catch(() => { });
+      .catch(() => {});
     const response = await fetch(`${this.#url}${urlPath}`, { ...options, signal: controller.signal });
     const out = { ok: response.ok, text: await response.text() };
     timeoutController.abort();
@@ -66,7 +66,10 @@ export class CompilerClient {
 
   /** Get server information, if server is running */
   info(): Promise<CompilerServerInfo | undefined> {
-    return this.#fetch('/info', { timeout: 200 }, false).then(response => JSON.parse(response.text), () => undefined);
+    return this.#fetch('/info', { timeout: 200 }, false).then(
+      response => JSON.parse(response.text),
+      () => undefined
+    );
   }
 
   async isWatching(): Promise<boolean> {
@@ -75,13 +78,19 @@ export class CompilerClient {
 
   /** Clean the server */
   async clean(forceOnFailure?: boolean): Promise<boolean> {
-    const result = await this.#fetch('/clean', { timeout: 300 }).then(response => response.ok, () => false);
+    const result = await this.#fetch('/clean', { timeout: 300 }).then(
+      response => response.ok,
+      () => false
+    );
     if (!result && forceOnFailure) {
       this.#log.warn('Clean request failed, forcing cleanup');
       try {
-        await Promise.all([this.#ctx.build.outputFolder, this.#ctx.build.typesFolder]
-          .map(file => fs.rm(CommonUtil.resolveWorkspace(this.#ctx, file), { force: true, recursive: true })));
-      } catch { }
+        await Promise.all(
+          [this.#ctx.build.outputFolder, this.#ctx.build.typesFolder].map(file =>
+            fs.rm(CommonUtil.resolveWorkspace(this.#ctx, file), { force: true, recursive: true })
+          )
+        );
+      } catch {}
     }
     return result;
   }
@@ -91,18 +100,20 @@ export class CompilerClient {
     const info = await this.info();
     if (!info) {
       this.#log.debug('Stopping server, info not found, manual killing');
-      return Promise.all([this.#handle.server.kill(), this.#handle.compiler.kill()])
-        .then(results => results.some(result => result));
+      return Promise.all([this.#handle.server.kill(), this.#handle.compiler.kill()]).then(results => results.some(result => result));
     }
 
-    await this.#fetch('/stop').catch(() => { }); // Trigger
+    await this.#fetch('/stop').catch(() => {}); // Trigger
     this.#log.debug('Waiting for compiler to exit');
     await this.#handle.compiler.ensureKilled();
     return true;
   }
 
   /** Fetch compiler events */
-  async * fetchEvents<V extends CompilerEventType, T extends CompilerEventPayload<V>>(type: V, config: FetchEventsConfig<T> = {}): AsyncIterable<T> {
+  async *fetchEvents<V extends CompilerEventType, T extends CompilerEventPayload<V>>(
+    type: V,
+    config: FetchEventsConfig<T> = {}
+  ): AsyncIterable<T> {
     let info = await this.info();
     if (!info) {
       return;
@@ -121,14 +132,13 @@ export class CompilerClient {
 
     const { iteration } = info;
 
-    for (; ;) {
+    for (;;) {
       const controller = new AbortController();
       const quit = (): void => controller.abort();
       try {
         signal.addEventListener('abort', quit);
         const response = await new Promise<http.IncomingMessage>((resolve, reject) =>
-          http.get(`${this.#url}/event/${type}`, { agent: streamAgent, signal: controller.signal }, resolve)
-            .on('error', reject)
+          http.get(`${this.#url}/event/${type}`, { agent: streamAgent, signal: controller.signal }, resolve).on('error', reject)
         );
 
         for await (const line of rl.createInterface(response)) {
@@ -143,7 +153,9 @@ export class CompilerClient {
         }
       } catch (error) {
         const aborted = controller.signal.aborted || (typeof error === 'object' && error && 'code' in error && error.code === 'ECONNRESET');
-        if (!aborted) { throw error; }
+        if (!aborted) {
+          throw error;
+        }
       }
       signal.removeEventListener('abort', quit);
 
@@ -156,7 +168,8 @@ export class CompilerClient {
         return;
       }
 
-      if (controller.signal.aborted || !info || (config.enforceIteration && info.iteration !== iteration)) { // If health check fails, or aborted
+      if (controller.signal.aborted || !info || (config.enforceIteration && info.iteration !== iteration)) {
+        // If health check fails, or aborted
         this.#log.debug(`Stopping watch for events of type "${type}"`);
         return;
       } else {
@@ -170,10 +183,11 @@ export class CompilerClient {
     const set = new Set(states);
     // Loop until
     this.#log.debug(`Waiting for states, ${states.join(', ')}`);
-    for await (const _ of this.fetchEvents('state', { signal, until: event => set.has(event.state) })) { }
+    for await (const _ of this.fetchEvents('state', { signal, until: event => set.has(event.state) })) {
+    }
     this.#log.debug(`Found state, one of ${states.join(', ')} `);
     if (message) {
       this.#log.info(message);
     }
   }
-}
+}

package/src/server/manager.ts

@@ -2,11 +2,11 @@ import { spawn } from 'node:child_process';
 
 import type { ManifestContext } from '@travetto/manifest';
 
-import type { CompilerEvent, CompilerLogLevel } from '../types.ts';
-import { AsyncQueue } from '../queue.ts';
-import { Log } from '../log.ts';
 import { CommonUtil } from '../common.ts';
 import { EventUtil } from '../event.ts';
+import { Log } from '../log.ts';
+import { AsyncQueue } from '../queue.ts';
+import type { CompilerEvent, CompilerLogLevel } from '../types.ts';
 import type { CompilerClient } from './client.ts';
 import { CompilerServer } from './server.ts';
 
@@ -17,7 +17,7 @@ const log = Log.scoped('compiler-exec');
  */
 export class CompilerManager {
   /** Run compile process */
-  static async * #runTarget(ctx: ManifestContext, watching: boolean, signal: AbortSignal): AsyncIterable<CompilerEvent> {
+  static async *#runTarget(ctx: ManifestContext, watching: boolean, signal: AbortSignal): AsyncIterable<CompilerEvent> {
     if (signal.aborted) {
       log.debug('Skipping, shutting down');
       return;
@@ -30,17 +30,17 @@ export class CompilerManager {
       env: {
         ...process.env,
         TRV_COMPILER_WATCH: String(watching),
-        TRV_MANIFEST: CommonUtil.resolveWorkspace(ctx, ctx.build.outputFolder, 'node_modules', ctx.workspace.name),
+        TRV_MANIFEST: CommonUtil.resolveWorkspace(ctx, ctx.build.outputFolder, 'node_modules', ctx.workspace.name)
       },
       detached: true,
-      stdio: ['pipe', 1, 2, 'ipc'],
+      stdio: ['pipe', 1, 2, 'ipc']
     })
       .on('message', message => EventUtil.isCompilerEvent(message) && queue.add(message))
       .on('exit', () => queue.close());
 
     const kill = (): unknown => {
       log.debug('Shutting down process');
-      return (subProcess.connected ? subProcess.send('shutdown', () => subProcess.kill()) : subProcess.kill());
+      return subProcess.connected ? subProcess.send('shutdown', () => subProcess.kill()) : subProcess.kill();
     };
 
     process.once('SIGINT', kill);
@@ -48,8 +48,9 @@ export class CompilerManager {
 
     yield* queue;
 
-    if (subProcess.exitCode !== 0) {
+    if (subProcess.exitCode !== 0 && subProcess.exitCode) {
       log.error(`Terminated during compilation, code=${subProcess.exitCode}, killed=${subProcess.killed}`);
+      process.exitCode = subProcess.exitCode;
     }
     process.off('SIGINT', kill);
 
@@ -57,11 +58,15 @@ export class CompilerManager {
   }
 
   /** Main entry point for compilation */
-  static async compile(ctx: ManifestContext, client: CompilerClient, config: { watch?: boolean, logLevel?: CompilerLogLevel, forceRestart?: boolean }): Promise<void> {
+  static async compile(
+    ctx: ManifestContext,
+    client: CompilerClient,
+    config: { watch?: boolean; logLevel?: CompilerLogLevel; forceRestart?: boolean }
+  ): Promise<void> {
     Log.initLevel(config.logLevel ?? 'info');
     const watch = !!config.watch;
 
-    if (config.forceRestart && await client.stop()) {
+    if (config.forceRestart && (await client.stop())) {
       log.info('Stopped existing server');
     }
 
@@ -83,8 +88,9 @@ export class CompilerManager {
 
   /** Compile only if necessary */
   static async compileIfNecessary(ctx: ManifestContext, client: CompilerClient): Promise<void> {
-    if (!(await client.isWatching())) { // Short circuit if we can
+    if (!(await client.isWatching())) {
+      // Short circuit if we can
       await this.compile(ctx, client, { watch: false, logLevel: 'error' });
     }
   }
-}
+}

package/src/server/process-handle.ts

@@ -3,11 +3,10 @@ import path from 'node:path';
 
 import type { ManifestContext } from '@travetto/manifest';
 
-import { Log, type Logger } from '../log.ts';
 import { CommonUtil } from '../common.ts';
+import { Log, type Logger } from '../log.ts';
 
 export class ProcessHandle {
-
   #file: string;
   #log: Logger;
 
@@ -22,13 +21,17 @@ export class ProcessHandle {
   }
 
   getProcessId(): Promise<number | undefined> {
-    return fs.readFile(this.#file, 'utf8')
-      .then(processId => +processId > 0 ? +processId : undefined, () => undefined);
+    return fs.readFile(this.#file, 'utf8').then(
+      processId => (+processId > 0 ? +processId : undefined),
+      () => undefined
+    );
   }
 
   async isRunning(): Promise<boolean> {
     const processId = await this.getProcessId();
-    if (!processId) { return false; }
+    if (!processId) {
+      return false;
+    }
     try {
       process.kill(processId, 0); // See if process is still running
       this.#log.debug('Is running', processId);
@@ -41,11 +44,11 @@ export class ProcessHandle {
 
   async kill(): Promise<boolean> {
     const processId = await this.getProcessId();
-    if (processId && await this.isRunning()) {
+    if (processId && (await this.isRunning())) {
       try {
         this.#log.debug('Killing', processId);
         return process.kill(processId);
-      } catch { }
+      } catch {}
     }
     return false;
   }
@@ -58,8 +61,9 @@ export class ProcessHandle {
     }
 
     this.#log.debug('Ensuring Killed', processId);
-    while ((Date.now() - start) < gracePeriod) { // Ensure its done
-      if (!await this.isRunning()) {
+    while (Date.now() - start < gracePeriod) {
+      // Ensure its done
+      if (!(await this.isRunning())) {
         return true;
       }
       await CommonUtil.blockingTimeout(100);
@@ -67,7 +71,7 @@ export class ProcessHandle {
     try {
       this.#log.debug('Force Killing', processId);
       process.kill(processId); // Force kill
-    } catch { }
+    } catch {}
     this.#log.debug('Did Kill', this.#file, !!processId);
     return true;
   }

package/src/server/server.ts

@@ -1,15 +1,15 @@
-import http from 'node:http';
-import fs from 'node:fs/promises';
 import { setMaxListeners } from 'node:events';
+import fs from 'node:fs/promises';
+import http from 'node:http';
 
 import type { ManifestContext } from '@travetto/manifest';
 
-import type { CompilerProgressEvent, CompilerEvent, CompilerEventType, CompilerServerInfo } from '../types.ts';
-import { Log } from '../log.ts';
 import { CommonUtil } from '../common.ts';
+import { EventUtil } from '../event.ts';
+import { Log } from '../log.ts';
+import type { CompilerEvent, CompilerEventType, CompilerProgressEvent, CompilerServerInfo } from '../types.ts';
 import { CompilerClient } from './client.ts';
 import { ProcessHandle } from './process-handle.ts';
-import { EventUtil } from '../event.ts';
 
 const log = Log.scoped('server');
 
@@ -17,7 +17,6 @@ const log = Log.scoped('server');
  * Compiler Server Class
  */
 export class CompilerServer {
-
   #ctx: ManifestContext;
   #server: http.Server;
   #listenersAll = new Set<http.ServerResponse>();
@@ -27,12 +26,14 @@ export class CompilerServer {
   #client: CompilerClient;
   #url: string;
   #handle: Record<'compiler' | 'server', ProcessHandle>;
+  #suppressLogs: boolean;
 
-  constructor(ctx: ManifestContext, watching: boolean) {
+  constructor(ctx: ManifestContext, watching: boolean, suppressLogs?: boolean) {
     this.#ctx = ctx;
     this.#client = new CompilerClient(ctx, Log.scoped('server.client'));
     this.#url = this.#client.url;
     this.#handle = { server: new ProcessHandle(ctx, 'server'), compiler: new ProcessHandle(ctx, 'compiler') };
+    this.#suppressLogs = suppressLogs ?? /^(1|true|on|yes)$/i.test(process.env.TRV_QUIET ?? '');
 
     this.info = {
       state: 'startup',
@@ -44,11 +45,14 @@ export class CompilerServer {
       url: this.#url
     };
 
-    this.#server = http.createServer({
-      keepAlive: true,
-      requestTimeout: 1000 * 60 * 60,
-      keepAliveTimeout: 1000 * 60 * 60,
-    }, (request, response) => this.#onRequest(request, response));
+    this.#server = http.createServer(
+      {
+        keepAlive: true,
+        requestTimeout: 1000 * 60 * 60,
+        keepAliveTimeout: 1000 * 60 * 60
+      },
+      (request, response) => this.#onRequest(request, response)
+    );
 
     setMaxListeners(1000, this.signal);
   }
@@ -72,7 +76,7 @@ export class CompilerServer {
         .on('error', async error => {
           if ('code' in error && error.code === 'EADDRINUSE') {
             const info = await this.#client.info();
-            resolve((info && !info.watching && this.watching) ? 'retry' : 'running');
+            resolve(info && !info.watching && this.watching ? 'retry' : 'running');
           } else {
             log.warn('Failed in running server', error);
             reject(error);
@@ -104,7 +108,8 @@ export class CompilerServer {
     const id = `id_${Date.now()}_${Math.random()}`.replace('.', '1');
     (this.#listeners[type] ??= {})[id] = response;
     this.#listenersAll.add(response);
-    if (type === 'state' || type === 'all') { // Send on initial connect
+    if (type === 'state' || type === 'all') {
+      // Send on initial connect
       this.#emitEvent({ type: 'state', payload: { state: this.info.state } }, id);
     } else {
       response.write('\n'); // Send at least one byte on listen
@@ -144,15 +149,20 @@ export class CompilerServer {
     this.info.iteration = Date.now();
     await CommonUtil.blockingTimeout(20);
     for (const listener of this.#listenersAll) {
-      try { listener.end(); } catch { }
+      try {
+        listener.end();
+      } catch {}
     }
     this.#listeners = {}; // Ensure its empty
     this.#listenersAll.clear();
   }
 
   async #clean(): Promise<{ clean: boolean }> {
-    await Promise.all([this.#ctx.build.outputFolder, this.#ctx.build.typesFolder]
-      .map(folder => fs.rm(CommonUtil.resolveWorkspace(this.#ctx, folder), { recursive: true, force: true })));
+    await Promise.all(
+      [this.#ctx.build.outputFolder, this.#ctx.build.typesFolder].map(folder =>
+        fs.rm(CommonUtil.resolveWorkspace(this.#ctx, folder), { recursive: true, force: true })
+      )
+    );
     return { clean: true };
   }
 
@@ -173,10 +183,16 @@ export class CompilerServer {
         }
         return;
       }
-      case 'clean': out = await this.#clean(); break;
-      case 'stop': out = JSON.stringify({ closing: true }); close = true; break;
-      case 'info':
-      default: out = this.info ?? {}; break;
+      case 'clean':
+        out = await this.#clean();
+        break;
+      case 'stop':
+        out = JSON.stringify({ closing: true });
+        close = true;
+        break;
+      default:
+        out = this.info ?? {};
+        break;
     }
     response.end(JSON.stringify(out));
     if (close) {
@@ -197,7 +213,12 @@ export class CompilerServer {
 
       if (event.type === 'state') {
         this.info.state = event.payload.state;
-        if (event.payload.state === 'init' && event.payload.extra && 'processId' in event.payload.extra && typeof event.payload.extra.processId === 'number') {
+        if (
+          event.payload.state === 'init' &&
+          event.payload.extra &&
+          'processId' in event.payload.extra &&
+          typeof event.payload.extra.processId === 'number'
+        ) {
           if (this.info.watching && !this.info.compilerProcessId) {
             // Ensure we are killing in watch mode on first set
             await this.#handle.compiler.kill();
@@ -207,7 +228,9 @@ export class CompilerServer {
         }
         log.info(`State changed: ${this.info.state}`);
       } else if (event.type === 'log') {
-        log.render(event.payload);
+        if (!this.#suppressLogs) {
+          log.render(event.payload);
+        }
       }
       if (this.isResetEvent(event)) {
         await this.#disconnectActive();
@@ -243,7 +266,8 @@ export class CompilerServer {
           this.#shutdown.abort();
         });
       });
-    } catch { // Timeout or other error
+    } catch {
+      // Timeout or other error
       // Force shutdown
       this.#server.closeAllConnections();
       await this.#handle.compiler.kill();
@@ -256,7 +280,7 @@ export class CompilerServer {
    * Start the server listening
    */
   async listen(): Promise<CompilerServer | undefined> {
-    const running = await this.#tryListen() === 'ok';
+    const running = (await this.#tryListen()) === 'ok';
     log.info(running ? 'Starting server' : 'Server already running under a different process', this.#url);
     return running ? this : undefined;
   }