@travetto/transformer 3.0.0-rc.12 → 3.0.0-rc.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/transformer",
-  "version": "3.0.0-rc.12",
+  "version": "3.0.0-rc.14",
   "description": "Functionality for AST transformations, with transformer registration, and general utils",
   "keywords": [
     "typescript",
@@ -24,7 +24,7 @@
     "directory": "module/transformer"
   },
   "dependencies": {
-    "@travetto/manifest": "^3.0.0-rc.9",
+    "@travetto/manifest": "^3.0.0-rc.11",
     "tslib": "^2.5.0",
     "typescript": "^4.9.5"
   },

package/src/importer.ts

@@ -2,13 +2,12 @@ import ts from 'typescript';
 
 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';
-import { TransformerIndex } from './manifest-index';
 
 const D_OR_D_TS_EXT_RE = /[.]d([.]ts)?$/;
 
@@ -22,10 +21,12 @@ export class ImportManager {
   #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.#importName = TransformerIndex.getImportName(source.fileName);
+    this.#resolver = resolver;
+    this.#importName = this.#resolver.getImportName(source.fileName);
   }
 
   #getImportFile(spec?: ts.Expression): string | undefined {
@@ -38,7 +39,7 @@ export class ImportManager {
     const fileOrImport = this.#getImportFile(spec);
     if (
       fileOrImport &&
-      (fileOrImport.startsWith('.') || TransformerIndex.isKnown(fileOrImport)) &&
+      (fileOrImport.startsWith('.') || this.#resolver.isKnownFile(fileOrImport)) &&
       !/[.]([mc]?js|ts|json)$/.test(fileOrImport)
     ) {
       return LiteralUtil.fromLiteral(this.factory, `${fileOrImport}.js`);
@@ -46,17 +47,13 @@ export class ImportManager {
     return spec;
   }
 
-  #rewriteImportClause(
-    spec: ts.Expression | undefined,
-    clause: ts.ImportClause | undefined,
-    checker: ts.TypeChecker
-  ): ts.ImportClause | undefined {
+  #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('.') || TransformerIndex.isKnown(fileOrImport)))) {
+    if (!(fileOrImport && (fileOrImport.startsWith('.') || this.#resolver.isKnownFile(fileOrImport)))) {
       return clause;
     }
 
@@ -65,7 +62,7 @@ export class ImportManager {
     // Remove all type only imports
     for (const el of bindings.elements) {
       if (!el.isTypeOnly) {
-        const type = checker.getTypeAtLocation(el.name);
+        const type = this.#resolver.getType(el.name);
         const objFlags = DeclarationUtil.getObjectFlags(type);
         const typeFlags = type.getFlags();
         if (objFlags || typeFlags !== 1) {
@@ -104,7 +101,7 @@ export class ImportManager {
    * Import a file if needed, and record it's identifier
    */
   importFile(file: string, name?: string): Import {
-    file = TransformerIndex.getImportName(file);
+    file = this.#resolver.getImportName(file);
 
     // Allow for node classes to be imported directly
     if (/@types\/node/.test(file)) {
@@ -176,7 +173,7 @@ export class ImportManager {
     }
   }
 
-  finalizeImportExportExtension(ret: ts.SourceFile, checker: ts.TypeChecker): ts.SourceFile {
+  finalizeImportExportExtension(ret: ts.SourceFile): ts.SourceFile {
     const toAdd: ts.Statement[] = [];
 
     for (const stmt of ret.statements) {
@@ -196,7 +193,7 @@ export class ImportManager {
           toAdd.push(this.factory.updateImportDeclaration(
             stmt,
             stmt.modifiers,
-            this.#rewriteImportClause(stmt.moduleSpecifier, stmt.importClause, checker)!,
+            this.#rewriteImportClause(stmt.moduleSpecifier, stmt.importClause)!,
             this.#rewriteModuleSpecifier(stmt.moduleSpecifier)!,
             stmt.assertClause
           ));
@@ -211,9 +208,9 @@ export class ImportManager {
   /**
    * Reset the imports into the source file
    */
-  finalize(ret: ts.SourceFile, checker: ts.TypeChecker): ts.SourceFile {
+  finalize(ret: ts.SourceFile): ts.SourceFile {
     ret = this.finalizeNewImports(ret) ?? ret;
-    ret = this.finalizeImportExportExtension(ret, checker) ?? ret;
+    ret = this.finalizeImportExportExtension(ret) ?? ret;
     return ret;
   }
 

package/src/manager.ts

@@ -1,6 +1,6 @@
 import ts from 'typescript';
 
-import { RootIndex } from '@travetto/manifest';
+import { ManifestIndex, path, RootIndex } from '@travetto/manifest';
 
 import { NodeTransformer } from './types/visitor';
 import { VisitorFactory } from './visitor';
@@ -18,7 +18,13 @@ export class TransformerManager {
    * @param manifest
    * @returns
    */
-  static async create(transformerFiles: string[]): Promise<TransformerManager> {
+  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
@@ -27,14 +33,16 @@ export class TransformerManager {
     }
 
     // Prepare a new visitor factory with a given type checker
-    return new TransformerManager(transformers);
+    return new TransformerManager(manifestIndex, transformers);
   }
 
   #cached: ts.CustomTransformers | undefined;
   #transformers: NodeTransformer<TransformerState>[];
+  #manifestIndex: ManifestIndex;
 
-  constructor(transformers: NodeTransformer<TransformerState>[]) {
+  constructor(manifestIndex: ManifestIndex, transformers: NodeTransformer<TransformerState>[]) {
     this.#transformers = transformers;
+    this.#manifestIndex = manifestIndex;
   }
 
   /**
@@ -43,7 +51,7 @@ export class TransformerManager {
    */
   init(checker: ts.TypeChecker): void {
     const visitor = new VisitorFactory(
-      (ctx, src) => new TransformerState(src, ctx.factory, checker),
+      (ctx, src) => new TransformerState(src, ctx.factory, checker, this.#manifestIndex),
       this.#transformers
     );
 

package/src/resolver/builder.ts

@@ -8,11 +8,9 @@ import { CoreUtil } from '../util/core';
 import { DeclarationUtil } from '../util/declaration';
 import { LiteralUtil } from '../util/literal';
 
-import { Type, AnyType, UnionType, Checker } from './types';
+import { Type, AnyType, UnionType, TransformResolver } from './types';
 import { CoerceUtil } from './coerce';
 
-import { TransformerIndex } from '../manifest-index';
-
 /**
  * List of global types that can be parameterized
  */
@@ -40,7 +38,7 @@ type Category = 'void' | 'undefined' | 'concrete' | 'unknown' | 'tuple' | 'shape
 /**
  * Type categorizer, input for builder
  */
-export function TypeCategorize(checker: ts.TypeChecker, type: ts.Type): { category: Category, type: ts.Type } {
+export function TypeCategorize(resolver: TransformResolver, type: ts.Type): { category: Category, type: ts.Type } {
   const flags = type.getFlags();
   const objectFlags = DeclarationUtil.getObjectFlags(type) ?? 0;
 
@@ -70,7 +68,7 @@ export function TypeCategorize(checker: ts.TypeChecker, type: ts.Type): { catego
     const sourceFile = source.fileName;
     if (sourceFile?.includes('@types/node/globals') || sourceFile?.includes('typescript/lib')) {
       return { category: 'literal', type };
-    } else if (sourceFile?.endsWith('.d.ts') && !TransformerIndex.isKnown(sourceFile)) {
+    } else if (sourceFile?.endsWith('.d.ts') && !resolver.isKnownFile(sourceFile)) {
       return { category: 'unknown', type };
     } else if (!resolvedType.isClass()) { // Not a real type
       return { category: 'shape', type: resolvedType };
@@ -99,26 +97,26 @@ export function TypeCategorize(checker: ts.TypeChecker, type: ts.Type): { catego
  */
 export const TypeBuilder: {
   [K in Category]: {
-    build(checker: Checker, type: ts.Type, alias?: ts.Symbol): AnyType | undefined;
+    build(resolver: TransformResolver, type: ts.Type, alias?: ts.Symbol): AnyType | undefined;
     finalize?(type: Type<K>): AnyType;
   }
 } = {
   unknown: {
-    build: (checker, type) => undefined
+    build: (resolver, type) => undefined
   },
   undefined: {
-    build: (checker, type) => ({ key: 'literal', name: 'undefined', ctor: undefined })
+    build: (resolver, type) => ({ key: 'literal', name: 'undefined', ctor: undefined })
   },
   void: {
-    build: (checker, type) => ({ key: 'literal', name: 'void', ctor: undefined })
+    build: (resolver, type) => ({ key: 'literal', name: 'void', ctor: undefined })
   },
   tuple: {
-    build: (checker, type) => ({ key: 'tuple', tsTupleTypes: checker.getAllTypeArguments(type), subTypes: [] })
+    build: (resolver, type) => ({ key: 'tuple', tsTupleTypes: resolver.getAllTypeArguments(type), subTypes: [] })
   },
   literal: {
-    build: (checker, type) => {
+    build: (resolver, type) => {
       // Handle void/undefined
-      const name = checker.getTypeAsString(type) ?? '';
+      const name = resolver.getTypeAsString(type) ?? '';
       const complexName = CoreUtil.getSymbol(type)?.getName() ?? '';
 
       if (name in GLOBAL_SIMPLE) {
@@ -139,21 +137,21 @@ export const TypeBuilder: {
           key: 'literal',
           name: cons.name,
           ctor: cons,
-          tsTypeArguments: checker.getAllTypeArguments(type)
+          tsTypeArguments: resolver.getAllTypeArguments(type)
         };
       }
     }
   },
   external: {
-    build: (checker, type) => {
+    build: (resolver, type) => {
       const name = CoreUtil.getSymbol(type)?.getName();
-      const importName = TransformerIndex.getImportName(type);
-      const tsTypeArguments = checker.getAllTypeArguments(type);
+      const importName = resolver.getImportName(type);
+      const tsTypeArguments = resolver.getAllTypeArguments(type);
       return { key: 'external', name, importName, tsTypeArguments };
     }
   },
   union: {
-    build: (checker, uType: ts.UnionType) => {
+    build: (resolver, uType: ts.UnionType) => {
       let undefinable = false;
       let nullable = false;
       const remainder = uType.types.filter(ut => {
@@ -179,15 +177,15 @@ export const TypeBuilder: {
     }
   },
   shape: {
-    build: (checker, type, alias?) => {
+    build: (resolver, type, alias?) => {
       const tsFieldTypes: Record<string, ts.Type> = {};
       const name = CoreUtil.getSymbol(alias ?? type)?.getName();
-      const importName = TransformerIndex.getImportName(type);
-      const tsTypeArguments = checker.getAllTypeArguments(type);
-      for (const member of checker.getPropertiesOfType(type)) {
+      const importName = resolver.getImportName(type);
+      const tsTypeArguments = resolver.getAllTypeArguments(type);
+      for (const member of resolver.getPropertiesOfType(type)) {
         const dec = DeclarationUtil.getPrimaryDeclarationNode(member);
         if (DeclarationUtil.isPublic(dec)) { // If public
-          const memberType = checker.getType(dec);
+          const memberType = resolver.getType(dec);
           if (
             !member.getName().includes('@') && // if not a symbol
             !memberType.getCallSignatures().length // if not a function
@@ -200,7 +198,7 @@ export const TypeBuilder: {
     }
   },
   concrete: {
-    build: (checker, type) => {
+    build: (resolver, type) => {
       const [tag] = DocUtil.readDocTag(type, 'concrete');
       if (tag) {
         // eslint-disable-next-line prefer-const
@@ -217,10 +215,10 @@ export const TypeBuilder: {
             ?.getSourceFile().fileName ?? '';
 
           if (importName === '.') {
-            importName = TransformerIndex.getImportName(rawSourceFile);
+            importName = resolver.getImportName(rawSourceFile);
           } else {
             const base = path.dirname(rawSourceFile);
-            importName = TransformerIndex.getImportName(path.resolve(base, importName));
+            importName = resolver.getImportName(path.resolve(base, importName));
           }
         }
         return { key: 'external', name, importName };

package/src/resolver/service.ts

@@ -1,18 +1,23 @@
 import ts from 'typescript';
 
-import type { AnyType, Checker } from './types';
+import { ManifestIndex, path } from '@travetto/manifest';
+
+import type { AnyType, TransformResolver } from './types';
 import { TypeCategorize, TypeBuilder } from './builder';
 import { VisitCache } from './cache';
 import { DocUtil } from '../util/doc';
+import { DeclarationUtil } from '../util/declaration';
 
 /**
- * Type resolver
+ * Implementation of TransformResolver
  */
-export class TypeResolver implements Checker {
+export class SimpleResolver implements TransformResolver {
   #tsChecker: ts.TypeChecker;
+  #manifestIndex: ManifestIndex;
 
-  constructor(tsChecker: ts.TypeChecker) {
+  constructor(tsChecker: ts.TypeChecker, manifestIndex: ManifestIndex) {
     this.#tsChecker = tsChecker;
+    this.#manifestIndex = manifestIndex;
   }
 
   /**
@@ -23,6 +28,33 @@ export class TypeResolver implements Checker {
     return this.#tsChecker;
   }
 
+  /**
+   * Resolve an import name (e.g. @module/path/file) for a given input or type
+   */
+  getImportName(fileOrType: string | ts.Type, removeExt?: boolean): string {
+    const ogSource = typeof fileOrType === 'string' ? fileOrType : DeclarationUtil.getPrimaryDeclarationNode(fileOrType).getSourceFile().fileName;
+    let sourceFile = path.toPosix(ogSource);
+
+    if (!sourceFile.endsWith('.js') && !sourceFile.endsWith('.ts')) {
+      sourceFile = `${sourceFile}.ts`;
+    }
+
+    const imp =
+      this.#manifestIndex.getEntry(/[.]ts$/.test(sourceFile) ? sourceFile : `${sourceFile}.js`)?.import ??
+      this.#manifestIndex.getFromImport(sourceFile.replace(/^.*node_modules\//, '').replace(/[.]ts$/, ''))?.import ??
+      ogSource;
+
+    return removeExt ? imp.replace(/[.]js$/, '') : imp;
+  }
+
+  /**
+   * Is the file/import known to the index, helpful for determine ownership
+   */
+  isKnownFile(fileOrImport: string): boolean {
+    return (this.#manifestIndex.getFromSource(fileOrImport) !== undefined) ||
+      (this.#manifestIndex.getFromImport(fileOrImport) !== undefined);
+  }
+
   /**
    * Get type from element
    * @param el
@@ -73,7 +105,7 @@ export class TypeResolver implements Checker {
         throw new Error('Object structure too nested');
       }
 
-      const { category, type } = TypeCategorize(this.#tsChecker, resType);
+      const { category, type } = TypeCategorize(this, resType);
       const { build, finalize } = TypeBuilder[category];
 
       let result = build(this, type, alias);

package/src/resolver/types.ts

@@ -151,7 +151,9 @@ export type AnyType = TupleType | ShapeType | UnionType | LiteralType | External
 /**
  * Simple interface for checked methods
  */
-export interface Checker {
+export interface TransformResolver {
+  isKnownFile(file: string): boolean;
+  getImportName(fileOrType: string | ts.Type, removeExt?: boolean): string;
   getAllTypeArguments(type: ts.Type): ts.Type[];
   getPropertiesOfType(type: ts.Type): ts.Symbol[];
   getTypeAsString(type: ts.Type): string | undefined;

package/src/state.ts

@@ -1,10 +1,10 @@
 import ts from 'typescript';
 
-import { path } from '@travetto/manifest';
+import { ManifestIndex, path } from '@travetto/manifest';
 
 import { ExternalType, AnyType } from './resolver/types';
 import { State, DecoratorMeta, Transformer, ModuleNameⲐ } from './types/visitor';
-import { TypeResolver } from './resolver/service';
+import { SimpleResolver } from './resolver/service';
 import { ImportManager } from './importer';
 import { Import } from './types/shared';
 
@@ -14,7 +14,6 @@ import { DeclarationUtil } from './util/declaration';
 import { CoreUtil } from './util/core';
 import { LiteralUtil } from './util/literal';
 import { SystemUtil } from './util/system';
-import { TransformerIndex } from './manifest-index';
 
 function hasOriginal(n: unknown): n is { original: ts.Node } {
   // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
@@ -32,28 +31,23 @@ function hasEscapedName(n: unknown): n is { name: { escapedText: string } } {
 export class TransformerState implements State {
   static SYNTHETIC_EXT = 'Ⲑsyn';
 
-  #resolver: TypeResolver;
+  #resolver: SimpleResolver;
   #imports: ImportManager;
   #fileIdent: ts.Identifier;
+  #manifestIndex: ManifestIndex;
   #syntheticIdentifiers = new Map<string, ts.Identifier>();
   #decorators = new Map<string, ts.PropertyAccessExpression>();
   added = new Map<number, ts.Statement[]>();
   importName: string;
   file: string;
 
-  constructor(public source: ts.SourceFile, public factory: ts.NodeFactory, checker: ts.TypeChecker) {
-    this.#imports = new ImportManager(source, factory);
-    this.#resolver = new TypeResolver(checker);
+  constructor(public source: ts.SourceFile, public factory: ts.NodeFactory, checker: ts.TypeChecker, manifestIndex: ManifestIndex) {
+    this.#manifestIndex = manifestIndex;
+    this.#resolver = new SimpleResolver(checker, manifestIndex);
+    this.#imports = new ImportManager(source, factory, this.#resolver);
     this.file = path.toPosix(this.source.fileName);
-    this.importName = TransformerIndex.getImportName(this.file, true);
-  }
 
-  /**
-   * Allow access to resolver
-   * @private
-   */
-  getResolver(): TypeResolver {
-    return this.#resolver;
+    this.importName = this.#resolver.getImportName(this.file, true);
   }
 
   /**
@@ -86,7 +80,7 @@ export class TransformerState implements State {
     const resolved = this.resolveType(node);
     if (resolved.key !== 'external') {
       const file = node.getSourceFile().fileName;
-      const src = TransformerIndex.getImportName(file);
+      const src = this.#resolver.getImportName(file);
       throw new Error(`Unable to import non-external type: ${node.getText()} ${resolved.key}: ${src}`);
     }
     return resolved;
@@ -153,8 +147,8 @@ export class TransformerState implements State {
       this.#resolver.getType(ident)
     );
     const src = decl?.getSourceFile().fileName;
-    const mod = src ? TransformerIndex.getImportName(src, true) : undefined;
-    const file = TransformerIndex.getFromImport(mod ?? '')?.outputFile;
+    const mod = src ? this.#resolver.getImportName(src, true) : undefined;
+    const file = this.#manifestIndex.getFromImport(mod ?? '')?.outputFile;
     const targets = DocUtil.readAugments(this.#resolver.getType(ident));
     const module = file ? mod : undefined;
     const name = ident ?
@@ -218,7 +212,7 @@ export class TransformerState implements State {
    * Finalize the source file for emission
    */
   finalize(ret: ts.SourceFile): ts.SourceFile {
-    ret = this.#imports.finalize(ret, this.#resolver.getChecker());
+    ret = this.#imports.finalize(ret);
     return ret;
   }
 
@@ -272,7 +266,7 @@ export class TransformerState implements State {
     if (this.#fileIdent === undefined) {
       this.#fileIdent = this.createIdentifier('ᚕf');
       const decl = this.factory.createVariableDeclaration(this.#fileIdent, undefined, undefined,
-        this.fromLiteral(TransformerIndex.getImportName(this.source.fileName) ?? this.source.fileName)
+        this.fromLiteral(this.#resolver.getImportName(this.source.fileName) ?? this.source.fileName)
       );
       this.addStatements([
         this.factory.createVariableStatement([], this.factory.createVariableDeclarationList([decl]))
@@ -345,7 +339,7 @@ export class TransformerState implements State {
         (m): m is ts.MethodDeclaration => ts.isMethodDeclaration(m) && ts.isIdentifier(m.name) && m.name.escapedText === method
       );
     } else {
-      const props = this.getResolver().getPropertiesOfType(cls);
+      const props = this.#resolver.getPropertiesOfType(cls);
       for (const prop of props) {
         const decl = prop.declarations?.[0];
         if (decl && prop.escapedName === method && ts.isMethodDeclaration(decl)) {

package/src/util/log.ts

@@ -36,7 +36,8 @@ export class LogUtil {
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       const ox = x as object;
       const out: Record<string, unknown> = {};
-      for (const key of Object.keys(ox)) {
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      for (const key of Object.keys(ox) as (keyof typeof ox)[]) {
         if (Object.getPrototypeOf(ox[key]) === Function.prototype || exclude.has(key) || ox[key] === undefined) {
           continue;
         }

package/src/manifest-index.ts

@@ -1,36 +0,0 @@
-import ts from 'typescript';
-
-import { RootIndex, IndexedFile, path } from '@travetto/manifest';
-import { DeclarationUtil } from './util/declaration';
-
-/**
- * Specific logic for the transformer
- */
-export class TransformerIndex {
-  /**
-   * Resolve import name for a given type
-   */
-  static getImportName(type: ts.Type | string, removeExt = false): string {
-    const ogSource = typeof type === 'string' ? type : DeclarationUtil.getPrimaryDeclarationNode(type).getSourceFile().fileName;
-    let sourceFile = path.toPosix(ogSource);
-
-    if (!sourceFile.endsWith('.js') && !sourceFile.endsWith('.ts')) {
-      sourceFile = `${sourceFile}.ts`;
-    }
-
-    const imp =
-      RootIndex.getEntry(/[.]ts$/.test(sourceFile) ? sourceFile : `${sourceFile}.js`)?.import ??
-      RootIndex.getFromImport(sourceFile.replace(/^.*node_modules\//, '').replace(/[.]ts$/, ''))?.import ??
-      ogSource;
-
-    return removeExt ? imp.replace(/[.]js$/, '') : imp;
-  }
-
-  static isKnown(fileOrImport: string): boolean {
-    return (RootIndex.getFromSource(fileOrImport) !== undefined) || (RootIndex.getFromImport(fileOrImport) !== undefined);
-  }
-
-  static getFromImport(imp: string): IndexedFile | undefined {
-    return RootIndex.getFromImport(imp);
-  }
-}