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

package/actions/deploy.action.js

@@ -0,0 +1,51 @@
+import { confirm } from '@inquirer/prompts';
+import { red } from 'ansis';
+import { PackageManagerFactory } from '../lib/package-managers/index.js';
+import { MauRunner } from '../lib/runners/mau.runner.js';
+import { ERROR_PREFIX, INFO_PREFIX, MESSAGES } from '../lib/ui/index.js';
+import { gracefullyExitOnPromptError } from '../lib/utils/gracefully-exit-on-prompt-error.js';
+import { isInteractive } from '../lib/utils/is-interactive.js';
+import { MAU_PACKAGE_NAME, findMauBinary } from '../lib/utils/mau.js';
+import { AbstractAction } from './abstract.action.js';
+const INSTALL_COMMAND = `npm install --save-dev ${MAU_PACKAGE_NAME}`;
+export class DeployAction extends AbstractAction {
+    async handle(context) {
+        const binaryPath = findMauBinary() ?? (await this.installMau());
+        const runner = new MauRunner(binaryPath);
+        // Not collected: mau owns the terminal from here on, so its output and
+        // any prompts it shows must reach the user directly.
+        await runner.run(['deploy', ...context.args].join(' '));
+    }
+    async installMau() {
+        if (!isInteractive()) {
+            console.error(`\n${ERROR_PREFIX} ${MESSAGES.MAU_NOT_INSTALLED_NON_INTERACTIVE(MAU_PACKAGE_NAME, INSTALL_COMMAND)}`);
+            throw new Error(MESSAGES.MAU_INSTALLATION_FAILED(MAU_PACKAGE_NAME));
+        }
+        const shouldInstall = await confirm({
+            message: MESSAGES.MAU_INSTALLATION_QUESTION(MAU_PACKAGE_NAME),
+            default: true,
+        }).catch(gracefullyExitOnPromptError);
+        if (!shouldInstall) {
+            console.error(`\n${ERROR_PREFIX} ${MESSAGES.MAU_INSTALLATION_DECLINED(MAU_PACKAGE_NAME, INSTALL_COMMAND)}`);
+            throw new Error(MESSAGES.MAU_INSTALLATION_FAILED(MAU_PACKAGE_NAME));
+        }
+        console.info(`${INFO_PREFIX} ${MESSAGES.MAU_INSTALLATION_IN_PROGRESS(MAU_PACKAGE_NAME)}`);
+        try {
+            const manager = await PackageManagerFactory.find();
+            await manager.addDevelopment([MAU_PACKAGE_NAME], 'latest');
+        }
+        catch (error) {
+            if (error instanceof Error && error.message) {
+                console.error(red(error.message));
+            }
+            throw new Error(MESSAGES.MAU_INSTALLATION_FAILED(MAU_PACKAGE_NAME));
+        }
+        // Resolve again rather than assuming a path: the package manager decides
+        // where the package physically lands.
+        const binaryPath = findMauBinary();
+        if (!binaryPath) {
+            throw new Error(MESSAGES.MAU_INSTALLATION_FAILED(MAU_PACKAGE_NAME));
+        }
+        return binaryPath;
+    }
+}

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,58 @@ 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, selectedProjectName, specFileSuffixValue);
+            generateSpec = shouldGenerateSpec(configuration, schematic, selectedProjectName, specValue, specPassedAsInput);
+            generateFlat = shouldGenerateFlat(configuration, selectedProjectName, flatValue);
+            generateSpecFileSuffix = getSpecFileSuffix(configuration, selectedProjectName, 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));
+    schematicOptions.push(new SchematicOption('format', context.format));
     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));
+    if (context.type !== undefined)
+        options.push(new SchematicOption('type', context.type));
+    if (context.crud !== undefined)
+        options.push(new SchematicOption('crud', context.crud));
+    // 'schematic', 'spec', 'flat', 'specFileSuffix' are handled separately
     return options;
 };

package/actions/index.d.ts

@@ -1,7 +1,9 @@
-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';
+export * from './deploy.action.js';
+export * from './upgrade.action.js';

package/actions/index.js

@@ -1,23 +1,9 @@
-"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("./abstract.action"), exports);
-__exportStar(require("./build.action"), exports);
-__exportStar(require("./generate.action"), exports);
-__exportStar(require("./info.action"), exports);
-__exportStar(require("./new.action"), exports);
-__exportStar(require("./start.action"), exports);
-__exportStar(require("./add.action"), exports);
+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';
+export * from './deploy.action.js';
+export * from './upgrade.action.js';

package/actions/info.action.d.ts

@@ -1,35 +1,25 @@
-import { AbstractAction } from './abstract.action';
-interface LockfileDependency {
-    version: string;
-}
-interface PackageJsonDependencies {
-    [key: string]: LockfileDependency;
-}
-interface NestDependency {
-    name: string;
-    value: string;
-    packageName: string;
-}
-interface NestDependencyWarnings {
-    [key: string]: Array<NestDependency>;
-}
+import { AbstractAction } from './abstract.action.js';
 export declare class InfoAction extends AbstractAction {
     private manager;
     private warningMessageDependenciesWhiteList;
     handle(): Promise<void>;
     private displayBanner;
     private displaySystemInformation;
-    displayPackageManagerVersion(): Promise<void>;
-    displayNestInformation(): Promise<void>;
-    displayNestInformationFromPackage(): Promise<void>;
-    displayCliVersion(): void;
-    readProjectPackageDependencies(): PackageJsonDependencies;
-    displayNestVersions(dependencies: PackageJsonDependencies): void;
-    displayWarningMessage(nestDependencies: NestDependency[]): void;
-    buildNestVersionsWarningMessage(nestDependencies: NestDependency[]): NestDependencyWarnings;
-    buildNestVersionsMessage(dependencies: PackageJsonDependencies): NestDependency[];
-    collectNestDependencies(dependencies: PackageJsonDependencies): NestDependency[];
-    format(dependencies: NestDependency[]): NestDependency[];
-    rightPad(name: string, length: number): string;
+    private displayPackageManagerVersion;
+    private displayNestInformation;
+    private displayNestInformationFromPackage;
+    private displayCliVersion;
+    private readProjectPackageDependencies;
+    private displayNestVersions;
+    private displayWarningMessage;
+    private buildNestVersionsWarningMessage;
+    private buildNestVersionsMessage;
+    private collectNestDependencies;
+    /**
+     * Reads the installed version of a package, or returns undefined when it
+     * cannot be determined (package not installed, or its "exports" map does
+     * not expose "./package.json" — as with @nestjs/* v12+).
+     */
+    private readInstalledVersion;
+    private format;
 }
-export {};

package/actions/info.action.js

@@ -1,56 +1,57 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InfoAction = void 0;
-const ansis_1 = require("ansis");
-const fs_1 = require("fs");
-const os_1 = require("os");
-const path_1 = require("path");
-const package_managers_1 = require("../lib/package-managers");
-const ui_1 = require("../lib/ui");
-const abstract_action_1 = require("./abstract.action");
-const os_info_utils_1 = require("../lib/utils/os-info.utils");
-class InfoAction extends abstract_action_1.AbstractAction {
-    constructor() {
-        super(...arguments);
-        // Nest dependencies whitelist used to compare the major version
-        this.warningMessageDependenciesWhiteList = [
-            '@nestjs/core',
-            '@nestjs/common',
-            '@nestjs/schematics',
-            '@nestjs/platform-express',
-            '@nestjs/platform-fastify',
-            '@nestjs/platform-socket.io',
-            '@nestjs/platform-ws',
-            '@nestjs/websockets',
-        ];
-    }
+import { blue, bold, green, red, yellow } from 'ansis';
+import { readFileSync } from 'fs';
+import { createRequire } from 'module';
+import { platform, release } from 'os';
+import { join } from 'path';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+import { PackageManagerFactory, } from '../lib/package-managers/index.js';
+import { BANNER, MESSAGES } from '../lib/ui/index.js';
+import osName from '../lib/utils/os-info.utils.js';
+import { AbstractAction } from './abstract.action.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const require = createRequire(import.meta.url);
+export class InfoAction extends AbstractAction {
+    manager;
+    // Nest dependencies whitelist used to compare the major version
+    warningMessageDependenciesWhiteList = [
+        '@nestjs/core',
+        '@nestjs/common',
+        '@nestjs/schematics',
+        '@nestjs/platform-express',
+        '@nestjs/platform-fastify',
+        '@nestjs/platform-socket.io',
+        '@nestjs/platform-ws',
+        '@nestjs/websockets',
+    ];
     async handle() {
-        this.manager = await package_managers_1.PackageManagerFactory.find();
+        this.manager = await PackageManagerFactory.find();
         this.displayBanner();
         await this.displaySystemInformation();
         await this.displayNestInformation();
     }
     displayBanner() {
-        console.info((0, ansis_1.red)(ui_1.BANNER));
+        console.info(red(BANNER));
     }
     async displaySystemInformation() {
-        console.info((0, ansis_1.green) `[System Information]`);
-        console.info('OS Version     :', (0, ansis_1.blue)((0, os_info_utils_1.default)((0, os_1.platform)(), (0, os_1.release)()) + ' ' + (0, os_1.release)()));
-        console.info('NodeJS Version :', (0, ansis_1.blue)(process.version));
+        console.info(green `[System Information]`);
+        console.info('OS Version     :', blue(osName(platform(), release()) + ' ' + release()));
+        console.info('NodeJS Version :', blue(process.version));
         await this.displayPackageManagerVersion();
     }
     async displayPackageManagerVersion() {
         try {
             const version = await this.manager.version();
-            console.info(`${this.manager.name} Version    :`, (0, ansis_1.blue)(version), '\n');
+            console.info(`${this.manager.name} Version    :`, blue(version), '\n');
         }
         catch {
-            console.error(`${this.manager.name} Version    :`, (0, ansis_1.red) `Unknown`, '\n');
+            console.error(`${this.manager.name} Version    :`, red `Unknown`, '\n');
         }
     }
     async displayNestInformation() {
         this.displayCliVersion();
-        console.info((0, ansis_1.green) `[Nest Platform Information]`);
+        console.info(green `[Nest Platform Information]`);
         await this.displayNestInformationFromPackage();
     }
     async displayNestInformationFromPackage() {
@@ -58,17 +59,17 @@ class InfoAction extends abstract_action_1.AbstractAction {
             const dependencies = this.readProjectPackageDependencies();
             this.displayNestVersions(dependencies);
         }
-        catch (err) {
-            console.error((0, ansis_1.red)(ui_1.MESSAGES.NEST_INFORMATION_PACKAGE_MANAGER_FAILED));
+        catch {
+            console.error(red(MESSAGES.NEST_INFORMATION_PACKAGE_MANAGER_FAILED));
         }
     }
     displayCliVersion() {
-        console.info((0, ansis_1.green) `[Nest CLI]`);
-        console.info('Nest CLI Version :', (0, ansis_1.blue)(JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(__dirname, '../package.json')).toString())
+        console.info(green `[Nest CLI]`);
+        console.info('Nest CLI Version :', blue(JSON.parse(readFileSync(join(__dirname, '../package.json')).toString())
             .version), '\n');
     }
     readProjectPackageDependencies() {
-        const buffer = (0, fs_1.readFileSync)((0, path_1.join)(process.cwd(), 'package.json'));
+        const buffer = readFileSync(join(process.cwd(), 'package.json'));
         const pack = JSON.parse(buffer.toString());
         const dependencies = { ...pack.dependencies, ...pack.devDependencies };
         Object.keys(dependencies).forEach((key) => {
@@ -80,7 +81,15 @@ class InfoAction extends abstract_action_1.AbstractAction {
     }
     displayNestVersions(dependencies) {
         const nestDependencies = this.buildNestVersionsMessage(dependencies);
-        nestDependencies.forEach((dependency) => console.info(dependency.name, (0, ansis_1.blue)(dependency.value)));
+        if (nestDependencies.length === 0) {
+            // No @nestjs/* packages declared in this package.json. Surfacing this
+            // explicitly is much more useful than letting `format([])` throw and
+            // showing the generic "cannot read your project package.json" error,
+            // which is misleading when the file was actually read successfully.
+            console.info('No @nestjs/* dependencies were found in package.json.');
+            return;
+        }
+        nestDependencies.forEach((dependency) => console.info(dependency.name, blue(dependency.value)));
         this.displayWarningMessage(nestDependencies);
     }
     displayWarningMessage(nestDependencies) {
@@ -89,11 +98,11 @@ class InfoAction extends abstract_action_1.AbstractAction {
             const majorVersions = Object.keys(warnings);
             if (majorVersions.length > 0) {
                 console.info('\r');
-                console.info((0, ansis_1.yellow) `[Warnings]`);
+                console.info(yellow `[Warnings]`);
                 console.info('The following packages are not in the same major version');
                 console.info('This could lead to runtime errors');
                 majorVersions.forEach((version) => {
-                    console.info((0, ansis_1.bold) `* Under version ${version}`);
+                    console.info(bold `* Under version ${version}`);
                     warnings[version].forEach(({ packageName, value }) => {
                         console.info(`- ${packageName} ${value}`);
                     });
@@ -102,7 +111,7 @@ class InfoAction extends abstract_action_1.AbstractAction {
         }
         catch {
             console.info('\t');
-            console.error((0, ansis_1.red)(ui_1.MESSAGES.NEST_INFORMATION_PACKAGE_WARNING_FAILED(this.warningMessageDependenciesWhiteList)));
+            console.error(red(MESSAGES.NEST_INFORMATION_PACKAGE_WARNING_FAILED(this.warningMessageDependenciesWhiteList)));
         }
     }
     buildNestVersionsWarningMessage(nestDependencies) {
@@ -145,37 +154,48 @@ class InfoAction extends abstract_action_1.AbstractAction {
         const nestDependencies = [];
         Object.keys(dependencies).forEach((key) => {
             if (key.indexOf('@nestjs') > -1) {
-                const depPackagePath = require.resolve(key + '/package.json', {
-                    paths: [process.cwd()],
-                });
-                const depPackage = (0, fs_1.readFileSync)(depPackagePath).toString();
-                const value = JSON.parse(depPackage).version;
                 nestDependencies.push({
                     name: `${key.replace(/@nestjs\//, '').replace(/@.*/, '')} version`,
-                    value: value || dependencies[key].version,
+                    value: this.readInstalledVersion(key) ?? dependencies[key].version,
                     packageName: key,
                 });
             }
         });
         return nestDependencies;
     }
+    /**
+     * Reads the installed version of a package, or returns undefined when it
+     * cannot be determined (package not installed, or its "exports" map does
+     * not expose "./package.json" — as with @nestjs/* v12+).
+     */
+    readInstalledVersion(packageName) {
+        let depPackagePath;
+        try {
+            depPackagePath = require.resolve(packageName + '/package.json', {
+                paths: [process.cwd()],
+            });
+        }
+        catch {
+            depPackagePath = join(process.cwd(), 'node_modules', packageName, 'package.json');
+        }
+        try {
+            return JSON.parse(readFileSync(depPackagePath).toString()).version;
+        }
+        catch {
+            return undefined;
+        }
+    }
     format(dependencies) {
+        if (dependencies.length === 0) {
+            return dependencies;
+        }
         const sorted = dependencies.sort((dependencyA, dependencyB) => dependencyB.name.length - dependencyA.name.length);
         const length = sorted[0].name.length;
         sorted.forEach((dependency) => {
-            if (dependency.name.length < length) {
-                dependency.name = this.rightPad(dependency.name, length);
-            }
+            dependency.name = dependency.name.padEnd(length);
             dependency.name = dependency.name.concat(' :');
-            dependency.value = dependency.value.replace(/(\^|\~)/, '');
+            dependency.value = dependency.value.replace(/([\^~])/, '');
         });
         return sorted;
     }
-    rightPad(name, length) {
-        while (name.length < length) {
-            name = name.concat(' ');
-        }
-        return name;
-    }
 }
-exports.InfoAction = InfoAction;

package/actions/new.action.d.ts

@@ -1,7 +1,7 @@
-import { Input } from '../commands';
-import { AbstractAction } from './abstract.action';
+import { NewCommandContext } from '../commands/index.js';
+import { AbstractAction } from './abstract.action.js';
 export declare class NewAction extends AbstractAction {
-    handle(inputs: Input[], options: Input[]): Promise<void>;
+    handle(context: NewCommandContext): Promise<void>;
 }
 export declare const retrieveCols: () => number;
 export declare const exit: () => never;