@travetto/runtime 5.0.0-rc.2

package/src/types.ts

@@ -0,0 +1,12 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export type Class<T = any> = abstract new (...args: any[]) => T;
+export type ConcreteClass<T = any> = new (...args: any[]) => T;
+export type ClassInstance<T = any> = T & {
+  constructor: ConcreteClass<T> & { Ⲑid: string };
+};
+
+export const TypedObject: {
+  keys<T = unknown, K extends keyof T = keyof T>(o: T): K[];
+  fromEntries<K extends string | symbol, V>(items: ([K, V] | readonly [K, V])[]): Record<K, V>;
+  entries<K extends Record<symbol | string, unknown>>(record: K): [keyof K, K[keyof K]][];
+} & ObjectConstructor = Object;

package/src/util.ts

@@ -0,0 +1,104 @@
+import crypto from 'node:crypto';
+import timers from 'node:timers/promises';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+type PromiseWithResolvers<T> = {
+  resolve: (v: T) => void;
+  reject: (err?: unknown) => void;
+  promise: Promise<T>;
+};
+
+type MapFn<T, U> = (val: T, i: number) => U | Promise<U>;
+
+/**
+ * Grab bag of common utilities
+ */
+export class Util {
+
+  /**
+   * Generate a random UUID
+   * @param len The length of the uuid to generate
+   */
+  static uuid(len: number = 32): string {
+    const bytes = crypto.randomBytes(Math.ceil(len / 2));
+    // eslint-disable-next-line no-bitwise
+    bytes[6] = (bytes[6] & 0x0f) | 0x40;
+    // eslint-disable-next-line no-bitwise
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
+    return bytes.toString('hex').substring(0, len);
+  }
+
+  /**
+   * Generate a proper sha512 hash from a src value
+   * @param src The seed value to build the hash from
+   * @param len The optional length of the hash to generate
+   */
+  static hash(src: string, len: number = -1): string {
+    const hash = crypto.createHash('sha512');
+    hash.update(src);
+    const ret = hash.digest('hex');
+    return len > 0 ? ret.substring(0, len) : ret;
+  }
+
+  /**
+   * Produce a promise that is externally resolvable
+   */
+  static resolvablePromise<T = void>(): PromiseWithResolvers<T> {
+    let ops: Pick<PromiseWithResolvers<T>, 'reject' | 'resolve'>;
+    const prom = new Promise<T>((resolve, reject) => ops = { resolve, reject });
+    return { ...ops!, promise: prom };
+  }
+
+  /**
+   * Map an async iterable with various mapping functions
+   */
+  static mapAsyncItr<T, U, V, W>(source: AsyncIterable<T>, fn1: MapFn<T, U>, fn2: MapFn<U, V>, fn3: MapFn<V, W>): AsyncIterable<W>;
+  static mapAsyncItr<T, U, V>(source: AsyncIterable<T>, fn1: MapFn<T, U>, fn2: MapFn<U, V>): AsyncIterable<V>;
+  static mapAsyncItr<T, U>(source: AsyncIterable<T>, fn: MapFn<T, U>): AsyncIterable<U>;
+  static async * mapAsyncItr<T>(source: AsyncIterable<T>, ...fns: MapFn<unknown, unknown>[]): AsyncIterable<unknown> {
+    let idx = -1;
+    for await (const el of source) {
+      if (el !== undefined) {
+        idx += 1;
+        let m = el;
+        for (const fn of fns) {
+          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+          m = (await fn(m, idx)) as typeof m;
+        }
+        yield m;
+      }
+    }
+  }
+
+  /**
+   * Write file and copy over when ready
+   */
+  static async bufferedFileWrite(file: string, content: string): Promise<void> {
+    const temp = path.resolve(path.dirname(file), `.${process.hrtime()[0]}.${path.basename(file)}`);
+    await fs.mkdir(path.dirname(file), { recursive: true });
+    await fs.writeFile(temp, content, 'utf8');
+    await fs.rename(temp, file);
+  }
+
+  /**
+   * Non-blocking timeout
+   */
+  static nonBlockingTimeout(time: number): Promise<void> {
+    return timers.setTimeout(time, undefined, { ref: false }).catch(() => { });
+  }
+
+  /**
+   * Blocking timeout
+   */
+  static blockingTimeout(time: number): Promise<void> {
+    return timers.setTimeout(time, undefined, { ref: true }).catch(() => { });
+  }
+
+  /**
+   * Queue new macrotask
+   */
+  static queueMacroTask(): Promise<void> {
+    return timers.setImmediate(undefined);
+  }
+}

package/src/watch.ts

@@ -0,0 +1,38 @@
+import { RuntimeIndex } from './manifest-index';
+import { ExecUtil } from './exec';
+import { ShutdownManager } from './shutdown';
+import { Util } from './util';
+
+export type WatchEvent = { file: string, action: 'create' | 'update' | 'delete', output: string, module: string, time: number };
+
+export async function* watchCompiler(cfg?: { restartOnExit?: boolean, signal?: AbortSignal }): AsyncIterable<WatchEvent> {
+  // Load at runtime
+  const { CompilerClient } = await import('@travetto/compiler/support/server/client');
+
+  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 ctrl = new AbortController();
+  const remove = ShutdownManager.onGracefulShutdown(async () => ctrl.abort(), watchCompiler);
+
+  await client.waitForState(['compile-end', 'watch-start'], undefined, ctrl.signal);
+
+  if (!await client.isWatching()) { // If we get here, without a watch
+    while (!await client.isWatching()) { // Wait until watch starts
+      await Util.nonBlockingTimeout(1000 * 60);
+    }
+  } else {
+    yield* client.fetchEvents('change', { signal: ctrl.signal, enforceIteration: true });
+  }
+
+  remove();
+
+  if (cfg?.restartOnExit) {
+    // We are done, request restart
+    await ShutdownManager.gracefulShutdown(ExecUtil.RESTART_EXIT_CODE);
+  }
+}

package/support/transformer.console-log.ts

@@ -0,0 +1,113 @@
+import ts from 'typescript';
+
+import {
+  TransformerState, OnCall, LiteralUtil,
+  OnClass, AfterClass, OnMethod, AfterMethod, AfterFunction, OnFunction
+} from '@travetto/transformer';
+
+const CONSOLE_IMPORT = '@travetto/runtime/src/console';
+const MANIFEST_MOD = '@travetto/manifest';
+
+type CustomState = TransformerState & {
+  scope: { type: 'method' | 'class' | 'function', name: string }[];
+  imported?: ts.Identifier;
+};
+
+const VALID_LEVELS: Record<string, string> = {
+  log: 'info',
+  info: 'info',
+  debug: 'debug',
+  warn: 'warn',
+  error: 'error'
+};
+
+/**
+ * Allows for removal of debug log messages depending on whether app is running
+ * in prod mode.
+ */
+export class ConsoleLogTransformer {
+
+  static initState(state: CustomState): void {
+    state.scope = state.scope ?? [];
+  }
+
+  @OnClass()
+  static startClassForLog(state: CustomState, node: ts.ClassDeclaration): typeof node {
+    this.initState(state);
+    state.scope.push({ type: 'class', name: node.name?.text ?? 'unknown' });
+    return node;
+  }
+
+  @AfterClass()
+  static leaveClassForLog(state: CustomState, node: ts.ClassDeclaration): typeof node {
+    state.scope.pop();
+    return node;
+  }
+
+  @OnMethod()
+  static startMethodForLog(state: CustomState, node: ts.MethodDeclaration): typeof node {
+    this.initState(state);
+    let name = 'unknown';
+    if (ts.isIdentifier(node.name) || ts.isPrivateIdentifier(node.name)) {
+      name = node.name?.text ?? name;
+    }
+    state.scope.push({ type: 'method', name });
+    return node;
+  }
+
+  @AfterMethod()
+  static leaveMethodForLog(state: CustomState, node: ts.MethodDeclaration): typeof node {
+    state.scope.pop();
+    return node;
+  }
+
+  @OnFunction()
+  static startFunctionForLog(state: CustomState, node: ts.FunctionDeclaration | ts.FunctionExpression): typeof node {
+    this.initState(state);
+    state.scope.push({ type: 'function', name: node.name?.text ?? 'unknown' });
+    return node;
+  }
+
+  @AfterFunction()
+  static leaveFunctionForLog(state: CustomState, node: ts.FunctionDeclaration | ts.FunctionExpression): typeof node {
+    state.scope.pop();
+    return node;
+  }
+
+  @OnCall()
+  static onLogCall(state: CustomState, node: ts.CallExpression): typeof node | ts.Identifier {
+    if (!ts.isPropertyAccessExpression(node.expression) || state.importName.startsWith(MANIFEST_MOD)) {
+      return node;
+    }
+
+    const chain = node.expression;
+    const name = chain.name;
+    const prop = chain.expression;
+
+    if (!ts.isIdentifier(prop) || prop.escapedText !== 'console' || !ts.isIdentifier(name)) {
+      return node;
+    }
+
+    const level = name.escapedText!;
+
+    if (VALID_LEVELS[level]) {
+      const ident = state.imported ??= state.importFile(CONSOLE_IMPORT, 'ᚕ_c').ident;
+      return state.factory.updateCallExpression(
+        node,
+        state.createAccess(ident, 'log'),
+        node.typeArguments,
+        [
+          LiteralUtil.fromLiteral(state.factory, {
+            level: state.factory.createStringLiteral(VALID_LEVELS[level]),
+            import: state.getModuleIdentifier(),
+            line: state.source.getLineAndCharacterOfPosition(node.getStart(state.source)).line + 1,
+            scope: state.scope?.map(x => x.name).join(':'),
+            args: node.arguments.slice(0)
+          }),
+        ]
+      );
+    } else {
+      return node;
+    }
+  }
+}

package/support/transformer.function-metadata.ts

@@ -0,0 +1,137 @@
+import ts from 'typescript';
+
+import {
+  TransformerState, OnMethod, OnClass, AfterClass,
+  AfterFunction, CoreUtil, SystemUtil, Import
+} from '@travetto/transformer';
+
+import type { FunctionMetadataTag } from '../src/function';
+
+const RUNTIME_MOD = '@travetto/runtime';
+const RUNTIME_MOD_SRC = `${RUNTIME_MOD}/src`;
+const REGISTER_IMPORT = `${RUNTIME_MOD_SRC}/function`;
+
+const methods = Symbol.for(`${RUNTIME_MOD}:methods`);
+const cls = Symbol.for(`${RUNTIME_MOD}:class`);
+const fn = Symbol.for(`${RUNTIME_MOD}:function`);
+const registerImport = Symbol.for(`${RUNTIME_MOD}:registerImport`);
+
+interface MetadataInfo {
+  [registerImport]?: Import;
+  [methods]?: Record<string, FunctionMetadataTag>;
+  [cls]?: FunctionMetadataTag;
+  [fn]?: number;
+}
+
+/**
+ * Providing metadata for classes
+ */
+export class RegisterTransformer {
+
+  static #tag(state: TransformerState, node: ts.Node): FunctionMetadataTag {
+    const hash = SystemUtil.naiveHash(node.getText());
+    try {
+      const range = CoreUtil.getRangeOf(state.source, node) ?? [0, 0];
+      return { hash, lines: range };
+    } catch (err) {
+      return { hash, lines: [0, 0] };
+    }
+  }
+
+  static #valid({ importName: imp }: TransformerState): boolean {
+    return !imp.startsWith(REGISTER_IMPORT);
+  }
+
+  /**
+   * Hash each class
+   */
+  @OnClass()
+  static collectClassMetadata(state: TransformerState & MetadataInfo, node: ts.ClassDeclaration): ts.ClassDeclaration {
+    if (!this.#valid(state)) {
+      return node; // Exclude self
+    }
+    state[cls] = this.#tag(state, node);
+    return node;
+  }
+
+  /**
+   * Hash each method
+   */
+  @OnMethod()
+  static collectMethodMetadata(state: TransformerState & MetadataInfo, node: ts.MethodDeclaration): ts.MethodDeclaration {
+    if (state[cls] && ts.isIdentifier(node.name) && !CoreUtil.isAbstract(node) && ts.isClassDeclaration(node.parent)) {
+      state[methods] ??= {};
+      state[methods]![node.name.escapedText.toString()] = this.#tag(state, node);
+    }
+    return node;
+  }
+
+  /**
+   * After visiting each class, register all the collected metadata
+   */
+  @AfterClass()
+  static registerClassMetadata(state: TransformerState & MetadataInfo, node: ts.ClassDeclaration): ts.ClassDeclaration {
+    if (!state[cls]) {
+      return node;
+    }
+
+    state[registerImport] ??= state.importFile(REGISTER_IMPORT);
+
+    const name = node.name?.escapedText.toString() ?? '';
+
+    const meta = state.factory.createCallExpression(
+      state.createAccess(state[registerImport].ident, 'register'),
+      [],
+      [
+        state.createIdentifier(name),
+        state.getModuleIdentifier(),
+        state.fromLiteral(state[cls]),
+        state.extendObjectLiteral(state[methods] || {}),
+        state.fromLiteral(CoreUtil.isAbstract(node)),
+        state.fromLiteral(name.endsWith(TransformerState.SYNTHETIC_EXT))
+      ]
+    );
+
+    state[methods] = {};
+    delete state[cls];
+
+    return state.factory.updateClassDeclaration(
+      node,
+      node.modifiers,
+      node.name,
+      node.typeParameters,
+      node.heritageClauses,
+      [
+        state.createStaticField('Ⲑinit', meta),
+        ...node.members
+      ]
+    );
+  }
+
+  /**
+   * Give proper functions a file name
+   */
+  @AfterFunction()
+  static registerFunctionMetadata(state: TransformerState & MetadataInfo, node: ts.FunctionDeclaration | ts.FunctionExpression): typeof node {
+    if (!this.#valid(state)) {
+      return node;
+    }
+
+    if (ts.isFunctionDeclaration(node) && node.name && node.parent && ts.isSourceFile(node.parent)) {
+      // If we have a class like function
+      state[registerImport] ??= state.importFile(REGISTER_IMPORT);
+      const tag = this.#tag(state, node);
+      const meta = state.factory.createCallExpression(
+        state.createAccess(state[registerImport].ident, 'register'),
+        [],
+        [
+          state.createIdentifier(node.name),
+          state.getModuleIdentifier(),
+          state.fromLiteral(tag),
+        ]
+      );
+      state.addStatements([state.factory.createExpressionStatement(meta)]);
+    }
+    return node;
+  }
+}

package/support/transformer.rewrite-path-import.ts

@@ -0,0 +1,39 @@
+import ts from 'typescript';
+
+import { TransformerState, OnFile } from '@travetto/transformer';
+
+const PATH_REGEX = /^['"](node:)?path['"]$/;
+const PATH_TARGET = '@travetto/manifest/src/path';
+const SKIP_SRC = /^@travetto\/manifest\/(src|support)/;
+
+/**
+ * Rewriting path imports to use manifest's path
+ */
+export class PathImportTransformer {
+
+  /**
+   * Hash each class
+   */
+  @OnFile()
+  static rewritePathImport(state: TransformerState, node: ts.SourceFile): ts.SourceFile {
+    if (SKIP_SRC.test(state.importName)) {
+      return node;
+    }
+
+    const stmt = node.statements.find((x): x is ts.ImportDeclaration =>
+      ts.isImportDeclaration(x) && PATH_REGEX.test(x.moduleSpecifier?.getText() ?? ''));
+    if (stmt) {
+      const updated = state.factory.updateImportDeclaration(
+        stmt,
+        stmt.modifiers,
+        stmt.importClause,
+        state.factory.createStringLiteral(PATH_TARGET),
+        stmt.attributes
+      );
+      return state.factory.updateSourceFile(node, node.statements.map(x =>
+        x === stmt ? updated : x
+      ));
+    }
+    return node;
+  }
+}