@depup/nestjs__cli 11.0.24-depup.7 → 12.0.0-depup.0

package/lib/compiler/assets-manager.js

@@ -1,52 +1,54 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AssetsManager = void 0;
-const chokidar = require("chokidar");
-const fs_1 = require("fs");
-const glob_1 = require("glob");
-const path_1 = require("path");
-const copy_path_resolve_1 = require("./helpers/copy-path-resolve");
-const get_value_or_default_1 = require("./helpers/get-value-or-default");
-class AssetsManager {
-    constructor() {
-        this.watchAssetsKeyValue = {};
-        this.watchers = [];
-        this.actionInProgress = false;
-    }
+import * as chokidar from 'chokidar';
+import { copyFileSync, mkdirSync, rmSync, statSync } from 'fs';
+import { dirname, join, sep } from 'path';
+import { ERROR_PREFIX } from '../ui/index.js';
+import { copyPathResolve } from './helpers/copy-path-resolve.js';
+import { globSync } from './helpers/glob.js';
+import { getValueOrDefault } from './helpers/get-value-or-default.js';
+import { areOutsidePathsAllowed, assertPathInsideProject, } from './helpers/path-confinement.js';
+const ASSET_CHANGE_RESTART_DEBOUNCE_MS = 150;
+export class AssetsManager {
+    watchAssetsKeyValue = {};
+    watchers = [];
+    watcherReadyPromises = [];
     /**
-     * Using on `nest build` to close file watch or the build process will not end
-     * Interval like process
-     * If no action has been taken recently close watchers
-     * If action has been taken recently flag and try again
+     * Using on `nest build` to close file watch or the build process will not end.
+     * Waits for all watchers to complete their initial scan before closing them,
+     * ensuring all assets are copied regardless of system speed.
+     *
+     * Returns a Promise that resolves once every watcher has been closed.
+     * Callers (e.g. `build.action.ts`, `swc-compiler.ts`) `await` this method,
+     * so it must surface the underlying close work — otherwise `await` resolves
+     * immediately while file watchers stay open and the build process can race
+     * its own exit, leaving handles dangling.
      */
-    closeWatchers() {
-        // Consider adjusting this for larger files
-        const timeoutMs = 500;
-        const closeFn = () => {
-            if (this.actionInProgress) {
-                this.actionInProgress = false;
-                setTimeout(closeFn, timeoutMs);
-            }
-            else {
-                this.watchers.forEach((watcher) => watcher.close());
-            }
-        };
-        setTimeout(closeFn, timeoutMs);
+    async closeWatchers() {
+        await Promise.all(this.watcherReadyPromises);
+        await Promise.all(this.watchers.map((watcher) => watcher.close()));
     }
-    copyAssets(configuration, appName, outDir, watchAssetsMode) {
-        const assets = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'compilerOptions.assets', appName) || [];
-        if (assets.length <= 0) {
+    copyAssets(configuration, appName, outDir, watchAssetsMode, onSuccess, rootDir) {
+        const assets = getValueOrDefault(configuration, 'compilerOptions.assets', appName) || [];
+        const includeLibraryAssets = getValueOrDefault(configuration, 'compilerOptions.includeLibraryAssets', appName) || [];
+        const libraryAssets = this.collectLibraryAssets(configuration, includeLibraryAssets, outDir);
+        if (assets.length <= 0 && libraryAssets.length <= 0) {
             return;
         }
         try {
-            let sourceRoot = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'sourceRoot', appName);
-            sourceRoot = (0, path_1.join)(process.cwd(), sourceRoot);
+            let sourceRoot = getValueOrDefault(configuration, 'sourceRoot', appName);
+            sourceRoot = join(process.cwd(), sourceRoot);
+            // The asset path stripping must mirror how the TypeScript compiler emits
+            // files. When the effective rootDir (either explicit or computed from
+            // input files) differs from the configured `sourceRoot` — typically the
+            // case when `--path` points at a tsconfig with a different rootDir — we
+            // use that rootDir instead so copied assets stay aligned with the
+            // emitted JavaScript output. See nestjs/nest-cli#3387.
+            const stripRoot = rootDir ? join(rootDir) : sourceRoot;
             const filesToCopy = assets.map((item) => {
                 let includePath = typeof item === 'string' ? item : item.include;
                 let excludePath = typeof item !== 'string' && item.exclude ? item.exclude : undefined;
-                includePath = (0, path_1.join)(sourceRoot, includePath).replace(/\\/g, '/');
+                includePath = join(sourceRoot, includePath).replace(/\\/g, '/');
                 excludePath = excludePath
-                    ? (0, path_1.join)(sourceRoot, excludePath).replace(/\\/g, '/')
+                    ? join(sourceRoot, excludePath).replace(/\\/g, '/')
                     : undefined;
                 return {
                     outDir: typeof item !== 'string' ? item.outDir || outDir : outDir,
@@ -56,39 +58,120 @@ class AssetsManager {
                     watchAssets: typeof item !== 'string' ? item.watchAssets : undefined,
                 };
             });
-            const isWatchEnabled = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'compilerOptions.watchAssets', appName) || watchAssetsMode;
-            for (const item of filesToCopy) {
+            const allFilesToCopy = [...filesToCopy, ...libraryAssets];
+            const isWatchEnabled = getValueOrDefault(configuration, 'compilerOptions.watchAssets', appName) || watchAssetsMode;
+            const confinePathsToProject = !areOutsidePathsAllowed(configuration, appName);
+            if (confinePathsToProject) {
+                // Validate the configured destinations once, before any watcher is
+                // registered, so that a misconfigured "outDir" surfaces as a single
+                // build error rather than as a failure per copied file.
+                const seenOutDirs = new Set();
+                for (const item of allFilesToCopy) {
+                    if (item.outDir && !seenOutDirs.has(item.outDir)) {
+                        seenOutDirs.add(item.outDir);
+                        assertPathInsideProject(item.outDir, 'assets[].outDir', {
+                            resolveSymlinks: true,
+                        });
+                    }
+                }
+            }
+            // Debounce onSuccess so that a burst of asset changes (e.g. a git
+            // checkout touching many files at once) only triggers a single restart.
+            let debouncedOnSuccess;
+            if (onSuccess) {
+                let pending;
+                debouncedOnSuccess = () => {
+                    if (pending) {
+                        clearTimeout(pending);
+                    }
+                    pending = setTimeout(() => {
+                        pending = undefined;
+                        onSuccess();
+                    }, ASSET_CHANGE_RESTART_DEBOUNCE_MS);
+                };
+            }
+            for (const item of allFilesToCopy) {
+                // Library assets carry their own `_sourceRoot` so the per-library
+                // directory layout is preserved verbatim. For application assets we
+                // strip relative to the effective tsconfig rootDir (falls back to
+                // sourceRoot when no rootDir is supplied or computable).
+                const itemSourceRoot = item._sourceRoot || stripRoot;
                 const option = {
                     action: 'change',
                     item,
                     path: '',
-                    sourceRoot,
+                    sourceRoot: itemSourceRoot,
                     watchAssetsMode: isWatchEnabled,
+                    confinePathsToProject,
                 };
                 if (isWatchEnabled || item.watchAssets) {
-                    // prettier-ignore
-                    const watcher = chokidar
-                        .watch((0, glob_1.sync)(item.glob, {
+                    const matchedPaths = globSync(item.glob, {
                         ignore: item.exclude,
                         dot: true,
-                    }))
-                        .on('add', (path) => this.actionOnFile({ ...option, path, action: 'change' }))
-                        .on('change', (path) => this.actionOnFile({ ...option, path, action: 'change' }))
-                        .on('unlink', (path) => this.actionOnFile({ ...option, path, action: 'unlink' }));
+                    });
+                    // Chokidar does not emit the 'ready' event when given an empty
+                    // array of paths, which causes closeWatchers() to hang forever
+                    // on Promise.all(watcherReadyPromises). Skip the watcher and
+                    // warn the user so the build can finish normally.
+                    if (matchedPaths.length === 0) {
+                        console.warn(`No files matched the asset pattern "${item.glob}". ` +
+                            `Skipping watcher for this entry.`);
+                        continue;
+                    }
+                    let ready = false;
+                    // prettier-ignore
+                    const watcher = chokidar
+                        .watch(matchedPaths)
+                        .on('add', (path) => {
+                        this.safeActionOnFile({ ...option, path, action: 'change' });
+                        if (ready && debouncedOnSuccess) {
+                            debouncedOnSuccess();
+                        }
+                    })
+                        .on('change', (path) => {
+                        this.safeActionOnFile({ ...option, path, action: 'change' });
+                        if (ready && debouncedOnSuccess) {
+                            debouncedOnSuccess();
+                        }
+                    })
+                        .on('unlink', (path) => {
+                        this.safeActionOnFile({ ...option, path, action: 'unlink' });
+                        if (ready && debouncedOnSuccess) {
+                            debouncedOnSuccess();
+                        }
+                    });
+                    let markSettled;
+                    const settled = new Promise((resolve) => {
+                        markSettled = resolve;
+                    });
+                    watcher.on('ready', () => {
+                        ready = true;
+                        markSettled();
+                    });
+                    // Without an 'error' listener chokidar rethrows as an uncaught
+                    // exception (EMFILE, ENOSPC, EPERM on network shares), and the
+                    // watcher never reaches 'ready' — which would leave closeWatchers()
+                    // waiting on a promise that can no longer settle.
+                    watcher.on('error', (error) => {
+                        console.error(`${ERROR_PREFIX} Asset watcher failed for "${item.glob}". ` +
+                            `${error instanceof Error ? error.message : String(error)}`);
+                        markSettled();
+                    });
                     this.watchers.push(watcher);
+                    this.watcherReadyPromises.push(settled);
                 }
                 else {
-                    const matchedPaths = (0, glob_1.sync)(item.glob, {
+                    const matchedPaths = globSync(item.glob, {
                         ignore: item.exclude,
                         dot: true,
                     });
                     const files = item.glob.endsWith('*')
-                        ? matchedPaths.filter((matched) => (0, fs_1.statSync)(matched).isFile())
+                        ? matchedPaths.filter((matched) => statSync(matched).isFile())
                         : matchedPaths.flatMap((matched) => {
-                            if ((0, fs_1.statSync)(matched).isDirectory()) {
-                                return (0, glob_1.sync)(`${matched}/**/*`, {
+                            if (statSync(matched).isDirectory()) {
+                                return globSync(`${matched}/**/*`, {
                                     ignore: item.exclude,
-                                }).filter((file) => (0, fs_1.statSync)(file).isFile());
+                                }).filter((file) => statSync(file).isFile());
                             }
                             return matched;
                         });
@@ -99,11 +182,59 @@ class AssetsManager {
             }
         }
         catch (err) {
-            throw new Error(`An error occurred during the assets copying process. ${err.message}`);
+            throw new Error(`An error occurred during the assets copying process. ${err.message}`, { cause: err });
+        }
+    }
+    collectLibraryAssets(configuration, libraryNames, outDir) {
+        if (!libraryNames.length || !configuration.projects) {
+            return [];
+        }
+        const result = [];
+        for (const libName of libraryNames) {
+            const libProject = configuration.projects[libName];
+            if (!libProject) {
+                continue;
+            }
+            const libAssets = libProject.compilerOptions?.assets;
+            if (!libAssets || libAssets.length <= 0) {
+                continue;
+            }
+            const libSourceRoot = join(process.cwd(), libProject.sourceRoot || libProject.root || '');
+            for (const item of libAssets) {
+                let includePath = typeof item === 'string' ? item : item.include;
+                let excludePath = typeof item !== 'string' && item.exclude ? item.exclude : undefined;
+                includePath = join(libSourceRoot, includePath).replace(/\\/g, '/');
+                excludePath = excludePath
+                    ? join(libSourceRoot, excludePath).replace(/\\/g, '/')
+                    : undefined;
+                const entry = {
+                    outDir: typeof item !== 'string' ? item.outDir || outDir : outDir,
+                    glob: includePath,
+                    exclude: excludePath,
+                    flat: typeof item !== 'string' ? item.flat : undefined,
+                    watchAssets: typeof item !== 'string' ? item.watchAssets : undefined,
+                    _sourceRoot: libSourceRoot,
+                };
+                result.push(entry);
+            }
+        }
+        return result;
+    }
+    /**
+     * Runs `actionOnFile` from a watcher callback. A rejected destination must not
+     * escalate into an uncaught exception: chokidar emits synchronously, so a
+     * throw here would tear down the whole watch session.
+     */
+    safeActionOnFile(option) {
+        try {
+            this.actionOnFile(option);
+        }
+        catch (err) {
+            console.error(`${ERROR_PREFIX} ${err instanceof Error ? err.message : String(err)}`);
         }
     }
     actionOnFile(option) {
-        const { action, item, path, sourceRoot, watchAssetsMode } = option;
+        const { action, item, path, sourceRoot, watchAssetsMode, confinePathsToProject, } = option;
         const isWatchEnabled = watchAssetsMode || item.watchAssets;
         const assetCheckKey = path + (item.outDir ?? '');
         // Allow to do action for the first time before check watchMode
@@ -112,18 +243,23 @@ class AssetsManager {
         }
         // Set path value to true for watching the first time
         this.watchAssetsKeyValue[assetCheckKey] = true;
-        // Set action to true to avoid watches getting cutoff
-        this.actionInProgress = true;
-        const dest = (0, copy_path_resolve_1.copyPathResolve)(path, item.outDir, sourceRoot.split(path_1.sep).length);
+        let dest = copyPathResolve(path, item.outDir, sourceRoot.split(sep).length);
+        // The destination is re-checked per file: the configured "outDir" is
+        // validated up front, but a symlinked directory *inside* it would still
+        // redirect an individual write out of the project.
+        if (confinePathsToProject) {
+            dest = assertPathInsideProject(dest, 'assets[].outDir', {
+                resolveSymlinks: true,
+            });
+        }
         // Copy to output dir if file is changed or added
         if (action === 'change') {
-            (0, fs_1.mkdirSync)((0, path_1.dirname)(dest), { recursive: true });
-            (0, fs_1.copyFileSync)(path, dest);
+            mkdirSync(dirname(dest), { recursive: true });
+            copyFileSync(path, dest);
         }
         else if (action === 'unlink') {
             // Remove from output dir if file is deleted
-            (0, fs_1.rmSync)(dest, { force: true });
+            rmSync(dest, { force: true });
         }
     }
 }
-exports.AssetsManager = AssetsManager;

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

@@ -1,9 +1,9 @@
-import { Configuration } from '../configuration';
-import { PluginsLoader } from './plugins/plugins-loader';
+import { Configuration } from '../configuration/index.js';
+import { PluginsLoader } from './plugins/plugins-loader.js';
 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;
+    abstract run(configuration: Required<Configuration>, tsConfigPath: string, appName: string | undefined, extras?: T, onSuccess?: () => void): void | Promise<void>;
+    protected loadPlugins(configuration: Required<Configuration>, tsConfigPath: string, appName: string | undefined): import("./plugins/plugins-loader.js").MultiNestCompilerPlugins;
+    protected getPathToSource(configuration: Required<Configuration>, tsConfigPath: string, appName: string | undefined): string;
 }

package/lib/compiler/base-compiler.js

@@ -1,26 +1,23 @@
-"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 {
+import { dirname, join, normalize, relative } from 'path';
+import { getValueOrDefault } from './helpers/get-value-or-default.js';
+export class BaseCompiler {
+    pluginsLoader;
     constructor(pluginsLoader) {
         this.pluginsLoader = pluginsLoader;
     }
     loadPlugins(configuration, tsConfigPath, appName) {
-        const pluginsConfig = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'compilerOptions.plugins', appName);
+        const pluginsConfig = 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 sourceRoot = 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);
+        const relativeRootPath = dirname(relative(cwd, tsConfigPath));
+        const pathToSource = normalize(sourceRoot).indexOf(normalize(relativeRootPath)) >= 0
+            ? join(cwd, sourceRoot)
+            : 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/plugins-loader';
-import { TypeScriptBinaryLoader } from './typescript-loader';
+import { Configuration } from '../configuration/index.js';
+import { BaseCompiler } from './base-compiler.js';
+import { TsConfigProvider } from './helpers/tsconfig-provider.js';
+import { PluginsLoader } from './plugins/plugins-loader.js';
+import { TypeScriptBinaryLoader } from './typescript-loader.js';
 export declare class Compiler extends BaseCompiler {
     private readonly tsConfigProvider;
     private readonly typescriptLoader;
     constructor(pluginsLoader: PluginsLoader, tsConfigProvider: TsConfigProvider, typescriptLoader: TypeScriptBinaryLoader);
-    run(configuration: Required<Configuration>, tsConfigPath: string, appName: string | undefined, _extras: any, onSuccess?: () => void): void;
+    run(configuration: Required<Configuration>, tsConfigPath: string, appName: string | undefined, _extras: unknown, onSuccess?: () => void): void;
     private reportAfterCompilationDiagnostic;
 }

package/lib/compiler/compiler.js

@@ -1,10 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Compiler = void 0;
-const ts = require("typescript");
-const base_compiler_1 = require("./base-compiler");
-const tsconfig_paths_hook_1 = require("./hooks/tsconfig-paths.hook");
-class Compiler extends base_compiler_1.BaseCompiler {
+import * as ts from 'typescript';
+import { BaseCompiler } from './base-compiler.js';
+import { tsconfigPathsBeforeHookFactory } from './hooks/tsconfig-paths.hook.js';
+export class Compiler extends BaseCompiler {
+    tsConfigProvider;
+    typescriptLoader;
     constructor(pluginsLoader, tsConfigProvider, typescriptLoader) {
         super(pluginsLoader);
         this.tsConfigProvider = tsConfigProvider;
@@ -25,7 +24,7 @@ class Compiler extends base_compiler_1.BaseCompiler {
             options,
         });
         const plugins = this.loadPlugins(configuration, tsConfigPath, appName);
-        const tsconfigPathsPlugin = (0, tsconfig_paths_hook_1.tsconfigPathsBeforeHookFactory)(options);
+        const tsconfigPathsPlugin = tsconfigPathsBeforeHookFactory(options);
         const programRef = program.getProgram
             ? program.getProgram()
             : program;
@@ -60,4 +59,3 @@ class Compiler extends base_compiler_1.BaseCompiler {
         return diagnostics.length;
     }
 }
-exports.Compiler = Compiler;

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

@@ -0,0 +1,3 @@
+import type * as ts from 'typescript';
+import { MultiNestCompilerPlugins } from '../plugins/plugins-loader.js';
+export declare const rspackDefaultsFactory: (sourceRoot: string, relativeSourceRoot: string, entryFilename: string, isDebugEnabled: boolean | undefined, tsConfigFile: string | undefined, plugins: MultiNestCompilerPlugins, isEsm?: boolean, tsOptions?: ts.CompilerOptions) => Record<string, any>;

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

@@ -0,0 +1,179 @@
+import { builtinModules, createRequire } from 'module';
+import { join } from 'path';
+import { defaultTsconfigFilename } from '../../configuration/defaults.js';
+import { appendTsExtension } from '../helpers/append-extension.js';
+const require = createRequire(import.meta.url);
+function loadRspackDeps() {
+    try {
+        const rspack = require('@rspack/core');
+        const externals = require('webpack-node-externals');
+        const { TsconfigPathsPlugin } = require('tsconfig-paths-webpack-plugin');
+        return { nodeExternals: externals, TsconfigPathsPlugin, rspack };
+    }
+    catch (e) {
+        if (e?.code !== 'MODULE_NOT_FOUND' && e?.code !== 'ERR_MODULE_NOT_FOUND') {
+            // Only the "package missing" branch is wrapped with install advice.
+            // Surfacing unrelated errors as "package not found" would mislead
+            // users into reinstalling perfectly valid dependencies.
+            throw e;
+        }
+        // Use a non-greedy match so error messages that contain multiple
+        // quoted paths (e.g. ESM "Cannot find package 'foo' imported from
+        // '/abs/path.mjs'") still extract the package name rather than the
+        // importing file path.
+        const pkg = e?.message?.match?.(/Cannot find.*?'([^']+)'/)?.[1] ??
+            'webpack-node-externals';
+        throw new Error(`The "${pkg}" package is required when using the rspack compiler but could not be found. ` +
+            `Please install it:\n\n  npm install --save-dev @rspack/core webpack-node-externals tsconfig-paths-webpack-plugin\n`, { cause: e });
+    }
+}
+export const rspackDefaultsFactory = (sourceRoot, relativeSourceRoot, entryFilename, isDebugEnabled = false, tsConfigFile = defaultTsconfigFilename, plugins, isEsm = false, tsOptions) => {
+    const { nodeExternals: externals, TsconfigPathsPlugin } = loadRspackDeps();
+    const isPluginRegistered = isAnyPluginRegistered(plugins);
+    const sourceMaps = tsOptions?.sourceMap || (tsOptions?.inlineSourceMap && 'inline');
+    const devtool = sourceMaps === 'inline'
+        ? 'inline-source-map'
+        : sourceMaps
+            ? 'source-map'
+            : false;
+    const rspackConfiguration = {
+        entry: appendTsExtension(join(sourceRoot, entryFilename)),
+        devtool,
+        target: 'node',
+        output: {
+            filename: join(relativeSourceRoot, `${entryFilename}.js`).replace(/\\/g, '/'),
+            ...(isEsm && {
+                module: true,
+                library: { type: 'module' },
+                chunkFormat: 'module',
+                chunkLoading: 'import',
+            }),
+        },
+        ...(isEsm && {
+            experiments: { outputModule: true, topLevelAwait: true },
+        }),
+        ignoreWarnings: [/^(?!CriticalDependenciesWarning$)/],
+        externals: [
+            externals(isEsm ? { importType: 'module' } : {}),
+            ...(isEsm
+                ? [
+                    ({ request }, callback) => {
+                        if (!request)
+                            return callback();
+                        const bare = request.startsWith('node:')
+                            ? request.slice(5)
+                            : request;
+                        if (builtinModules.includes(bare)) {
+                            return callback(null, `module ${request}`);
+                        }
+                        callback();
+                    },
+                ]
+                : []),
+        ],
+        externalsPresets: { node: !isEsm },
+        module: {
+            rules: [
+                {
+                    test: /\.tsx?$/,
+                    use: [
+                        {
+                            loader: 'builtin:swc-loader',
+                            options: {
+                                jsc: {
+                                    parser: {
+                                        syntax: 'typescript',
+                                        decorators: true,
+                                    },
+                                    transform: {
+                                        legacyDecorator: true,
+                                        decoratorMetadata: true,
+                                    },
+                                    target: 'es2021',
+                                },
+                                sourceMaps,
+                            },
+                        },
+                    ],
+                    exclude: /node_modules/,
+                    ...(isEsm && { type: 'javascript/esm' }),
+                },
+            ],
+        },
+        resolve: {
+            extensions: ['.tsx', '.ts', '.js'],
+            ...(isEsm && {
+                extensionAlias: {
+                    '.js': ['.ts', '.js'],
+                    '.mjs': ['.mts', '.mjs'],
+                },
+            }),
+            tsConfig: tsConfigFile,
+            plugins: [
+                new TsconfigPathsPlugin({
+                    configFile: tsConfigFile,
+                }),
+            ],
+        },
+        mode: 'none',
+        optimization: {
+            nodeEnv: false,
+        },
+        node: {
+            __filename: false,
+            __dirname: false,
+        },
+        plugins: [],
+    };
+    // rspack has built-in IgnorePlugin (compatible with webpack's)
+    try {
+        const rspack = require('@rspack/core');
+        rspackConfiguration.plugins.push(new rspack.IgnorePlugin({
+            checkResource(resource) {
+                const lazyImports = [
+                    '@nestjs/microservices',
+                    '@nestjs/microservices/microservices-module',
+                    '@nestjs/websockets/socket-module',
+                    'class-validator',
+                    'class-transformer',
+                    'class-transformer/storage',
+                ];
+                if (!lazyImports.includes(resource)) {
+                    return false;
+                }
+                try {
+                    require.resolve(resource, {
+                        paths: [process.cwd()],
+                    });
+                }
+                catch {
+                    return true;
+                }
+                return false;
+            },
+        }));
+    }
+    catch {
+        // @rspack/core not available, skip IgnorePlugin
+    }
+    if (!isPluginRegistered) {
+        try {
+            const ForkTsCheckerWebpackPlugin = require('fork-ts-checker-webpack-plugin');
+            rspackConfiguration.plugins.push(new ForkTsCheckerWebpackPlugin({
+                typescript: {
+                    configFile: tsConfigFile,
+                },
+            }));
+        }
+        catch {
+            // fork-ts-checker-webpack-plugin not available, skip
+        }
+    }
+    return rspackConfiguration;
+};
+function isAnyPluginRegistered(plugins) {
+    return ((plugins.afterHooks && plugins.afterHooks.length > 0) ||
+        (plugins.beforeHooks && plugins.beforeHooks.length > 0) ||
+        (plugins.afterDeclarationsHooks &&
+            plugins.afterDeclarationsHooks.length > 0));
+}

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

@@ -1,6 +1,6 @@
 import * as ts from 'typescript';
-import { Configuration } from '../../configuration';
-export declare const swcDefaultsFactory: (tsOptions?: ts.CompilerOptions, configuration?: Configuration) => {
+import { Configuration } from '../../configuration/index.js';
+export declare const swcDefaultsFactory: (tsOptions?: ts.CompilerOptions, configuration?: Configuration, tsConfigExclude?: string[]) => {
     swcOptions: {
         sourceMaps: string | boolean | undefined;
         module: {
@@ -32,6 +32,7 @@ export declare const swcDefaultsFactory: (tsOptions?: ts.CompilerOptions, config
         extensions: string[];
         copyFiles: boolean;
         includeDotfiles: boolean;
+        ignore: string[] | undefined;
         quiet: boolean;
         watch: boolean;
         stripLeadingPaths: boolean;
@@ -44,6 +45,7 @@ export declare const swcDefaultsFactory: (tsOptions?: ts.CompilerOptions, config
         copyFiles: boolean;
         includeDotfiles: boolean;
         quiet: boolean;
+        ignore: string[] | undefined;
         watch: boolean;
         stripLeadingPaths: boolean;
     } | {
@@ -54,6 +56,7 @@ export declare const swcDefaultsFactory: (tsOptions?: ts.CompilerOptions, config
         extensions: string[];
         copyFiles: boolean;
         includeDotfiles: boolean;
+        ignore: string[] | undefined;
         quiet: boolean;
         watch: boolean;
         stripLeadingPaths: boolean;