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

package/commands/info.command.d.ts

@@ -1,5 +1,5 @@
-import { CommanderStatic } from 'commander';
-import { AbstractCommand } from './abstract.command';
+import { Command } from 'commander';
+import { AbstractCommand } from './abstract.command.js';
 export declare class InfoCommand extends AbstractCommand {
-    load(program: CommanderStatic): void;
+    load(program: Command): void;
 }

package/commands/info.command.js

@@ -1,18 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InfoCommand = void 0;
-const extra_args_warning_1 = require("../lib/utils/extra-args-warning");
-const abstract_command_1 = require("./abstract.command");
-class InfoCommand extends abstract_command_1.AbstractCommand {
+import { exitIfExtraArgs } from '../lib/utils/extra-args-warning.js';
+import { AbstractCommand } from './abstract.command.js';
+export class InfoCommand extends AbstractCommand {
     load(program) {
         program
             .command('info')
             .alias('i')
             .description('Display Nest project details.')
             .action(async (command) => {
-            (0, extra_args_warning_1.exitIfExtraArgs)(command, 0);
+            exitIfExtraArgs(command, 0);
             await this.action.handle();
         });
     }
 }
-exports.InfoCommand = InfoCommand;

package/commands/new.command.d.ts

@@ -1,5 +1,5 @@
-import { CommanderStatic } from 'commander';
-import { AbstractCommand } from './abstract.command';
+import { Command } from 'commander';
+import { AbstractCommand } from './abstract.command.js';
 export declare class NewCommand extends AbstractCommand {
-    load(program: CommanderStatic): void;
+    load(program: Command): void;
 }

package/commands/new.command.js

@@ -1,10 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NewCommand = void 0;
-const schematics_1 = require("../lib/schematics");
-const extra_args_warning_1 = require("../lib/utils/extra-args-warning");
-const abstract_command_1 = require("./abstract.command");
-class NewCommand extends abstract_command_1.AbstractCommand {
+import { Collection } from '../lib/schematics/index.js';
+import { AbstractCommand } from './abstract.command.js';
+export class NewCommand extends AbstractCommand {
     load(program) {
         program
             .command('new [name]')
@@ -16,48 +12,50 @@ class NewCommand extends abstract_command_1.AbstractCommand {
             .option('-s, --skip-install', 'Skip package installation.', false)
             .option('-p, --package-manager [packageManager]', 'Specify package manager.')
             .option('-l, --language [language]', 'Programming language to be used (TypeScript or JavaScript)', 'TypeScript')
-            .option('-c, --collection [collectionName]', 'Schematics collection to use', schematics_1.Collection.NESTJS)
-            .option('--strict', 'Enables strict mode in TypeScript.', false)
-            .action(async (name, command) => {
-            (0, extra_args_warning_1.exitIfExtraArgs)(command, 1);
-            const options = [];
-            options.push({ name: 'directory', value: command.directory });
-            options.push({ name: 'dry-run', value: command.dryRun });
-            options.push({ name: 'skip-git', value: command.skipGit });
-            options.push({ name: 'skip-install', value: command.skipInstall });
-            options.push({ name: 'strict', value: command.strict });
-            options.push({
-                name: 'packageManager',
-                value: command.packageManager,
-            });
-            options.push({ name: 'collection', value: command.collection });
+            .option('-c, --collection [collectionName]', 'Schematics collection to use', Collection.NESTJS)
+            .option('--strict', 'Enables strict mode in TypeScript.', true)
+            .option('-t, --skip-tests', 'Do not generate testing files for the new project.', false)
+            .option('--format', 'Format generated files using Prettier.', false)
+            .option('--observe', 'Auto-configure observability with @nestjs/observe.')
+            .option('--no-observe', 'Skip observability setup without being prompted for it.')
+            .action(async (name, options) => {
             const availableLanguages = ['js', 'ts', 'javascript', 'typescript'];
-            if (!!command.language) {
-                const lowercasedLanguage = command.language.toLowerCase();
+            let language = options.language;
+            if (language) {
+                const lowercasedLanguage = language.toLowerCase();
                 const langMatch = availableLanguages.includes(lowercasedLanguage);
                 if (!langMatch) {
-                    throw new Error(`Invalid language "${command.language}" selected. Available languages are "typescript" or "javascript"`);
+                    throw new Error(`Invalid language "${language}" selected. Available languages are "typescript" or "javascript"`);
                 }
                 switch (lowercasedLanguage) {
                     case 'javascript':
-                        command.language = 'js';
+                        language = 'js';
                         break;
                     case 'typescript':
-                        command.language = 'ts';
+                        language = 'ts';
                         break;
                     default:
-                        command.language = lowercasedLanguage;
+                        language = lowercasedLanguage;
                         break;
                 }
             }
-            options.push({
-                name: 'language',
-                value: command.language,
-            });
-            const inputs = [];
-            inputs.push({ name: 'name', value: name });
-            await this.action.handle(inputs, options);
+            const context = {
+                name,
+                directory: options.directory,
+                dryRun: options.dryRun,
+                skipGit: options.skipGit,
+                skipInstall: options.skipInstall,
+                skipTests: options.skipTests,
+                packageManager: options.packageManager,
+                language,
+                collection: options.collection,
+                strict: options.strict,
+                format: options.format === true,
+                // Stays undefined unless a flag was given, which is what tells the
+                // action to prompt instead of assuming an answer.
+                observe: options.observe,
+            };
+            await this.action.handle(context);
         });
     }
 }
-exports.NewCommand = NewCommand;

package/commands/start.command.d.ts

@@ -1,5 +1,5 @@
-import { CommanderStatic } from 'commander';
-import { AbstractCommand } from './abstract.command';
+import { Command } from 'commander';
+import { AbstractCommand } from './abstract.command.js';
 export declare class StartCommand extends AbstractCommand {
-    load(program: CommanderStatic): void;
+    load(program: Command): void;
 }

package/commands/start.command.js

@@ -1,10 +1,7 @@
-"use strict";
-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 {
+import { ERROR_PREFIX } from '../lib/ui/index.js';
+import { getRemainingFlags } from '../lib/utils/remaining-flags.js';
+import { AbstractCommand } from './abstract.command.js';
+export class StartCommand extends AbstractCommand {
     load(program) {
         const collect = (value, previous) => {
             return previous.concat([value]);
@@ -12,15 +9,22 @@ class StartCommand extends abstract_command_1.AbstractCommand {
         program
             .command('start [app]')
             .allowUnknownOption()
+            // Unknown options are collected into `args`, which commander otherwise
+            // rejects as excess arguments once an app name is also present.
+            .allowExcessArguments()
             .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('-b, --builder [name]', 'Builder to be used (tsc, webpack, swc, rspack).')
             .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 (deprecated option, use --builder instead).')
             .option('--webpackPath [path]', 'Path to webpack configuration.')
-            .option('--type-check', 'Enable type checking (when SWC is used).')
+            .option('--rspackPath [path]', 'Path to rspack configuration.')
+            .option('--type-check', 'Enable type checking (when SWC is used).', () => true)
+            .option('--no-type-check', 'Disable type checking (when SWC is used).', () => false)
+            .option('--emit-declarations', 'Emit declaration files (.d.ts) when using SWC builder.')
+            .option('--silent', 'Suppress informational compiler logs.')
             .option('--tsc', 'Use typescript compiler 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,75 +34,46 @@ class StartCommand extends abstract_command_1.AbstractCommand {
             .option('--no-shell', 'Do not spawn child processes within a shell.')
             .option('--env-file [path]', 'Path to an env file (.env) to be loaded into the environment.', collect, [])
             .description('Run Nest application.')
-            .action(async (app, command) => {
-            const options = [];
-            options.push({
-                name: 'config',
-                value: command.config,
-            });
-            const isWebpackEnabled = command.tsc ? false : command.webpack;
-            options.push({ name: 'webpack', value: isWebpackEnabled });
-            options.push({ name: 'debug', value: command.debug });
-            options.push({ name: 'watch', value: !!command.watch });
-            options.push({ name: 'watchAssets', value: !!command.watchAssets });
-            options.push({
-                name: 'path',
-                value: command.path,
-            });
-            options.push({
-                name: 'webpackPath',
-                value: command.webpackPath,
-            });
-            options.push({
-                name: 'exec',
-                value: command.exec,
-            });
-            options.push({
-                name: 'sourceRoot',
-                value: command.sourceRoot,
-            });
-            options.push({
-                name: 'entryFile',
-                value: command.entryFile,
-            });
-            options.push({
-                name: 'preserveWatchOutput',
-                value: !!command.preserveWatchOutput &&
-                    !!command.watch &&
-                    !isWebpackEnabled,
-            });
-            options.push({
-                name: 'shell',
-                value: !!command.shell,
-            });
-            options.push({
-                name: 'envFile',
-                value: command.envFile,
-            });
-            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;
+            .action(async (app, options) => {
+            const isWebpackEnabled = options.tsc ? false : options.webpack;
+            const availableBuilders = ['tsc', 'webpack', 'swc', 'rspack'];
+            if (options.builder && !availableBuilders.includes(options.builder)) {
+                console.error(ERROR_PREFIX +
+                    ` Invalid builder option: ${options.builder}. Available builders: ${availableBuilders.join(', ')}`);
+                process.exit(1);
             }
-            options.push({
-                name: 'builder',
-                value: command.builder,
-            });
-            options.push({
-                name: 'typeCheck',
-                value: command.typeCheck,
-            });
-            const inputs = [];
-            inputs.push({ name: 'app', value: app });
-            const flags = (0, remaining_flags_1.getRemainingFlags)(program);
+            const context = {
+                app,
+                config: options.config,
+                webpack: isWebpackEnabled,
+                watch: !!options.watch,
+                watchAssets: !!options.watchAssets,
+                path: options.path,
+                webpackPath: options.webpackPath,
+                rspackPath: options.rspackPath,
+                builder: options.builder,
+                typeCheck: options.typeCheck,
+                // Left undefined when the flag is absent so `getValueOrDefault` can
+                // still fall through to `compilerOptions.emitDeclarations`.
+                emitDeclarations: options.emitDeclarations,
+                silent: !!options.silent,
+                preserveWatchOutput: !!options.preserveWatchOutput &&
+                    !!options.watch &&
+                    !isWebpackEnabled,
+                debug: options.debug,
+                exec: options.exec,
+                sourceRoot: options.sourceRoot,
+                entryFile: options.entryFile,
+                shell: !!options.shell,
+                envFile: options.envFile ?? [],
+                extraFlags: getRemainingFlags(program),
+            };
             try {
-                await this.action.handle(inputs, options, flags);
+                await this.action.handle(context);
             }
-            catch (err) {
+            catch {
                 process.exit(1);
             }
         });
     }
 }
-exports.StartCommand = StartCommand;

package/commands/upgrade.command.d.ts

@@ -0,0 +1,5 @@
+import { Command } from 'commander';
+import { AbstractCommand } from './abstract.command.js';
+export declare class UpgradeCommand extends AbstractCommand {
+    load(program: Command): void;
+}

package/commands/upgrade.command.js

@@ -0,0 +1,32 @@
+import { AbstractCommand } from './abstract.command.js';
+export class UpgradeCommand extends AbstractCommand {
+    load(program) {
+        program
+            .command('upgrade')
+            .alias('update')
+            .description('Upgrade your project to the latest NestJS major version.')
+            .option('-d, --dry-run', 'Report actions that would be performed without writing out results.')
+            .option('-s, --skip-install', 'Skip package installation.', false)
+            .option('--observe', 'Set up @nestjs/observe (skips the prompt).')
+            .option('--no-observe', 'Do not set up @nestjs/observe (skips the prompt).')
+            .option('-t, --tag [tag]', 'Use an npm dist-tag (e.g. "next") instead of the default version ranges.')
+            .option('-c, --collection [collectionName]', 'Schematics collection to use.')
+            .action(async (options) => {
+            const context = {
+                dryRun: !!options.dryRun,
+                skipInstall: options.skipInstall,
+                // Stays `undefined` when neither --observe nor --no-observe was
+                // given so the schematic can prompt for it.
+                observe: options.observe,
+                tag: options.tag,
+                collection: options.collection,
+            };
+            try {
+                await this.action.handle(context);
+            }
+            catch {
+                process.exit(1);
+            }
+        });
+    }
+}

package/lib/compiler/assets-manager.d.ts

@@ -1,15 +1,27 @@
-import { Configuration } from '../configuration';
+import { Configuration } from '../configuration/index.js';
 export declare class AssetsManager {
     private watchAssetsKeyValue;
     private watchers;
-    private actionInProgress;
+    private 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(): void;
-    copyAssets(configuration: Required<Configuration>, appName: string | undefined, outDir: string, watchAssetsMode: boolean): void;
+    closeWatchers(): Promise<void>;
+    copyAssets(configuration: Required<Configuration>, appName: string | undefined, outDir: string, watchAssetsMode: boolean, onSuccess?: () => void, rootDir?: string): void;
+    private collectLibraryAssets;
+    /**
+     * 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.
+     */
+    private safeActionOnFile;
     private actionOnFile;
 }