@travetto/transformer 3.0.0-rc.2 → 3.0.0-rc.20

package/README.md

@@ -1,5 +1,5 @@
 <!-- This file was generated by @travetto/doc and should not be modified directly -->
-<!-- Please modify https://github.com/travetto/travetto/tree/main/module/transformer/doc.ts and execute "npx trv doc" to rebuild -->
+<!-- Please modify https://github.com/travetto/travetto/tree/main/module/transformer/DOC.ts and execute "npx trv doc" to rebuild -->
 # Transformation
 ## Functionality for AST transformations, with transformer registration, and general utils
 
@@ -10,7 +10,7 @@ npm install @travetto/transformer
 
 This module provides support for enhanced AST transformations, and declarative transformer registration, with common patterns to support all the transformers used throughout the framework. Transformations are located by `support/transformer.<name>.ts` as the filename. 
 
-The module is primarily aimed at extremely advanced usages for things that cannot be detected at runtime.  The [Registry](https://github.com/travetto/travetto/tree/main/module/registry#readme "Patterns and utilities for handling registration of metadata and functionality for run-time use") module already has knowledge of all `class`es and `field`s, and is able to listen to changes there.  Many of the modules build upon work by some of the foundational transformers defined in [Registry](https://github.com/travetto/travetto/tree/main/module/registry#readme "Patterns and utilities for handling registration of metadata and functionality for run-time use"), [Schema](https://github.com/travetto/travetto/tree/main/module/schema#readme "Data type registry for runtime validation, reflection and binding. ") and [Dependency Injection](https://github.com/travetto/travetto/tree/main/module/di#readme "Dependency registration/management and injection support.").  These all center around defining a registry of classes, and associated type information.
+The module is primarily aimed at extremely advanced usages for things that cannot be detected at runtime.  The [Registry](https://github.com/travetto/travetto/tree/main/module/registry#readme "Patterns and utilities for handling registration of metadata and functionality for run-time use") module already has knowledge of all `class`es and `field`s, and is able to listen to changes there.  Many of the modules build upon work by some of the foundational transformers defined in [Registry](https://github.com/travetto/travetto/tree/main/module/registry#readme "Patterns and utilities for handling registration of metadata and functionality for run-time use"), [Schema](https://github.com/travetto/travetto/tree/main/module/schema#readme "Data type registry for runtime validation, reflection and binding.") and [Dependency Injection](https://github.com/travetto/travetto/tree/main/module/di#readme "Dependency registration/management and injection support.").  These all center around defining a registry of classes, and associated type information.
 
 Because working with the [Typescript](https://typescriptlang.org) API can be delicate (and open to breaking changes), creating new transformers should be done cautiously. 
 
@@ -20,22 +20,19 @@ Below is an example of a transformer that upper cases all `class`, `method` and
 
 **Code: Sample Transformer - Upper case all declarations**
 ```typescript
-import * as ts from 'typescript';
+import ts from 'typescript';
 
-import { OnProperty, TransformerState, OnMethod, OnClass, TransformerId } from '@travetto/transformer';
+import { OnProperty, TransformerState, OnMethod, OnClass } from '@travetto/transformer';
 
 export class MakeUpper {
 
-  static [TransformerId] = '@trv:transformer-test';
-
   @OnProperty()
   static handleProperty(state: TransformerState, node: ts.PropertyDeclaration): ts.PropertyDeclaration {
-    if (!state.source.fileName.includes('doc/src')) {
+    if (!state.file.includes('doc/src')) {
       return node;
     }
     return state.factory.updatePropertyDeclaration(
       node,
-      [],
       node.modifiers,
       node.name.getText().toUpperCase(),
       undefined,
@@ -46,12 +43,11 @@ export class MakeUpper {
 
   @OnClass()
   static handleClass(state: TransformerState, node: ts.ClassDeclaration): ts.ClassDeclaration {
-    if (!state.source.fileName.includes('doc/src')) {
+    if (!state.file.includes('doc/src')) {
       return node;
     }
     return state.factory.updateClassDeclaration(
       node,
-      [],
       node.modifiers,
       state.createIdentifier(node.name!.getText().toUpperCase()),
       node.typeParameters,
@@ -62,12 +58,11 @@ export class MakeUpper {
 
   @OnMethod()
   static handleMethod(state: TransformerState, node: ts.MethodDeclaration): ts.MethodDeclaration {
-    if (!state.source.fileName.includes('doc/src')) {
+    if (!state.file.includes('doc/src')) {
       return node;
     }
     return state.factory.updateMethodDeclaration(
       node,
-      [],
       node.modifiers,
       undefined,
       state.createIdentifier(node.name.getText().toUpperCase()),

package/__index__.ts

@@ -0,0 +1,15 @@
+export * from './src/state';
+export * from './src/visitor';
+export * from './src/register';
+export * from './src/types/visitor';
+export * from './src/types/shared';
+export type { AnyType } from './src/resolver/types';
+export * from './src/manager';
+
+export * from './src/util/core';
+export * from './src/util/declaration';
+export * from './src/util/decorator';
+export * from './src/util/doc';
+export * from './src/util/literal';
+export * from './src/util/log';
+export * from './src/util/system';

package/package.json

@@ -1,7 +1,6 @@
 {
   "name": "@travetto/transformer",
-  "displayName": "Transformation",
-  "version": "3.0.0-rc.2",
+  "version": "3.0.0-rc.20",
   "description": "Functionality for AST transformations, with transformer registration, and general utils",
   "keywords": [
     "typescript",
@@ -15,17 +14,25 @@
     "name": "Travetto Framework"
   },
   "files": [
-    "index.ts",
+    "__index__.ts",
     "src",
-    "test-support"
+    "support"
   ],
-  "main": "index.ts",
+  "main": "__index__.ts",
   "repository": {
     "url": "https://github.com/travetto/travetto.git",
     "directory": "module/transformer"
   },
   "dependencies": {
-    "@travetto/base": "^3.0.0-rc.0"
+    "@travetto/manifest": "^3.0.0-rc.16",
+    "tslib": "^2.5.0",
+    "typescript": "^4.9.5"
+  },
+  "travetto": {
+    "displayName": "Transformation",
+    "profiles": [
+      "compile"
+    ]
   },
   "publishConfig": {
     "access": "public"

package/src/importer.ts

@@ -1,13 +1,15 @@
-import * as ts from 'typescript';
-import { basename, dirname, relative } from 'path';
+import ts from 'typescript';
 
-import { PathUtil } from '@travetto/boot';
-import { ModuleUtil } from '@travetto/boot/src/internal/module-util';
+import { PackageUtil, path } from '@travetto/manifest';
 
-import { AnyType, ExternalType } from './resolver/types';
+import { AnyType, TransformResolver, ExternalType } from './resolver/types';
 import { ImportUtil } from './util/import';
 import { CoreUtil } from './util/core';
 import { Import } from './types/shared';
+import { LiteralUtil } from './util/literal';
+import { DeclarationUtil } from './util/declaration';
+
+const D_OR_D_TS_EXT_RE = /[.]d([.]ts)?$/;
 
 /**
  * Manages imports within a ts.SourceFile
@@ -18,18 +20,79 @@ export class ImportManager {
   #imports: Map<string, Import>;
   #idx: Record<string, number> = {};
   #ids = new Map<string, string>();
+  #importName: string;
+  #resolver: TransformResolver;
 
-  constructor(public source: ts.SourceFile, public factory: ts.NodeFactory) {
+  constructor(public source: ts.SourceFile, public factory: ts.NodeFactory, resolver: TransformResolver) {
     this.#imports = ImportUtil.collectImports(source);
+    this.#resolver = resolver;
+    this.#importName = this.#resolver.getFileImportName(source.fileName);
+  }
+
+  #getImportFile(spec?: ts.Expression): string | undefined {
+    if (spec && ts.isStringLiteral(spec)) {
+      return spec.text.replace(/^['"]|["']$/g, '');
+    }
+  }
+
+  #rewriteModuleSpecifier(spec: ts.Expression | undefined): ts.Expression | undefined {
+    const fileOrImport = this.#getImportFile(spec);
+    if (
+      fileOrImport &&
+      (fileOrImport.startsWith('.') || this.#resolver.isKnownFile(fileOrImport)) &&
+      !/[.]([mc]?js|ts|json)$/.test(fileOrImport)
+    ) {
+      return LiteralUtil.fromLiteral(this.factory, `${fileOrImport}.js`);
+    }
+    return spec;
+  }
+
+  #rewriteImportClause(spec: ts.Expression | undefined, clause: ts.ImportClause | undefined): ts.ImportClause | undefined {
+    if (!(spec && clause?.namedBindings && ts.isNamedImports(clause.namedBindings))) {
+      return clause;
+    }
+
+    const fileOrImport = this.#getImportFile(spec);
+    if (!(fileOrImport && (fileOrImport.startsWith('.') || this.#resolver.isKnownFile(fileOrImport)))) {
+      return clause;
+    }
+
+    const bindings = clause.namedBindings;
+    const newBindings: ts.ImportSpecifier[] = [];
+    // Remove all type only imports
+    for (const el of bindings.elements) {
+      if (!el.isTypeOnly) {
+        const type = this.#resolver.getType(el.name);
+        const objFlags = DeclarationUtil.getObjectFlags(type);
+        const typeFlags = type.getFlags();
+        if (objFlags || typeFlags !== 1) {
+          newBindings.push(el);
+        }
+      }
+    }
+    if (newBindings.length !== bindings.elements.length) {
+      return this.factory.updateImportClause(
+        clause,
+        clause.isTypeOnly,
+        clause.name,
+        this.factory.createNamedImports(newBindings)
+      );
+    } else {
+      return clause;
+    }
   }
 
   /**
    * Produces a unique ID for a given file, importing if needed
    */
-  getId(file: string): string {
+  getId(file: string, name?: string): string {
     if (!this.#ids.has(file)) {
-      const key = basename(file).replace(/[.][^.]*$/, '').replace(/[^A-Za-z0-9]+/g, '_');
-      this.#ids.set(file, `ᚕ_${key}_${this.#idx[key] = (this.#idx[key] || 0) + 1}`);
+      if (name) {
+        this.#ids.set(file, name);
+      } else {
+        const key = path.basename(file).replace(/[.][^.]*$/, '').replace(/[^A-Za-z0-9]+/g, '_');
+        this.#ids.set(file, `Ⲑ_${key}_${this.#idx[key] = (this.#idx[key] || 0) + 1}`);
+      }
     }
     return this.#ids.get(file)!;
   }
@@ -37,28 +100,16 @@ export class ImportManager {
   /**
    * Import a file if needed, and record it's identifier
    */
-  importFile(file: string, base?: string): Import {
-    file = ModuleUtil.normalizePath(file);
+  importFile(file: string, name?: string): Import {
+    file = this.#resolver.getFileImportName(file);
 
     // Allow for node classes to be imported directly
     if (/@types\/node/.test(file)) {
-      file = require.resolve(file.replace(/.*@types\/node\//, '').replace(/[.]d([.]ts)?$/, ''));
-    }
-
-    // Handle relative imports
-    if (file.startsWith('.') && base &&
-      !base.startsWith('@travetto') && !base.includes('node_modules')
-    ) { // Relative path
-      const fileDir = dirname(PathUtil.resolveUnix(file));
-      const baseDir = dirname(PathUtil.resolveUnix(base));
-      file = `${relative(baseDir, fileDir) || '.'}/${basename(file)}`;
-      if (/^[A-Za-z]/.test(file)) {
-        file = `./${file}`;
-      }
+      file = PackageUtil.resolveImport(file.replace(/.*@types\/node\//, '').replace(D_OR_D_TS_EXT_RE, ''));
     }
 
-    if (!/[.]d([.]ts)?$/.test(file) && !this.#newImports.has(file)) {
-      const id = this.getId(file);
+    if (!D_OR_D_TS_EXT_RE.test(file) && !this.#newImports.has(file)) {
+      const id = this.getId(file, name);
 
       if (this.#imports.has(id)) { // Already imported, be cool
         return this.#imports.get(id)!;
@@ -77,8 +128,8 @@ export class ImportManager {
    */
   importFromResolved(...types: AnyType[]): void {
     for (const type of types) {
-      if (type.key === 'external' && type.source && type.source !== this.source.fileName) {
-        this.importFile(type.source, this.source.fileName);
+      if (type.key === 'external' && type.importName && type.importName !== this.#importName) {
+        this.importFile(type.importName);
       }
       switch (type.key) {
         case 'external':
@@ -99,11 +150,11 @@ export class ImportManager {
     }
 
     try {
-      const importStmts = [...this.#newImports.values()].map(({ path, ident }) => {
+      const importStmts = [...this.#newImports.values()].map(({ path: resolved, ident }) => {
         const importStmt = this.factory.createImportDeclaration(
-          undefined, undefined,
+          undefined,
           this.factory.createImportClause(false, undefined, this.factory.createNamespaceImport(ident)),
-          this.factory.createStringLiteral(path)
+          this.factory.createStringLiteral(resolved)
         );
         return importStmt;
       });
@@ -116,27 +167,61 @@ export class ImportManager {
       if (!(err instanceof Error)) {
         throw err;
       }
-      const out = new Error(`${err.message} in ${file.fileName.replace(PathUtil.cwd, '.')}`);
+      const out = new Error(`${err.message} in ${file.fileName.replace(process.cwd(), '.')}`);
       out.stack = err.stack;
       throw out;
     }
   }
 
+  finalizeImportExportExtension(ret: ts.SourceFile): ts.SourceFile {
+    const toAdd: ts.Statement[] = [];
+
+    for (const stmt of ret.statements) {
+      if (ts.isExportDeclaration(stmt)) {
+        if (!stmt.isTypeOnly) {
+          toAdd.push(this.factory.updateExportDeclaration(
+            stmt,
+            stmt.modifiers,
+            stmt.isTypeOnly,
+            stmt.exportClause,
+            this.#rewriteModuleSpecifier(stmt.moduleSpecifier),
+            stmt.assertClause
+          ));
+        }
+      } else if (ts.isImportDeclaration(stmt)) {
+        if (!stmt.importClause?.isTypeOnly) {
+          toAdd.push(this.factory.updateImportDeclaration(
+            stmt,
+            stmt.modifiers,
+            this.#rewriteImportClause(stmt.moduleSpecifier, stmt.importClause)!,
+            this.#rewriteModuleSpecifier(stmt.moduleSpecifier)!,
+            stmt.assertClause
+          ));
+        }
+      } else {
+        toAdd.push(stmt);
+      }
+    }
+    return CoreUtil.updateSource(this.factory, ret, toAdd);
+  }
+
   /**
    * Reset the imports into the source file
    */
   finalize(ret: ts.SourceFile): ts.SourceFile {
-    return this.finalizeNewImports(ret) ?? ret;
+    ret = this.finalizeNewImports(ret) ?? ret;
+    ret = this.finalizeImportExportExtension(ret) ?? ret;
+    return ret;
   }
 
   /**
    * Get the identifier and import if needed
    */
   getOrImport(factory: ts.NodeFactory, type: ExternalType): ts.Identifier | ts.PropertyAccessExpression {
-    if (type.source === this.source.fileName) {
+    if (type.importName === this.#importName) {
       return factory.createIdentifier(type.name!);
     } else {
-      const { ident } = this.#imports.get(type.source) ?? this.importFile(type.source, this.source.fileName);
+      const { ident } = this.#imports.get(type.importName) ?? this.importFile(type.importName);
       return factory.createPropertyAccessExpression(ident, type.name!);
     }
   }

package/src/manager.ts

@@ -0,0 +1,74 @@
+import ts from 'typescript';
+
+import { ManifestIndex, path, RootIndex } from '@travetto/manifest';
+
+import { NodeTransformer } from './types/visitor';
+import { VisitorFactory } from './visitor';
+import { TransformerState } from './state';
+import { getAllTransformers } from './register';
+
+/**
+ * Manages the typescript transformers
+ */
+export class TransformerManager {
+
+  /**
+   * Create transformer manager
+   * @param transformerFiles
+   * @param manifest
+   * @returns
+   */
+  static async create(manifestIndex: ManifestIndex): Promise<TransformerManager> {
+    const transformerFiles = Object.values(manifestIndex.manifest.modules).flatMap(
+      x => (x.files.$transformer ?? []).map(([f]) =>
+        path.resolve(manifestIndex.manifest.workspacePath, x.sourceFolder, f)
+      )
+    );
+
+    const transformers: NodeTransformer<TransformerState>[] = [];
+
+    for (const file of transformerFiles) { // Exclude based on blacklist
+      const entry = RootIndex.getEntry(file)!;
+      transformers.push(...getAllTransformers(await import(entry.import), entry.module));
+    }
+
+    for (const x of transformers) {
+      process.send?.(['debug', `Loaded Transformer: ${x.key}#${x.type}`]);
+    }
+
+    // Prepare a new visitor factory with a given type checker
+    return new TransformerManager(manifestIndex, transformers);
+  }
+
+  #cached: ts.CustomTransformers | undefined;
+  #transformers: NodeTransformer<TransformerState>[];
+  #manifestIndex: ManifestIndex;
+
+  constructor(manifestIndex: ManifestIndex, transformers: NodeTransformer<TransformerState>[]) {
+    this.#transformers = transformers;
+    this.#manifestIndex = manifestIndex;
+  }
+
+  /**
+   * Initialize with type checker
+   * @param checker
+   */
+  init(checker: ts.TypeChecker): void {
+    const visitor = new VisitorFactory(
+      (ctx, src) => new TransformerState(src, ctx.factory, checker, this.#manifestIndex),
+      this.#transformers
+    );
+
+    // Define transformers for the compiler
+    this.#cached = {
+      before: [visitor.visitor()]
+    };
+  }
+
+  /**
+   * Get typescript transformer object
+   */
+  get(): ts.CustomTransformers | undefined {
+    return this.#cached!;
+  }
+}

package/src/register.ts

@@ -1,26 +1,55 @@
-import * as ts from 'typescript';
-import { DecoratorMeta, NodeTransformer, State, TransformPhase, TransformerType, Transformer, TransformerId } from './types/visitor';
+import ts from 'typescript';
 
-const HandlersProp = Symbol.for('@trv:transformer/handlers');
+import { DecoratorMeta, NodeTransformer, State, TransformPhase, TransformerType, Transformer, ModuleNameⲐ } from './types/visitor';
+
+const HandlersProp = Symbol.for('@travetto/transformer:handlers');
 
 type TransformerWithHandlers = Transformer & { [HandlersProp]?: NodeTransformer[] };
 
+function isTransformer(x: unknown): x is Transformer {
+  return x !== null && x !== undefined && typeof x === 'function';
+}
+
 /**
  * Get all transformers
  * @param obj Object to search for transformers
  */
-export function getAllTransformers(obj: Record<string, { [HandlersProp]?: NodeTransformer[] }>): NodeTransformer[] {
-  return Object.values(obj).flatMap(x => x[HandlersProp] ?? []);
+export function getAllTransformers(obj: Record<string, { [HandlersProp]?: NodeTransformer[] }>, module: string): NodeTransformer[] {
+  return Object.values(obj)
+    .flatMap(x => {
+      if (isTransformer(x)) {
+        x[ModuleNameⲐ] = module;
+      }
+      return (x[HandlersProp] ?? []);
+    })
+    .map(handler => ({
+      ...handler,
+      key: `${module}:${handler.key}`,
+      target: handler.target?.map(t => `${module}:${t}`)
+    }));
 }
 
 // Store handlers in class
 function storeHandler(cls: TransformerWithHandlers, fn: Function, phase: TransformPhase, type: TransformerType, target?: string[]): void {
-  if (target) {
-    const ns = cls[TransformerId].split('/')[0]; // Everything before the '/'
-    target = target.map(x => x.startsWith('@') ? x : `${ns}/${x}`);
-  }
-  cls[HandlersProp] = cls[HandlersProp] ?? [];
-  cls[HandlersProp]!.push({ key: `${cls[TransformerId]}/${fn.name}`, [phase]: fn.bind(cls), type, target });
+  (cls[HandlersProp] ??= []).push({ key: fn.name, [phase]: fn.bind(cls), type, target });
+}
+
+/**
+ * Wraps entire file before transforming
+ */
+export function OnFile(...target: string[]) {
+  return <S extends State = State, R extends ts.Node = ts.Node>(
+    inst: Transformer, __: unknown, d: TypedPropertyDescriptor<(state: S, node: ts.SourceFile) => R>
+  ): void => storeHandler(inst, d.value!, 'before', 'file', target);
+}
+
+/**
+ * Wraps entire file after transforming
+ */
+export function AfterFile(...target: string[]) {
+  return <S extends State = State, R extends ts.Node = ts.Node>(
+    inst: Transformer, __: unknown, d: TypedPropertyDescriptor<(state: S, node: ts.SourceFile) => R>
+  ): void => storeHandler(inst, d.value!, 'before', 'file', target);
 }
 
 /**