@travetto/compiler 7.0.0-rc.0 → 7.0.0-rc.2

package/support/server/process-handle.ts

@@ -16,35 +16,35 @@ export class ProcessHandle {
     this.#log = Log.scoped(`process-handle.${name}`);
   }
 
-  async writePid(pid: number): Promise<void> {
+  async writePidFile(processId: number): Promise<void> {
     await fs.mkdir(path.dirname(this.#file), { recursive: true });
-    return fs.writeFile(this.#file, JSON.stringify(pid), 'utf8');
+    return fs.writeFile(this.#file, JSON.stringify(processId), 'utf8');
   }
 
-  getPid(): Promise<number | undefined> {
+  getProcessId(): Promise<number | undefined> {
     return fs.readFile(this.#file, 'utf8')
-      .then(v => +v > 0 ? +v : undefined, () => undefined);
+      .then(processId => +processId > 0 ? +processId : undefined, () => undefined);
   }
 
   async isRunning(): Promise<boolean> {
-    const pid = await this.getPid();
-    if (!pid) { return false; }
+    const processId = await this.getProcessId();
+    if (!processId) { return false; }
     try {
-      process.kill(pid, 0); // See if process is still running
-      this.#log.debug('Is running', pid);
+      process.kill(processId, 0); // See if process is still running
+      this.#log.debug('Is running', processId);
       return true;
     } catch {
-      this.#log.debug('Is not running', pid);
+      this.#log.debug('Is not running', processId);
     }
     return false; // Not running
   }
 
   async kill(): Promise<boolean> {
-    const pid = await this.getPid();
-    if (pid && await this.isRunning()) {
+    const processId = await this.getProcessId();
+    if (processId && await this.isRunning()) {
       try {
-        this.#log.debug('Killing', pid);
-        return process.kill(pid);
+        this.#log.debug('Killing', processId);
+        return process.kill(processId);
       } catch { }
     }
     return false;
@@ -52,12 +52,12 @@ export class ProcessHandle {
 
   async ensureKilled(gracePeriod: number = 3000): Promise<boolean> {
     const start = Date.now();
-    const pid = await this.getPid();
-    if (!pid) {
+    const processId = await this.getProcessId();
+    if (!processId) {
       return false;
     }
 
-    this.#log.debug('Ensuring Killed', pid);
+    this.#log.debug('Ensuring Killed', processId);
     while ((Date.now() - start) < gracePeriod) { // Ensure its done
       if (!await this.isRunning()) {
         return true;
@@ -65,10 +65,10 @@ export class ProcessHandle {
       await CommonUtil.blockingTimeout(100);
     }
     try {
-      this.#log.debug('Force Killing', pid);
-      process.kill(pid); // Force kill
+      this.#log.debug('Force Killing', processId);
+      process.kill(processId); // Force kill
     } catch { }
-    this.#log.debug('Did Kill', this.#file, !!pid);
+    this.#log.debug('Did Kill', this.#file, !!processId);
     return true;
   }
 }

package/support/server/runner.ts

@@ -9,7 +9,7 @@ import { Log } from '../log.ts';
 import { CommonUtil } from '../util.ts';
 
 const log = Log.scoped('compiler-exec');
-const isEvent = (msg: unknown): msg is CompilerEvent => !!msg && typeof msg === 'object' && 'type' in msg;
+const isEvent = (value: unknown): value is CompilerEvent => !!value && typeof value === 'object' && 'type' in value;
 
 /**
  * Running the compiler
@@ -31,13 +31,14 @@ export class CompilerRunner {
       log.debug('Skipped');
       return;
     } else {
-      log.debug(`Started watch=${watch} changed=${changed.slice(0, 10).map(x => `${x.module}/${x.file}`)}`);
+      const changedList = changed.slice(0, 10).map(event => `${event.module}/${event.file}`);
+      log.debug(`Started watch=${watch} changed=${changedList}`);
     }
 
     const main = CommonUtil.resolveWorkspace(ctx, ctx.build.compilerFolder, 'node_modules', '@travetto/compiler/support/entry.compiler.js');
     const deltaFile = CommonUtil.resolveWorkspace(ctx, ctx.build.compilerFolder, `manifest-delta-${Date.now()}.json`);
 
-    const changedFiles = changed[0]?.file === '*' ? ['*'] : changed.map(ev => ev.sourceFile);
+    const changedFiles = changed[0]?.file === '*' ? ['*'] : changed.map(event => event.sourceFile);
 
     const queue = new AsyncQueue<CompilerEvent>();
 
@@ -45,7 +46,7 @@ export class CompilerRunner {
       await CommonUtil.writeTextFile(deltaFile, changedFiles.join('\n'));
 
       log.info('Launching compiler');
-      const proc = cp.spawn(process.argv0, [main, deltaFile, `${watch}`], {
+      const subProcess = cp.spawn(process.argv0, [main, deltaFile, `${watch}`], {
         env: {
           ...process.env,
           TRV_MANIFEST: CommonUtil.resolveWorkspace(ctx, ctx.build.outputFolder, 'node_modules', ctx.workspace.name),
@@ -53,12 +54,12 @@ export class CompilerRunner {
         detached: true,
         stdio: ['pipe', 1, 2, 'ipc'],
       })
-        .on('message', msg => isEvent(msg) && queue.add(msg))
+        .on('message', message => isEvent(message) && queue.add(message))
         .on('exit', () => queue.close());
 
       const kill = (): unknown => {
         log.debug('Shutting down process');
-        return (proc.connected ? proc.send('shutdown', () => proc.kill()) : proc.kill());
+        return (subProcess.connected ? subProcess.send('shutdown', () => subProcess.kill()) : subProcess.kill());
       };
 
       process.once('SIGINT', kill);
@@ -66,8 +67,8 @@ export class CompilerRunner {
 
       yield* queue;
 
-      if (proc.exitCode !== 0) {
-        log.error(`Terminated during compilation, code=${proc.exitCode}, killed=${proc.killed}`);
+      if (subProcess.exitCode !== 0) {
+        log.error(`Terminated during compilation, code=${subProcess.exitCode}, killed=${subProcess.killed}`);
       }
       process.off('SIGINT', kill);
 

package/support/server/server.ts

@@ -37,8 +37,8 @@ export class CompilerServer {
       state: 'startup',
       iteration: Date.now(),
       mode,
-      serverPid: process.pid,
-      compilerPid: -1,
+      serverProcessId: process.pid,
+      compilerProcessId: -1,
       path: ctx.workspace.path,
       url: this.#url
     };
@@ -47,7 +47,7 @@ export class CompilerServer {
       keepAlive: true,
       requestTimeout: 1000 * 60 * 60,
       keepAliveTimeout: 1000 * 60 * 60,
-    }, (req, res) => this.#onRequest(req, res));
+    }, (request, response) => this.#onRequest(request, response));
 
     setMaxListeners(1000, this.signal);
   }
@@ -60,21 +60,21 @@ export class CompilerServer {
     return this.info.mode;
   }
 
-  isResetEvent(ev: CompilerEvent): boolean {
-    return ev.type === 'state' && ev.payload.state === 'reset';
+  isResetEvent(event: CompilerEvent): boolean {
+    return event.type === 'state' && event.payload.state === 'reset';
   }
 
   async #tryListen(attempt = 0): Promise<'ok' | 'running'> {
     const output = await new Promise<'ok' | 'running' | 'retry'>((resolve, reject) => {
       this.#server
         .on('listening', () => resolve('ok'))
-        .on('error', async err => {
-          if ('code' in err && err.code === 'EADDRINUSE') {
+        .on('error', async error => {
+          if ('code' in error && error.code === 'EADDRINUSE') {
             const info = await this.#client.info();
             resolve((info && info.mode === 'build' && this.mode === 'watch') ? 'retry' : 'running');
           } else {
-            log.warn('Failed in running server', err);
-            reject(err);
+            log.warn('Failed in running server', error);
+            reject(error);
           }
         })
         .on('close', () => log.debug('Server close event'));
@@ -92,48 +92,48 @@ export class CompilerServer {
       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);
+      await this.#handle.server.writePidFile(this.info.serverProcessId);
     }
 
     return output;
   }
 
-  #addListener(type: CompilerEventType | 'all', res: http.ServerResponse): void {
-    res.writeHead(200);
+  #addListener(type: CompilerEventType | 'all', response: http.ServerResponse): void {
+    response.writeHead(200);
     const id = `id_${Date.now()}_${Math.random()}`.replace('.', '1');
-    (this.#listeners[type] ??= {})[id] = res;
-    this.#listenersAll.add(res);
+    (this.#listeners[type] ??= {})[id] = response;
+    this.#listenersAll.add(response);
     if (type === 'state' || type === 'all') { // Send on initial connect
       this.#emitEvent({ type: 'state', payload: { state: this.info.state } }, id);
     } else {
-      res.write('\n'); // Send at least one byte on listen
+      response.write('\n'); // Send at least one byte on listen
     }
 
     // Do not wait on it
-    res.on('close', () => {
+    response.on('close', () => {
       delete this.#listeners[type]?.[id];
-      this.#listenersAll.delete(res);
+      this.#listenersAll.delete(response);
     });
   }
 
-  #emitEvent(ev: CompilerEvent, to?: string): void {
+  #emitEvent(event: CompilerEvent, to?: string): void {
     if (this.#listeners.all) {
-      const msg = JSON.stringify(ev);
+      const eventText = JSON.stringify(event);
       for (const [id, item] of Object.entries(this.#listeners.all)) {
         if (item.closed || (to && id !== to)) {
           continue;
         }
-        item.write(msg);
+        item.write(eventText);
         item.write('\n');
       }
     }
-    if (this.#listeners[ev.type]) {
-      const msg = JSON.stringify(ev.payload);
-      for (const [id, item] of Object.entries(this.#listeners[ev.type]!)) {
+    if (this.#listeners[event.type]) {
+      const eventText = JSON.stringify(event.payload);
+      for (const [id, item] of Object.entries(this.#listeners[event.type]!)) {
         if (item.closed || (to && id !== to)) {
           continue;
         }
-        item.write(msg);
+        item.write(eventText);
         item.write('\n');
       }
     }
@@ -143,8 +143,8 @@ export class CompilerServer {
     log.info('Server disconnect requested');
     this.info.iteration = Date.now();
     await CommonUtil.blockingTimeout(20);
-    for (const el of this.#listenersAll) {
-      try { el.end(); } catch { }
+    for (const listener of this.#listenersAll) {
+      try { listener.end(); } catch { }
     }
     this.#listeners = {}; // Ensure its empty
     this.#listenersAll.clear();
@@ -152,17 +152,17 @@ export class CompilerServer {
 
   async #clean(): Promise<{ clean: boolean }> {
     await Promise.all([this.#ctx.build.compilerFolder, this.#ctx.build.outputFolder]
-      .map(f => fs.rm(CommonUtil.resolveWorkspace(this.#ctx, f), { recursive: true, force: true })));
+      .map(folder => fs.rm(CommonUtil.resolveWorkspace(this.#ctx, folder), { recursive: true, force: true })));
     return { clean: true };
   }
 
   /**
    * Request handler
    */
-  async #onRequest(req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
-    res.setHeader('Content-Type', 'application/json');
+  async #onRequest(request: http.IncomingMessage, response: http.ServerResponse): Promise<void> {
+    response.setHeader('Content-Type', 'application/json');
 
-    const [, action, subAction] = new URL(`${this.#url}${req.url}`).pathname.split('/');
+    const [, action, subAction] = new URL(`${this.#url}${request.url}`).pathname.split('/');
 
     let out: unknown;
     let close = false;
@@ -170,7 +170,7 @@ export class CompilerServer {
       case 'event': {
         switch (subAction) {
           case 'change': case 'log': case 'progress': case 'state': case 'all':
-            return this.#addListener(subAction, res);
+            return this.#addListener(subAction, response);
           default: return;
         }
       }
@@ -179,7 +179,7 @@ export class CompilerServer {
       case 'info':
       default: out = this.info ?? {}; break;
     }
-    res.end(JSON.stringify(out));
+    response.end(JSON.stringify(out));
     if (close) {
       await this.close();
     }
@@ -188,29 +188,29 @@ export class CompilerServer {
   /**
    * Process events
    */
-  async processEvents(src: (signal: AbortSignal) => AsyncIterable<CompilerEvent>): Promise<void> {
-    for await (const ev of CommonUtil.restartableEvents(src, this.signal, this.isResetEvent)) {
-      if (ev.type === 'progress') {
-        await Log.onProgressEvent(ev.payload);
+  async processEvents(input: (signal: AbortSignal) => AsyncIterable<CompilerEvent>): Promise<void> {
+    for await (const event of CommonUtil.restartableEvents(input, this.signal, this.isResetEvent)) {
+      if (event.type === 'progress') {
+        await Log.onProgressEvent(event.payload);
       }
 
-      this.#emitEvent(ev);
+      this.#emitEvent(event);
 
-      if (ev.type === 'state') {
-        this.info.state = ev.payload.state;
-        if (ev.payload.state === 'init' && ev.payload.extra && 'pid' in ev.payload.extra && typeof ev.payload.extra.pid === 'number') {
-          if (this.info.mode === 'watch' && !this.info.compilerPid) {
+      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 (this.info.mode === 'watch' && !this.info.compilerProcessId) {
             // Ensure we are killing in watch mode on first set
             await this.#handle.compiler.kill();
           }
-          this.info.compilerPid = ev.payload.extra.pid;
-          await this.#handle.compiler.writePid(this.info.compilerPid);
+          this.info.compilerProcessId = event.payload.extra.processId;
+          await this.#handle.compiler.writePidFile(this.info.compilerProcessId);
         }
         log.info(`State changed: ${this.info.state}`);
-      } else if (ev.type === 'log') {
-        log.render(ev.payload);
+      } else if (event.type === 'log') {
+        log.render(event.payload);
       }
-      if (this.isResetEvent(ev)) {
+      if (this.isResetEvent(event)) {
         await this.#disconnectActive();
       }
     }

package/support/setup.ts

@@ -13,10 +13,10 @@ type ModFile = { input: string, output: string, stale: boolean };
 const SOURCE_SEED = ['package.json', '__index__.ts', 'src', 'support', 'bin'];
 const PRECOMPILE_MODS = ['@travetto/manifest', '@travetto/transformer', '@travetto/compiler'];
 const RECENT_STAT = (stat: { ctimeMs: number, mtimeMs: number }): number => Math.max(stat.ctimeMs, stat.mtimeMs);
-const REQ = createRequire(path.resolve('node_modules')).resolve.bind(null);
+const REQUIRE = createRequire(path.resolve('node_modules')).resolve.bind(null);
 
-const SOURCE_EXT_RE = /[.][cm]?[tj]s$/;
-const BARE_IMPORT_RE = /^(@[^/]+[/])?[^.][^@/]+$/;
+const SOURCE_EXT_REGEX = /[.][cm]?[tj]s$/;
+const BARE_IMPORT_REGEX = /^(@[^/]+[/])?[^.][^@/]+$/;
 const OUTPUT_EXT = '.js';
 
 /**
@@ -30,15 +30,15 @@ export class CompilerSetup {
   static #importManifest = (ctx: ManifestContext): Promise<
     Pick<typeof import('@travetto/manifest'), 'ManifestDeltaUtil' | 'ManifestUtil'>
   > => {
-    const all = ['util', 'delta'].map(f =>
-      import(CommonUtil.resolveWorkspace(ctx, ctx.build.compilerFolder, 'node_modules', `@travetto/manifest/src/${f}${OUTPUT_EXT}`))
+    const all = ['util', 'delta'].map(file =>
+      import(CommonUtil.resolveWorkspace(ctx, ctx.build.compilerFolder, 'node_modules', `@travetto/manifest/src/${file}${OUTPUT_EXT}`))
     );
-    return Promise.all(all).then(props => Object.assign({}, ...props));
+    return Promise.all(all).then(results => Object.assign({}, ...results));
   };
 
   /**  Convert a file to a given ext */
   static #sourceToExtension(sourceFile: string, ext: string): string {
-    return sourceFile.replace(SOURCE_EXT_RE, ext);
+    return sourceFile.replace(SOURCE_EXT_REGEX, ext);
   }
 
   /**
@@ -57,11 +57,11 @@ export class CompilerSetup {
       const compilerOut = CommonUtil.resolveWorkspace(ctx, ctx.build.compilerFolder, 'node_modules');
 
       const text = (await fs.readFile(sourceFile, 'utf8'))
-        .replace(/from ['"](([.]+|@travetto)[/][^']+)['"]/g, (_, clause, m) => {
-          const s = this.#sourceToOutputExt(clause);
-          const suf = s.endsWith(OUTPUT_EXT) ? '' : (BARE_IMPORT_RE.test(clause) ? `/__index__${OUTPUT_EXT}` : OUTPUT_EXT);
-          const pre = m === '@travetto' ? `${compilerOut}/` : '';
-          return `from '${pre}${s}${suf}'`;
+        .replace(/from ['"](([.]+|@travetto)[/][^']+)['"]/g, (_, clause, moduleName) => {
+          const root = this.#sourceToOutputExt(clause);
+          const suffix = root.endsWith(OUTPUT_EXT) ? '' : (BARE_IMPORT_REGEX.test(clause) ? `/__index__${OUTPUT_EXT}` : OUTPUT_EXT);
+          const prefix = moduleName === '@travetto' ? `${compilerOut}/` : '';
+          return `from '${prefix}${root}${suffix}'`;
         });
 
       const ts = (await import('typescript')).default;
@@ -75,7 +75,7 @@ export class CompilerSetup {
     } else if (type === 'package-json') {
       const pkg: Package = JSON.parse(await fs.readFile(sourceFile, 'utf8'));
       const main = pkg.main ? this.#sourceToOutputExt(pkg.main) : undefined;
-      const files = pkg.files?.map(x => this.#sourceToOutputExt(x));
+      const files = pkg.files?.map(file => this.#sourceToOutputExt(file));
 
       const content = JSON.stringify({ ...pkg, main, type: ctx.workspace.type, files }, null, 2);
       await CommonUtil.writeTextFile(outputFile, content);
@@ -86,10 +86,10 @@ export class CompilerSetup {
    * Scan directory to find all project sources for comparison
    */
   static async #getModuleSources(ctx: ManifestContext, module: string, seed: string[]): Promise<ModFile[]> {
-    const inputFolder = path.dirname(REQ(`${module}/package.json`));
+    const inputFolder = path.dirname(REQUIRE(`${module}/package.json`));
 
-    const folders = seed.filter(x => !/[.]/.test(x)).map(x => path.resolve(inputFolder, x));
-    const files = seed.filter(x => /[.]/.test(x)).map(x => path.resolve(inputFolder, x));
+    const folders = seed.filter(folder => !/[.]/.test(folder)).map(folder => path.resolve(inputFolder, folder));
+    const files = seed.filter(file => /[.]/.test(file)).map(file => path.resolve(inputFolder, file));
 
     while (folders.length) {
       const sub = folders.pop();
@@ -134,18 +134,20 @@ export class CompilerSetup {
    */
   static async #compileIfStale(ctx: ManifestContext, scope: string, mod: string, seed: string[]): Promise<string[]> {
     const files = await this.#getModuleSources(ctx, mod, seed);
-    const changes = files.filter(x => x.stale).map(x => x.input);
+    const changes = files.filter(file => file.stale).map(file => file.input);
     const out: string[] = [];
 
     try {
       await Log.wrap(scope, async log => {
-        if (files.some(f => f.stale)) {
+        if (files.some(file => file.stale)) {
           log.debug('Starting', mod);
-          for (const file of files.filter(x => x.stale)) {
-            await this.#transpileFile(ctx, file.input, file.output);
+          for (const file of files) {
+            if (file.stale) {
+              await this.#transpileFile(ctx, file.input, file.output);
+            }
           }
           if (changes.length) {
-            out.push(...changes.map(x => `${mod}/${x}`));
+            out.push(...changes.map(file => `${mod}/${file}`));
             log.debug(`Source changed: ${changes.join(', ')}`, mod);
           }
           log.debug('Completed', mod);
@@ -153,8 +155,8 @@ export class CompilerSetup {
           log.debug('Skipped', mod);
         }
       }, false);
-    } catch (err) {
-      console.error(err);
+    } catch (error) {
+      console.error(error);
     }
     return out;
   }
@@ -195,8 +197,11 @@ export class CompilerSetup {
       ManifestUtil.buildManifest(ManifestUtil.getWorkspaceContext(ctx)));
 
     await Log.wrap('transformers', async () => {
-      for (const mod of Object.values(manifest.modules).filter(m => m.files.$transformer?.length)) {
-        changes += (await this.#compileIfStale(ctx, 'transformers', mod.name, ['package.json', ...mod.files.$transformer!.map(x => x[0])])).length;
+      for (const mod of Object.values(manifest.modules)) {
+        if (mod.files.$transformer?.length) {
+          changes += (await this.#compileIfStale(ctx, 'transformers', mod.name,
+            ['package.json', ...mod.files.$transformer!.map(file => file[0])])).length;
+        }
       }
     });
 
@@ -224,18 +229,18 @@ export class CompilerSetup {
       // Update all manifests when in mono repo
       if (delta.length && ctx.workspace.mono) {
         const names: string[] = [];
-        const mods = Object.values(manifest.modules).filter(x => x.workspace && x.name !== ctx.workspace.name);
+        const mods = Object.values(manifest.modules).filter(mod => mod.workspace && mod.name !== ctx.workspace.name);
         for (const mod of mods) {
           const modCtx = ManifestUtil.getModuleContext(ctx, mod.sourceFolder, true);
           const modManifest = await ManifestUtil.buildManifest(modCtx);
           await ManifestUtil.writeManifest(modManifest);
           names.push(mod.name);
         }
-        log.debug(`Changes triggered ${delta.slice(0, 10).map(x => `${x.type}:${x.module}:${x.file}`)}`);
+        log.debug(`Changes triggered ${delta.slice(0, 10).map(event => `${event.type}:${event.module}:${event.file}`)}`);
         log.debug(`Rewrote monorepo manifests [changes=${delta.length}] ${names.slice(0, 10).join(', ')}`);
       }
     });
 
-    return delta.filter(x => x.type === 'added' || x.type === 'changed');
+    return delta.filter(event => event.type === 'added' || event.type === 'changed');
   }
 }

package/support/types.ts

@@ -17,8 +17,8 @@ export type CompilerEventType = CompilerEvent['type'];
 
 export type CompilerServerInfo = {
   path: string;
-  serverPid: number;
-  compilerPid: number;
+  serverProcessId: number;
+  compilerProcessId: number;
   state: CompilerStateType;
   mode: CompilerMode;
   iteration: number;

package/support/util.ts

@@ -29,7 +29,7 @@ export class CommonUtil {
   /**
    * Restartable Event Stream
    */
-  static async * restartableEvents<T>(src: (signal: AbortSignal) => AsyncIterable<T>, parent: AbortSignal, shouldRestart: (item: T) => boolean): AsyncIterable<T> {
+  static async * restartableEvents<T>(input: (signal: AbortSignal) => AsyncIterable<T>, parent: AbortSignal, shouldRestart: (item: T) => boolean): AsyncIterable<T> {
     const log = Log.scoped('event-stream');
     outer: while (!parent.aborted) {
       const controller = new AbortController();
@@ -38,14 +38,14 @@ export class CommonUtil {
       const kill = (): void => controller.abort();
       parent.addEventListener('abort', kill);
 
-      const comp = src(controller.signal);
+      const comp = input(controller.signal);
 
       log.debug('Started event stream');
 
       // Wait for all events, close at the end
-      for await (const ev of comp) {
-        yield ev;
-        if (shouldRestart(ev)) {
+      for await (const event of comp) {
+        yield event;
+        if (shouldRestart(event)) {
           log.debug('Restarting stream');
           controller.abort(); // Ensure terminated of process
           parent.removeEventListener('abort', kill);