@depup/nestjs__cli 12.0.0-depup.0 → 12.0.1-depup.0

package/README.md

@@ -13,18 +13,16 @@ npm install @depup/nestjs__cli
 
 | Field | Value |
 |-------|-------|
-| Original | [@nestjs/cli](https://www.npmjs.com/package/@nestjs/cli) @ 12.0.0 |
-| Processed | 2026-08-27 |
+| Original | [@nestjs/cli](https://www.npmjs.com/package/@nestjs/cli) @ 12.0.1 |
+| Processed | 2026-09-14 |
 | Smoke test | failed |
-| Deps updated | 4 |
+| Deps updated | 2 |
 
 ## Dependency Changes
 
 | Dependency | From | To |
 |------------|------|-----|
-| @angular-devkit/core | 22.1.5 | ^22.1.6 |
-| @angular-devkit/schematics | 22.1.5 | ^22.1.6 |
-| @angular-devkit/schematics-cli | 22.1.5 | ^22.1.6 |
+| @nestjs/schematics | ^12.0.0 | ^12.0.2 |
 | typescript | ~6.0.2 | ^7.0.2 |
 
 ---

package/actions/build.action.js

@@ -1,6 +1,4 @@
-import { createRequire } from 'module';
 import { red } from 'ansis';
-import { join } from 'path';
 import { AssetsManager } from '../lib/compiler/assets-manager.js';
 import { deleteOutDirIfEnabled } from '../lib/compiler/helpers/delete-out-dir.js';
 import { getBuilder } from '../lib/compiler/helpers/get-builder.js';
@@ -16,9 +14,8 @@ import { NestConfigurationLoader, } from '../lib/configuration/index.js';
 import { defaultOutDir, defaultRspackConfigFilename, defaultWebpackConfigFilename, } from '../lib/configuration/defaults.js';
 import { FileSystemReader } from '../lib/readers/index.js';
 import { ERROR_PREFIX, INFO_PREFIX } from '../lib/ui/index.js';
-import { isModuleAvailable } from '../lib/utils/is-module-available.js';
+import { loadBuilderConfig } from '../lib/utils/load-builder-config.js';
 import { AbstractAction } from './abstract.action.js';
-const require = createRequire(import.meta.url);
 export class BuildAction extends AbstractAction {
     pluginsLoader = new PluginsLoader();
     tsLoader = new TypeScriptBinaryLoader();
@@ -155,7 +152,7 @@ export class BuildAction extends AbstractAction {
         const webpackCompiler = new WebpackCompiler(this.pluginsLoader);
         const webpackPath = getWebpackConfigPath(configuration, options, appName) ??
             defaultWebpackConfigFilename;
-        const webpackConfigFactoryOrConfig = this.getWebpackConfigFactoryByPath(webpackPath, defaultWebpackConfigFilename);
+        const webpackConfigFactoryOrConfig = await this.getWebpackConfigFactoryByPath(webpackPath, defaultWebpackConfigFilename);
         return webpackCompiler.run(configuration, pathToTsconfig, appName, {
             options,
             webpackConfigFactoryOrConfig,
@@ -168,8 +165,10 @@ export class BuildAction extends AbstractAction {
         if (watchMode) {
             const { WatchCompiler } = await import('../lib/compiler/watch-compiler.js');
             const watchCompiler = new WatchCompiler(this.pluginsLoader, this.tsConfigProvider, this.tsLoader);
-            const isPreserveWatchOutputEnabled = !!options.preserveWatchOutput;
-            watchCompiler.run(configuration, pathToTsconfig, appName, { preserveWatchOutput: isPreserveWatchOutputEnabled }, onSuccess);
+            watchCompiler.run(configuration, pathToTsconfig, appName, 
+            // Left undefined when the flag is absent so `WatchCompiler` can
+            // fall through to the tsconfig 'preserveWatchOutput' option.
+            { preserveWatchOutput: options.preserveWatchOutput }, onSuccess);
         }
         else {
             const { Compiler } = await import('../lib/compiler/compiler.js');
@@ -178,20 +177,15 @@ export class BuildAction extends AbstractAction {
             await assetsManager.closeWatchers();
         }
     }
-    getWebpackConfigFactoryByPath(webpackPath, defaultPath) {
-        const pathToWebpackFile = join(process.cwd(), webpackPath);
-        const isWebpackFileAvailable = isModuleAvailable(pathToWebpackFile);
-        if (!isWebpackFileAvailable && webpackPath === defaultPath) {
-            return (_config) => ({});
-        }
-        return require(pathToWebpackFile);
+    async getWebpackConfigFactoryByPath(webpackPath, defaultPath) {
+        return loadBuilderConfig(webpackPath, defaultPath);
     }
     async runRspack(configuration, appName, options, pathToTsconfig, tsOptions, debug, watchMode, onSuccess, assetsManager) {
         const { RspackCompiler } = await import('../lib/compiler/rspack-compiler.js');
         const rspackCompiler = new RspackCompiler(this.pluginsLoader);
         const rspackPath = getRspackConfigPath(configuration, options, appName) ??
             defaultRspackConfigFilename;
-        const rspackConfigFactoryOrConfig = this.getRspackConfigFactoryByPath(rspackPath, defaultRspackConfigFilename);
+        const rspackConfigFactoryOrConfig = await this.getRspackConfigFactoryByPath(rspackPath, defaultRspackConfigFilename);
         return rspackCompiler.run(configuration, pathToTsconfig, appName, {
             options,
             rspackConfigFactoryOrConfig,
@@ -201,13 +195,8 @@ export class BuildAction extends AbstractAction {
             assetsManager,
         }, onSuccess);
     }
-    getRspackConfigFactoryByPath(rspackPath, defaultPath) {
-        const pathToRspackFile = join(process.cwd(), rspackPath);
-        const isRspackFileAvailable = isModuleAvailable(pathToRspackFile);
-        if (!isRspackFileAvailable && rspackPath === defaultPath) {
-            return (_config) => ({});
-        }
-        return require(pathToRspackFile);
+    async getRspackConfigFactoryByPath(rspackPath, defaultPath) {
+        return loadBuilderConfig(rspackPath, defaultPath);
     }
     warnOnIgnoredLibraryAssets(configuration, appNames) {
         if (!configuration.projects) {

package/changes.json

@@ -1,22 +1,14 @@
 {
   "bumped": {
-    "@angular-devkit/core": {
-      "from": "22.1.5",
-      "to": "^22.1.6"
-    },
-    "@angular-devkit/schematics": {
-      "from": "22.1.5",
-      "to": "^22.1.6"
-    },
-    "@angular-devkit/schematics-cli": {
-      "from": "22.1.5",
-      "to": "^22.1.6"
+    "@nestjs/schematics": {
+      "from": "^12.0.0",
+      "to": "^12.0.2"
     },
     "typescript": {
       "from": "~6.0.2",
       "to": "^7.0.2"
     }
   },
-  "timestamp": "2026-08-27T11:23:37.886Z",
-  "totalUpdated": 4
+  "timestamp": "2026-09-14T16:08:56.059Z",
+  "totalUpdated": 2
 }

package/commands/build.command.js

@@ -58,9 +58,11 @@ export class BuildCommand extends AbstractCommand {
                 // still fall through to `compilerOptions.emitDeclarations`.
                 emitDeclarations: options.emitDeclarations,
                 silent: !!options.silent,
-                preserveWatchOutput: !!options.preserveWatchOutput &&
-                    !!options.watch &&
-                    !isWebpackEnabled,
+                // Left undefined when the flag is absent so `WatchCompiler` can
+                // fall through to the tsconfig 'preserveWatchOutput' option.
+                preserveWatchOutput: !!options.watch && !isWebpackEnabled
+                    ? options.preserveWatchOutput
+                    : false,
                 all: !!options.all,
                 parallel,
             };

package/commands/context/build.context.d.ts

@@ -11,7 +11,7 @@ export interface BuildCommandContext {
     typeCheck?: boolean;
     emitDeclarations?: boolean;
     silent?: boolean;
-    preserveWatchOutput: boolean;
+    preserveWatchOutput?: boolean;
     all: boolean;
     parallel?: number | boolean;
 }

package/commands/context/start.context.d.ts

@@ -11,7 +11,7 @@ export interface StartCommandContext {
     typeCheck?: boolean;
     emitDeclarations?: boolean;
     silent?: boolean;
-    preserveWatchOutput: boolean;
+    preserveWatchOutput?: boolean;
     debug?: boolean | string;
     exec?: string;
     sourceRoot?: string;

package/commands/generate.command.js

@@ -57,8 +57,19 @@ export class GenerateCommand extends AbstractCommand {
     }
     buildSchematicsListAsTable(schematics) {
         const leftMargin = '    ';
+        if ((process.stdout.columns ?? 80) < 80) {
+            return schematics
+                .map((schematic) => {
+                const header = `${leftMargin}${green(schematic.name)} ${cyan(schematic.alias)}`;
+                return schematic.description
+                    ? `${header}\n${leftMargin}  ${schematic.description}`
+                    : header;
+            })
+                .join('\n');
+        }
         const tableConfig = {
             head: ['name', 'alias', 'description'],
+            wordWrap: true,
             chars: {
                 'left': leftMargin.concat('│'),
                 'top-left': leftMargin.concat('┌'),

package/commands/start.command.js

@@ -57,9 +57,11 @@ export class StartCommand extends AbstractCommand {
                 // still fall through to `compilerOptions.emitDeclarations`.
                 emitDeclarations: options.emitDeclarations,
                 silent: !!options.silent,
-                preserveWatchOutput: !!options.preserveWatchOutput &&
-                    !!options.watch &&
-                    !isWebpackEnabled,
+                // Left undefined when the flag is absent so `WatchCompiler` can
+                // fall through to the tsconfig 'preserveWatchOutput' option.
+                preserveWatchOutput: !!options.watch && !isWebpackEnabled
+                    ? options.preserveWatchOutput
+                    : false,
                 debug: options.debug,
                 exec: options.exec,
                 sourceRoot: options.sourceRoot,

package/lib/compiler/assets-manager.js

@@ -1,6 +1,6 @@
 import * as chokidar from 'chokidar';
 import { copyFileSync, mkdirSync, rmSync, statSync } from 'fs';
-import { dirname, join, sep } from 'path';
+import { dirname, join, resolve as resolvePath, sep } from 'path';
 import { ERROR_PREFIX } from '../ui/index.js';
 import { copyPathResolve } from './helpers/copy-path-resolve.js';
 import { globSync } from './helpers/glob.js';
@@ -171,6 +171,7 @@ export class AssetsManager {
                             if (statSync(matched).isDirectory()) {
                                 return globSync(`${matched}/**/*`, {
                                     ignore: item.exclude,
+                                    dot: true,
                                 }).filter((file) => statSync(file).isFile());
                             }
                             return matched;
@@ -244,6 +245,17 @@ export class AssetsManager {
         // Set path value to true for watching the first time
         this.watchAssetsKeyValue[assetCheckKey] = true;
         let dest = copyPathResolve(path, item.outDir, sourceRoot.split(sep).length);
+        // When an "include" path resolves outside the strip root, stripping that
+        // root's segment count from the file's path can consume the filename
+        // itself, collapsing the destination to "outDir" — silently overwriting
+        // the output directory with the asset's contents before the compiler even
+        // runs. Fail loudly instead.
+        if (resolvePath(dest) === resolvePath(item.outDir)) {
+            throw new Error(`Refusing to copy "${path}" to "${item.outDir}": the "include" path resolves outside ` +
+                `"${sourceRoot}", so no path segment survives stripping and the file would overwrite ` +
+                `the "${item.outDir}" directory itself. Move the file inside "${sourceRoot}", or set ` +
+                `"rootDir" in your tsconfig to a directory that contains both it and your sources.`);
+        }
         // 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.

package/lib/compiler/helpers/requires-explicit-import-extensions.d.ts

@@ -0,0 +1,10 @@
+import * as ts from 'typescript';
+/**
+ * Returns `true` when the consuming project uses an ESM-style module
+ * resolution strategy (`node16` / `nodenext`). Under those resolution
+ * modes, dynamic `import()` specifiers MUST include the file extension
+ * (typically `.js`) for the runtime resolver to find the module. Without
+ * the extension, executing the generated metadata file fails with
+ * `ERR_MODULE_NOT_FOUND`, and TypeScript reports a diagnostic.
+ */
+export declare function requiresExplicitImportExtensions(options: ts.CompilerOptions, tsBinary: typeof ts): boolean;

package/lib/compiler/helpers/requires-explicit-import-extensions.js

@@ -0,0 +1,13 @@
+/**
+ * Returns `true` when the consuming project uses an ESM-style module
+ * resolution strategy (`node16` / `nodenext`). Under those resolution
+ * modes, dynamic `import()` specifiers MUST include the file extension
+ * (typically `.js`) for the runtime resolver to find the module. Without
+ * the extension, executing the generated metadata file fails with
+ * `ERR_MODULE_NOT_FOUND`, and TypeScript reports a diagnostic.
+ */
+export function requiresExplicitImportExtensions(options, tsBinary) {
+    const moduleResolution = options.moduleResolution;
+    return (moduleResolution === tsBinary.ModuleResolutionKind.Node16 ||
+        moduleResolution === tsBinary.ModuleResolutionKind.NodeNext);
+}

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

@@ -1,12 +1,18 @@
+import { existsSync } from 'fs';
 import { createRequire } from 'module';
 import { dirname, posix } from 'path';
 import * as tsPaths from 'tsconfig-paths';
+import { requiresExplicitImportExtensions } from '../helpers/requires-explicit-import-extensions.js';
 import { TypeScriptBinaryLoader } from '../typescript-loader.js';
 const require = createRequire(import.meta.url);
 export function tsconfigPathsBeforeHookFactory(compilerOptions) {
     const tsBinary = new TypeScriptBinaryLoader().load();
     const { paths = {}, baseUrl = './' } = compilerOptions;
     const matcher = tsPaths.createMatchPath(baseUrl, paths, ['main']);
+    const esm = requiresExplicitImportExtensions(compilerOptions, tsBinary);
+    const extensions = sourceToOutputExtension(compilerOptions, tsBinary);
+    // Resolution is immutable within a build, and the hook runs per import.
+    const emittedPaths = new Map();
     return (ctx) => {
         return (sf) => {
             const visitNode = (node) => {
@@ -17,7 +23,7 @@ export function tsconfigPathsBeforeHookFactory(compilerOptions) {
                         if (!text) {
                             return node;
                         }
-                        const result = getNotAliasedPath(sf, matcher, text);
+                        const result = getNotAliasedPath(sf, matcher, text, esm, extensions, emittedPaths);
                         if (!result) {
                             return node;
                         }
@@ -57,13 +63,71 @@ function getModuleSpecifierText(moduleSpecifier, sourceFile) {
     }
     return importPathWithQuotes.substring(1, importPathWithQuotes.length - 1);
 }
-function getNotAliasedPath(sf, matcher, text) {
-    let result = matcher(text, undefined, undefined, [
-        '.ts',
-        '.tsx',
-        '.js',
-        '.jsx',
-    ]);
+// The matcher strips the extension off the file it found, so the path it
+// returns cannot be used to tell which source file that was.
+function sourceToOutputExtension(compilerOptions, tsBinary) {
+    // `jsx: preserve` leaves the syntax in place and emits `.jsx`; every other
+    // mode compiles it away.
+    const jsxOutput = compilerOptions.jsx === tsBinary.JsxEmit.Preserve ? '.jsx' : '.js';
+    return {
+        '.mts': '.mjs',
+        '.cts': '.cjs',
+        '.ts': '.js',
+        '.tsx': jsxOutput,
+        '.js': '.js',
+        '.jsx': jsxOutput,
+    };
+}
+const MATCHER_EXTENSIONS = ['.mts', '.cts', '.ts', '.tsx', '.js', '.jsx'];
+/**
+ * Resolves an alias that ESM writes with the extension the file will have
+ * *after* emit. The matcher looks for `./foo.js` on disk, finds only
+ * `./foo.ts`, and gives up, so the alias is emitted untouched and fails at
+ * runtime. Retrying without that extension resolves it to the source file.
+ */
+function matchPath(matcher, text, esm) {
+    const result = matcher(text, undefined, undefined, MATCHER_EXTENSIONS);
+    if (result || !esm) {
+        return result;
+    }
+    const withoutOutputExtension = text.replace(/\.(m|c)?js$/, '');
+    return withoutOutputExtension === text
+        ? undefined
+        : matcher(withoutOutputExtension, undefined, undefined, MATCHER_EXTENSIONS);
+}
+/**
+ * Probes the disk to learn which source file the matcher resolved, and returns
+ * it with the extension it will carry after emit. ESM has no directory or
+ * extensionless resolution, so the specifier must name the emitted file, and
+ * the extension cannot be read off a path the matcher already stripped.
+ */
+function toEmittedPath(resolvedPath, extensions, cache) {
+    const cached = cache.get(resolvedPath);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const entries = Object.entries(extensions);
+    // An alias that names the file keeps its extension through the matcher.
+    for (const [source, output] of entries) {
+        if (resolvedPath.endsWith(source)) {
+            return remember(cache, resolvedPath, resolvedPath.slice(0, -source.length) + output);
+        }
+    }
+    for (const candidate of [resolvedPath, posix.join(resolvedPath, 'index')]) {
+        for (const [source, output] of entries) {
+            if (existsSync(`${candidate}${source}`)) {
+                return remember(cache, resolvedPath, `${candidate}${output}`);
+            }
+        }
+    }
+    return remember(cache, resolvedPath, resolvedPath);
+}
+function remember(cache, key, value) {
+    cache.set(key, value);
+    return value;
+}
+function getNotAliasedPath(sf, matcher, text, esm = false, extensions = {}, emittedPaths = new Map()) {
+    let result = matchPath(matcher, text, esm);
     if (!result) {
         return;
     }
@@ -83,6 +147,9 @@ function getNotAliasedPath(sf, matcher, text) {
     catch {
         // package resolution failed, fall through to relative path
     }
+    if (esm) {
+        result = toEmittedPath(result, extensions, emittedPaths);
+    }
     const resolvedPath = posix.relative(dirname(sf.fileName), result) || './';
     return resolvedPath[0] === '.' ? resolvedPath : './' + resolvedPath;
 }

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

@@ -1,14 +1,5 @@
 import * as ts from 'typescript';
 import { DeepPluginMeta, ReadonlyVisitor } from '../interfaces/readonly-visitor.interface.js';
-/**
- * Returns `true` when the consuming project uses an ESM-style module
- * resolution strategy (`node16` / `nodenext`). Under those resolution
- * modes, dynamic `import()` specifiers MUST include the file extension
- * (typically `.js`) for the runtime resolver to find the module. Without
- * the extension, executing the generated metadata file fails with
- * `ERR_MODULE_NOT_FOUND`, and TypeScript reports a diagnostic.
- */
-export declare function requiresExplicitImportExtensions(options: ts.CompilerOptions, tsBinary: typeof ts): boolean;
 /**
  * Returns the same import path with `.js` appended when (and only when)
  * the path is relative and does not already end in a recognized

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

@@ -1,20 +1,8 @@
+import { requiresExplicitImportExtensions } from '../helpers/requires-explicit-import-extensions.js';
 import { FOUND_NO_ISSUES_GENERATING_METADATA } from '../swc/constants.js';
 import { TypeCheckerHost } from '../swc/type-checker-host.js';
 import { TypeScriptBinaryLoader } from '../typescript-loader.js';
 import { PluginMetadataPrinter } from './plugin-metadata-printer.js';
-/**
- * Returns `true` when the consuming project uses an ESM-style module
- * resolution strategy (`node16` / `nodenext`). Under those resolution
- * modes, dynamic `import()` specifiers MUST include the file extension
- * (typically `.js`) for the runtime resolver to find the module. Without
- * the extension, executing the generated metadata file fails with
- * `ERR_MODULE_NOT_FOUND`, and TypeScript reports a diagnostic.
- */
-export function requiresExplicitImportExtensions(options, tsBinary) {
-    const moduleResolution = options.moduleResolution;
-    return (moduleResolution === tsBinary.ModuleResolutionKind.Node16 ||
-        moduleResolution === tsBinary.ModuleResolutionKind.NodeNext);
-}
 const RELATIVE_PATH_RE = /^\.\.?\//;
 // Any common JS/TS-style extension that the user could have authored or
 // that our rewrite would have already produced. Prevents double-appending.

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

@@ -26,5 +26,6 @@ export declare class PluginsLoader {
         pathToSource?: string;
     }): MultiNestCompilerPlugins;
     private resolvePluginReferences;
+    private resolvePluginPath;
 }
 export {};

package/lib/compiler/plugins/plugins-loader.js

@@ -49,22 +49,33 @@ export class PluginsLoader {
             ...(require.resolve.paths('typescript') ?? []),
         ];
         return pluginNames.map((item) => {
+            const binaryPath = this.resolvePluginPath(item, nodeModulePaths);
             try {
-                try {
-                    const binaryPath = require.resolve(`${item}/${PLUGIN_ENTRY_FILENAME}`, {
-                        paths: nodeModulePaths,
-                    });
-                    return require(binaryPath);
-                }
-                catch {
-                    // entry-point resolution failed, try bare module resolve
-                }
-                const binaryPath = require.resolve(item, { paths: nodeModulePaths });
                 return require(binaryPath);
             }
             catch (e) {
-                throw new Error(`"${item}" plugin is not installed.`, { cause: e });
+                // Resolution succeeded, so the plugin IS installed — it crashed while
+                // being evaluated (e.g. its own imports are incompatible with the
+                // TypeScript version it ended up resolving). Surface the real reason
+                // instead of falling through to a misleading "not compatible" error.
+                throw new Error(`"${item}" plugin failed to load: ${e?.message ?? e}`, { cause: e });
             }
         });
     }
+    resolvePluginPath(item, nodeModulePaths) {
+        try {
+            return require.resolve(`${item}/${PLUGIN_ENTRY_FILENAME}`, {
+                paths: nodeModulePaths,
+            });
+        }
+        catch {
+            // entry-point resolution failed, try bare module resolve
+        }
+        try {
+            return require.resolve(item, { paths: nodeModulePaths });
+        }
+        catch (e) {
+            throw new Error(`"${item}" plugin is not installed.`, { cause: e });
+        }
+    }
 }

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

@@ -3,9 +3,9 @@ import { Configuration } from '../configuration/index.js';
 import { AssetsManager } from './assets-manager.js';
 import { BaseCompiler } from './base-compiler.js';
 import { PluginsLoader } from './plugins/plugins-loader.js';
-type RspackConfigFactory = (config: Record<string, any>, rspackRef: any) => Record<string, any>;
-type RspackConfigFactoryOrConfig = RspackConfigFactory | Record<string, any>;
-type RspackCompilerExtras = {
+export type RspackConfigFactory = (config: Record<string, any>, rspackRef: any) => Record<string, any>;
+export type RspackConfigFactoryOrConfig = RspackConfigFactory | Record<string, any>;
+export type RspackCompilerExtras = {
     options: Record<string, any>;
     assetsManager: AssetsManager;
     rspackConfigFactoryOrConfig: RspackConfigFactoryOrConfig | RspackConfigFactoryOrConfig[];
@@ -18,4 +18,3 @@ export declare class RspackCompiler extends BaseCompiler<RspackCompilerExtras> {
     run(configuration: Required<Configuration>, tsConfigPath: string, appName: string | undefined, extras: RspackCompilerExtras, onSuccess?: () => void): void;
     private createAfterCallback;
 }
-export {};

package/lib/compiler/rspack-compiler.js

@@ -1,6 +1,6 @@
 import { existsSync } from 'fs';
 import { createRequire } from 'module';
-import { join } from 'path';
+import { resolve } from 'path';
 import { ERROR_PREFIX, INFO_PREFIX } from '../ui/index.js';
 import { isEsmProject } from '../utils/is-esm-project.js';
 import { BaseCompiler } from './base-compiler.js';
@@ -13,7 +13,7 @@ export class RspackCompiler extends BaseCompiler {
     }
     run(configuration, tsConfigPath, appName, extras, onSuccess) {
         const cwd = process.cwd();
-        const configPath = join(cwd, tsConfigPath);
+        const configPath = resolve(cwd, tsConfigPath);
         if (!existsSync(configPath)) {
             throw new Error(`Could not find TypeScript configuration file "${tsConfigPath}".`);
         }
@@ -21,7 +21,7 @@ export class RspackCompiler extends BaseCompiler {
         const pathToSource = this.getPathToSource(configuration, tsConfigPath, appName);
         const entryFile = getValueOrDefault(configuration, 'entryFile', appName, 'entryFile', extras.options);
         const entryFileRoot = getValueOrDefault(configuration, 'root', appName) || '';
-        const defaultOptions = rspackDefaultsFactory(pathToSource, entryFileRoot, entryFile, extras.debug ?? false, tsConfigPath, plugins, isEsmProject(), extras.tsOptions);
+        const defaultOptions = rspackDefaultsFactory(pathToSource, entryFileRoot, entryFile, extras.debug ?? false, configPath, plugins, isEsmProject(), extras.tsOptions);
         let rspack;
         try {
             rspack = require('@rspack/core');

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

@@ -3,9 +3,9 @@ import { AssetsManager } from './assets-manager.js';
 import { BaseCompiler } from './base-compiler.js';
 import { PluginsLoader } from './plugins/plugins-loader.js';
 import type webpack from 'webpack';
-type WebpackConfigFactory = (config: webpack.Configuration, webpackRef: typeof webpack) => webpack.Configuration;
-type WebpackConfigFactoryOrConfig = WebpackConfigFactory | webpack.Configuration;
-type WebpackCompilerExtras = {
+export type WebpackConfigFactory = (config: webpack.Configuration, webpackRef: typeof webpack) => webpack.Configuration;
+export type WebpackConfigFactoryOrConfig = WebpackConfigFactory | webpack.Configuration;
+export type WebpackCompilerExtras = {
     options: Record<string, any>;
     assetsManager: AssetsManager;
     webpackConfigFactoryOrConfig: WebpackConfigFactoryOrConfig | WebpackConfigFactoryOrConfig[];
@@ -17,4 +17,3 @@ export declare class WebpackCompiler extends BaseCompiler<WebpackCompilerExtras>
     run(configuration: Required<Configuration>, tsConfigPath: string, appName: string | undefined, extras: WebpackCompilerExtras, onSuccess?: () => void): void;
     private createAfterCallback;
 }
-export {};

package/lib/configuration/defaults.d.ts

@@ -4,4 +4,4 @@ export declare const defaultTsconfigFilename: string;
 export declare const defaultWebpackConfigFilename = "webpack.config.js";
 export declare const defaultRspackConfigFilename = "rspack.config.js";
 export declare const defaultOutDir = "dist";
-export declare const defaultGitIgnore = "# compiled output\n/dist\n/node_modules\n/build\n\n# Logs\nlogs\n*.log\nnpm-debug.log*\npnpm-debug.log*\nyarn-debug.log*\nyarn-error.log*\nlerna-debug.log*\n\n# OS\n.DS_Store\n\n# Tests\n/coverage\n/.nyc_output\n\n# IDEs and editors\n/.idea\n.project\n.classpath\n.c9/\n*.launch\n.settings/\n*.sublime-workspace\n\n# IDE - VSCode\n.vscode/*\n!.vscode/settings.json\n!.vscode/tasks.json\n!.vscode/launch.json\n!.vscode/extensions.json\n\n# dotenv environment variable files\n.env\n.env.development.local\n.env.test.local\n.env.production.local\n.env.local\n\n# temp directory\n.temp\n.tmp\n\n# Runtime data\npids\n*.pid\n*.seed\n*.pid.lock\n\n# Diagnostic reports (https://nodejs.org/api/report.html)\nreport.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json\n";
+export declare const defaultGitIgnore = "# compiled output\n/dist\n/node_modules\n/build\n\n# TypeScript build cache\n*.tsbuildinfo\n\n# Logs\nlogs\n*.log\nnpm-debug.log*\npnpm-debug.log*\nyarn-debug.log*\nyarn-error.log*\nlerna-debug.log*\n\n# OS\n.DS_Store\n\n# Tests\n/coverage\n/.nyc_output\n\n# IDEs and editors\n/.idea\n.project\n.classpath\n.c9/\n*.launch\n.settings/\n*.sublime-workspace\n\n# IDE - VSCode\n.vscode/*\n!.vscode/settings.json\n!.vscode/tasks.json\n!.vscode/launch.json\n!.vscode/extensions.json\n\n# dotenv environment variable files\n.env\n.env.development.local\n.env.test.local\n.env.production.local\n.env.local\n\n# temp directory\n.temp\n.tmp\n\n# Runtime data\npids\n*.pid\n*.seed\n*.pid.lock\n\n# Diagnostic reports (https://nodejs.org/api/report.html)\nreport.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json\n";

package/lib/configuration/defaults.js

@@ -30,6 +30,9 @@ export const defaultGitIgnore = `# compiled output
 /node_modules
 /build
 
+# TypeScript build cache
+*.tsbuildinfo
+
 # Logs
 logs
 *.log

package/lib/utils/load-builder-config.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Loads a builder (webpack/rspack) configuration file, which may be CommonJS,
+ * native ESM, or JSON. When `configPath` is the builder's default filename and
+ * no such file exists, the project simply has no overrides, so an identity
+ * factory is returned; an explicitly configured path that cannot be found is
+ * an error.
+ */
+export declare function loadBuilderConfig<T = any>(configPath: string, defaultPath: string, cwd?: string): Promise<T>;

package/lib/utils/load-builder-config.js

@@ -0,0 +1,40 @@
+import { existsSync } from 'fs';
+import { createRequire } from 'module';
+import { extname, join } from 'path';
+import { pathToFileURL } from 'url';
+import { resolveModulePath } from './resolve-module-path.js';
+const require = createRequire(import.meta.url);
+/**
+ * Loads a builder (webpack/rspack) configuration file, which may be CommonJS,
+ * native ESM, or JSON. When `configPath` is the builder's default filename and
+ * no such file exists, the project simply has no overrides, so an identity
+ * factory is returned; an explicitly configured path that cannot be found is
+ * an error.
+ */
+export async function loadBuilderConfig(configPath, defaultPath, cwd = process.cwd()) {
+    const pathToConfigFile = join(cwd, configPath);
+    // `require.resolve` handles extensionless and directory-index paths, but
+    // does not know about ESM-only extensions, hence the `existsSync` fallback.
+    const resolvedPath = resolveModulePath(pathToConfigFile) ??
+        (existsSync(pathToConfigFile) ? pathToConfigFile : undefined);
+    if (!resolvedPath) {
+        if (configPath === defaultPath) {
+            return ((_config) => ({}));
+        }
+        throw new Error(`Could not find the builder configuration file "${configPath}".`);
+    }
+    if (extname(resolvedPath) === '.json') {
+        return require(resolvedPath);
+    }
+    const imported = await import(pathToFileURL(resolvedPath).href);
+    const result = imported.default ?? imported;
+    // A CommonJS file compiled from TypeScript exposes its real export under a
+    // second `default`, behind the `__esModule` marker Node preserves as-is.
+    return (isTranspiledEsModule(result) ? result.default : result);
+}
+function isTranspiledEsModule(value) {
+    return (!!value &&
+        typeof value === 'object' &&
+        value.__esModule === true &&
+        'default' in value);
+}

package/lib/utils/resolve-module-path.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Resolves `path` through Node's module resolution, returning the resolved
+ * filename or `undefined` when it cannot be found. Callers need the resolved
+ * path itself (to decide how to load the file), not merely whether it exists.
+ */
+export declare function resolveModulePath(path: string): string | undefined;

package/lib/utils/resolve-module-path.js

@@ -0,0 +1,15 @@
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+/**
+ * Resolves `path` through Node's module resolution, returning the resolved
+ * filename or `undefined` when it cannot be found. Callers need the resolved
+ * path itself (to decide how to load the file), not merely whether it exists.
+ */
+export function resolveModulePath(path) {
+    try {
+        return require.resolve(path);
+    }
+    catch {
+        return undefined;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@depup/nestjs__cli",
-  "version": "12.0.0-depup.0",
+  "version": "12.0.1-depup.0",
   "type": "module",
   "description": "Nest - modern, fast, powerful node.js web framework (@cli) (with updated dependencies)",
   "engines": {
@@ -35,12 +35,12 @@
   },
   "homepage": "https://github.com/nestjs/nest-cli#readme",
   "dependencies": {
-    "@angular-devkit/core": "^22.1.6",
-    "@angular-devkit/schematics": "^22.1.6",
-    "@angular-devkit/schematics-cli": "^22.1.6",
-    "@inquirer/prompts": "8.7.0",
-    "@nestjs/schematics": "^12.0.0",
-    "ansis": "4.3.1",
+    "@angular-devkit/core": "22.1.8",
+    "@angular-devkit/schematics": "22.1.8",
+    "@angular-devkit/schematics-cli": "22.1.8",
+    "@inquirer/prompts": "8.7.2",
+    "@nestjs/schematics": "^12.0.2",
+    "ansis": "4.4.0",
     "chokidar": "5.0.0",
     "cli-table3": "0.6.5",
     "commander": "15.0.0",
@@ -55,22 +55,23 @@
     "@commitlint/config-angular": "21.2.2",
     "@rspack/core": "^2.0.0",
     "@swc/cli": "0.8.1",
-    "@swc/core": "1.16.1",
-    "@types/node": "25.9.5",
+    "@swc/core": "1.16.2",
+    "@types/node": "25.9.6",
     "@types/webpack-node-externals": "3.0.4",
     "delete-empty": "3.0.0",
     "fork-ts-checker-webpack-plugin": "9.1.0",
     "gulp": "5.0.1",
     "gulp-clean": "0.4.0",
     "husky": "9.1.7",
-    "lint-staged": "17.3.0",
-    "oxlint": "1.80.0",
+    "lint-staged": "17.5.1",
+    "oxlint": "1.82.0",
     "prettier": "3.9.6",
-    "release-it": "21.0.2",
+    "release-it": "21.0.3",
     "ts-loader": "9.6.2",
     "tsconfig-paths-webpack-plugin": "4.2.0",
-    "vitest": "4.1.11",
-    "webpack": "5.109.2",
+    "vite": "8.3.0",
+    "vitest": "5.0.0",
+    "webpack": "5.111.0",
     "webpack-node-externals": "3.0.0"
   },
   "lint-staged": {
@@ -122,27 +123,19 @@
   ],
   "depup": {
     "changes": {
-      "@angular-devkit/core": {
-        "from": "22.1.5",
-        "to": "^22.1.6"
-      },
-      "@angular-devkit/schematics": {
-        "from": "22.1.5",
-        "to": "^22.1.6"
-      },
-      "@angular-devkit/schematics-cli": {
-        "from": "22.1.5",
-        "to": "^22.1.6"
+      "@nestjs/schematics": {
+        "from": "^12.0.0",
+        "to": "^12.0.2"
       },
       "typescript": {
         "from": "~6.0.2",
         "to": "^7.0.2"
       }
     },
-    "depsUpdated": 4,
+    "depsUpdated": 2,
     "originalPackage": "@nestjs/cli",
-    "originalVersion": "12.0.0",
-    "processedAt": "2026-08-27T11:23:55.035Z",
+    "originalVersion": "12.0.1",
+    "processedAt": "2026-09-14T16:09:17.970Z",
     "smokeTest": "failed"
   }
 }

package/lib/utils/is-module-available.d.ts

@@ -1 +0,0 @@
-export declare function isModuleAvailable(path: string): boolean;

package/lib/utils/is-module-available.js

@@ -1,11 +0,0 @@
-import { createRequire } from 'module';
-const require = createRequire(import.meta.url);
-export function isModuleAvailable(path) {
-    try {
-        require.resolve(path);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}