@nestjs/cli 11.0.16 → 12.0.0-alpha.0

package/actions/abstract.action.d.ts

@@ -1,4 +1,3 @@
-import { Input } from '../commands';
 export declare abstract class AbstractAction {
-    abstract handle(inputs?: Input[], options?: Input[], extraFlags?: string[]): Promise<void>;
+    abstract handle(context?: any): Promise<void>;
 }

package/actions/abstract.action.js

@@ -1,6 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AbstractAction = void 0;
-class AbstractAction {
+export class AbstractAction {
 }
-exports.AbstractAction = AbstractAction;

package/actions/add.action.d.ts

@@ -1,11 +1,10 @@
-import { Input } from '../commands';
-import { AbstractAction } from './abstract.action';
+import { AddCommandContext } from '../commands/index.js';
+import { AbstractAction } from './abstract.action.js';
 export declare class AddAction extends AbstractAction {
-    handle(inputs: Input[], options: Input[], extraFlags: string[]): Promise<void>;
+    handle(context: AddCommandContext): Promise<void>;
     private getSourceRoot;
     private installPackage;
     private addLibrary;
-    private getLibraryName;
     private getPackageName;
     private getCollectionName;
     private getTagName;

package/actions/add.action.js

@@ -1,42 +1,36 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AddAction = void 0;
-const ansis_1 = require("ansis");
-const get_value_or_default_1 = require("../lib/compiler/helpers/get-value-or-default");
-const package_managers_1 = require("../lib/package-managers");
-const schematics_1 = require("../lib/schematics");
-const ui_1 = require("../lib/ui");
-const load_configuration_1 = require("../lib/utils/load-configuration");
-const project_utils_1 = require("../lib/utils/project-utils");
-const abstract_action_1 = require("./abstract.action");
+import { red } from 'ansis';
+import { getValueOrDefault } from '../lib/compiler/helpers/get-value-or-default.js';
+import { PackageManagerFactory, } from '../lib/package-managers/index.js';
+import { CollectionFactory, SchematicOption, } from '../lib/schematics/index.js';
+import { MESSAGES } from '../lib/ui/index.js';
+import { loadConfiguration } from '../lib/utils/load-configuration.js';
+import { askForProjectName, moveDefaultProjectToStart, shouldAskForProject, } from '../lib/utils/project-utils.js';
+import { AbstractAction } from './abstract.action.js';
 const schematicName = 'nest-add';
-class AddAction extends abstract_action_1.AbstractAction {
-    async handle(inputs, options, extraFlags) {
-        const libraryName = this.getLibraryName(inputs);
+export class AddAction extends AbstractAction {
+    async handle(context) {
+        const libraryName = context.library;
         const packageName = this.getPackageName(libraryName);
         const collectionName = this.getCollectionName(libraryName, packageName);
         const tagName = this.getTagName(packageName);
-        const skipInstall = (0, project_utils_1.hasValidOptionFlag)('skip-install', options);
-        const packageInstallSuccess = skipInstall || (await this.installPackage(collectionName, tagName));
+        const packageInstallSuccess = context.skipInstall ||
+            (await this.installPackage(collectionName, tagName));
         if (packageInstallSuccess) {
-            const sourceRootOption = await this.getSourceRoot(inputs.concat(options));
-            options.push(sourceRootOption);
-            await this.addLibrary(collectionName, options, extraFlags);
+            const sourceRoot = await this.getSourceRoot(context.project);
+            await this.addLibrary(collectionName, sourceRoot, context.extraFlags);
         }
         else {
-            console.error((0, ansis_1.red)(ui_1.MESSAGES.LIBRARY_INSTALLATION_FAILED_BAD_PACKAGE(libraryName)));
-            throw new Error(ui_1.MESSAGES.LIBRARY_INSTALLATION_FAILED_BAD_PACKAGE(libraryName));
+            console.error(red(MESSAGES.LIBRARY_INSTALLATION_FAILED_BAD_PACKAGE(libraryName)));
+            throw new Error(MESSAGES.LIBRARY_INSTALLATION_FAILED_BAD_PACKAGE(libraryName));
         }
     }
-    async getSourceRoot(inputs) {
-        const configuration = await (0, load_configuration_1.loadConfiguration)();
+    async getSourceRoot(project) {
+        const configuration = await loadConfiguration();
         const configurationProjects = configuration.projects;
-        const appName = inputs.find((option) => option.name === 'project')
-            .value;
-        let sourceRoot = appName
-            ? (0, get_value_or_default_1.getValueOrDefault)(configuration, 'sourceRoot', appName)
+        let sourceRoot = project
+            ? getValueOrDefault(configuration, 'sourceRoot', project)
             : configuration.sourceRoot;
-        const shouldAsk = (0, project_utils_1.shouldAskForProject)(schematicName, configurationProjects, appName);
+        const shouldAsk = shouldAskForProject(schematicName, configurationProjects, project ?? '');
         if (shouldAsk) {
             const defaultLabel = ' [ Default ]';
             let defaultProjectName = configuration.sourceRoot + defaultLabel;
@@ -47,52 +41,45 @@ class AddAction extends abstract_action_1.AbstractAction {
                     break;
                 }
             }
-            const projects = (0, project_utils_1.moveDefaultProjectToStart)(configuration, defaultProjectName, defaultLabel);
-            const selectedProject = (await (0, project_utils_1.askForProjectName)(ui_1.MESSAGES.LIBRARY_PROJECT_SELECTION_QUESTION, projects));
-            const project = selectedProject.replace(defaultLabel, '');
-            if (project !== configuration.sourceRoot) {
-                sourceRoot = configurationProjects[project].sourceRoot;
+            const projects = moveDefaultProjectToStart(configuration, defaultProjectName, defaultLabel);
+            const selectedProject = (await askForProjectName(MESSAGES.LIBRARY_PROJECT_SELECTION_QUESTION, projects));
+            const projectName = selectedProject.replace(defaultLabel, '');
+            if (projectName !== configuration.sourceRoot) {
+                sourceRoot = configurationProjects[projectName].sourceRoot;
             }
         }
-        return { name: 'sourceRoot', value: sourceRoot };
+        return sourceRoot;
     }
     async installPackage(collectionName, tagName) {
-        const manager = await package_managers_1.PackageManagerFactory.find();
+        const manager = await PackageManagerFactory.find();
         tagName = tagName || 'latest';
         let installResult = false;
         try {
             installResult = await manager.addProduction([collectionName], tagName);
         }
         catch (error) {
-            if (error && error.message) {
-                console.error((0, ansis_1.red)(error.message));
+            if (error instanceof Error) {
+                console.error(red(error.message));
             }
         }
         return installResult;
     }
-    async addLibrary(collectionName, options, extraFlags) {
-        console.info(ui_1.MESSAGES.LIBRARY_INSTALLATION_STARTS);
+    async addLibrary(collectionName, sourceRoot, extraFlags) {
+        console.info(MESSAGES.LIBRARY_INSTALLATION_STARTS);
         const schematicOptions = [];
-        schematicOptions.push(new schematics_1.SchematicOption('sourceRoot', options.find((option) => option.name === 'sourceRoot').value));
+        schematicOptions.push(new SchematicOption('sourceRoot', sourceRoot));
         const extraFlagsString = extraFlags ? extraFlags.join(' ') : undefined;
         try {
-            const collection = schematics_1.CollectionFactory.create(collectionName);
+            const collection = CollectionFactory.create(collectionName);
             await collection.execute(schematicName, schematicOptions, extraFlagsString);
         }
         catch (error) {
-            if (error && error.message) {
-                console.error((0, ansis_1.red)(error.message));
-                return Promise.reject();
+            if (error instanceof Error) {
+                console.error(red(error.message));
             }
+            throw error;
         }
     }
-    getLibraryName(inputs) {
-        const libraryInput = inputs.find((input) => input.name === 'library');
-        if (!libraryInput) {
-            throw new Error('No library found in command input');
-        }
-        return libraryInput.value;
-    }
     getPackageName(library) {
         return library.startsWith('@')
             ? library.split('/', 2).join('/')
@@ -110,4 +97,3 @@ class AddAction extends abstract_action_1.AbstractAction {
             : packageName.split('@', 2)[1];
     }
 }
-exports.AddAction = AddAction;

package/actions/build.action.d.ts

@@ -1,11 +1,10 @@
-import { Input } from '../commands';
-import { AssetsManager } from '../lib/compiler/assets-manager';
-import { TsConfigProvider } from '../lib/compiler/helpers/tsconfig-provider';
-import { PluginsLoader } from '../lib/compiler/plugins/plugins-loader';
-import { TypeScriptBinaryLoader } from '../lib/compiler/typescript-loader';
-import { ConfigurationLoader } from '../lib/configuration';
-import { FileSystemReader } from '../lib/readers';
-import { AbstractAction } from './abstract.action';
+import { AssetsManager } from '../lib/compiler/assets-manager.js';
+import { TsConfigProvider } from '../lib/compiler/helpers/tsconfig-provider.js';
+import { PluginsLoader } from '../lib/compiler/plugins/plugins-loader.js';
+import { TypeScriptBinaryLoader } from '../lib/compiler/typescript-loader.js';
+import { ConfigurationLoader } from '../lib/configuration/index.js';
+import { FileSystemReader } from '../lib/readers/index.js';
+import { AbstractAction } from './abstract.action.js';
 export declare class BuildAction extends AbstractAction {
     protected readonly pluginsLoader: PluginsLoader;
     protected readonly tsLoader: TypeScriptBinaryLoader;
@@ -13,10 +12,12 @@ export declare class BuildAction extends AbstractAction {
     protected readonly fileSystemReader: FileSystemReader;
     protected readonly loader: ConfigurationLoader;
     protected readonly assetsManager: AssetsManager;
-    handle(commandInputs: Input[], commandOptions: Input[]): Promise<void>;
-    runBuild(commandInputs: Input[], commandOptions: Input[], watchMode: boolean, watchAssetsMode: boolean, isDebugEnabled?: boolean, onSuccess?: () => void): Promise<void>;
+    handle(context: any): Promise<void>;
+    runBuild(apps: (string | undefined)[], options: Record<string, any>, watchMode: boolean, watchAssetsMode: boolean, isDebugEnabled?: boolean, onSuccess?: () => void): Promise<void>;
     private runSwc;
     private runWebpack;
     private runTsc;
     private getWebpackConfigFactoryByPath;
+    private runRspack;
+    private getRspackConfigFactoryByPath;
 }

package/actions/build.action.js

@@ -1,118 +1,110 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BuildAction = void 0;
-const ansis_1 = require("ansis");
-const path_1 = require("path");
-const assets_manager_1 = require("../lib/compiler/assets-manager");
-const delete_out_dir_1 = require("../lib/compiler/helpers/delete-out-dir");
-const get_builder_1 = require("../lib/compiler/helpers/get-builder");
-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 get_webpack_config_path_1 = require("../lib/compiler/helpers/get-webpack-config-path");
-const tsconfig_provider_1 = require("../lib/compiler/helpers/tsconfig-provider");
-const plugins_loader_1 = require("../lib/compiler/plugins/plugins-loader");
-const typescript_loader_1 = require("../lib/compiler/typescript-loader");
-const configuration_1 = require("../lib/configuration");
-const defaults_1 = require("../lib/configuration/defaults");
-const readers_1 = require("../lib/readers");
-const ui_1 = require("../lib/ui");
-const is_module_available_1 = require("../lib/utils/is-module-available");
-const abstract_action_1 = require("./abstract.action");
-class BuildAction extends abstract_action_1.AbstractAction {
-    constructor() {
-        super(...arguments);
-        this.pluginsLoader = new plugins_loader_1.PluginsLoader();
-        this.tsLoader = new typescript_loader_1.TypeScriptBinaryLoader();
-        this.tsConfigProvider = new tsconfig_provider_1.TsConfigProvider(this.tsLoader);
-        this.fileSystemReader = new readers_1.FileSystemReader(process.cwd());
-        this.loader = new configuration_1.NestConfigurationLoader(this.fileSystemReader);
-        this.assetsManager = new assets_manager_1.AssetsManager();
-    }
-    async handle(commandInputs, commandOptions) {
+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';
+import { getRspackConfigPath } from '../lib/compiler/helpers/get-rspack-config-path.js';
+import { getTscConfigPath } from '../lib/compiler/helpers/get-tsc-config.path.js';
+import { getValueOrDefault } from '../lib/compiler/helpers/get-value-or-default.js';
+import { getWebpackConfigPath } from '../lib/compiler/helpers/get-webpack-config-path.js';
+import { TsConfigProvider } from '../lib/compiler/helpers/tsconfig-provider.js';
+import { PluginsLoader } from '../lib/compiler/plugins/plugins-loader.js';
+import { TypeScriptBinaryLoader } from '../lib/compiler/typescript-loader.js';
+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 { AbstractAction } from './abstract.action.js';
+const require = createRequire(import.meta.url);
+export class BuildAction extends AbstractAction {
+    pluginsLoader = new PluginsLoader();
+    tsLoader = new TypeScriptBinaryLoader();
+    tsConfigProvider = new TsConfigProvider(this.tsLoader);
+    fileSystemReader = new FileSystemReader(process.cwd());
+    loader = new NestConfigurationLoader(this.fileSystemReader);
+    assetsManager = new AssetsManager();
+    async handle(context) {
+        const { apps, watch, watchAssets } = context;
         try {
-            const watchModeOption = commandOptions.find((option) => option.name === 'watch');
-            const watchMode = !!(watchModeOption && watchModeOption.value);
-            const watchAssetsModeOption = commandOptions.find((option) => option.name === 'watchAssets');
-            const watchAssetsMode = !!(watchAssetsModeOption && watchAssetsModeOption.value);
-            await this.runBuild(commandInputs, commandOptions, watchMode, watchAssetsMode);
+            await this.runBuild(apps, context, watch, watchAssets);
         }
         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`);
             }
             process.exit(1);
         }
     }
-    async runBuild(commandInputs, commandOptions, watchMode, watchAssetsMode, isDebugEnabled = false, onSuccess) {
-        const configFileName = commandOptions.find((option) => option.name === 'config').value;
+    async runBuild(apps, options, watchMode, watchAssetsMode, isDebugEnabled = false, onSuccess) {
+        const configFileName = options.config;
         const configuration = await this.loader.load(configFileName);
-        const buildAll = commandOptions.find((opt) => opt.name === 'all')?.value;
         let appNames;
-        if (buildAll) {
-            // If the "all" flag is set, we need to build all projects in a monorepo.
+        if (options.all) {
             appNames = [];
             if (configuration.projects) {
                 appNames.push(...Object.keys(configuration.projects));
             }
         }
         else {
-            appNames = commandInputs
-                .filter((input) => input.name === 'app')
-                .map((input) => input.value);
+            appNames = apps;
         }
         if (appNames.length === 0) {
-            // If there are no projects, use "undefined" to build the default project.
             appNames.push(undefined);
         }
         for (const appName of appNames) {
-            const pathToTsconfig = (0, get_tsc_config_path_1.getTscConfigPath)(configuration, commandOptions, appName);
+            const pathToTsconfig = getTscConfigPath(configuration, options, appName);
             const { options: tsOptions } = this.tsConfigProvider.getByConfigFilename(pathToTsconfig);
-            const outDir = tsOptions.outDir || defaults_1.defaultOutDir;
-            const isWebpackEnabled = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'compilerOptions.webpack', appName, 'webpack', commandOptions);
+            const outDir = tsOptions.outDir || defaultOutDir;
+            const isWebpackEnabled = getValueOrDefault(configuration, 'compilerOptions.webpack', appName, 'webpack', options);
             const builder = isWebpackEnabled
                 ? { type: 'webpack' }
-                : (0, get_builder_1.getBuilder)(configuration, commandOptions, appName);
-            await (0, delete_out_dir_1.deleteOutDirIfEnabled)(configuration, appName, outDir);
+                : getBuilder(configuration, options, appName);
+            await deleteOutDirIfEnabled(configuration, appName, outDir);
             this.assetsManager.copyAssets(configuration, appName, outDir, watchAssetsMode);
-            const typeCheck = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'compilerOptions.typeCheck', appName, 'typeCheck', commandOptions);
+            const typeCheck = getValueOrDefault(configuration, 'compilerOptions.typeCheck', appName, 'typeCheck', options);
             if (typeCheck && builder.type !== 'swc') {
-                console.warn(ui_1.INFO_PREFIX +
+                console.warn(INFO_PREFIX +
                     ` "typeCheck" will not have any effect when "builder" is not "swc".`);
             }
             switch (builder.type) {
                 case 'tsc':
-                    await this.runTsc(watchMode, commandOptions, configuration, pathToTsconfig, appName, onSuccess);
+                    await this.runTsc(watchMode, options, configuration, pathToTsconfig, appName, onSuccess);
                     break;
                 case 'webpack':
-                    await this.runWebpack(configuration, appName, commandOptions, pathToTsconfig, isDebugEnabled, watchMode, onSuccess);
+                    await this.runWebpack(configuration, appName, options, pathToTsconfig, isDebugEnabled, watchMode, onSuccess);
+                    break;
+                case 'rspack':
+                    await this.runRspack(configuration, appName, options, pathToTsconfig, isDebugEnabled, watchMode, onSuccess);
                     break;
                 case 'swc':
-                    await this.runSwc(configuration, appName, pathToTsconfig, watchMode, commandOptions, tsOptions, onSuccess);
+                    await this.runSwc(configuration, appName, pathToTsconfig, watchMode, options, tsOptions, onSuccess);
                     break;
             }
         }
     }
     async runSwc(configuration, appName, pathToTsconfig, watchMode, options, tsOptions, onSuccess) {
-        const { SwcCompiler } = await Promise.resolve().then(() => require('../lib/compiler/swc/swc-compiler'));
+        const { SwcCompiler } = await import('../lib/compiler/swc/swc-compiler.js');
         const swc = new SwcCompiler(this.pluginsLoader);
         await swc.run(configuration, pathToTsconfig, appName, {
             watch: watchMode,
-            typeCheck: (0, get_value_or_default_1.getValueOrDefault)(configuration, 'compilerOptions.typeCheck', appName, 'typeCheck', options),
+            typeCheck: getValueOrDefault(configuration, 'compilerOptions.typeCheck', appName, 'typeCheck', options),
             tsOptions,
             assetsManager: this.assetsManager,
         }, onSuccess);
     }
-    async runWebpack(configuration, appName, commandOptions, pathToTsconfig, debug, watchMode, onSuccess) {
-        const { WebpackCompiler } = await Promise.resolve().then(() => require('../lib/compiler/webpack-compiler'));
+    async runWebpack(configuration, appName, options, pathToTsconfig, debug, watchMode, onSuccess) {
+        const { WebpackCompiler } = await import('../lib/compiler/webpack-compiler.js');
         const webpackCompiler = new WebpackCompiler(this.pluginsLoader);
-        const webpackPath = (0, get_webpack_config_path_1.getWebpackConfigPath)(configuration, commandOptions, appName) ??
-            defaults_1.defaultWebpackConfigFilename;
-        const webpackConfigFactoryOrConfig = this.getWebpackConfigFactoryByPath(webpackPath, defaults_1.defaultWebpackConfigFilename);
+        const webpackPath = getWebpackConfigPath(configuration, options, appName) ??
+            defaultWebpackConfigFilename;
+        const webpackConfigFactoryOrConfig = this.getWebpackConfigFactoryByPath(webpackPath, defaultWebpackConfigFilename);
         return webpackCompiler.run(configuration, pathToTsconfig, appName, {
-            inputs: commandOptions,
+            options,
             webpackConfigFactoryOrConfig,
             debug,
             watchMode,
@@ -121,25 +113,46 @@ class BuildAction extends abstract_action_1.AbstractAction {
     }
     async runTsc(watchMode, options, configuration, pathToTsconfig, appName, onSuccess) {
         if (watchMode) {
-            const { WatchCompiler } = await Promise.resolve().then(() => require('../lib/compiler/watch-compiler'));
+            const { WatchCompiler } = await import('../lib/compiler/watch-compiler.js');
             const watchCompiler = new WatchCompiler(this.pluginsLoader, this.tsConfigProvider, this.tsLoader);
-            const isPreserveWatchOutputEnabled = options.find((option) => option.name === 'preserveWatchOutput' && option.value === true)?.value;
+            const isPreserveWatchOutputEnabled = !!options.preserveWatchOutput;
             watchCompiler.run(configuration, pathToTsconfig, appName, { preserveWatchOutput: isPreserveWatchOutputEnabled }, onSuccess);
         }
         else {
-            const { Compiler } = await Promise.resolve().then(() => require('../lib/compiler/compiler'));
+            const { Compiler } = await import('../lib/compiler/compiler.js');
             const compiler = new Compiler(this.pluginsLoader, this.tsConfigProvider, this.tsLoader);
             compiler.run(configuration, pathToTsconfig, appName, undefined, onSuccess);
             this.assetsManager.closeWatchers();
         }
     }
     getWebpackConfigFactoryByPath(webpackPath, defaultPath) {
-        const pathToWebpackFile = (0, path_1.join)(process.cwd(), webpackPath);
-        const isWebpackFileAvailable = (0, is_module_available_1.isModuleAvailable)(pathToWebpackFile);
+        const pathToWebpackFile = join(process.cwd(), webpackPath);
+        const isWebpackFileAvailable = isModuleAvailable(pathToWebpackFile);
         if (!isWebpackFileAvailable && webpackPath === defaultPath) {
-            return ({}) => ({});
+            return (_config) => ({});
         }
         return require(pathToWebpackFile);
     }
+    async runRspack(configuration, appName, options, pathToTsconfig, debug, watchMode, onSuccess) {
+        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);
+        return rspackCompiler.run(configuration, pathToTsconfig, appName, {
+            options,
+            rspackConfigFactoryOrConfig,
+            debug,
+            watchMode,
+            assetsManager: this.assetsManager,
+        }, onSuccess);
+    }
+    getRspackConfigFactoryByPath(rspackPath, defaultPath) {
+        const pathToRspackFile = join(process.cwd(), rspackPath);
+        const isRspackFileAvailable = isModuleAvailable(pathToRspackFile);
+        if (!isRspackFileAvailable && rspackPath === defaultPath) {
+            return (_config) => ({});
+        }
+        return require(pathToRspackFile);
+    }
 }
-exports.BuildAction = BuildAction;

package/actions/generate.action.d.ts

@@ -1,5 +1,5 @@
-import { Input } from '../commands';
-import { AbstractAction } from './abstract.action';
+import { GenerateCommandContext } from '../commands/index.js';
+import { AbstractAction } from './abstract.action.js';
 export declare class GenerateAction extends AbstractAction {
-    handle(inputs: Input[], options: Input[]): Promise<void>;
+    handle(context: GenerateCommandContext): Promise<void>;
 }

package/actions/generate.action.js

@@ -1,48 +1,39 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GenerateAction = void 0;
-const ansis_1 = require("ansis");
-const path = require("path");
-const get_value_or_default_1 = require("../lib/compiler/helpers/get-value-or-default");
-const schematics_1 = require("../lib/schematics");
-const ui_1 = require("../lib/ui");
-const load_configuration_1 = require("../lib/utils/load-configuration");
-const project_utils_1 = require("../lib/utils/project-utils");
-const abstract_action_1 = require("./abstract.action");
-const type_assertions_1 = require("../lib/utils/type-assertions");
-class GenerateAction extends abstract_action_1.AbstractAction {
-    async handle(inputs, options) {
-        await generateFiles(inputs.concat(options));
+import { red } from 'ansis';
+import * as path from 'path';
+import { getValueOrDefault } from '../lib/compiler/helpers/get-value-or-default.js';
+import { Collection, CollectionFactory, SchematicOption, } from '../lib/schematics/index.js';
+import { MESSAGES } from '../lib/ui/index.js';
+import { loadConfiguration } from '../lib/utils/load-configuration.js';
+import { askForProjectName, getSpecFileSuffix, moveDefaultProjectToStart, shouldAskForProject, shouldGenerateFlat, shouldGenerateSpec, } from '../lib/utils/project-utils.js';
+import { AbstractAction } from './abstract.action.js';
+export class GenerateAction extends AbstractAction {
+    async handle(context) {
+        await generateFiles(context);
     }
 }
-exports.GenerateAction = GenerateAction;
-const generateFiles = async (inputs) => {
-    const configuration = await (0, load_configuration_1.loadConfiguration)();
-    const collectionOption = inputs.find((option) => option.name === 'collection').value;
-    const schematic = inputs.find((option) => option.name === 'schematic')
-        .value;
-    const appName = inputs.find((option) => option.name === 'project')
-        .value;
-    const spec = inputs.find((option) => option.name === 'spec');
-    const flat = inputs.find((option) => option.name === 'flat');
-    const specFileSuffix = inputs.find((option) => option.name === 'specFileSuffix');
-    const collection = schematics_1.CollectionFactory.create(collectionOption || configuration.collection || schematics_1.Collection.NESTJS);
-    const schematicOptions = mapSchematicOptions(inputs);
-    schematicOptions.push(new schematics_1.SchematicOption('language', configuration.language));
+const generateFiles = async (context) => {
+    const configuration = await loadConfiguration();
+    const collectionOption = context.collection;
+    const schematic = context.schematic;
+    const appName = context.project ?? '';
+    const specFileSuffix = context.specFileSuffix;
+    const collection = CollectionFactory.create(collectionOption || configuration.collection || Collection.NESTJS);
+    const schematicOptions = mapContextToSchematicOptions(context);
+    schematicOptions.push(new SchematicOption('language', configuration.language));
     const configurationProjects = configuration.projects;
     let sourceRoot = appName
-        ? (0, get_value_or_default_1.getValueOrDefault)(configuration, 'sourceRoot', appName)
+        ? getValueOrDefault(configuration, 'sourceRoot', appName)
         : configuration.sourceRoot;
-    const specValue = spec.value;
-    const flatValue = !!flat?.value;
-    const specFileSuffixValue = specFileSuffix.value;
-    const specOptions = spec.options;
-    let generateSpec = (0, project_utils_1.shouldGenerateSpec)(configuration, schematic, appName, specValue, specOptions.passedAsInput);
-    let generateFlat = (0, project_utils_1.shouldGenerateFlat)(configuration, appName, flatValue);
-    let generateSpecFileSuffix = (0, project_utils_1.getSpecFileSuffix)(configuration, appName, specFileSuffixValue);
+    const specValue = typeof context.spec === 'boolean' ? context.spec : context.spec.value;
+    const specPassedAsInput = typeof context.spec === 'boolean' ? false : context.spec.passedAsInput;
+    const flatValue = context.flat !== undefined ? !!context.flat : false;
+    const specFileSuffixValue = specFileSuffix;
+    let generateSpec = shouldGenerateSpec(configuration, schematic, appName, specValue, specPassedAsInput);
+    let generateFlat = shouldGenerateFlat(configuration, appName, flatValue);
+    let generateSpecFileSuffix = getSpecFileSuffix(configuration, appName, specFileSuffixValue);
     // If you only add a `lib` we actually don't have monorepo: true BUT we do have "projects"
     // Ensure we don't run for new app/libs schematics
-    if ((0, project_utils_1.shouldAskForProject)(schematic, configurationProjects, appName)) {
+    if (shouldAskForProject(schematic, configurationProjects, appName)) {
         const defaultLabel = ' [ Default ]';
         let defaultProjectName = configuration.sourceRoot + defaultLabel;
         for (const property in configurationProjects) {
@@ -51,47 +42,53 @@ const generateFiles = async (inputs) => {
                 break;
             }
         }
-        const projects = (0, project_utils_1.moveDefaultProjectToStart)(configuration, defaultProjectName, defaultLabel);
-        const selectedProjectName = (await (0, project_utils_1.askForProjectName)(ui_1.MESSAGES.PROJECT_SELECTION_QUESTION, projects));
+        const projects = moveDefaultProjectToStart(configuration, defaultProjectName, defaultLabel);
+        const selectedProjectName = (await askForProjectName(MESSAGES.PROJECT_SELECTION_QUESTION, projects));
         const project = selectedProjectName.replace(defaultLabel, '');
         if (project !== configuration.sourceRoot) {
             sourceRoot = configurationProjects[project].sourceRoot;
         }
         if (selectedProjectName !== defaultProjectName) {
             // Only overwrite if the appName is not the default- as it has already been loaded above
-            generateSpec = (0, project_utils_1.shouldGenerateSpec)(configuration, schematic, selectedProjectName, specValue, specOptions.passedAsInput);
-            generateFlat = (0, project_utils_1.shouldGenerateFlat)(configuration, selectedProjectName, flatValue);
-            generateSpecFileSuffix = (0, project_utils_1.getSpecFileSuffix)(configuration, appName, specFileSuffixValue);
+            generateSpec = shouldGenerateSpec(configuration, schematic, selectedProjectName, specValue, specPassedAsInput);
+            generateFlat = shouldGenerateFlat(configuration, selectedProjectName, flatValue);
+            generateSpecFileSuffix = getSpecFileSuffix(configuration, appName, specFileSuffixValue);
         }
     }
     if (configuration.generateOptions?.baseDir) {
         sourceRoot = path.join(sourceRoot, configuration.generateOptions.baseDir);
     }
-    schematicOptions.push(new schematics_1.SchematicOption('sourceRoot', sourceRoot));
-    schematicOptions.push(new schematics_1.SchematicOption('spec', generateSpec));
-    schematicOptions.push(new schematics_1.SchematicOption('flat', generateFlat));
-    schematicOptions.push(new schematics_1.SchematicOption('specFileSuffix', generateSpecFileSuffix));
+    schematicOptions.push(new SchematicOption('sourceRoot', sourceRoot));
+    schematicOptions.push(new SchematicOption('spec', generateSpec));
+    schematicOptions.push(new SchematicOption('flat', generateFlat));
+    schematicOptions.push(new SchematicOption('specFileSuffix', generateSpecFileSuffix));
     try {
-        const schematicInput = inputs.find((input) => input.name === 'schematic');
-        if (!schematicInput) {
+        if (!schematic) {
             throw new Error('Unable to find a schematic for this configuration');
         }
-        await collection.execute(schematicInput.value, schematicOptions);
+        await collection.execute(schematic, schematicOptions);
     }
     catch (error) {
         if (error && error.message) {
-            console.error((0, ansis_1.red)(error.message));
+            console.error(red(error.message));
         }
     }
 };
-const mapSchematicOptions = (inputs) => {
-    const excludedInputNames = ['schematic', 'spec', 'flat', 'specFileSuffix'];
+const mapContextToSchematicOptions = (context) => {
     const options = [];
-    inputs.forEach((input) => {
-        if (!excludedInputNames.includes(input.name) && input.value !== undefined) {
-            (0, type_assertions_1.assertNonArray)(input.value);
-            options.push(new schematics_1.SchematicOption(input.name, input.value));
-        }
-    });
+    // Only include fields that schematics expect; exclude those handled separately
+    if (context.name !== undefined)
+        options.push(new SchematicOption('name', context.name));
+    if (context.path !== undefined)
+        options.push(new SchematicOption('path', context.path));
+    if (context.dryRun)
+        options.push(new SchematicOption('dry-run', true));
+    if (context.collection !== undefined)
+        options.push(new SchematicOption('collection', context.collection));
+    if (context.project !== undefined)
+        options.push(new SchematicOption('project', context.project));
+    if (context.skipImport !== undefined)
+        options.push(new SchematicOption('skipImport', context.skipImport));
+    // 'schematic', 'spec', 'flat', 'specFileSuffix' are handled separately
     return options;
 };

package/actions/index.d.ts

@@ -1,7 +1,7 @@
-export * from './abstract.action';
-export * from './build.action';
-export * from './generate.action';
-export * from './info.action';
-export * from './new.action';
-export * from './start.action';
-export * from './add.action';
+export * from './abstract.action.js';
+export * from './build.action.js';
+export * from './generate.action.js';
+export * from './info.action.js';
+export * from './new.action.js';
+export * from './start.action.js';
+export * from './add.action.js';