@runtyped/type-compiler 1.0.20-alpha.1

package/src/config.ts

@@ -0,0 +1,331 @@
+import { dirname, isAbsolute, join } from 'path';
+import type { CompilerOptions, ParseConfigHost } from 'typescript';
+import ts from 'typescript';
+
+import { debug, debug2, isDebug } from './debug.js';
+import { patternMatch } from './resolver.js';
+
+/**
+ * Default means reflection is enabled for this file.
+ * Never means the whole reflection is disabled for this file.
+ * Explicit means that reflection is per default disabled for this file, but each symbol/type
+ * in it is allowed to enable it using jsdoc `@reflection`.
+ */
+export const reflectionModes = ['default', 'explicit', 'never'] as const;
+export type Mode = (typeof reflectionModes)[number];
+export type RawMode = Mode | '' | boolean | string | string[] | undefined;
+
+// don't use from @runtyped/core since we don't want to have a dependency to @runtyped/core
+export function isObject(obj: any): obj is { [key: string]: any } {
+    if (!obj) {
+        return false;
+    }
+    return typeof obj === 'object' && !Array.isArray(obj);
+}
+
+const defaultMergeStrategy = 'merge';
+
+/**
+ * These are the values that can be in the tsconfig.json file.
+ */
+export interface TsConfigJson {
+    extends?: string;
+    compilerOptions?: any;
+
+    reflection?: RawMode;
+
+    deepkitCompilerOptions?: {
+        /**
+         * Either true to activate reflection for all files compiled using this tsconfig,
+         * or a list of globs/file paths relative to this tsconfig.json.
+         * Globs/file paths can be prefixed with a ! to exclude them.
+         */
+        reflection?: RawMode;
+
+        /**
+         * If a tsconfig extends another tsconfig, this option defines how the reflection/exclude
+         * options are merged. The default strategy is `merge`, which means that the reflection/exclude
+         * options are merged with the parent tsconfig.json. If set to `replace`, the reflection/exclude
+         * options are not merged, but the parent tsconfig.json is ignored.
+         */
+        mergeStrategy?: 'merge' | 'replace';
+
+        /**
+         * List of globs/file paths relative to this tsconfig.json
+         * which are then excluded from the type compilation step.
+         * Per default a few global .d.ts files are excluded like `lib.dom*.d.ts` and `*typedarrays.d.ts`.
+         */
+        exclude?: string[];
+    };
+}
+
+/**
+ * Read config and parses under TypeScript specification.
+ */
+function readTsConfig(parseConfigHost: ParseConfigHost, path: string): TsConfigJson | undefined {
+    const configFile = ts.readConfigFile(path, (path: string) => parseConfigHost.readFile(path));
+    if (configFile.error) {
+        debug(`Failed to read tsconfig ${path}: ${configFile.error.messageText}`);
+        return;
+    }
+
+    const parsed = ts.parseJsonConfigFileContent(configFile.config, parseConfigHost, dirname(path));
+    // errors we ignore entirely
+    const ignoredErrors = [
+        18003, // No inputs were found in config file.
+    ];
+    // errors we soft ignore but still log
+    const softErrors: number[] = [
+        18000, // Circularity detected while resolving configuration
+    ];
+    const errors = parsed.errors.filter(v => !ignoredErrors.includes(v.code));
+    if (errors.length) {
+        debug(`Failed to parse tsconfig ${path}: ${parsed.errors.map(v => v.messageText).join(', ')}`);
+    }
+    const hardErrors = errors.filter(v => !softErrors.includes(v.code));
+    if (hardErrors.length) {
+        return;
+    }
+
+    return Object.assign(configFile.config, {
+        compilerOptions: parsed.options,
+    });
+}
+
+export interface ReflectionConfig {
+    /**
+     * Allows to exclude type definitions/TS files from being included in the type compilation step.
+     * When a global .d.ts is matched, their types won't be embedded (useful to exclude DOM for example)
+     */
+    exclude?: string[];
+
+    /**
+     * Either a boolean indication general reflection mode,
+     * or a list of globs to match against.
+     */
+    reflection?: string[] | Mode;
+}
+
+export interface CurrentConfig extends ReflectionConfig {
+    compilerOptions: ts.CompilerOptions;
+    mergeStrategy?: 'merge' | 'replace';
+    extends?: string;
+}
+
+export interface ResolvedConfig extends ReflectionConfig {
+    path: string; //tsconfig path
+    compilerOptions: ts.CompilerOptions;
+    mergeStrategy: 'merge' | 'replace';
+}
+
+export function reflectionModeMatcher(config: ReflectionConfig, filePath: string): Mode {
+    if (Array.isArray(config.exclude)) {
+        if (patternMatch(filePath, config.exclude)) return 'never';
+    }
+    if (Array.isArray(config.reflection)) {
+        return patternMatch(filePath, config.reflection) ? 'default' : 'never';
+    }
+    if (config.reflection === 'default' || config.reflection === 'explicit') return config.reflection;
+    return 'never';
+}
+
+function ensureStringArray(value: any): string[] {
+    if (Array.isArray(value)) return value.map(v => '' + v);
+    if ('string' === typeof value) return [value];
+    return [];
+}
+
+export function parseRawMode(mode: RawMode): string[] | Mode {
+    if ('boolean' === typeof mode) return mode ? 'default' : 'never';
+    if (mode === 'default' || mode === 'explicit') return mode;
+    return ensureStringArray(mode);
+}
+
+function resolvePaths(baseDir: string, paths: any): void {
+    if (!paths || !Array.isArray(paths)) return;
+
+    for (let i = 0; i < paths.length; i++) {
+        if ('string' !== typeof paths[i]) continue;
+        if (isAbsolute(paths[i])) continue;
+        let path = paths[i];
+        let exclude = false;
+        if (path.startsWith('!')) {
+            exclude = true;
+            path = path.substring(1);
+        }
+
+        // we treat as relative if it starts with ./ or contains a /
+        if (path.startsWith('./') || path.includes('/')) {
+            path = join(baseDir, path);
+        }
+        // ensure backslashes are forward slashes
+        path = path.replace(/\\/g, '/');
+        if (exclude) path = '!' + path;
+        paths[i] = path;
+    }
+}
+
+function appendPaths(strategy: 'merge' | 'replace' = defaultMergeStrategy, parent: string[], existing?: string[]) {
+    // important to always return a new array, otherwise we would modify the parent array with subsequent calls
+    if (strategy === 'replace') {
+        // replace means we stick with existing if it is defined, otherwise we use parent
+        return [...(existing || parent)];
+    }
+    if (!existing) return [...parent];
+    return [...parent, ...existing];
+}
+
+function applyConfigValues(existing: CurrentConfig, parent: TsConfigJson, baseDir: string) {
+    const parentReflection = isObject(parent.deepkitCompilerOptions)
+        ? parent.deepkitCompilerOptions?.reflection
+        : parent.reflection;
+
+    if (isObject(parent.deepkitCompilerOptions) && 'undefined' === typeof existing.mergeStrategy) {
+        existing.mergeStrategy = parent.deepkitCompilerOptions.mergeStrategy;
+    }
+
+    if ('undefined' !== typeof parentReflection) {
+        const next = parseRawMode(parentReflection);
+        if ('undefined' === typeof existing.reflection) {
+            existing.reflection = next;
+        } else if ('string' === typeof existing.reflection) {
+            // if existing is already a string, there is nothing to inherit from parent
+        } else if (Array.isArray(next) && Array.isArray(existing.reflection)) {
+            existing.reflection = appendPaths(existing.mergeStrategy, next, existing.reflection);
+        } else if ('string' === typeof next && Array.isArray(existing.reflection)) {
+            // debug(`Warning: config parent tsconfig has reflection=${next}, but child tsconfig has reflection=${JSON.stringify(existing.reflection)}. reflection stays as array.`);
+        }
+    }
+
+    if (isObject(parent.deepkitCompilerOptions)) {
+        if (`undefined` !== typeof parent.deepkitCompilerOptions.exclude) {
+            const next = ensureStringArray(parent.deepkitCompilerOptions.exclude);
+            existing.exclude = appendPaths(existing.mergeStrategy, next, existing.exclude);
+        }
+    }
+
+    resolvePaths(baseDir, existing.reflection);
+    resolvePaths(baseDir, existing.exclude);
+
+    if (parent.compilerOptions) {
+        // typescript already correctly merges the compiler options
+        if (Object.keys(existing.compilerOptions).length === 0) {
+            Object.assign(existing.compilerOptions, parent.compilerOptions);
+        }
+    }
+    existing.extends = parent.extends;
+}
+
+export interface MatchResult {
+    tsConfigPath: string;
+    mode: (typeof reflectionModes)[number];
+}
+
+export const defaultExcluded = [
+    'lib.dom*.d.ts',
+    '*typedarrays.d.ts',
+    'lib.webworker*.d.ts',
+    'lib.decorator*.d.ts',
+    'lib.es2015.proxy.d.ts',
+    'lib.es2020.sharedmemory.d.ts',
+    'lib.es2015.core.d.ts',
+];
+
+export type Matcher = (path: string) => MatchResult;
+export type ConfigResolver = { match: Matcher; config: ResolvedConfig };
+export type ReflectionConfigCache = { [path: string]: ConfigResolver };
+
+export function getConfigResolver(
+    cache: ReflectionConfigCache,
+    host: ParseConfigHost,
+    compilerOptions: CompilerOptions,
+    sourceFile: { fileName: string },
+    tsConfigPath: string = '',
+): ConfigResolver {
+    let config: CurrentConfig = {
+        // We use the parameter `compilerOptions` only for compilerOptions.configFilePath.
+        // We load the compilerOptions manually since transformers don't get the full picture
+        // (path aliases are missing for example).
+        // It's important to load compilerOptions manually if there is compilerOptions.configFilePath
+        // since not all build tools provide the full compilerOptions.
+        compilerOptions: {},
+    };
+
+    tsConfigPath = tsConfigPath || ('string' === typeof compilerOptions.configFilePath ? compilerOptions.configFilePath : '');
+
+    if (tsConfigPath) {
+        if (cache[tsConfigPath]) return cache[tsConfigPath];
+        const configFile = readTsConfig(host, tsConfigPath);
+        if (configFile) applyConfigValues(config, configFile, dirname(tsConfigPath));
+    } else {
+        if (!tsConfigPath && sourceFile) {
+            //find tsconfig via sourceFile.fileName
+            const baseDir = dirname(sourceFile.fileName);
+            const configPath = ts.findConfigFile(baseDir, path => {
+                path = isAbsolute(path) ? path : join(baseDir, path);
+                return host.fileExists(path);
+            });
+            debug2(`No tsConfigPath|compilerOptions.configFilePath provided. Manually searching for tsconfig.json in ${baseDir} returned ${configPath}`);
+            if (configPath) {
+                //configPath might be relative to passed basedir
+                tsConfigPath = isAbsolute(configPath) ? configPath : join(baseDir, configPath);
+            }
+        }
+        if (tsConfigPath) {
+            if (cache[tsConfigPath]) return cache[tsConfigPath];
+            //configPath might be relative to passed basedir
+            const configFile = readTsConfig(host, tsConfigPath);
+            if (configFile) applyConfigValues(config, configFile, dirname(tsConfigPath));
+        }
+    }
+
+    if (tsConfigPath) {
+        let basePath = dirname(tsConfigPath);
+        let currentConfig = config;
+        const seen = new Set<string>();
+        seen.add(tsConfigPath);
+        //iterate through all configs (this.config.extends) until we have all reflection options found.
+        while (currentConfig.extends) {
+            const path = join(basePath, currentConfig.extends);
+            if (seen.has(path)) break;
+            seen.add(path);
+            const nextConfig = ts.readConfigFile(path, (path: string) => host.readFile(path));
+            if (!nextConfig) break;
+            basePath = dirname(path);
+            applyConfigValues(currentConfig, nextConfig.config, basePath);
+        }
+    } else {
+        throw new Error(`No tsconfig found for ${sourceFile?.fileName}, that is weird. Either provide a tsconfig or compilerOptions.configFilePath`);
+    }
+
+    config.exclude = config.exclude ? [...defaultExcluded, ...config.exclude] : [...defaultExcluded];
+
+    config.compilerOptions.configFilePath = tsConfigPath;
+
+    const resolvedConfig: ResolvedConfig = {
+        path: tsConfigPath,
+        // we want to maintain options passed from tsc API (transpile, Program)
+        compilerOptions: Object.assign(config.compilerOptions, compilerOptions),
+        exclude: config.exclude,
+        reflection: config.reflection,
+        mergeStrategy: config.mergeStrategy || defaultMergeStrategy,
+    };
+
+    if (isDebug()) {
+        debug(
+            `Found config ${resolvedConfig.path}:\nreflection:`,
+            resolvedConfig.reflection,
+            `\nexclude:`,
+            resolvedConfig.exclude,
+            `\npaths:`,
+            resolvedConfig.compilerOptions.paths,
+        );
+    }
+
+    const match = (path: string) => {
+        const mode = reflectionModeMatcher(config, path);
+        return { mode, tsConfigPath };
+    };
+
+    return (cache[tsConfigPath] = { config: resolvedConfig, match });
+}

package/src/debug.ts

@@ -0,0 +1,22 @@
+export function isDebug(level: number = 1) {
+    const expected = 'runtyped' + (level > 1 ? '+'.repeat(level - 1) : '');
+    return 'undefined' !== typeof process && 'string' === typeof process.env.DEBUG && process.env.DEBUG.includes(expected);
+}
+
+/**
+ * First level debugging with DEBUG=runtyped
+ */
+export function debug(...message: any[]): void {
+    if (isDebug(1)) {
+        console.debug(...message);
+    }
+}
+
+/**
+ * Second level debugging with DEBUG=runtyped+
+ */
+export function debug2(...message: any[]): void {
+    if (isDebug(2)) {
+        console.debug(...message);
+    }
+}

package/src/loader.ts

@@ -0,0 +1,58 @@
+import type { CompilerOptions, SourceFile, TransformationContext } from 'typescript';
+import ts from 'typescript';
+import { Cache, ReflectionTransformer } from './compiler.js';
+
+export class DeepkitLoader {
+    protected options: CompilerOptions = {
+        allowJs: true,
+        declaration: false,
+    };
+
+    protected host = ts.createCompilerHost(this.options);
+
+    protected program = ts.createProgram([], this.options, this.host);
+
+    protected printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
+    protected cache = new Cache;
+
+    protected knownFiles: { [path: string]: string } = {};
+    protected sourceFiles: { [path: string]: SourceFile } = {};
+
+    constructor() {
+        const originReadFile = this.host.readFile;
+        this.host.readFile = (fileName: string) => {
+            if (this.knownFiles[fileName]) return this.knownFiles[fileName];
+            return originReadFile.call(this.host, fileName);
+        };
+
+        //the program should not write any files
+        this.host.writeFile = () => {
+        };
+
+        const originalGetSourceFile = this.host.getSourceFile;
+        this.host.getSourceFile = (fileName: string, languageVersion: ts.ScriptTarget, onError?: (message: string) => void, shouldCreateNewSourceFile?: boolean): SourceFile | undefined => {
+            if (this.sourceFiles[fileName]) return this.sourceFiles[fileName];
+            return originalGetSourceFile.call(this.host, fileName, languageVersion, onError, shouldCreateNewSourceFile);
+        };
+    }
+
+    transform(source: string, path: string): string {
+        this.knownFiles[path] = source;
+        const sourceFile = ts.createSourceFile(path, source, ts.ScriptTarget.ESNext, true, path.endsWith('.tsx') ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
+        let newSource = source;
+
+        ts.transform(sourceFile, [
+            (context: TransformationContext) => {
+                const transformer = new ReflectionTransformer(context, this.cache).forHost(this.host).withReflection({ reflection: 'default' });
+                return (node: SourceFile): SourceFile => {
+                    const sourceFile = transformer.transformSourceFile(node);
+
+                    newSource = this.printer.printNode(ts.EmitHint.SourceFile, sourceFile, sourceFile);
+                    return sourceFile;
+                };
+            }
+        ], this.options);
+
+        return newSource;
+    }
+}

package/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,
+        };
+    };
+}