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

package/src/resolver/builder.ts

@@ -1,12 +1,15 @@
 /* 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 { Type, AnyType, UnionType, Checker } from './types';
-import { DocUtil, CoreUtil, DeclarationUtil, LiteralUtil } from '../util';
+import { DocUtil } from '../util/doc';
+import { CoreUtil } from '../util/core';
+import { DeclarationUtil } from '../util/declaration';
+import { LiteralUtil } from '../util/literal';
+
+import { Type, AnyType, UnionType, TransformResolver } from './types';
+import { CoerceUtil } from './coerce';
 
 /**
  * List of global types that can be parameterized
@@ -35,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;
 
@@ -62,9 +65,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') && !resolver.isKnownFile(sourceFile)) {
       return { category: 'unknown', type };
     } else if (!resolvedType.isClass()) { // Not a real type
       return { category: 'shape', type: resolvedType };
@@ -93,32 +97,32 @@ 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) {
         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 {
@@ -133,23 +137,21 @@ export const TypeBuilder: {
           key: 'literal',
           name: cons.name,
           ctor: cons,
-          tsTypeArguments: checker.getAllTypeArguments(type)
+          tsTypeArguments: resolver.getAllTypeArguments(type)
         };
       }
     }
   },
   external: {
-    build: (checker, type) => {
-      const source = DeclarationUtil.getPrimaryDeclarationNode(type).getSourceFile();
+    build: (resolver, type) => {
       const name = CoreUtil.getSymbol(type)?.getName();
-      return {
-        key: 'external', name, source: source.fileName,
-        tsTypeArguments: checker.getAllTypeArguments(type)
-      };
+      const importName = resolver.getTypeImportName(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 => {
@@ -175,50 +177,56 @@ 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();
-      for (const member of checker.getPropertiesOfType(type)) {
+    build: (resolver, type, alias?) => {
+      const tsFieldTypes: Record<string, ts.Type> = {};
+      const name = CoreUtil.getSymbol(alias ?? type)?.getName();
+      const importName = resolver.getTypeImportName(type) ?? '<unknown>';
+      const tsTypeArguments = resolver.getAllTypeArguments(type);
+      const props = resolver.getPropertiesOfType(type);
+      if (props.length === 0) {
+        return { key: 'unknown', name, importName };
+      }
+
+      for (const member of props) {
         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;
+          const memberType = resolver.getType(dec);
+          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: {
-    build: (checker, type) => {
+    build: (resolver, type) => {
       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 = resolver.getFileImportName(rawSourceFile);
+          } else {
+            const base = path.dirname(rawSourceFile);
+            importName = resolver.getFileImportName(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

package/src/resolver/coerce.ts

@@ -0,0 +1,103 @@
+const REGEX_PAT = /[\/](.*)[\/](i|g|m|s)?/;
+
+export class CoerceUtil {
+  /**
+   * Is a value a plain JS object, created using {}
+   */
+  static #isPlainObject(obj: unknown): obj is Record<string, unknown> {
+    return typeof obj === 'object' // separate from primitives
+      && obj !== undefined
+      && obj !== null         // is obvious
+      && obj.constructor === Object // separate instances (Array, DOM, ...)
+      && Object.prototype.toString.call(obj) === '[object Object]'; // separate build-in like Math
+  }
+
+  /**
+   * Create regex from string, including flags
+   */
+  static #toRegex(input: string | RegExp): RegExp {
+    if (input instanceof RegExp) {
+      return input;
+    } else if (REGEX_PAT.test(input)) {
+      const [, pat, mod] = input.match(REGEX_PAT) ?? [];
+      return new RegExp(pat, mod);
+    } else {
+      return new RegExp(input);
+    }
+  }
+
+  /**
+   * Coerce an input of any type to the class provided
+   * @param input Input value
+   * @param type Class to coerce to (String, Boolean, Number, Date, RegEx, Object)
+   * @param strict Should a failure to coerce throw an error?
+   */
+  static coerce(input: unknown, type: typeof String, strict?: boolean): string;
+  static coerce(input: unknown, type: typeof Number, strict?: boolean): number;
+  static coerce(input: unknown, type: typeof Boolean, strict?: boolean): boolean;
+  static coerce(input: unknown, type: typeof Date, strict?: boolean): Date;
+  static coerce(input: unknown, type: typeof RegExp, strict?: boolean): RegExp;
+  static coerce(input: unknown, type: Function, strict = true): unknown {
+    // Do nothing
+    if (input === null || input === undefined) {
+      return input;
+    } else if (!strict && type !== String && input === '') {
+      return undefined; // treat empty string as undefined for non-strings in non-strict mode
+    } else if (type && input instanceof type) {
+      return input;
+    }
+
+    switch (type) {
+      case Date: {
+        const res = typeof input === 'number' || /^[-]?\d+$/.test(`${input}`) ?
+          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+          new Date(parseInt(input as string, 10)) : new Date(input as Date);
+        if (strict && Number.isNaN(res.getTime())) {
+          throw new Error(`Invalid date value: ${input}`);
+        }
+        return res;
+      }
+      case Number: {
+        const res = `${input}`.includes('.') ? parseFloat(`${input}`) : parseInt(`${input}`, 10);
+        if (strict && Number.isNaN(res)) {
+          throw new Error(`Invalid numeric value: ${input}`);
+        }
+        return res;
+      }
+      case Boolean: {
+        const match = `${input}`.match(/^((?<TRUE>true|yes|1|on)|false|no|off|0)$/i);
+        if (strict && !match) {
+          throw new Error(`Invalid boolean value: ${input}`);
+        }
+        return !!match?.groups?.TRUE;
+      }
+      case RegExp: {
+        if (typeof input === 'string') {
+          try {
+            return this.#toRegex(input);
+          } catch {
+            if (strict) {
+              throw new Error(`Invalid regex: ${input}`);
+            } else {
+              return;
+            }
+          }
+        } else if (strict) {
+          throw new Error('Invalid regex type');
+        } else {
+          return;
+        }
+      }
+      case Object: {
+        if (!strict || this.#isPlainObject(input)) {
+          return input;
+        } else {
+          throw new Error('Invalid object type');
+        }
+      }
+      case undefined:
+      case String: return `${input}`;
+    }
+    throw new Error(`Unknown type ${type.name}`);
+  }
+}

package/src/resolver/service.ts

@@ -1,18 +1,23 @@
-import * as ts from 'typescript';
+import ts from 'typescript';
 
-import { 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';
+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,40 @@ export class TypeResolver implements Checker {
     return this.#tsChecker;
   }
 
+  /**
+   * Resolve an import name (e.g. @module/path/file) for a file
+   */
+  getFileImportName(file: string, removeExt?: boolean): string {
+    let sourceFile = path.toPosix(file);
+
+    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 ??
+      file;
+
+    return removeExt ? imp.replace(/[.]js$/, '') : imp;
+  }
+
+  /**
+   * Resolve an import name (e.g. @module/path/file) for a type
+   */
+  getTypeImportName(type: ts.Type, removeExt?: boolean): string | undefined {
+    const ogSource = DeclarationUtil.getPrimaryDeclarationNode(type)?.getSourceFile()?.fileName;
+    return ogSource ? this.getFileImportName(ogSource, removeExt) : undefined;
+  }
+
+  /**
+   * 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
@@ -65,7 +104,7 @@ export class TypeResolver implements Checker {
   /**
    * Resolve an `AnyType` from a `ts.Type` or a `ts.Node`
    */
-  resolveType(node: ts.Type | ts.Node): AnyType {
+  resolveType(node: ts.Type | ts.Node, importName: string): AnyType {
     const visited = new VisitCache();
     const resolve = (resType: ts.Type, alias?: ts.Symbol, depth = 0): AnyType => {
 
@@ -73,7 +112,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);
@@ -117,7 +156,7 @@ export class TypeResolver implements Checker {
       if (!(err instanceof Error)) {
         throw err;
       }
-      console.error('Unable to resolve type', err.stack);
+      console.error(`Unable to resolve type in ${importName}`, err.stack);
       return { key: 'literal', ctor: Object, name: 'object' };
     }
   }

package/src/resolver/types.ts

@@ -1,4 +1,4 @@
-import type * as ts from 'typescript';
+import type ts from 'typescript';
 
 /**
  * Base type for a simplistic type structure
@@ -37,7 +37,7 @@ export interface ExternalType extends Type<'external'> {
   /**
    *  Location the type came from, for class references
    */
-  source: string;
+  importName: string;
   /**
    * Type arguments
    */
@@ -55,7 +55,7 @@ export interface ShapeType extends Type<'shape'> {
   /**
    *  Location the type came from, for class references
    */
-  source: string;
+  importName: string;
   /**
    * Does not include methods, used for shapes not concrete types
    */
@@ -151,7 +151,10 @@ export type AnyType = TupleType | ShapeType | UnionType | LiteralType | External
 /**
  * Simple interface for checked methods
  */
-export interface Checker {
+export interface TransformResolver {
+  isKnownFile(file: string): boolean;
+  getFileImportName(file: string, removeExt?: boolean): string;
+  getTypeImportName(type: ts.Type, removeExt?: boolean): string | undefined;
   getAllTypeArguments(type: ts.Type): ts.Type[];
   getPropertiesOfType(type: ts.Type): ts.Symbol[];
   getTypeAsString(type: ts.Type): string | undefined;