@travetto/transformer 3.0.0-rc.1 → 3.0.0-rc.10

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.1",
+  "version": "3.0.0-rc.10",
   "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.7",
+    "tslib": "^2.5.0",
+    "typescript": "^4.9.5"
+  },
+  "travetto": {
+    "displayName": "Transformation",
+    "profiles": [
+      "compile"
+    ]
   },
   "publishConfig": {
     "access": "public"

package/src/importer.ts

@@ -1,13 +1,16 @@
-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 { 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)?$/;
 
 /**
  * Manages imports within a ts.SourceFile
@@ -18,18 +21,81 @@ export class ImportManager {
   #imports: Map<string, Import>;
   #idx: Record<string, number> = {};
   #ids = new Map<string, string>();
+  #importName: string;
 
   constructor(public source: ts.SourceFile, public factory: ts.NodeFactory) {
     this.#imports = ImportUtil.collectImports(source);
+    this.#importName = TransformerIndex.getImportName(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('.') || TransformerIndex.isKnown(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,
+    checker: ts.TypeChecker
+  ): 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)))) {
+      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 = checker.getTypeAtLocation(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 +103,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 = TransformerIndex.getImportName(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 +131,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 +153,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 +170,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, checker: ts.TypeChecker): 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, checker)!,
+            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;
+  finalize(ret: ts.SourceFile, checker: ts.TypeChecker): ts.SourceFile {
+    ret = this.finalizeNewImports(ret) ?? ret;
+    ret = this.finalizeImportExportExtension(ret, checker) ?? 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,62 @@
+import ts from 'typescript';
+
+import { 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(transformerFiles: string[]): Promise<TransformerManager> {
+    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));
+    }
+
+    // Prepare a new visitor factory with a given type checker
+    return new TransformerManager(transformers);
+  }
+
+  #cached: ts.CustomTransformers | undefined;
+  #transformers: NodeTransformer<TransformerState>[];
+
+  constructor(transformers: NodeTransformer<TransformerState>[]) {
+    this.#transformers = transformers;
+  }
+
+  /**
+   * Initialize with type checker
+   * @param checker
+   */
+  init(checker: ts.TypeChecker): void {
+    const visitor = new VisitorFactory(
+      (ctx, src) => new TransformerState(src, ctx.factory, checker),
+      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/manifest-index.ts

@@ -0,0 +1,36 @@
+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);
+  }
+}

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);
 }
 
 /**

package/src/resolver/builder.ts

@@ -1,12 +1,17 @@
 /* eslint-disable no-bitwise */
-import * as ts from 'typescript';
-import { dirname } from 'path';
+import ts from 'typescript';
 
-import { PathUtil } from '@travetto/boot';
-import { Util } from '@travetto/base';
+import { path } from '@travetto/manifest';
+
+import { DocUtil } from '../util/doc';
+import { CoreUtil } from '../util/core';
+import { DeclarationUtil } from '../util/declaration';
+import { LiteralUtil } from '../util/literal';
 
 import { Type, AnyType, UnionType, Checker } from './types';
-import { DocUtil, CoreUtil, DeclarationUtil, LiteralUtil } from '../util';
+import { CoerceUtil } from './coerce';
+
+import { TransformerIndex } from '../manifest-index';
 
 /**
  * List of global types that can be parameterized
@@ -62,9 +67,10 @@ export function TypeCategorize(checker: ts.TypeChecker, type: ts.Type): { catego
     }
 
     const source = DeclarationUtil.getPrimaryDeclarationNode(resolvedType).getSourceFile();
-    if (source?.fileName.includes('@types/node/globals') || source?.fileName.includes('typescript/lib')) {
+    const sourceFile = source.fileName;
+    if (sourceFile?.includes('@types/node/globals') || sourceFile?.includes('typescript/lib')) {
       return { category: 'literal', type };
-    } else if (!source?.fileName.includes('@travetto') && source?.fileName.endsWith('.d.ts')) {
+    } else if (sourceFile?.endsWith('.d.ts') && !TransformerIndex.isKnown(sourceFile)) {
       return { category: 'unknown', type };
     } else if (!resolvedType.isClass()) { // Not a real type
       return { category: 'shape', type: resolvedType };
@@ -118,7 +124,7 @@ export const TypeBuilder: {
       if (name in GLOBAL_SIMPLE) {
         const cons = GLOBAL_SIMPLE[name];
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        const ret = LiteralUtil.isLiteralType(type) ? Util.coerceType(type.value, cons as typeof String, false) :
+        const ret = LiteralUtil.isLiteralType(type) ? CoerceUtil.coerce(type.value, cons as typeof String, false) :
           undefined;
 
         return {
@@ -140,12 +146,10 @@ export const TypeBuilder: {
   },
   external: {
     build: (checker, type) => {
-      const source = DeclarationUtil.getPrimaryDeclarationNode(type).getSourceFile();
       const name = CoreUtil.getSymbol(type)?.getName();
-      return {
-        key: 'external', name, source: source.fileName,
-        tsTypeArguments: checker.getAllTypeArguments(type)
-      };
+      const importName = TransformerIndex.getImportName(type);
+      const tsTypeArguments = checker.getAllTypeArguments(type);
+      return { key: 'external', name, importName, tsTypeArguments };
     }
   },
   union: {
@@ -176,25 +180,23 @@ export const TypeBuilder: {
   },
   shape: {
     build: (checker, type, alias?) => {
-      const fieldNodes: Record<string, ts.Type> = {};
-      const name = CoreUtil.getSymbol(alias ?? type);
-      const source = DeclarationUtil.getPrimaryDeclarationNode(type)?.getSourceFile();
+      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 dec = DeclarationUtil.getPrimaryDeclarationNode(member);
         if (DeclarationUtil.isPublic(dec)) { // If public
           const memberType = checker.getType(dec);
-          if (!memberType.getCallSignatures().length) { // if not a function
-            fieldNodes[member.getName()] = memberType;
+          if (
+            !member.getName().includes('@') && // if not a symbol
+            !memberType.getCallSignatures().length // if not a function
+          ) {
+            tsFieldTypes[member.getName()] = memberType;
           }
         }
       }
-      return {
-        key: 'shape', name: name?.getName(),
-        source: source?.fileName,
-        tsFieldTypes: fieldNodes,
-        tsTypeArguments: checker.getAllTypeArguments(type),
-        fieldTypes: {}
-      };
+      return { key: 'shape', name, importName, tsFieldTypes, tsTypeArguments, fieldTypes: {} };
     }
   },
   concrete: {
@@ -202,23 +204,26 @@ export const TypeBuilder: {
       const [tag] = DocUtil.readDocTag(type, 'concrete');
       if (tag) {
         // eslint-disable-next-line prefer-const
-        let [source, name, ext] = tag.split(':');
+        let [importName, name] = tag.split(':');
         if (!name) {
-          name = source;
-          source = '.';
+          name = importName;
+          importName = '.';
         }
 
-        const sourceFile: string = DeclarationUtil.getDeclarations(type)
-          ?.find(x => ts.getAllJSDocTags(x, (t): t is ts.JSDocTag => t.tagName.getText() === 'concrete').length)
-          ?.getSourceFile().fileName ?? '';
+        // Resolving relative to source file
+        if (importName.startsWith('.')) {
+          const rawSourceFile: string = DeclarationUtil.getDeclarations(type)
+            ?.find(x => ts.getAllJSDocTags(x, (t): t is ts.JSDocTag => t.tagName.getText() === 'concrete').length)
+            ?.getSourceFile().fileName ?? '';
 
-        if (source === '.') {
-          source = sourceFile;
-        } else if (source.startsWith('.')) {
-          source = PathUtil.resolveUnix(dirname(sourceFile), source);
+          if (importName === '.') {
+            importName = TransformerIndex.getImportName(rawSourceFile);
+          } else {
+            const base = path.dirname(rawSourceFile);
+            importName = TransformerIndex.getImportName(path.resolve(base, importName));
+          }
         }
-
-        return { key: 'external', name, source: ext === 'node' ? source : PathUtil.resolveUnix(sourceFile, source) };
+        return { key: 'external', name, importName };
       }
     }
   }

package/src/resolver/cache.ts

@@ -1,5 +1,5 @@
-import * as ts from 'typescript';
-import { AnyType } from './types';
+import ts from 'typescript';
+import type { AnyType } from './types';
 
 /**
  * Cache for handling recursive checks