@nestjs/cli 11.0.15 → 12.0.0-alpha.0

package/actions/start.action.js

@@ -1,59 +1,50 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StartAction = void 0;
-const ansis_1 = require("ansis");
-const child_process_1 = require("child_process");
-const fs = require("fs");
-const path_1 = require("path");
-const get_tsc_config_path_1 = require("../lib/compiler/helpers/get-tsc-config.path");
-const get_value_or_default_1 = require("../lib/compiler/helpers/get-value-or-default");
-const defaults_1 = require("../lib/configuration/defaults");
-const ui_1 = require("../lib/ui");
-const tree_kill_1 = require("../lib/utils/tree-kill");
-const type_assertions_1 = require("../lib/utils/type-assertions");
-const build_action_1 = require("./build.action");
-class StartAction extends build_action_1.BuildAction {
-    async handle(commandInputs, commandOptions) {
+import { red } from 'ansis';
+import { spawn } from 'child_process';
+import * as fs from 'fs';
+import { join } from 'path';
+import { getTscConfigPath } from '../lib/compiler/helpers/get-tsc-config.path.js';
+import { getValueOrDefault } from '../lib/compiler/helpers/get-value-or-default.js';
+import { defaultConfiguration, defaultOutDir, } from '../lib/configuration/defaults.js';
+import { ERROR_PREFIX } from '../lib/ui/index.js';
+import { treeKillSync as killProcessSync } from '../lib/utils/tree-kill.js';
+import { assertNonArray } from '../lib/utils/type-assertions.js';
+import { BuildAction } from './build.action.js';
+export class StartAction extends BuildAction {
+    async handle(context) {
         try {
-            const configFileName = commandOptions.find((option) => option.name === 'config').value;
+            const configFileName = context.config;
             const configuration = await this.loader.load(configFileName);
-            const appName = commandInputs.find((input) => input.name === 'app')
-                .value;
-            const pathToTsconfig = (0, get_tsc_config_path_1.getTscConfigPath)(configuration, commandOptions, appName);
-            const debugModeOption = commandOptions.find((option) => option.name === 'debug');
-            const watchModeOption = commandOptions.find((option) => option.name === 'watch');
-            const isWatchEnabled = !!(watchModeOption && watchModeOption.value);
-            const watchAssetsModeOption = commandOptions.find((option) => option.name === 'watchAssets');
-            const isWatchAssetsEnabled = !!(watchAssetsModeOption && watchAssetsModeOption.value);
-            const debugFlag = debugModeOption && debugModeOption.value;
-            (0, type_assertions_1.assertNonArray)(debugFlag);
-            const binaryToRun = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'exec', appName, 'exec', commandOptions, defaults_1.defaultConfiguration.exec);
+            const appName = context.app;
+            const pathToTsconfig = getTscConfigPath(configuration, context, appName);
+            const isWatchEnabled = !!context.watch;
+            const isWatchAssetsEnabled = !!context.watchAssets;
+            const debugFlag = context.debug;
+            assertNonArray(debugFlag);
+            const binaryToRun = getValueOrDefault(configuration, 'exec', appName, 'exec', context, defaultConfiguration.exec);
             const { options: tsOptions } = this.tsConfigProvider.getByConfigFilename(pathToTsconfig);
-            const outDir = tsOptions.outDir || defaults_1.defaultOutDir;
-            const entryFile = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'entryFile', appName, 'entryFile', commandOptions, defaults_1.defaultConfiguration.entryFile);
-            const sourceRoot = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'sourceRoot', appName, 'sourceRoot', commandOptions, defaults_1.defaultConfiguration.sourceRoot);
-            const shellOption = commandOptions.find((option) => option.name === 'shell');
-            const useShell = !!shellOption?.value;
-            const envFileOption = commandOptions.find((option) => option.name === 'envFile');
-            const envFile = (envFileOption?.value ?? []);
+            const outDir = tsOptions.outDir || defaultOutDir;
+            const entryFile = getValueOrDefault(configuration, 'entryFile', appName, 'entryFile', context, defaultConfiguration.entryFile);
+            const sourceRoot = getValueOrDefault(configuration, 'sourceRoot', appName, 'sourceRoot', context, defaultConfiguration.sourceRoot);
+            const useShell = !!context.shell;
+            const envFile = context.envFile ?? [];
             const onSuccess = this.createOnSuccessHook(entryFile, sourceRoot, debugFlag, outDir, binaryToRun, {
                 shell: useShell,
                 envFile,
             });
-            await this.runBuild(commandInputs, commandOptions, isWatchEnabled, isWatchAssetsEnabled, !!debugFlag, onSuccess);
+            await this.runBuild(appName ? [appName] : [], context, isWatchEnabled, isWatchAssetsEnabled, !!debugFlag, onSuccess);
         }
         catch (err) {
             if (err instanceof Error) {
-                console.log(`\n${ui_1.ERROR_PREFIX} ${err.message}\n`);
+                console.error(`\n${ERROR_PREFIX} ${err.message}\n`);
             }
             else {
-                console.error(`\n${(0, ansis_1.red)(err)}\n`);
+                console.error(`\n${red(err)}\n`);
             }
         }
     }
     createOnSuccessHook(entryFile, sourceRoot, debugFlag, outDirName, binaryToRun, options) {
         let childProcessRef;
-        process.on('exit', () => childProcessRef && (0, tree_kill_1.treeKillSync)(childProcessRef.pid));
+        process.on('exit', () => childProcessRef && killProcessSync(childProcessRef.pid));
         return () => {
             if (childProcessRef) {
                 childProcessRef.removeAllListeners('exit');
@@ -64,8 +55,8 @@ class StartAction extends build_action_1.BuildAction {
                     });
                     childProcessRef.on('exit', () => (childProcessRef = undefined));
                 });
-                childProcessRef.stdin && childProcessRef.stdin.pause();
-                (0, tree_kill_1.treeKillSync)(childProcessRef.pid);
+                childProcessRef.stdin?.pause?.();
+                killProcessSync(childProcessRef.pid);
             }
             else {
                 childProcessRef = this.spawnChildProcess(entryFile, sourceRoot, debugFlag, outDirName, binaryToRun, {
@@ -80,9 +71,9 @@ class StartAction extends build_action_1.BuildAction {
         };
     }
     spawnChildProcess(entryFile, sourceRoot, debug, outDirName, binaryToRun, options) {
-        let outputFilePath = (0, path_1.join)(outDirName, sourceRoot, entryFile);
+        let outputFilePath = join(outDirName, sourceRoot, entryFile);
         if (!fs.existsSync(outputFilePath + '.js')) {
-            outputFilePath = (0, path_1.join)(outDirName, entryFile);
+            outputFilePath = join(outDirName, entryFile);
         }
         let childProcessArgs = [];
         const argsStartIndex = process.argv.indexOf('--');
@@ -114,9 +105,8 @@ class StartAction extends build_action_1.BuildAction {
         };
         if (options.shell) {
             const command = [binaryToRun, ...processArgs].join(' ');
-            return (0, child_process_1.spawn)(command, spawnOptions);
+            return spawn(command, spawnOptions);
         }
-        return (0, child_process_1.spawn)(binaryToRun, processArgs, spawnOptions);
+        return spawn(binaryToRun, processArgs, spawnOptions);
     }
 }
-exports.StartAction = StartAction;

package/bin/nest.js

@@ -1,23 +1,27 @@
 #!/usr/bin/env node
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const commander = require("commander");
-const commands_1 = require("../commands");
-const local_binaries_1 = require("../lib/utils/local-binaries");
+import { createRequire } from 'module';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+import { Command } from 'commander';
+import { CommandLoader } from '../commands/index.js';
+import { loadLocalBinCommandLoader, localBinExists, } from '../lib/utils/local-binaries.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const require = createRequire(import.meta.url);
 const bootstrap = async () => {
-    const program = commander;
+    const program = new Command();
     program
         .version(require('../package.json').version, '-v, --version', 'Output the current version.')
         .usage('<command> [options]')
         .helpOption('-h, --help', 'Output usage information.');
-    if ((0, local_binaries_1.localBinExists)()) {
-        const localCommandLoader = (0, local_binaries_1.loadLocalBinCommandLoader)();
+    if (localBinExists()) {
+        const localCommandLoader = loadLocalBinCommandLoader();
         await localCommandLoader.load(program);
     }
     else {
-        await commands_1.CommandLoader.load(program);
+        await CommandLoader.load(program);
     }
-    await commander.parseAsync(process.argv);
+    await program.parseAsync(process.argv);
     if (!process.argv.slice(2).length) {
         program.outputHelp();
     }

package/commands/abstract.command.d.ts

@@ -1,7 +1,7 @@
-import { CommanderStatic } from 'commander';
-import { AbstractAction } from '../actions/abstract.action';
+import { Command } from 'commander';
+import { AbstractAction } from '../actions/abstract.action.js';
 export declare abstract class AbstractCommand {
     protected action: AbstractAction;
     constructor(action: AbstractAction);
-    abstract load(program: CommanderStatic): void;
+    abstract load(program: Command): void;
 }

package/commands/abstract.command.js

@@ -1,9 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AbstractCommand = void 0;
-class AbstractCommand {
+export class AbstractCommand {
+    action;
     constructor(action) {
         this.action = action;
     }
 }
-exports.AbstractCommand = AbstractCommand;

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

package/commands/add.command.js

@@ -1,9 +1,6 @@
-"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>')
@@ -13,24 +10,20 @@ class AddCommand extends abstract_command_1.AbstractCommand {
             .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,16 +1,13 @@
-"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).')
@@ -19,56 +16,30 @@ class BuildCommand extends abstract_command_1.AbstractCommand {
             .option('--preserveWatchOutput', 'Use "preserveWatchOutput" option when using tsc watch mode.')
             .option('--all', 'Build all projects in a monorepo.')
             .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(', ')}`);
+            .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(', ')}`);
                 return;
             }
-            options.push({
-                name: 'builder',
-                value: command.builder,
-            });
-            options.push({
-                name: 'typeCheck',
-                value: command.typeCheck,
-            });
-            options.push({
-                name: 'preserveWatchOutput',
-                value: !!command.preserveWatchOutput &&
-                    !!command.watch &&
+            const context = {
+                apps: apps.length > 0 ? apps : [],
+                config: options.config,
+                webpack: isWebpackEnabled,
+                watch: !!options.watch,
+                watchAssets: !!options.watchAssets,
+                path: options.path,
+                webpackPath: options.webpackPath,
+                builder: options.builder,
+                typeCheck: options.typeCheck,
+                preserveWatchOutput: !!options.preserveWatchOutput &&
+                    !!options.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 });
-            }
-            await this.action.handle(inputs, options);
+                all: !!options.all,
+            };
+            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,27 @@
-"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, GenerateAction, InfoAction, NewAction, StartAction, } 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 { GenerateCommand } from './generate.command.js';
+import { InfoCommand } from './info.command.js';
+import { NewCommand } from './new.command.js';
+import { StartCommand } from './start.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);
+        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);
+        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,13 @@
+export interface BuildCommandContext {
+    apps: string[];
+    config?: string;
+    webpack?: boolean;
+    watch: boolean;
+    watchAssets: boolean;
+    path?: string;
+    webpackPath?: string;
+    builder?: string;
+    typeCheck?: boolean;
+    preserveWatchOutput: boolean;
+    all: boolean;
+}

package/commands/context/build.context.js

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

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

@@ -0,0 +1,15 @@
+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;
+}

package/commands/context/generate.context.js

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

package/commands/context/index.d.ts

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

package/commands/context/index.js

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

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

@@ -0,0 +1,11 @@
+export interface NewCommandContext {
+    name?: string;
+    directory?: string;
+    dryRun: boolean;
+    skipGit: boolean;
+    skipInstall: boolean;
+    packageManager?: string;
+    language: string;
+    collection: string;
+    strict: boolean;
+}

package/commands/context/new.context.js

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

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

@@ -0,0 +1,19 @@
+export interface StartCommandContext {
+    app?: string;
+    config?: string;
+    webpack?: boolean;
+    watch: boolean;
+    watchAssets: boolean;
+    path?: string;
+    webpackPath?: string;
+    builder?: string;
+    typeCheck?: 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/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;