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

package/lib/compiler/helpers/glob.js

@@ -0,0 +1,185 @@
+/**
+ * A minimal synchronous glob over `fs` + `minimatch`, covering just the
+ * surface `assets-manager` needs: one pattern, one optional `ignore`
+ * pattern, and `dot`.
+ *
+ * This replaced the `glob` package (see nestjs/nest-cli#3520), and asset
+ * copying is expected to behave exactly as it did before that swap. Several
+ * rules below therefore look arbitrary in isolation — zero-segment trailing
+ * globstars, the symlink depth budget — but each one preserves a documented
+ * behavior that build configurations already depend on. The tests in
+ * `test/lib/compiler/helpers/glob.spec.ts` pin them.
+ */
+import { readdirSync, statSync } from 'fs';
+import { minimatch } from 'minimatch';
+/**
+ * Characters that make a path segment a pattern rather than a literal, under
+ * minimatch's default options (no extglob).
+ *
+ * Matches the literal chars `*`, `?`, `[`, `{` anywhere, plus `!`, `+`, `@`,
+ * `?`, or `*` immediately followed by `(` (an extglob-looking prefix, which
+ * minimatch still treats specially even without extglob enabled). Chars like
+ * `@`, `(`, `)`, `]`, `}` on their own are NOT magic here: treating them as
+ * such previously collapsed the literal base far above the real directory
+ * (e.g. an `@` in a username segment), causing `readdir` to walk huge trees
+ * and silently return no matches on the first unreadable subdirectory.
+ */
+const MAGIC_CHARS = /[*?[{]|[!+@?*]\(/;
+const toPosix = (value) => value.replace(/\\/g, '/');
+/**
+ * Splits a pattern into the literal prefix we can hand to `readdir` and the
+ * trailing segments that still need matching: `/src/a/*.hbs` -> `/src/a`.
+ */
+function splitPattern(pattern) {
+    const segments = pattern.split('/');
+    const magicIndex = segments.findIndex((segment) => MAGIC_CHARS.test(segment));
+    if (magicIndex === -1) {
+        return { base: pattern, rest: [] };
+    }
+    return {
+        base: segments.slice(0, magicIndex).join('/') || '/',
+        rest: segments.slice(magicIndex),
+    };
+}
+/**
+ * A trailing globstar matches zero segments, so `a/**` must match `a`
+ * itself; `minimatch` alone does not. Expanding the suffix restores that for
+ * the include pattern, and for `ignore` it prunes the ignored directory
+ * itself rather than only its contents.
+ */
+function expandGlobstarSuffix(pattern) {
+    return pattern.endsWith('/**') ? [pattern, pattern.slice(0, -3)] : [pattern];
+}
+/**
+ * How far below a symlinked directory a pattern can still reach.
+ *
+ * A globstar never recurses *through* a symlinked directory, but the
+ * explicit segments that follow the last one keep matching normally once
+ * there. So a pattern ending in a bare globstar stops at the symlink itself
+ * and gets a budget of 0; adding one more segment after it reaches a single
+ * level inside (budget 1), and two segments reach two levels (budget 2). A
+ * pattern with no globstar at all does no recursion of this kind, so its own
+ * depth is the only bound.
+ *
+ * Returning a finite number also bounds the walk: symlink cycles terminate
+ * because each crossing costs depth we can never regain.
+ */
+function symlinkDepthBudget(rest) {
+    for (let index = rest.length - 1; index >= 0; index--) {
+        if (rest[index].includes('**')) {
+            return rest.length - index - 1;
+        }
+    }
+    return rest.length;
+}
+/**
+ * Walks the directory tree rooted at `dir`, without using `fs`'s own
+ * `recursive` option so we can:
+ *
+ * - Skip an unreadable directory instead of failing the whole walk: one
+ *   `EACCES` deep in an asset tree must not silently empty the result.
+ * - Stop descending once we are `budget` levels past a symlinked directory
+ *   (see `symlinkDepthBudget`), which also makes symlink cycles terminate.
+ *
+ * `depth` is how many levels below the nearest symlinked ancestor an entry
+ * sits; 0 means it was reached without crossing one.
+ */
+function walk(dir, recursive, budget, depth = 0) {
+    let entries;
+    try {
+        entries = readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        // Unreadable or missing directory: contribute nothing here, but let
+        // sibling directories elsewhere in the walk still report their matches.
+        return [];
+    }
+    const results = entries.map((entry) => ({
+        parent: dir,
+        entry,
+    }));
+    if (!recursive) {
+        return results;
+    }
+    for (const entry of entries) {
+        const full = `${dir}/${entry.name}`;
+        // Below a symlink every further level costs budget; above one, plain
+        // directory recursion is unbounded.
+        if (entry.isDirectory()) {
+            const childDepth = depth === 0 ? 0 : depth + 1;
+            if (childDepth <= budget) {
+                results.push(...walk(full, true, budget, childDepth));
+            }
+            continue;
+        }
+        // `Dirent.isDirectory()` is false for a symlink (it reports on the link
+        // itself), so a symlinked directory only ever reaches this branch.
+        if (entry.isSymbolicLink() && depth + 1 <= budget) {
+            let stats;
+            try {
+                stats = statSync(full);
+            }
+            catch {
+                continue;
+            }
+            if (stats.isDirectory()) {
+                results.push(...walk(full, true, budget, depth + 1));
+            }
+        }
+    }
+    return results;
+}
+/**
+ * Expands `pattern` to every matching path, with the type of each entry.
+ * See the file header for the compatibility rules this preserves.
+ */
+export function globEntriesSync(pattern, options = {}) {
+    const { ignore, dot = false } = options;
+    const normalized = toPosix(pattern);
+    const { base, rest } = splitPattern(normalized);
+    const includeMatchers = expandGlobstarSuffix(normalized);
+    const ignoreMatchers = ignore ? expandGlobstarSuffix(toPosix(ignore)) : [];
+    const accept = (candidate) => includeMatchers.some((matcher) => minimatch(candidate, matcher, { dot })) &&
+        !ignoreMatchers.some((matcher) => minimatch(candidate, matcher, { dot }));
+    // No wildcard anywhere: the pattern names one concrete path.
+    if (rest.length === 0) {
+        const stats = statSync(normalized, { throwIfNoEntry: false });
+        if (!stats || !accept(normalized)) {
+            return [];
+        }
+        return [
+            {
+                path: normalized,
+                isFile: stats.isFile(),
+                isDirectory: stats.isDirectory(),
+            },
+        ];
+    }
+    // Only the immediate children of `base` can match a single trailing
+    // wildcard segment, so skip the deep walk in that (common) case.
+    const recursive = rest.length > 1 || rest.some((segment) => segment.includes('**'));
+    // An asset may be configured for a directory that does not exist, or one
+    // that turns out to be unreadable; `walk` reports no matches for it (and
+    // any nested directories that fail) rather than failing the whole build.
+    const walked = walk(base, recursive, symlinkDepthBudget(rest));
+    const matches = [];
+    // A trailing `**` matches zero segments, so `base` itself can be a result.
+    if (accept(base)) {
+        matches.push({ path: base, isFile: false, isDirectory: true });
+    }
+    for (const { parent, entry } of walked) {
+        const full = `${toPosix(parent)}/${entry.name}`;
+        if (accept(full)) {
+            matches.push({
+                path: full,
+                isFile: entry.isFile(),
+                isDirectory: entry.isDirectory(),
+            });
+        }
+    }
+    return matches;
+}
+/** Expands `pattern` to every matching path. */
+export function globSync(pattern, options = {}) {
+    return globEntriesSync(pattern, options).map((entry) => entry.path);
+}

package/lib/compiler/helpers/manual-restart.js

@@ -1,9 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.listenForManualRestart = listenForManualRestart;
-exports.displayManualRestartTip = displayManualRestartTip;
-const ansis_1 = require("ansis");
-function listenForManualRestart(callback) {
+import { gray } from 'ansis';
+export function listenForManualRestart(callback) {
     const stdinListener = (data) => {
         if (data.toString().trim() === 'rs') {
             process.stdin.removeListener('data', stdinListener);
@@ -12,6 +8,6 @@ function listenForManualRestart(callback) {
     };
     process.stdin.on('data', stdinListener);
 }
-function displayManualRestartTip() {
-    console.log(`To restart at any time, enter ${(0, ansis_1.gray) `rs`}.\n`);
+export function displayManualRestartTip() {
+    console.log(`To restart at any time, enter ${gray `rs`}.\n`);
 }

package/lib/compiler/helpers/path-confinement.d.ts

@@ -0,0 +1,33 @@
+import { Configuration } from '../../configuration/index.js';
+/**
+ * Whether paths are allowed to point outside of the project directory.
+ *
+ * Confinement is on by default: `compilerOptions.allowOutsidePaths` has to be
+ * set to `true` explicitly to build to (or delete) locations outside of the
+ * project, which some monorepo layouts legitimately rely on. See
+ * nestjs/nest-cli#3463.
+ */
+export declare function areOutsidePathsAllowed(configuration: Required<Configuration>, appName: string | undefined): boolean;
+export interface PathConfinementOptions {
+    /**
+     * Resolve symlinks before comparing. Required whenever the path is going to be
+     * *written through*: a lexical check alone accepts a path such as "dist" that
+     * is itself a symlink pointing outside of the project, and the write would
+     * land outside.
+     *
+     * Deletion does not need it — `fs.rm` unlinks a symlink instead of following
+     * it — and turning it on there would reject ordinary setups that legitimately
+     * symlink a directory inside the project (a workspace "node_modules", for
+     * instance), which is the regression that got the first attempt at this
+     * reverted. See nestjs/nest-cli#3460.
+     */
+    resolveSymlinks?: boolean;
+    projectRoot?: string;
+}
+/**
+ * Resolves `targetPath` against the project directory and asserts that it stays
+ * within it. Returns the resolved absolute path.
+ *
+ * @throws when the path resolves to the project directory itself or escapes it
+ */
+export declare function assertPathInsideProject(targetPath: string, propertyName: string, { resolveSymlinks, projectRoot, }?: PathConfinementOptions): string;

package/lib/compiler/helpers/path-confinement.js

@@ -0,0 +1,63 @@
+import { realpathSync } from 'fs';
+import { basename, dirname, isAbsolute, relative, resolve, sep } from 'path';
+import { getValueOrDefault } from './get-value-or-default.js';
+/**
+ * Whether paths are allowed to point outside of the project directory.
+ *
+ * Confinement is on by default: `compilerOptions.allowOutsidePaths` has to be
+ * set to `true` explicitly to build to (or delete) locations outside of the
+ * project, which some monorepo layouts legitimately rely on. See
+ * nestjs/nest-cli#3463.
+ */
+export function areOutsidePathsAllowed(configuration, appName) {
+    return (getValueOrDefault(configuration, 'compilerOptions.allowOutsidePaths', appName) ?? false);
+}
+/**
+ * Resolves `targetPath` against the project directory and asserts that it stays
+ * within it. Returns the resolved absolute path.
+ *
+ * @throws when the path resolves to the project directory itself or escapes it
+ */
+export function assertPathInsideProject(targetPath, propertyName, { resolveSymlinks = false, projectRoot = process.cwd(), } = {}) {
+    const resolvedPath = resolve(projectRoot, targetPath);
+    const comparableRoot = resolveSymlinks
+        ? realpathOrClosestExisting(projectRoot)
+        : resolve(projectRoot);
+    const comparablePath = resolveSymlinks
+        ? realpathOrClosestExisting(resolvedPath)
+        : resolvedPath;
+    const relativePath = relative(comparableRoot, comparablePath);
+    const isProjectRoot = relativePath === '';
+    const isOutsideProject = relativePath === '..' ||
+        relativePath.startsWith(`..${sep}`) ||
+        isAbsolute(relativePath);
+    if (isProjectRoot || isOutsideProject) {
+        throw new Error(`Refusing to use "${propertyName}" path outside of or equal to the project directory: ${targetPath}. ` +
+            `Set "compilerOptions.allowOutsidePaths" to true if this is intentional.`);
+    }
+    return resolvedPath;
+}
+/**
+ * Resolves symlinks in `targetPath`. Output paths routinely do not exist yet, so
+ * the closest existing ancestor is resolved instead and the remaining segments
+ * are appended back — enough to catch a symlinked ancestor while still working
+ * for a directory that is about to be created.
+ */
+function realpathOrClosestExisting(targetPath) {
+    let current = resolve(targetPath);
+    const trailingSegments = [];
+    for (;;) {
+        try {
+            return resolve(realpathSync(current), ...trailingSegments);
+        }
+        catch {
+            const parent = dirname(current);
+            if (parent === current) {
+                // Reached the root without finding an existing path; nothing to resolve.
+                return resolve(targetPath);
+            }
+            trailingSegments.unshift(basename(current));
+            current = parent;
+        }
+    }
+}

package/lib/compiler/helpers/tsconfig-provider.d.ts

@@ -1,11 +1,12 @@
 import * as ts from 'typescript';
-import { TypeScriptBinaryLoader } from '../typescript-loader';
+import { TypeScriptBinaryLoader } from '../typescript-loader.js';
+export type TsConfigProviderOutput = Pick<ts.ParsedCommandLine, 'options' | 'fileNames' | 'projectReferences'> & {
+    exclude: string[];
+};
 export declare class TsConfigProvider {
     private readonly typescriptLoader;
     constructor(typescriptLoader: TypeScriptBinaryLoader);
-    getByConfigFilename(configFilename: string): {
-        options: ts.CompilerOptions;
-        fileNames: string[];
-        projectReferences: readonly ts.ProjectReference[] | undefined;
-    };
+    getByConfigFilename(configFilename: string): TsConfigProviderOutput;
+    private parseExclude;
+    private normalizeExclude;
 }

package/lib/compiler/helpers/tsconfig-provider.js

@@ -1,22 +1,41 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TsConfigProvider = void 0;
-const fs_1 = require("fs");
-const path_1 = require("path");
-const ui_1 = require("../../ui");
-class TsConfigProvider {
+import { existsSync } from 'fs';
+import { dirname, isAbsolute, join, relative } from 'path';
+import { CLI_ERRORS } from '../../ui/index.js';
+export class TsConfigProvider {
+    typescriptLoader;
     constructor(typescriptLoader) {
         this.typescriptLoader = typescriptLoader;
     }
     getByConfigFilename(configFilename) {
-        const configPath = (0, path_1.join)(process.cwd(), configFilename);
-        if (!(0, fs_1.existsSync)(configPath)) {
-            throw new Error(ui_1.CLI_ERRORS.MISSING_TYPESCRIPT(configFilename));
+        const configPath = join(process.cwd(), configFilename);
+        if (!existsSync(configPath)) {
+            throw new Error(CLI_ERRORS.MISSING_TYPESCRIPT(configFilename));
         }
         const tsBinary = this.typescriptLoader.load();
         const parsedCmd = tsBinary.getParsedCommandLineOfConfigFile(configPath, undefined, tsBinary.sys);
-        const { options, fileNames, projectReferences } = parsedCmd;
-        return { options, fileNames, projectReferences };
+        if (!parsedCmd) {
+            throw new Error(`Could not parse TypeScript configuration file "${configFilename}". Please, ensure that the file contains valid JSON and compiler options.`);
+        }
+        const { options, fileNames, projectReferences, raw } = parsedCmd;
+        const exclude = this.normalizeExclude(this.parseExclude(raw?.exclude), configPath);
+        return { options, fileNames, projectReferences, exclude };
+    }
+    parseExclude(exclude) {
+        const passesTypeValidation = Array.isArray(exclude) &&
+            exclude.every((item) => typeof item === 'string');
+        if (!passesTypeValidation) {
+            return [];
+        }
+        return exclude;
+    }
+    normalizeExclude(exclude, configPath) {
+        const configDir = dirname(configPath);
+        const relativeConfigDir = relative(process.cwd(), configDir);
+        return exclude.map((pattern) => {
+            const normalized = isAbsolute(pattern)
+                ? relative(process.cwd(), pattern)
+                : join(relativeConfigDir, pattern);
+            return normalized.replace(/\\/g, '/');
+        });
     }
 }
-exports.TsConfigProvider = TsConfigProvider;

package/lib/compiler/hooks/tsconfig-paths.hook.js

@@ -1,12 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.tsconfigPathsBeforeHookFactory = tsconfigPathsBeforeHookFactory;
-const os = require("os");
-const path_1 = require("path");
-const typescript_loader_1 = require("../typescript-loader");
-const tsPaths = require("tsconfig-paths");
-function tsconfigPathsBeforeHookFactory(compilerOptions) {
-    const tsBinary = new typescript_loader_1.TypeScriptBinaryLoader().load();
+import { createRequire } from 'module';
+import { dirname, posix } from 'path';
+import * as tsPaths from 'tsconfig-paths';
+import { TypeScriptBinaryLoader } from '../typescript-loader.js';
+const require = createRequire(import.meta.url);
+export function tsconfigPathsBeforeHookFactory(compilerOptions) {
+    const tsBinary = new TypeScriptBinaryLoader().load();
     const { paths = {}, baseUrl = './' } = compilerOptions;
     const matcher = tsPaths.createMatchPath(baseUrl, paths, ['main']);
     return (ctx) => {
@@ -69,20 +67,22 @@ function getNotAliasedPath(sf, matcher, text) {
     if (!result) {
         return;
     }
-    if (os.platform() === 'win32') {
+    if (process.platform === 'win32') {
         result = result.replace(/\\/g, '/');
     }
     try {
         // Installed packages (node modules) should take precedence over root files with the same name.
         // Ref: https://github.com/nestjs/nest-cli/issues/838
         const packagePath = require.resolve(text, {
-            paths: [process.cwd(), ...module.paths],
+            paths: [process.cwd(), ...(require.resolve.paths(text) ?? [])],
         });
         if (packagePath) {
             return text;
         }
     }
-    catch { }
-    const resolvedPath = path_1.posix.relative((0, path_1.dirname)(sf.fileName), result) || './';
+    catch {
+        // package resolution failed, fall through to relative path
+    }
+    const resolvedPath = posix.relative(dirname(sf.fileName), result) || './';
     return resolvedPath[0] === '.' ? resolvedPath : './' + resolvedPath;
 }

package/lib/compiler/interfaces/readonly-visitor.interface.js

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

package/lib/compiler/plugins/plugin-metadata-generator.d.ts

@@ -1,5 +1,41 @@
 import * as ts from 'typescript';
-import { ReadonlyVisitor } from '../interfaces/readonly-visitor.interface';
+import { DeepPluginMeta, ReadonlyVisitor } from '../interfaces/readonly-visitor.interface.js';
+/**
+ * Returns `true` when the consuming project uses an ESM-style module
+ * resolution strategy (`node16` / `nodenext`). Under those resolution
+ * modes, dynamic `import()` specifiers MUST include the file extension
+ * (typically `.js`) for the runtime resolver to find the module. Without
+ * the extension, executing the generated metadata file fails with
+ * `ERR_MODULE_NOT_FOUND`, and TypeScript reports a diagnostic.
+ */
+export declare function requiresExplicitImportExtensions(options: ts.CompilerOptions, tsBinary: typeof ts): boolean;
+/**
+ * Returns the same import path with `.js` appended when (and only when)
+ * the path is relative and does not already end in a recognized
+ * extension. Bare specifiers (e.g. `@nestjs/common`) and absolute paths
+ * are returned unchanged because the caller's resolver handles them.
+ */
+export declare function appendJsExtensionIfMissing(importPath: string): string;
+/**
+ * Rewrites a single `await import("...")`-style string by appending the
+ * `.js` extension to the inner specifier when it is a relative path
+ * without an extension. Used to patch the visitor-supplied `typeImports`
+ * map values.
+ */
+export declare function rewriteAsyncImportString(target: string): string;
+/**
+ * Walks the given `ts.CallExpression` tree and rewrites every dynamic
+ * `import("...")` whose specifier is a relative path missing an
+ * extension. Returns a new node when changes are required, or the input
+ * node unchanged otherwise.
+ */
+export declare function rewriteImportExpressionForNodeNext(expression: ts.CallExpression, tsBinary: typeof ts): ts.CallExpression;
+/**
+ * Recursively walks the collected plugin metadata, rewriting every
+ * dynamic `import("./relative")` call expression to include the `.js`
+ * extension required by node16 / nodenext module resolution.
+ */
+export declare function rewriteCollectedMetadataForNodeNext(metadata: Record<string, Record<string, Array<[ts.CallExpression, DeepPluginMeta]>>>, tsBinary: typeof ts): void;
 export interface PluginMetadataGenerateOptions {
     /**
      * The visitors to use to generate the metadata.

package/lib/compiler/plugins/plugin-metadata-generator.js

@@ -1,10 +1,97 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PluginMetadataGenerator = void 0;
-const constants_1 = require("../swc/constants");
-const type_checker_host_1 = require("../swc/type-checker-host");
-const typescript_loader_1 = require("../typescript-loader");
-const plugin_metadata_printer_1 = require("./plugin-metadata-printer");
+import { FOUND_NO_ISSUES_GENERATING_METADATA } from '../swc/constants.js';
+import { TypeCheckerHost } from '../swc/type-checker-host.js';
+import { TypeScriptBinaryLoader } from '../typescript-loader.js';
+import { PluginMetadataPrinter } from './plugin-metadata-printer.js';
+/**
+ * Returns `true` when the consuming project uses an ESM-style module
+ * resolution strategy (`node16` / `nodenext`). Under those resolution
+ * modes, dynamic `import()` specifiers MUST include the file extension
+ * (typically `.js`) for the runtime resolver to find the module. Without
+ * the extension, executing the generated metadata file fails with
+ * `ERR_MODULE_NOT_FOUND`, and TypeScript reports a diagnostic.
+ */
+export function requiresExplicitImportExtensions(options, tsBinary) {
+    const moduleResolution = options.moduleResolution;
+    return (moduleResolution === tsBinary.ModuleResolutionKind.Node16 ||
+        moduleResolution === tsBinary.ModuleResolutionKind.NodeNext);
+}
+const RELATIVE_PATH_RE = /^\.\.?\//;
+// Any common JS/TS-style extension that the user could have authored or
+// that our rewrite would have already produced. Prevents double-appending.
+const HAS_KNOWN_EXTENSION_RE = /\.(m?js|c?js|m?ts|c?ts|json|node)$/i;
+/**
+ * Returns the same import path with `.js` appended when (and only when)
+ * the path is relative and does not already end in a recognized
+ * extension. Bare specifiers (e.g. `@nestjs/common`) and absolute paths
+ * are returned unchanged because the caller's resolver handles them.
+ */
+export function appendJsExtensionIfMissing(importPath) {
+    if (!RELATIVE_PATH_RE.test(importPath)) {
+        return importPath;
+    }
+    if (HAS_KNOWN_EXTENSION_RE.test(importPath)) {
+        return importPath;
+    }
+    return `${importPath}.js`;
+}
+/**
+ * Rewrites a single `await import("...")`-style string by appending the
+ * `.js` extension to the inner specifier when it is a relative path
+ * without an extension. Used to patch the visitor-supplied `typeImports`
+ * map values.
+ */
+export function rewriteAsyncImportString(target) {
+    return target.replace(/import\((['"])((?:\\\1|(?!\1).)*)\1\)/g, (match, quote, specifier) => `import(${quote}${appendJsExtensionIfMissing(specifier)}${quote})`);
+}
+/**
+ * Walks the given `ts.CallExpression` tree and rewrites every dynamic
+ * `import("...")` whose specifier is a relative path missing an
+ * extension. Returns a new node when changes are required, or the input
+ * node unchanged otherwise.
+ */
+export function rewriteImportExpressionForNodeNext(expression, tsBinary) {
+    const visit = (node) => {
+        if (tsBinary.isCallExpression(node) &&
+            node.expression.kind === tsBinary.SyntaxKind.ImportKeyword &&
+            node.arguments.length > 0 &&
+            tsBinary.isStringLiteralLike(node.arguments[0])) {
+            const original = node.arguments[0].text;
+            const rewritten = appendJsExtensionIfMissing(original);
+            if (rewritten !== original) {
+                const updatedArgs = [
+                    tsBinary.factory.createStringLiteral(rewritten),
+                    ...node.arguments.slice(1),
+                ];
+                return tsBinary.factory.updateCallExpression(node, node.expression, node.typeArguments, updatedArgs);
+            }
+        }
+        return tsBinary.visitEachChild(node, visit, undefined);
+    };
+    return visit(expression);
+}
+/**
+ * Recursively walks the collected plugin metadata, rewriting every
+ * dynamic `import("./relative")` call expression to include the `.js`
+ * extension required by node16 / nodenext module resolution.
+ */
+export function rewriteCollectedMetadataForNodeNext(metadata, tsBinary) {
+    for (const visitorKey of Object.keys(metadata)) {
+        const sections = metadata[visitorKey];
+        for (const sectionKey of Object.keys(sections)) {
+            const tuples = sections[sectionKey];
+            if (!Array.isArray(tuples)) {
+                continue;
+            }
+            for (let i = 0; i < tuples.length; i++) {
+                const [importExpr, meta] = tuples[i];
+                tuples[i] = [
+                    rewriteImportExpressionForNodeNext(importExpr, tsBinary),
+                    meta,
+                ];
+            }
+        }
+    }
+}
 /**
  * Generates plugins metadata by traversing the AST of the project.
  * @example
@@ -20,11 +107,12 @@ const plugin_metadata_printer_1 = require("./plugin-metadata-printer");
  * });
  * ```
  */
-class PluginMetadataGenerator {
+export class PluginMetadataGenerator {
+    pluginMetadataPrinter = new PluginMetadataPrinter();
+    typeCheckerHost = new TypeCheckerHost();
+    typescriptLoader = new TypeScriptBinaryLoader();
+    tsBinary;
     constructor() {
-        this.pluginMetadataPrinter = new plugin_metadata_printer_1.PluginMetadataPrinter();
-        this.typeCheckerHost = new type_checker_host_1.TypeCheckerHost();
-        this.typescriptLoader = new typescript_loader_1.TypeScriptBinaryLoader();
         this.tsBinary = this.typescriptLoader.load();
     }
     generate(options) {
@@ -50,7 +138,7 @@ class PluginMetadataGenerator {
                     console.log(tsBinary.formatDiagnosticsWithColorAndContext(diagnostics, formatDiagnosticsHost));
                 }
                 else {
-                    console.log(constants_1.FOUND_NO_ISSUES_GENERATING_METADATA);
+                    console.log(FOUND_NO_ISSUES_GENERATING_METADATA);
                 }
             }
         };
@@ -75,10 +163,22 @@ class PluginMetadataGenerator {
                 ...visitor.typeImports,
             };
         });
+        // Under `node16` / `nodenext` module resolution, dynamic `import()`
+        // specifiers must include explicit file extensions. The visitors emit
+        // bare relative specifiers (e.g. `import("./hello.dto")`), which are
+        // valid under classic / node10 resolution but break compilation and
+        // runtime under nodenext. When the consuming project uses an ESM-style
+        // resolver, rewrite both the metadata import call expressions and the
+        // typeImports map values to include the `.js` extension. See #3364.
+        if (requiresExplicitImportExtensions(programRef.getCompilerOptions(), this.tsBinary)) {
+            rewriteCollectedMetadataForNodeNext(collectedMetadata, this.tsBinary);
+            for (const key of Object.keys(typeImports)) {
+                typeImports[key] = rewriteAsyncImportString(typeImports[key]);
+            }
+        }
         this.pluginMetadataPrinter.print(collectedMetadata, typeImports, {
             outputDir,
             filename,
         }, this.tsBinary);
     }
 }
-exports.PluginMetadataGenerator = PluginMetadataGenerator;

package/lib/compiler/plugins/plugin-metadata-printer.d.ts

@@ -1,5 +1,5 @@
 import * as ts from 'typescript';
-import { DeepPluginMeta } from '../interfaces/readonly-visitor.interface';
+import { DeepPluginMeta } from '../interfaces/readonly-visitor.interface.js';
 export interface PluginMetadataPrintOptions {
     outputDir: string;
     filename?: string;