fix(type-compiler): resolve reflection mode paths correctly

previously complex reflection options like

```
reflection: [
  'src/ts/**/*.ts',
  '!src/ts/exclude-this.ts'
]
```

did not work. this works now

Also add a new script `deepkit-compiler-debug` to allow transpile a single typescript file and see its transformed output directly.

Also include a plugin function that can be used in custom build systems more easily

Author: marcj

packages/type-compiler/compiler-debug.ts

@@ -0,0 +1,38 @@
+import { deepkitType } from './src/plugin.js';
+import { readFileSync } from 'fs';
+
+interface Arguments {
+    file: string;
+    config?: string;
+}
+
+function parseArguments(args: string[]): Arguments {
+    const result: Arguments = {
+        file: '',
+    };
+
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--config') {
+            result.config = args[i + 1];
+            i++;
+        } else {
+            result.file = arg;
+        }
+    }
+
+    return result;
+}
+
+const args = parseArguments(process.argv.slice(2));
+
+
+
+const transformer = deepkitType({
+    tsConfig: args.config,
+});
+
+const code = readFileSync(args.file, 'utf8');
+const transformed = transformer(code, args.file);
+
+console.log(transformed?.code);

packages/type-compiler/deepkit-compiler-debug.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+try {
+    require('./dist/cjs/compiler-debug.js');
+} catch (error) {}

packages/type-compiler/index.ts

@@ -12,6 +12,7 @@ import { declarationTransformer, transformer } from './src/compiler.js';
 import type { Program } from 'typescript';
 
 export * from './src/compiler.js';
+export * from './src/plugin.js';
 export * from './src/loader.js';
 
 export default function myTransformerPlugin(program: Program, opts: {}) {

packages/type-compiler/package.json

@@ -14,7 +14,8 @@
     }
   },
   "bin": {
-    "deepkit-type-install": "./deepkit-type-install.js"
+    "deepkit-type-install": "./deepkit-type-install.js",
+    "deepkit-compiler-debug": "./deepkit-compiler-debug.js"
   },
   "sideEffects": false,
   "publishConfig": {

packages/type-compiler/src/compiler.ts

@@ -90,9 +90,8 @@ import { existsSync, readFileSync } from 'fs';
 import { dirname, isAbsolute, join, resolve } from 'path';
 import stripJsonComments from 'strip-json-comments';
 import { MappedModifier, ReflectionOp, TypeNumberBrand } from '@deepkit/type-spec';
-import { Resolver } from './resolver.js';
+import { patternMatch, ReflectionMode, reflectionModeMatcher, reflectionModes, Resolver } from './resolver.js';
 import { knownLibFilesForCompilerOptions } from '@typescript/vfs';
-import * as micromatch from 'micromatch';
 
 // don't use from @deepkit/core since we don't want to have a dependency to @deepkit/core
 export function isObject(obj: any): obj is { [key: string]: any } {
@@ -186,7 +185,6 @@ const serverEnv = 'undefined' !== typeof process;
  * It can't be more ops than this given number
  */
 export const packSize: number = 2 ** packSizeByte; //64
-const reflectionModes = ['always', 'default', 'never'] as const;
 
 interface ReflectionOptions {
     /**
@@ -695,7 +693,7 @@ export class ReflectionTransformer implements CustomTransformer {
             }
         }
 
-        debug(`Transform file ${sourceFile.fileName} via config ${this.compilerOptions.configFilePath || 'none'}, reflection=${this.reflectionMode}.`);
+        debug(`Transform file ${sourceFile.fileName} via config ${this.compilerOptions.configFilePath || 'none'}, reflection=${this.reflectionMode} (${this.getModuleType()}).`);
 
         if (this.reflectionMode === 'never') {
             return sourceFile;
@@ -992,15 +990,15 @@ export class ReflectionTransformer implements CustomTransformer {
         this.sourceFile = visitNode(this.sourceFile, compileDeclarations);
 
         if (this.addImports.length) {
-            const compilerOptions = this.compilerOptions;
             const handledIdentifier: string[] = [];
             for (const imp of this.addImports) {
                 if (handledIdentifier.includes(getIdentifierName(imp.identifier))) continue;
                 handledIdentifier.push(getIdentifierName(imp.identifier));
-                if (compilerOptions.module === ModuleKind.CommonJS) {
+                if (this.getModuleType() === 'cjs') {
                     //var {identifier} = require('./bar')
+                    const test = this.f.createIdentifier(getIdentifierName(imp.identifier));
                     const variable = this.f.createVariableStatement(undefined, this.f.createVariableDeclarationList([this.f.createVariableDeclaration(
-                        this.f.createObjectBindingPattern([this.f.createBindingElement(undefined, undefined, imp.identifier)]),
+                        this.f.createObjectBindingPattern([this.f.createBindingElement(undefined, undefined, test)]),
                         undefined, undefined,
                         this.f.createCallExpression(this.f.createIdentifier('require'), undefined, [imp.from])
                     )], NodeFlags.Const));
@@ -1015,7 +1013,7 @@ export class ReflectionTransformer implements CustomTransformer {
                     //import {identifier} from './bar.js'
                     // import { identifier as identifier } is used to avoid automatic elision of imports (in angular builds for example)
                     // that's probably a bit unstable.
-                    const specifier = this.f.createImportSpecifier(false, imp.identifier, imp.identifier);
+                    const specifier = this.f.createImportSpecifier(false, undefined, imp.identifier);
                     const namedImports = this.f.createNamedImports([specifier]);
                     const importStatement = this.f.createImportDeclaration(undefined,
                         this.f.createImportClause(false, undefined, namedImports), imp.from
@@ -1111,6 +1109,10 @@ export class ReflectionTransformer implements CustomTransformer {
         return this.sourceFile;
     }
 
+    protected getModuleType(): 'cjs' | 'esm' {
+        return this.compilerOptions.module === ModuleKind.CommonJS ? 'cjs' : 'esm';
+    }
+
     protected injectResetΩ<T extends FunctionDeclaration | FunctionExpression | MethodDeclaration | ConstructorDeclaration>(node: T): T {
         let hasReceiveType = false;
         for (const param of node.parameters) {
@@ -1997,12 +1999,7 @@ export class ReflectionTransformer implements CustomTransformer {
 
     protected isExcluded(filePath: string): boolean {
         if (!this.currentReflectionConfig.options.exclude) return false;
-
-        const excluded = micromatch.contains(filePath, this.currentReflectionConfig.options.exclude, {
-            basename: true,
-            cwd: this.currentReflectionConfig.baseDir
-        });
-        return excluded;
+        return patternMatch(filePath, this.currentReflectionConfig.options.exclude, this.currentReflectionConfig.baseDir);
     }
 
     protected extractPackStructOfTypeReference(type: TypeReferenceNode | ExpressionWithTypeArguments, program: CompilerProgram): void {
@@ -2144,12 +2141,15 @@ export class ReflectionTransformer implements CustomTransformer {
                     return;
                 }
 
+                const runtimeTypeName = this.getDeclarationVariableName(typeName);
+
                 //to break recursion, we track which declaration has already been compiled
                 if (!this.compiledDeclarations.has(declaration) && !this.compileDeclarations.has(declaration)) {
                     const declarationSourceFile = findSourceFile(declaration) || this.sourceFile;
                     const isGlobal = resolved.importDeclaration === undefined && declarationSourceFile.fileName !== this.sourceFile.fileName;
                     const isFromImport = resolved.importDeclaration !== undefined;
 
+
                     if (this.isExcluded(declarationSourceFile.fileName)) {
                         program.pushOp(ReflectionOp.any);
                         return;
@@ -2185,7 +2185,7 @@ export class ReflectionTransformer implements CustomTransformer {
 
                             // check if this is a viable option:
                             // //check if the referenced file has reflection info emitted. if not, any is emitted for that reference
-                            // const typeVar = this.getDeclarationVariableName(typeName);
+                            // const typeVar = runtimeRypeName;
                             // //check if typeVar is exported in referenced file
                             // const builtType = isNodeWithLocals(found) && found.locals && found.locals.has(typeVar.escapedText);
                             // if (!builtType) {
@@ -2201,7 +2201,7 @@ export class ReflectionTransformer implements CustomTransformer {
                             }
 
                             // this.addImports.push({ identifier: typeVar, from: resolved.importDeclaration.moduleSpecifier });
-                            this.addImports.push({ identifier: this.getDeclarationVariableName(typeName), from: resolved.importDeclaration.moduleSpecifier });
+                            this.addImports.push({ identifier: runtimeTypeName, from: resolved.importDeclaration.moduleSpecifier });
                         }
                     } else {
                         //it's a reference type inside the same file. Make sure its type is reflected
@@ -2219,7 +2219,7 @@ export class ReflectionTransformer implements CustomTransformer {
                 }
 
                 const index = program.pushStack(
-                    program.forNode === declaration ? 0 : this.f.createArrowFunction(undefined, undefined, [], undefined, undefined, this.getDeclarationVariableName(typeName))
+                    program.forNode === declaration ? 0 : this.f.createArrowFunction(undefined, undefined, [], undefined, undefined, runtimeTypeName)
                 );
                 if (type.typeArguments) {
                     for (const argument of type.typeArguments) {
@@ -2647,18 +2647,8 @@ export class ReflectionTransformer implements CustomTransformer {
         );
     }
 
-    protected parseReflectionMode(mode: typeof reflectionModes[number] | '' | boolean | string | string[] | undefined, configPathDir: string): typeof reflectionModes[number] {
-        if (Array.isArray(mode)) {
-            if (!configPathDir) return 'never';
-            const matches = micromatch.contains(this.sourceFile.fileName, mode, {
-                cwd: configPathDir
-            });
-
-            return matches ? 'default' : 'never';
-        }
-        if ('boolean' === typeof mode) return mode ? 'default' : 'never';
-        if (mode === 'default' || mode === 'always') return mode;
-        return 'never';
+    protected parseReflectionMode(mode: ReflectionMode, configPathDir: string): typeof reflectionModes[number] {
+        return reflectionModeMatcher(this.sourceFile.fileName, mode, configPathDir);
     }
 
     protected resolvedTsConfig: { [path: string]: { data: Record<string, any>, exists: boolean } } = {};

packages/type-compiler/src/plugin.ts

@@ -0,0 +1,58 @@
+import ts from 'typescript';
+import { cwd } from 'process';
+import { createFilter } from '@rollup/pluginutils';
+import { declarationTransformer, transformer } from './compiler.js';
+
+export interface Options {
+    include?: string;
+    exclude?: string;
+    tsConfig?: string;
+    transformers?: ts.CustomTransformers;
+    compilerOptions?: ts.CompilerOptions;
+    readFile?: (path: string) => string | undefined;
+}
+
+export type Transform = (code: string, fileName: string) => { code: string, map?: string } | undefined;
+
+export function deepkitType(options: Options = {}): Transform {
+    const filter = createFilter(options.include ?? ['**/*.tsx', '**/*.ts'], options.exclude ?? 'node_modules/**');
+
+    const transformers = options.transformers || {
+        before: [transformer],
+        after: [declarationTransformer],
+    };
+
+    const configFilePath = options.tsConfig || cwd() + '/tsconfig.json';
+
+    const tsConfig = ts.readConfigFile(configFilePath, options.readFile || ts.sys.readFile);
+
+    if (tsConfig.error) {
+        throw new Error(ts.formatDiagnostic(tsConfig.error, {
+            getCanonicalFileName: (fileName: string) => fileName,
+            getCurrentDirectory: ts.sys.getCurrentDirectory,
+            getNewLine: () => ts.sys.newLine,
+        }));
+    }
+
+    const compilerOptions = Object.assign({
+        'target': ts.ScriptTarget.ESNext,
+        'module': ts.ModuleKind.ESNext,
+        configFilePath,
+    }, tsConfig.config, options.compilerOptions || {});
+
+    return function transform(code: string, fileName: string) {
+        if (!filter(fileName)) return;
+
+        const transformed = ts.transpileModule(code, {
+            compilerOptions,
+            fileName,
+            //@ts-ignore
+            transformers
+        });
+
+        return {
+            code: transformed.outputText,
+            map: transformed.sourceMapText,
+        };
+    };
+}

packages/type-compiler/src/resolver.ts

@@ -1,14 +1,7 @@
-import type {
-    CompilerHost,
-    CompilerOptions,
-    ExportDeclaration,
-    Expression,
-    ImportDeclaration,
-    ResolvedModule,
-    SourceFile,
-    StringLiteral,
-} from 'typescript';
+import type { CompilerHost, CompilerOptions, ExportDeclaration, Expression, ImportDeclaration, ResolvedModule, SourceFile, StringLiteral, } from 'typescript';
 import ts from 'typescript';
+import * as micromatch from 'micromatch';
+import { isAbsolute } from 'path';
 
 const {
     createSourceFile,
@@ -17,6 +10,38 @@ const {
     ScriptTarget,
 } = ts;
 
+export const reflectionModes = ['always', 'default', 'never'] as const;
+
+export type ReflectionMode = typeof reflectionModes[number] | '' | boolean | string | string[] | undefined;
+
+export function patternMatch(path: string, patterns: string[], base?: string) {
+    const normalized = patterns.map(v => {
+        if (v[0] === '!') {
+            if (!isAbsolute(v.slice(1))) return `!${base}/${v.substr(1)}`;
+            return v;
+        }
+
+        if (!isAbsolute(v)) return `${base}/${v}`;
+        return v;
+    })
+    const matched =  micromatch.default([path], normalized, {});
+    return matched.length > 0;
+}
+
+export function reflectionModeMatcher(
+    filePath: string,
+    mode: ReflectionMode,
+    configPathDir?: string
+): typeof reflectionModes[number] {
+    if (Array.isArray(mode)) {
+        if (!configPathDir) return 'never';
+        return patternMatch(filePath, mode, configPathDir) ? 'default' : 'never';
+    }
+    if ('boolean' === typeof mode) return mode ? 'default' : 'never';
+    if (mode === 'default' || mode === 'always') return mode;
+    return 'never';
+}
+
 /**
  * A utility to resolve a module path and its declaration.
  *

packages/type-compiler/tests/resolver.spec.ts

@@ -0,0 +1,31 @@
+import { expect, test } from '@jest/globals';
+import { patternMatch, ReflectionMode, reflectionModeMatcher } from '../src/resolver.js';
+
+test('patternMatch', () => {
+    expect(patternMatch('/app/model/test.ts', ['model/**/*.ts'], '/app')).toBe(true);
+    expect(patternMatch('/app/model/test.ts', ['model/**/*.ts', '!**/*.ts'], '/app')).toBe(false);
+    expect(patternMatch('/app/model/test.ts', ['model/**/*.ts', '!model/test.ts'], '/app')).toBe(false);
+});
+
+test('match', () => {
+    const mode: ReflectionMode = [
+        'model/**/*.ts',
+    ];
+
+    expect(reflectionModeMatcher('/app/model/test.ts', mode, '/app')).toBe('default');
+    expect(reflectionModeMatcher('/app/model/controller/test.controller.ts', mode, '/app')).toBe('default');
+    expect(reflectionModeMatcher('/app/external/file.ts', mode, '/app')).toBe('never');
+});
+
+test('match negate', () => {
+    const mode: ReflectionMode = [
+        'server/controllers/**/*.ts',
+        'server/services/**/*.ts',
+        'server/dao/**/*.ts',
+        '!server/dao/mongoose.ts',
+        'shared/**/*.ts',
+    ];
+
+    expect(reflectionModeMatcher('/path/portal/server/dao/models.ts', mode, '/path/portal')).toBe('default');
+    expect(reflectionModeMatcher('/path/portal/server/dao/mongoose.ts', mode, '/path/portal')).toBe('never');
+});

packages/type-compiler/tsconfig.json

@@ -23,6 +23,7 @@
     "src",
     "tests",
     "install-transformer.ts",
+    "compiler-debug.ts",
     "index.ts"
   ],
   "references": [