@nestjs/cli 9.4.2 → 10.0.0-next.1

package/.circleci/config.yml

@@ -21,7 +21,7 @@ jobs:
   build:
     working_directory: ~/nest
     docker:
-      - image: cimg/node:20.0
+      - image: cimg/node:20.2
     steps:
       - checkout
       - run:
@@ -43,7 +43,7 @@ jobs:
   unit_tests:
     working_directory: ~/nest
     docker:
-      - image: cimg/node:20.0
+      - image: cimg/node:20.2
     steps:
       - checkout
       - *restore-cache

package/actions/build.action.d.ts

@@ -1,11 +1,8 @@
 import { Input } from '../commands';
 import { AssetsManager } from '../lib/compiler/assets-manager';
-import { Compiler } from '../lib/compiler/compiler';
 import { TsConfigProvider } from '../lib/compiler/helpers/tsconfig-provider';
-import { PluginsLoader } from '../lib/compiler/plugins-loader';
+import { PluginsLoader } from '../lib/compiler/plugins/plugins-loader';
 import { TypeScriptBinaryLoader } from '../lib/compiler/typescript-loader';
-import { WatchCompiler } from '../lib/compiler/watch-compiler';
-import { WebpackCompiler } from '../lib/compiler/webpack-compiler';
 import { WorkspaceUtils } from '../lib/compiler/workspace-utils';
 import { ConfigurationLoader } from '../lib/configuration';
 import { FileSystemReader } from '../lib/readers';
@@ -14,14 +11,14 @@ export declare class BuildAction extends AbstractAction {
     protected readonly pluginsLoader: PluginsLoader;
     protected readonly tsLoader: TypeScriptBinaryLoader;
     protected readonly tsConfigProvider: TsConfigProvider;
-    protected readonly compiler: Compiler;
-    protected readonly webpackCompiler: WebpackCompiler;
-    protected readonly watchCompiler: WatchCompiler;
     protected readonly fileSystemReader: FileSystemReader;
     protected readonly loader: ConfigurationLoader;
     protected readonly assetsManager: AssetsManager;
     protected readonly workspaceUtils: WorkspaceUtils;
     handle(inputs: Input[], options: Input[]): Promise<void>;
     runBuild(inputs: Input[], options: Input[], watchMode: boolean, watchAssetsMode: boolean, isDebugEnabled?: boolean, onSuccess?: () => void): Promise<void>;
+    private runSwc;
+    private runWebpack;
+    private runTsc;
     private getWebpackConfigFactoryByPath;
 }

package/actions/build.action.js

@@ -16,7 +16,8 @@ const assets_manager_1 = require("../lib/compiler/assets-manager");
 const compiler_1 = require("../lib/compiler/compiler");
 const get_value_or_default_1 = require("../lib/compiler/helpers/get-value-or-default");
 const tsconfig_provider_1 = require("../lib/compiler/helpers/tsconfig-provider");
-const plugins_loader_1 = require("../lib/compiler/plugins-loader");
+const plugins_loader_1 = require("../lib/compiler/plugins/plugins-loader");
+const swc_compiler_1 = require("../lib/compiler/swc/swc-compiler");
 const typescript_loader_1 = require("../lib/compiler/typescript-loader");
 const watch_compiler_1 = require("../lib/compiler/watch-compiler");
 const webpack_compiler_1 = require("../lib/compiler/webpack-compiler");
@@ -32,9 +33,6 @@ class BuildAction extends abstract_action_1.AbstractAction {
         this.pluginsLoader = new plugins_loader_1.PluginsLoader();
         this.tsLoader = new typescript_loader_1.TypeScriptBinaryLoader();
         this.tsConfigProvider = new tsconfig_provider_1.TsConfigProvider(this.tsLoader);
-        this.compiler = new compiler_1.Compiler(this.pluginsLoader, this.tsConfigProvider, this.tsLoader);
-        this.webpackCompiler = new webpack_compiler_1.WebpackCompiler(this.pluginsLoader);
-        this.watchCompiler = new watch_compiler_1.WatchCompiler(this.pluginsLoader, this.tsConfigProvider, this.tsLoader);
         this.fileSystemReader = new readers_1.FileSystemReader(process.cwd());
         this.loader = new configuration_1.NestConfigurationLoader(this.fileSystemReader);
         this.assetsManager = new assets_manager_1.AssetsManager();
@@ -70,28 +68,52 @@ class BuildAction extends abstract_action_1.AbstractAction {
             const pathToTsconfig = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'compilerOptions.tsConfigPath', appName, 'path', options);
             const { options: tsOptions } = this.tsConfigProvider.getByConfigFilename(pathToTsconfig);
             const outDir = tsOptions.outDir || defaults_1.defaultOutDir;
-            const isWebpackEnabled = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'compilerOptions.webpack', appName, 'webpack', options);
+            const builder = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'compilerOptions.builder', appName, 'builder', options);
             yield this.workspaceUtils.deleteOutDirIfEnabled(configuration, appName, outDir);
             this.assetsManager.copyAssets(configuration, appName, outDir, watchAssetsMode);
-            if (isWebpackEnabled) {
-                const webpackPath = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'compilerOptions.webpackConfigPath', appName, 'webpackPath', options);
-                const webpackConfigFactoryOrConfig = this.getWebpackConfigFactoryByPath(webpackPath, configuration.compilerOptions.webpackConfigPath);
-                return this.webpackCompiler.run(configuration, options, webpackConfigFactoryOrConfig, pathToTsconfig, appName, isDebugEnabled, watchMode, this.assetsManager, onSuccess);
-            }
-            if (watchMode) {
-                const tsCompilerOptions = {};
-                const isPreserveWatchOutputEnabled = options.find((option) => option.name === 'preserveWatchOutput' && option.value === true);
-                if (isPreserveWatchOutputEnabled) {
-                    tsCompilerOptions.preserveWatchOutput = true;
-                }
-                this.watchCompiler.run(configuration, pathToTsconfig, appName, tsCompilerOptions, onSuccess);
-            }
-            else {
-                this.compiler.run(configuration, pathToTsconfig, appName, onSuccess);
-                this.assetsManager.closeWatchers();
+            switch (builder) {
+                case 'tsc':
+                    return this.runTsc(watchMode, options, configuration, pathToTsconfig, appName, onSuccess);
+                case 'webpack':
+                    return this.runWebpack(configuration, appName, options, pathToTsconfig, isDebugEnabled, watchMode, onSuccess);
+                case 'swc':
+                    return this.runSwc(configuration, appName, pathToTsconfig, watchMode, options, onSuccess);
             }
         });
     }
+    runSwc(configuration, appName, pathToTsconfig, watchMode, options, onSuccess) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const swc = new swc_compiler_1.SwcCompiler(this.pluginsLoader);
+            yield swc.run(configuration, pathToTsconfig, appName, {
+                watch: watchMode,
+                typeCheck: (0, get_value_or_default_1.getValueOrDefault)(configuration, 'compilerOptions.typeCheck', appName, 'typeCheck', options),
+            }, onSuccess);
+        });
+    }
+    runWebpack(configuration, appName, inputs, pathToTsconfig, debug, watchMode, onSuccess) {
+        const webpackCompiler = new webpack_compiler_1.WebpackCompiler(this.pluginsLoader);
+        const webpackPath = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'compilerOptions.webpackConfigPath', appName, 'webpackPath', inputs);
+        const webpackConfigFactoryOrConfig = this.getWebpackConfigFactoryByPath(webpackPath, configuration.compilerOptions.webpackConfigPath);
+        return webpackCompiler.run(configuration, pathToTsconfig, appName, {
+            inputs,
+            webpackConfigFactoryOrConfig,
+            debug,
+            watchMode,
+            assetsManager: this.assetsManager,
+        }, onSuccess);
+    }
+    runTsc(watchMode, options, configuration, pathToTsconfig, appName, onSuccess) {
+        if (watchMode) {
+            const watchCompiler = new watch_compiler_1.WatchCompiler(this.pluginsLoader, this.tsConfigProvider, this.tsLoader);
+            const isPreserveWatchOutputEnabled = options.find((option) => option.name === 'preserveWatchOutput' && option.value === true);
+            watchCompiler.run(configuration, pathToTsconfig, appName, { preserveWatchOutput: !!isPreserveWatchOutputEnabled }, onSuccess);
+        }
+        else {
+            const compiler = new compiler_1.Compiler(this.pluginsLoader, this.tsConfigProvider, this.tsLoader);
+            compiler.run(configuration, pathToTsconfig, appName, undefined, onSuccess);
+            this.assetsManager.closeWatchers();
+        }
+    }
     getWebpackConfigFactoryByPath(webpackPath, defaultPath) {
         const pathToWebpackFile = (0, path_1.join)(process.cwd(), webpackPath);
         try {

package/actions/new.action.js

@@ -15,7 +15,6 @@ const child_process_1 = require("child_process");
 const fs = require("fs");
 const inquirer = require("inquirer");
 const path_1 = require("path");
-const util_1 = require("util");
 const defaults_1 = require("../lib/configuration/defaults");
 const package_managers_1 = require("../lib/package-managers");
 const questions_1 = require("../lib/questions/questions");
@@ -144,7 +143,7 @@ const createGitIgnoreFile = (dir, content) => {
     if (fileExists(filePath)) {
         return;
     }
-    return (0, util_1.promisify)(fs.writeFile)(filePath, fileContent);
+    return fs.promises.writeFile(filePath, fileContent);
 };
 const printCollective = () => {
     const dim = print('dim');

package/commands/build.command.js

@@ -10,6 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BuildCommand = void 0;
+const ui_1 = require("../lib/ui");
 const abstract_command_1 = require("./abstract.command");
 class BuildCommand extends abstract_command_1.AbstractCommand {
     load(program) {
@@ -18,12 +19,15 @@ class BuildCommand extends abstract_command_1.AbstractCommand {
             .option('-c, --config [path]', 'Path to nest-cli configuration file.')
             .option('-p, --path [path]', 'Path to tsconfig file.')
             .option('-w, --watch', 'Run in watch mode (live-reload).')
+            .option('-b, --builder [name]', 'Builder to be used (tsc, webpack, swc).')
             .option('--watchAssets', 'Watch non-ts (e.g., .graphql) files mode.')
-            .option('--webpack', 'Use webpack for compilation.')
+            .option('--webpack', 'Use webpack for compilation (deprecated option, use --build instead).')
+            .option('--type-check', 'Enable type checking (when SWC is used).', false)
             .option('--webpackPath [path]', 'Path to webpack configuration.')
             .option('--tsc', 'Use tsc for compilation.')
             .description('Build Nest application.')
             .action((app, command) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
             const options = [];
             options.push({
                 name: 'config',
@@ -41,6 +45,24 @@ class BuildCommand extends abstract_command_1.AbstractCommand {
                 name: 'webpackPath',
                 value: command.webpackPath,
             });
+            const availableBuilders = ['tsc', 'webpack', 'swc'];
+            if (command.builder && !availableBuilders.includes(command.builder)) {
+                console.error(ui_1.ERROR_PREFIX +
+                    ` Invalid builder option: ${command.builder}. Available builders: ${availableBuilders.join(', ')}`);
+                return;
+            }
+            options.push({
+                name: 'builder',
+                value: (_a = command.builder) !== null && _a !== void 0 ? _a : (isWebpackEnabled ? 'webpack' : 'tsc'),
+            });
+            if (command.typeCheck && command.builder !== 'swc') {
+                console.warn(ui_1.INFO_PREFIX +
+                    ` "typeCheck" will not have any effect when "builder" is not "swc".`);
+            }
+            options.push({
+                name: 'typeCheck',
+                value: command.typeCheck,
+            });
             const inputs = [];
             inputs.push({ name: 'app', value: app });
             yield this.action.handle(inputs, options);

package/commands/start.command.js

@@ -10,6 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StartCommand = void 0;
+const ui_1 = require("../lib/ui");
 const remaining_flags_1 = require("../lib/utils/remaining-flags");
 const abstract_command_1 = require("./abstract.command");
 class StartCommand extends abstract_command_1.AbstractCommand {
@@ -19,10 +20,12 @@ class StartCommand extends abstract_command_1.AbstractCommand {
             .option('-c, --config [path]', 'Path to nest-cli configuration file.')
             .option('-p, --path [path]', 'Path to tsconfig file.')
             .option('-w, --watch', 'Run in watch mode (live-reload).')
+            .option('-b, --builder [name]', 'Builder to be used (tsc, webpack, swc).')
             .option('--watchAssets', 'Watch non-ts (e.g., .graphql) files mode.')
             .option('-d, --debug [hostport] ', 'Run in debug mode (with --inspect flag).')
-            .option('--webpack', 'Use webpack for compilation.')
+            .option('--webpack', 'Use webpack for compilation (deprecated option, use --build instead).')
             .option('--webpackPath [path]', 'Path to webpack configuration.')
+            .option('--type-check', 'Enable type checking (when SWC is used).', false)
             .option('--tsc', 'Use tsc for compilation.')
             .option('--sourceRoot [sourceRoot]', 'Points at the root of the source code for the single project in standard mode structures, or the default project in monorepo mode structures.')
             .option('--entryFile [entryFile]', "Path to the entry file where this command will work with. Defaults to the one defined at your Nest's CLI config file.")
@@ -30,6 +33,7 @@ class StartCommand extends abstract_command_1.AbstractCommand {
             .option('--preserveWatchOutput', 'Use "preserveWatchOutput" option when tsc watch mode.')
             .description('Run Nest application.')
             .action((app, command) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
             const options = [];
             options.push({
                 name: 'config',
@@ -66,6 +70,24 @@ class StartCommand extends abstract_command_1.AbstractCommand {
                     !!command.watch &&
                     !isWebpackEnabled,
             });
+            const availableBuilders = ['tsc', 'webpack', 'swc'];
+            if (command.builder && !availableBuilders.includes(command.builder)) {
+                console.error(ui_1.ERROR_PREFIX +
+                    ` Invalid builder option: ${command.builder}. Available builders: ${availableBuilders.join(', ')}`);
+                return;
+            }
+            options.push({
+                name: 'builder',
+                value: (_a = command.builder) !== null && _a !== void 0 ? _a : (isWebpackEnabled ? 'webpack' : 'tsc'),
+            });
+            if (command.typeCheck && command.builder !== 'swc') {
+                console.warn(ui_1.INFO_PREFIX +
+                    ` "typeCheck" will not have any effect when "builder" is not "swc".`);
+            }
+            options.push({
+                name: 'typeCheck',
+                value: command.typeCheck,
+            });
             const inputs = [];
             inputs.push({ name: 'app', value: app });
             const flags = (0, remaining_flags_1.getRemainingFlags)(program);

package/lib/compiler/base-compiler.d.ts

@@ -0,0 +1,9 @@
+import { Configuration } from '../configuration';
+import { PluginsLoader } from './plugins/plugins-loader';
+export declare abstract class BaseCompiler<T = Record<string, any>> {
+    private readonly pluginsLoader;
+    constructor(pluginsLoader: PluginsLoader);
+    abstract run(configuration: Required<Configuration>, tsConfigPath: string, appName: string | undefined, extras?: T, onSuccess?: () => void): any;
+    loadPlugins(configuration: Required<Configuration>, tsConfigPath: string, appName: string | undefined): import("./plugins/plugins-loader").MultiNestCompilerPlugins;
+    getPathToSource(configuration: Required<Configuration>, tsConfigPath: string, appName: string | undefined): string;
+}

package/lib/compiler/base-compiler.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseCompiler = void 0;
+const path_1 = require("path");
+const get_value_or_default_1 = require("./helpers/get-value-or-default");
+class BaseCompiler {
+    constructor(pluginsLoader) {
+        this.pluginsLoader = pluginsLoader;
+    }
+    loadPlugins(configuration, tsConfigPath, appName) {
+        const pluginsConfig = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'compilerOptions.plugins', appName);
+        const pathToSource = this.getPathToSource(configuration, tsConfigPath, appName);
+        const plugins = this.pluginsLoader.load(pluginsConfig, { pathToSource });
+        return plugins;
+    }
+    getPathToSource(configuration, tsConfigPath, appName) {
+        const sourceRoot = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'sourceRoot', appName, 'sourceRoot');
+        const cwd = process.cwd();
+        const relativeRootPath = (0, path_1.dirname)((0, path_1.relative)(cwd, tsConfigPath));
+        const pathToSource = (0, path_1.normalize)(sourceRoot).indexOf((0, path_1.normalize)(relativeRootPath)) >= 0
+            ? (0, path_1.join)(cwd, sourceRoot)
+            : (0, path_1.join)(cwd, relativeRootPath, sourceRoot);
+        return pathToSource;
+    }
+}
+exports.BaseCompiler = BaseCompiler;

package/lib/compiler/compiler.d.ts

@@ -1,12 +1,12 @@
 import { Configuration } from '../configuration';
+import { BaseCompiler } from './base-compiler';
 import { TsConfigProvider } from './helpers/tsconfig-provider';
-import { PluginsLoader } from './plugins-loader';
+import { PluginsLoader } from './plugins/plugins-loader';
 import { TypeScriptBinaryLoader } from './typescript-loader';
-export declare class Compiler {
-    private readonly pluginsLoader;
+export declare class Compiler extends BaseCompiler {
     private readonly tsConfigProvider;
     private readonly typescriptLoader;
     constructor(pluginsLoader: PluginsLoader, tsConfigProvider: TsConfigProvider, typescriptLoader: TypeScriptBinaryLoader);
-    run(configuration: Required<Configuration>, configFilename: string, appName: string, onSuccess?: () => void): void;
+    run(configuration: Required<Configuration>, tsConfigPath: string, appName: string, _extras: any, onSuccess?: () => void): void;
     private reportAfterCompilationDiagnostic;
 }

package/lib/compiler/compiler.js

@@ -2,30 +2,29 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Compiler = void 0;
 const ts = require("typescript");
-const get_value_or_default_1 = require("./helpers/get-value-or-default");
+const base_compiler_1 = require("./base-compiler");
 const tsconfig_paths_hook_1 = require("./hooks/tsconfig-paths.hook");
-class Compiler {
+class Compiler extends base_compiler_1.BaseCompiler {
     constructor(pluginsLoader, tsConfigProvider, typescriptLoader) {
-        this.pluginsLoader = pluginsLoader;
+        super(pluginsLoader);
         this.tsConfigProvider = tsConfigProvider;
         this.typescriptLoader = typescriptLoader;
     }
-    run(configuration, configFilename, appName, onSuccess) {
+    run(configuration, tsConfigPath, appName, _extras, onSuccess) {
         const tsBinary = this.typescriptLoader.load();
         const formatHost = {
             getCanonicalFileName: (path) => path,
             getCurrentDirectory: tsBinary.sys.getCurrentDirectory,
             getNewLine: () => tsBinary.sys.newLine,
         };
-        const { options, fileNames, projectReferences } = this.tsConfigProvider.getByConfigFilename(configFilename);
+        const { options, fileNames, projectReferences } = this.tsConfigProvider.getByConfigFilename(tsConfigPath);
         const createProgram = tsBinary.createIncrementalProgram || tsBinary.createProgram;
         const program = createProgram.call(ts, {
             rootNames: fileNames,
             projectReferences,
             options,
         });
-        const pluginsConfig = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'compilerOptions.plugins', appName);
-        const plugins = this.pluginsLoader.load(pluginsConfig);
+        const plugins = this.loadPlugins(configuration, tsConfigPath, appName);
         const tsconfigPathsPlugin = (0, tsconfig_paths_hook_1.tsconfigPathsBeforeHookFactory)(options);
         const programRef = program.getProgram
             ? program.getProgram()

package/lib/compiler/defaults/swc-defaults.d.ts

@@ -0,0 +1,31 @@
+export declare const swcDefaultsFactory: () => {
+    swcOptions: {
+        jsc: {
+            target: string;
+            parser: {
+                syntax: string;
+                decorators: boolean;
+                dynamicImport: boolean;
+            };
+            transform: {
+                legacyDecorator: boolean;
+                decoratorMetadata: boolean;
+            };
+            keepClassNames: boolean;
+            baseUrl: string;
+        };
+        minify: boolean;
+        swcrc: boolean;
+    };
+    cliOptions: {
+        outDir: string;
+        filenames: string[];
+        sync: boolean;
+        extensions: string[];
+        watch: boolean;
+        copyFiles: boolean;
+        includeDotfiles: boolean;
+        deleteDirOnStart: boolean;
+        quiet: boolean;
+    };
+};

package/lib/compiler/defaults/swc-defaults.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.swcDefaultsFactory = void 0;
+const swcDefaultsFactory = () => {
+    return {
+        swcOptions: {
+            jsc: {
+                target: 'es2021',
+                parser: {
+                    'syntax': 'typescript',
+                    'decorators': true,
+                    'dynamicImport': true,
+                },
+                transform: {
+                    'legacyDecorator': true,
+                    'decoratorMetadata': true,
+                },
+                keepClassNames: true,
+                baseUrl: './',
+            },
+            minify: false,
+            swcrc: true,
+        },
+        cliOptions: {
+            outDir: 'dist',
+            filenames: ['src'],
+            sync: false,
+            extensions: [
+                '.js',
+                '.jsx',
+                '.es6',
+                '.es',
+                '.mjs',
+                '.ts',
+                '.tsx',
+                '.cts',
+                '.mts',
+            ],
+            watch: false,
+            copyFiles: false,
+            includeDotfiles: false,
+            deleteDirOnStart: true,
+            quiet: false,
+        },
+    };
+};
+exports.swcDefaultsFactory = swcDefaultsFactory;

package/lib/compiler/defaults/webpack-defaults.d.ts

@@ -1,3 +1,3 @@
-import { MultiNestCompilerPlugins } from '../plugins-loader';
+import { MultiNestCompilerPlugins } from '../plugins/plugins-loader';
 import webpack = require('webpack');
 export declare const webpackDefaultsFactory: (sourceRoot: string, relativeSourceRoot: string, entryFilename: string, isDebugEnabled: boolean | undefined, tsConfigFile: string | undefined, plugins: MultiNestCompilerPlugins) => webpack.Configuration;

package/lib/compiler/helpers/get-value-or-default.d.ts

@@ -1,4 +1,4 @@
 import { Input } from '../../../commands';
 import { Configuration } from '../../configuration';
-export declare function getValueOrDefault<T = any>(configuration: Required<Configuration>, propertyPath: string, appName: string, key?: 'path' | 'webpack' | 'webpackPath' | 'entryFile' | 'sourceRoot' | 'exec', options?: Input[], defaultValue?: T): T;
+export declare function getValueOrDefault<T = any>(configuration: Required<Configuration>, propertyPath: string, appName: string | undefined, key?: 'path' | 'webpack' | 'webpackPath' | 'entryFile' | 'sourceRoot' | 'exec' | 'builder' | 'typeCheck', options?: Input[], defaultValue?: T): T;
 export declare function getValueOfPath<T = any>(object: Record<string, any>, propertyPath: string): T;

package/lib/compiler/helpers/is-compilable-extension.d.ts

@@ -0,0 +1 @@
+export declare function isCompilableExtension(filename: string, allowedExtension: string[]): boolean;

package/lib/compiler/helpers/is-compilable-extension.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCompilableExtension = void 0;
+const path_1 = require("path");
+function isCompilableExtension(filename, allowedExtension) {
+    const ext = (0, path_1.extname)(filename);
+    return allowedExtension.includes(ext);
+}
+exports.isCompilableExtension = isCompilableExtension;

package/lib/compiler/hooks/tsconfig-paths.hook.js

@@ -6,10 +6,7 @@ const path_1 = require("path");
 const typescript_loader_1 = require("../typescript-loader");
 const tsPaths = require("tsconfig-paths");
 function tsconfigPathsBeforeHookFactory(compilerOptions) {
-    var _a;
     const tsBinary = new typescript_loader_1.TypeScriptBinaryLoader().load();
-    const [tsVersionMajor, tsVersionMinor] = (_a = tsBinary.versionMajorMinor) === null || _a === void 0 ? void 0 : _a.split('.').map((x) => +x);
-    const isInUpdatedAstContext = tsVersionMinor >= 8 || tsVersionMajor > 4;
     const { paths = {}, baseUrl = './' } = compilerOptions;
     const matcher = tsPaths.createMatchPath(baseUrl, paths, ['main']);
     return (ctx) => {
@@ -30,16 +27,12 @@ function tsconfigPathsBeforeHookFactory(compilerOptions) {
                         const moduleSpecifier = tsBinary.factory.createStringLiteral(result);
                         moduleSpecifier.parent = node.moduleSpecifier.parent;
                         if (tsBinary.isImportDeclaration(node)) {
-                            const updatedNode = isInUpdatedAstContext
-                                ? tsBinary.factory.updateImportDeclaration(node, node.modifiers, node.importClause, moduleSpecifier, node.assertClause)
-                                : tsBinary.factory.updateImportDeclaration(node, node.decorators, node.modifiers, node.importClause, moduleSpecifier, node.assertClause);
+                            const updatedNode = tsBinary.factory.updateImportDeclaration(node, node.modifiers, node.importClause, moduleSpecifier, node.assertClause);
                             updatedNode.flags = node.flags;
                             return updatedNode;
                         }
                         else {
-                            const updatedNode = isInUpdatedAstContext
-                                ? tsBinary.factory.updateExportDeclaration(node, node.modifiers, node.isTypeOnly, node.exportClause, moduleSpecifier, node.assertClause)
-                                : tsBinary.factory.updateExportDeclaration(node, node.decorators, node.modifiers, node.isTypeOnly, node.exportClause, moduleSpecifier, node.assertClause);
+                            const updatedNode = tsBinary.factory.updateExportDeclaration(node, node.modifiers, node.isTypeOnly, node.exportClause, moduleSpecifier, node.assertClause);
                             updatedNode.flags = node.flags;
                             return updatedNode;
                         }

package/lib/compiler/interfaces/readonly-visitor.interface.d.ts

@@ -0,0 +1,9 @@
+import * as ts from 'typescript';
+export type DeepPluginMeta = ts.ObjectLiteralExpression | {
+    [key: string]: DeepPluginMeta;
+};
+export interface ReadonlyVisitor {
+    key: string;
+    visit(program: ts.Program, sf: ts.SourceFile): void;
+    collect(): Record<string, DeepPluginMeta>;
+}

package/lib/compiler/interfaces/readonly-visitor.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/compiler/plugins/plugin-metadata-generator.d.ts

@@ -0,0 +1,15 @@
+import * as ts from 'typescript';
+import { ReadonlyVisitor } from '../interfaces/readonly-visitor.interface';
+export interface PluginMetadataGenerateOptions {
+    visitors: ReadonlyVisitor[];
+    outputDir: string;
+    watch?: boolean;
+    tsconfigPath?: string;
+    tsProgramRef?: ts.Program;
+}
+export declare class PluginMetadataGenerator {
+    private readonly pluginMetadataPrinter;
+    private readonly typeCheckerHost;
+    generate(options: PluginMetadataGenerateOptions): void;
+    private traverseAndPrintMetadata;
+}

package/lib/compiler/plugins/plugin-metadata-generator.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginMetadataGenerator = void 0;
+const type_checker_host_1 = require("../swc/type-checker-host");
+const plugin_metadata_printer_1 = require("./plugin-metadata-printer");
+class PluginMetadataGenerator {
+    constructor() {
+        this.pluginMetadataPrinter = new plugin_metadata_printer_1.PluginMetadataPrinter();
+        this.typeCheckerHost = new type_checker_host_1.TypeCheckerHost();
+    }
+    generate(options) {
+        const { tsconfigPath, visitors, tsProgramRef, outputDir, watch } = options;
+        if (visitors.length === 0) {
+            return;
+        }
+        if (tsProgramRef) {
+            return this.traverseAndPrintMetadata(tsProgramRef, visitors, outputDir);
+        }
+        this.typeCheckerHost.run(tsconfigPath, {
+            watch,
+            onSuccess: (program) => {
+                this.traverseAndPrintMetadata(program, visitors, outputDir);
+            },
+        });
+    }
+    traverseAndPrintMetadata(programRef, visitors, outputDir) {
+        for (const sourceFile of programRef.getSourceFiles()) {
+            if (!sourceFile.isDeclarationFile) {
+                visitors.forEach((visitor) => visitor.visit(programRef, sourceFile));
+            }
+        }
+        const collectedMetadata = {};
+        visitors.forEach((visitor) => {
+            collectedMetadata[visitor.key] = visitor.collect();
+        });
+        this.pluginMetadataPrinter.print(collectedMetadata, outputDir);
+    }
+}
+exports.PluginMetadataGenerator = PluginMetadataGenerator;

package/lib/compiler/plugins/plugin-metadata-printer.d.ts

@@ -0,0 +1,5 @@
+import { DeepPluginMeta } from '../interfaces/readonly-visitor.interface';
+export declare class PluginMetadataPrinter {
+    print(metadata: DeepPluginMeta, outputDir: string): void;
+    private recursivelyCreatePropertyAssignment;
+}

package/lib/compiler/plugins/plugin-metadata-printer.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginMetadataPrinter = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const ts = require("typescript");
+const SERIALIZED_METADATA_FILENAME = 'metadata.ts';
+class PluginMetadataPrinter {
+    print(metadata, outputDir) {
+        const objectLiteralExpr = ts.factory.createObjectLiteralExpression(Object.keys(metadata).map((key) => this.recursivelyCreatePropertyAssignment(key, metadata[key])));
+        const metadataCacheVariableStatement = ts.factory.createVariableStatement([ts.factory.createToken(ts.SyntaxKind.ExportKeyword)], ts.factory.createVariableDeclarationList([
+            ts.factory.createVariableDeclaration(ts.factory.createIdentifier('metadataCache'), undefined, undefined, objectLiteralExpr),
+        ], ts.NodeFlags.Const));
+        const printer = ts.createPrinter({
+            newLine: ts.NewLineKind.LineFeed,
+        });
+        const resultFile = ts.createSourceFile('file.ts', '', ts.ScriptTarget.Latest, 
+        /*setParentNodes*/ false, ts.ScriptKind.TS);
+        const filename = (0, path_1.join)(outputDir, SERIALIZED_METADATA_FILENAME);
+        const eslintPrefix = `/* eslint-disable */\n`;
+        (0, fs_1.writeFileSync)(filename, eslintPrefix +
+            printer.printNode(ts.EmitHint.Unspecified, metadataCacheVariableStatement, resultFile));
+    }
+    recursivelyCreatePropertyAssignment(identifier, meta) {
+        return ts.factory.createPropertyAssignment(ts.factory.createStringLiteral(identifier), ts.isObjectLiteralExpression(meta)
+            ? meta
+            : ts.factory.createObjectLiteralExpression(Object.keys(meta).map((key) => this.recursivelyCreatePropertyAssignment(key, meta[key]))));
+    }
+}
+exports.PluginMetadataPrinter = PluginMetadataPrinter;

package/lib/compiler/plugins/plugins-loader.d.ts

@@ -0,0 +1,30 @@
+import * as ts from 'typescript';
+import { ReadonlyVisitor } from '../interfaces/readonly-visitor.interface';
+type Transformer = ts.TransformerFactory<any> | ts.CustomTransformerFactory;
+type PluginEntry = string | PluginAndOptions;
+type PluginOptions = Record<string, any>;
+interface PluginAndOptions {
+    name: 'string';
+    options: PluginOptions;
+}
+export interface NestCompilerPlugin {
+    before?: (options?: PluginOptions, program?: ts.Program) => Transformer;
+    after?: (options?: PluginOptions, program?: ts.Program) => Transformer;
+    afterDeclarations?: (options?: PluginOptions, program?: ts.Program) => Transformer;
+    ReadonlyVisitor?: {
+        new (options: PluginOptions): ReadonlyVisitor;
+    };
+}
+export interface MultiNestCompilerPlugins {
+    beforeHooks: Array<(program?: ts.Program) => Transformer>;
+    afterHooks: Array<(program?: ts.Program) => Transformer>;
+    afterDeclarationsHooks: Array<(program?: ts.Program) => Transformer>;
+    readonlyVisitors: Array<ReadonlyVisitor>;
+}
+export declare class PluginsLoader {
+    load(plugins?: PluginEntry[], extras?: {
+        pathToSource?: string;
+    }): MultiNestCompilerPlugins;
+    private resolvePluginReferences;
+}
+export {};