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

package/commands/add.command.js

@@ -1,36 +1,33 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AddCommand = void 0;
-const remaining_flags_1 = require("../lib/utils/remaining-flags");
-const abstract_command_1 = require("./abstract.command");
-class AddCommand extends abstract_command_1.AbstractCommand {
+import { getRemainingFlags } from '../lib/utils/remaining-flags.js';
+import { AbstractCommand } from './abstract.command.js';
+export class AddCommand extends AbstractCommand {
     load(program) {
         program
             .command('add <library>')
             .allowUnknownOption()
+            // Unknown options are collected into `args`, which commander otherwise
+            // rejects as excess arguments — that would break the documented
+            // library-specific options this command forwards via `extraFlags`.
+            .allowExcessArguments()
             .description('Adds support for an external library to your project.')
             .option('-d, --dry-run', 'Report actions that would be performed without writing out results.')
             .option('-s, --skip-install', 'Skip package installation.', false)
             .option('-p, --project [project]', 'Project in which to generate files.')
             .usage('<library> [options] [library-specific-options]')
-            .action(async (library, command) => {
-            const options = [];
-            options.push({ name: 'dry-run', value: !!command.dryRun });
-            options.push({ name: 'skip-install', value: command.skipInstall });
-            options.push({
-                name: 'project',
-                value: command.project,
-            });
-            const inputs = [];
-            inputs.push({ name: 'library', value: library });
-            const flags = (0, remaining_flags_1.getRemainingFlags)(program);
+            .action(async (library, options) => {
+            const context = {
+                library,
+                dryRun: !!options.dryRun,
+                skipInstall: options.skipInstall,
+                project: options.project,
+                extraFlags: getRemainingFlags(program),
+            };
             try {
-                await this.action.handle(inputs, options, flags);
+                await this.action.handle(context);
             }
-            catch (err) {
+            catch {
                 process.exit(1);
             }
         });
     }
 }
-exports.AddCommand = AddCommand;

package/commands/build.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 BuildCommand extends AbstractCommand {
-    load(program: CommanderStatic): void;
+    load(program: Command): void;
 }

package/commands/build.command.js

@@ -1,74 +1,70 @@
-"use strict";
-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 {
+import { ERROR_PREFIX } from '../lib/ui/index.js';
+import { AbstractCommand } from './abstract.command.js';
+export class BuildCommand extends AbstractCommand {
     load(program) {
         program
             .command('build [apps...]')
             .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('--webpack', 'Use webpack for compilation (deprecated option, use --builder instead).')
-            .option('--type-check', 'Enable type checking (when SWC is used).')
+            .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('--webpackPath [path]', 'Path to webpack configuration.')
+            .option('--rspackPath [path]', 'Path to rspack configuration.')
             .option('--tsc', 'Use typescript compiler for compilation.')
             .option('--preserveWatchOutput', 'Use "preserveWatchOutput" option when using tsc watch mode.')
             .option('--all', 'Build all projects in a monorepo.')
+            .option('--parallel [concurrency]', 'Build projects in parallel (with --all). Optionally limit concurrency.')
             .description('Build Nest application.')
-            .action(async (apps, 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: '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,
-            });
-            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 (apps, 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,
-            });
-            options.push({
-                name: 'preserveWatchOutput',
-                value: !!command.preserveWatchOutput &&
-                    !!command.watch &&
-                    !isWebpackEnabled,
-            });
-            options.push({ name: 'all', value: !!command.all });
-            const inputs = apps.map((app) => ({
-                name: 'app',
-                value: app,
-            }));
-            // Handle the default project for `nest build` with no args
-            // The action instance will pick up the default project when value is `undefined`
-            if (inputs.length === 0) {
-                inputs.push({ name: 'app', value: undefined });
+            let parallel;
+            if (options.parallel === true || options.parallel === undefined) {
+                // `--parallel` with no value means unlimited; absent means sequential.
+                parallel = options.parallel;
+            }
+            else {
+                const parsed = parseInt(options.parallel, 10);
+                if (!Number.isFinite(parsed) || parsed < 1) {
+                    console.error(ERROR_PREFIX +
+                        ` Invalid --parallel value: "${options.parallel}". Expected a positive integer (e.g. --parallel 4) or no value for unlimited concurrency.`);
+                    process.exit(1);
+                }
+                parallel = parsed;
             }
-            await this.action.handle(inputs, options);
+            const context = {
+                apps: apps.length > 0 ? apps : [],
+                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,
+                all: !!options.all,
+                parallel,
+            };
+            await this.action.handle(context);
         });
     }
 }
-exports.BuildCommand = BuildCommand;

package/commands/command.input.js

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

package/commands/command.loader.d.ts

@@ -1,5 +1,5 @@
-import { CommanderStatic } from 'commander';
+import { Command } from 'commander';
 export declare class CommandLoader {
-    static load(program: CommanderStatic): Promise<void>;
+    static load(program: Command): Promise<void>;
     private static handleInvalidCommand;
 }

package/commands/command.loader.js

@@ -1,31 +1,38 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CommandLoader = void 0;
-const ansis_1 = require("ansis");
-const actions_1 = require("../actions");
-const ui_1 = require("../lib/ui");
-const add_command_1 = require("./add.command");
-const build_command_1 = require("./build.command");
-const generate_command_1 = require("./generate.command");
-const info_command_1 = require("./info.command");
-const new_command_1 = require("./new.command");
-const start_command_1 = require("./start.command");
-class CommandLoader {
+import { red } from 'ansis';
+import { AddAction, BuildAction, DeployAction, GenerateAction, InfoAction, NewAction, StartAction, UpgradeAction, } from '../actions/index.js';
+import { ERROR_PREFIX } from '../lib/ui/index.js';
+import { AddCommand } from './add.command.js';
+import { BuildCommand } from './build.command.js';
+import { DeployCommand } from './deploy.command.js';
+import { GenerateCommand } from './generate.command.js';
+import { InfoCommand } from './info.command.js';
+import { NewCommand } from './new.command.js';
+import { StartCommand } from './start.command.js';
+import { UpgradeCommand } from './upgrade.command.js';
+export class CommandLoader {
     static async load(program) {
-        new new_command_1.NewCommand(new actions_1.NewAction()).load(program);
-        new build_command_1.BuildCommand(new actions_1.BuildAction()).load(program);
-        new start_command_1.StartCommand(new actions_1.StartAction()).load(program);
-        new info_command_1.InfoCommand(new actions_1.InfoAction()).load(program);
-        new add_command_1.AddCommand(new actions_1.AddAction()).load(program);
-        await new generate_command_1.GenerateCommand(new actions_1.GenerateAction()).load(program);
+        if (!program.__nestCliEsm) {
+            console.error(`\n${ERROR_PREFIX} The globally installed ${red('@nestjs/cli')} is outdated and ` +
+                'incompatible with the local version (which requires ESM).\n' +
+                'Please upgrade your global installation:\n\n' +
+                `  ${red('npm i -g @nestjs/cli')}\n`);
+            process.exit(1);
+        }
+        new NewCommand(new NewAction()).load(program);
+        new BuildCommand(new BuildAction()).load(program);
+        new StartCommand(new StartAction()).load(program);
+        new InfoCommand(new InfoAction()).load(program);
+        new AddCommand(new AddAction()).load(program);
+        new DeployCommand(new DeployAction()).load(program);
+        new UpgradeCommand(new UpgradeAction()).load(program);
+        await new GenerateCommand(new GenerateAction()).load(program);
         this.handleInvalidCommand(program);
     }
     static handleInvalidCommand(program) {
         program.on('command:*', () => {
-            console.error(`\n${ui_1.ERROR_PREFIX} Invalid command: ${(0, ansis_1.red) `%s`}`, program.args.join(' '));
-            console.log(`See ${(0, ansis_1.red) `--help`} for a list of available commands.\n`);
+            console.error(`\n${ERROR_PREFIX} Invalid command: ${red `%s`}`, program.args.join(' '));
+            console.error(`See ${red `--help`} for a list of available commands.\n`);
             process.exit(1);
         });
     }
 }
-exports.CommandLoader = CommandLoader;

package/commands/context/add.context.d.ts

@@ -0,0 +1,7 @@
+export interface AddCommandContext {
+    library: string;
+    dryRun: boolean;
+    skipInstall: boolean;
+    project?: string;
+    extraFlags: string[];
+}

package/commands/context/add.context.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,17 @@
+export interface BuildCommandContext {
+    apps: string[];
+    config?: string;
+    webpack?: boolean;
+    watch: boolean;
+    watchAssets: boolean;
+    path?: string;
+    webpackPath?: string;
+    rspackPath?: string;
+    builder?: string;
+    typeCheck?: boolean;
+    emitDeclarations?: boolean;
+    silent?: boolean;
+    preserveWatchOutput: boolean;
+    all: boolean;
+    parallel?: number | boolean;
+}

package/commands/context/build.context.js

@@ -0,0 +1 @@
+export {};

package/commands/context/deploy.context.d.ts

@@ -0,0 +1,7 @@
+export interface DeployCommandContext {
+    /**
+     * Arguments forwarded verbatim to `mau deploy`, so every option Mau
+     * supports keeps working without the CLI having to mirror it.
+     */
+    args: string[];
+}

package/commands/context/deploy.context.js

@@ -0,0 +1 @@
+export {};

package/commands/context/generate.context.d.ts

@@ -0,0 +1,18 @@
+export interface GenerateCommandContext {
+    schematic: string;
+    name?: string;
+    path?: string;
+    dryRun: boolean;
+    flat?: boolean;
+    spec: boolean | {
+        value: boolean;
+        passedAsInput: boolean;
+    };
+    specFileSuffix?: string;
+    collection?: string;
+    project?: string;
+    skipImport: boolean;
+    format: boolean;
+    type?: string;
+    crud?: boolean;
+}

package/commands/context/generate.context.js

@@ -0,0 +1 @@
+export {};

package/commands/context/index.d.ts

@@ -0,0 +1,7 @@
+export * from './add.context.js';
+export * from './build.context.js';
+export * from './deploy.context.js';
+export * from './generate.context.js';
+export * from './new.context.js';
+export * from './start.context.js';
+export * from './upgrade.context.js';

package/commands/context/index.js

@@ -0,0 +1,7 @@
+export * from './add.context.js';
+export * from './build.context.js';
+export * from './deploy.context.js';
+export * from './generate.context.js';
+export * from './new.context.js';
+export * from './start.context.js';
+export * from './upgrade.context.js';

package/commands/context/new.context.d.ts

@@ -0,0 +1,19 @@
+export interface NewCommandContext {
+    name?: string;
+    directory?: string;
+    dryRun: boolean;
+    skipGit: boolean;
+    skipInstall: boolean;
+    skipTests: boolean;
+    packageManager?: string;
+    language: string;
+    collection: string;
+    strict: boolean;
+    format: boolean;
+    /**
+     * Whether to auto-configure `@nestjs/observe`. Left `undefined` when the
+     * user passed neither `--observe` nor `--no-observe`, so the action knows it
+     * still has to ask.
+     */
+    observe?: boolean;
+}

package/commands/context/new.context.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,22 @@
+export interface StartCommandContext {
+    app?: string;
+    config?: string;
+    webpack?: boolean;
+    watch: boolean;
+    watchAssets: boolean;
+    path?: string;
+    webpackPath?: string;
+    rspackPath?: string;
+    builder?: string;
+    typeCheck?: boolean;
+    emitDeclarations?: boolean;
+    silent?: boolean;
+    preserveWatchOutput: boolean;
+    debug?: boolean | string;
+    exec?: string;
+    sourceRoot?: string;
+    entryFile?: string;
+    shell: boolean;
+    envFile: string[];
+    extraFlags: string[];
+}

package/commands/context/start.context.js

@@ -0,0 +1 @@
+export {};

package/commands/context/upgrade.context.d.ts

@@ -0,0 +1,11 @@
+export interface UpgradeCommandContext {
+    dryRun: boolean;
+    skipInstall: boolean;
+    /**
+     * Tri-state on purpose: `undefined` means neither `--observe` nor
+     * `--no-observe` was passed, which lets the schematic's own `x-prompt` ask.
+     */
+    observe?: boolean;
+    tag?: string;
+    collection?: string;
+}

package/commands/context/upgrade.context.js

@@ -0,0 +1 @@
+export {};

package/commands/deploy.command.d.ts

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

package/commands/deploy.command.js

@@ -0,0 +1,22 @@
+import { AbstractCommand } from './abstract.command.js';
+export class DeployCommand extends AbstractCommand {
+    load(program) {
+        program
+            .command('deploy')
+            // Every option belongs to `mau deploy`, so nothing is claimed here and
+            // whatever the user typed is passed straight through.
+            .allowUnknownOption()
+            .allowExcessArguments()
+            .usage('[mau-options]')
+            .description('Deploy your application to the cloud (powered by Mau).')
+            .action(async (_options, command) => {
+            const context = { args: command.args };
+            try {
+                await this.action.handle(context);
+            }
+            catch {
+                process.exit(1);
+            }
+        });
+    }
+}

package/commands/generate.command.d.ts

@@ -1,7 +1,7 @@
-import { CommanderStatic } from 'commander';
-import { AbstractCommand } from './abstract.command';
+import { Command } from 'commander';
+import { AbstractCommand } from './abstract.command.js';
 export declare class GenerateCommand extends AbstractCommand {
-    load(program: CommanderStatic): Promise<void>;
+    load(program: Command): Promise<void>;
     private buildDescription;
     private buildSchematicsListAsTable;
     private getCollection;

package/commands/generate.command.js

@@ -1,13 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GenerateCommand = void 0;
-const ansis_1 = require("ansis");
-const Table = require("cli-table3");
-const schematics_1 = require("../lib/schematics");
-const extra_args_warning_1 = require("../lib/utils/extra-args-warning");
-const load_configuration_1 = require("../lib/utils/load-configuration");
-const abstract_command_1 = require("./abstract.command");
-class GenerateCommand extends abstract_command_1.AbstractCommand {
+import { bold, cyan, green } from 'ansis';
+import Table from 'cli-table3';
+import { CollectionFactory, } from '../lib/schematics/index.js';
+import { loadConfiguration } from '../lib/utils/load-configuration.js';
+import { AbstractCommand } from './abstract.command.js';
+export class GenerateCommand extends AbstractCommand {
     async load(program) {
         program
             .command('generate <schematic> [name] [path]')
@@ -19,70 +15,44 @@ class GenerateCommand extends abstract_command_1.AbstractCommand {
             .option('--no-flat', 'Enforce that directories are generated.', () => false)
             .option('--spec', 'Enforce spec files generation.', () => {
             return { value: true, passedAsInput: true };
-        }, true)
+        }, { value: true, passedAsInput: false })
             .option('--spec-file-suffix [suffix]', 'Use a custom suffix for spec files.')
             .option('--skip-import', 'Skip importing', () => true, false)
+            .option('--format', 'Format generated files using Prettier.', false)
             .option('--no-spec', 'Disable spec files generation.', () => {
             return { value: false, passedAsInput: true };
         })
             .option('-c, --collection [collectionName]', 'Schematics collection to use.')
             .option('--type <type>', 'Transport layer type (rest, graphql, microservice)')
             .option('--crud [value]', 'Generate CRUD entry points')
-            .action(async (schematic, name, path, command) => {
-            (0, extra_args_warning_1.exitIfExtraArgs)(command, 3);
-            const options = [];
-            options.push({ name: 'dry-run', value: !!command.dryRun });
-            if (command.flat !== undefined) {
-                options.push({ name: 'flat', value: command.flat });
-            }
-            options.push({
-                name: 'spec',
-                value: typeof command.spec === 'boolean'
-                    ? command.spec
-                    : command.spec.value,
-                options: {
-                    passedAsInput: typeof command.spec === 'boolean'
-                        ? false
-                        : command.spec.passedAsInput,
-                },
-            });
-            options.push({
-                name: 'specFileSuffix',
-                value: command.specFileSuffix,
-            });
-            options.push({
-                name: 'collection',
-                value: command.collection,
-            });
-            options.push({
-                name: 'project',
-                value: command.project,
-            });
-            options.push({
-                name: 'skipImport',
-                value: command.skipImport,
-            });
-            options.push({
-                name: 'type',
-                value: command.type,
-            });
-            if (command.crud !== undefined) {
-                options.push({
-                    name: 'crud',
-                    value: command.crud === true || command.crud === 'true',
-                });
-            }
-            const inputs = [];
-            inputs.push({ name: 'schematic', value: schematic });
-            inputs.push({ name: 'name', value: name });
-            inputs.push({ name: 'path', value: path });
-            await this.action.handle(inputs, options);
+            .action(async (schematic, name, path, options) => {
+            const context = {
+                schematic,
+                name,
+                path,
+                dryRun: !!options.dryRun,
+                flat: options.flat,
+                spec: options.spec,
+                specFileSuffix: options.specFileSuffix,
+                collection: options.collection,
+                project: options.project,
+                skipImport: options.skipImport,
+                format: options.format === true,
+                type: options.type,
+                // `--crud [value]` yields a string whenever a value is supplied,
+                // so `--crud false` must still be forwarded (as false) rather than
+                // dropped, which would let the schematic apply its own default.
+                crud: options.crud === undefined
+                    ? undefined
+                    : options.crud === true || options.crud === 'true',
+            };
+            await this.action.handle(context);
         });
     }
     async buildDescription() {
         const collection = await this.getCollection();
         return ('Generate a Nest element.\n' +
-            `  Schematics available on ${(0, ansis_1.bold)(collection)} collection:\n` +
+            `  Schematics available on ${bold(collection)} collection:\n` +
             this.buildSchematicsListAsTable(await this.getSchematics(collection)));
     }
     buildSchematicsListAsTable(schematics) {
@@ -102,20 +72,19 @@ class GenerateCommand extends abstract_command_1.AbstractCommand {
         const table = new Table(tableConfig);
         for (const schematic of schematics) {
             table.push([
-                (0, ansis_1.green)(schematic.name),
-                (0, ansis_1.cyan)(schematic.alias),
+                green(schematic.name),
+                cyan(schematic.alias),
                 schematic.description,
             ]);
         }
         return table.toString();
     }
     async getCollection() {
-        const configuration = await (0, load_configuration_1.loadConfiguration)();
+        const configuration = await loadConfiguration();
         return configuration.collection;
     }
     async getSchematics(collection) {
-        const abstractCollection = schematics_1.CollectionFactory.create(collection);
+        const abstractCollection = CollectionFactory.create(collection);
         return abstractCollection.getSchematics();
     }
 }
-exports.GenerateCommand = GenerateCommand;

package/commands/index.d.ts

@@ -1,2 +1,3 @@
-export * from './command.loader';
-export * from './command.input';
+export * from './command.input.js';
+export * from './command.loader.js';
+export * from './context/index.js';

package/commands/index.js

@@ -1,18 +1,3 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./command.loader"), exports);
-__exportStar(require("./command.input"), exports);
+export * from './command.input.js';
+export * from './command.loader.js';
+export * from './context/index.js';