nx 23.0.0-beta.18 → 23.0.0-beta.19

package/dist/src/command-line/migrate/prompt-files.d.ts

@@ -2,6 +2,25 @@ import { MigrationsJson } from '../../config/misc-interfaces';
 export declare const AI_MIGRATIONS_DIR: string;
 export declare function promptContentKey(packageName: string, promptRelPath: string): string;
 export declare function validateMigrationEntries(packageName: string, packageVersion: string, migrations: MigrationsJson): void;
+/**
+ * Thrown when the markdown prompt file referenced by a migration cannot be
+ * resolved.
+ */
+export declare class PromptResolutionError extends Error {
+    readonly promptPath: string;
+    readonly migrationsDir: string;
+    constructor(promptPath: string, migrationsDir: string, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Resolves a migration prompt file path to an absolute path. Prompt paths are
+ * plain markdown files referenced relative to the directory containing the
+ * `migrations.json` - unlike schemas, they are not resolved through package
+ * exports or `require.resolve`. The path must stay within the migrations
+ * directory and point at an existing file.
+ */
+export declare function resolvePrompt(promptPath: string, migrationsDir: string): string;
 export declare function extractPromptFilesFromTarball(packageName: string, packageVersion: string, migrations: MigrationsJson, migrationsFilePath: string, fullTarballPath: string, destDir: string): Promise<Record<string, string> | undefined>;
 export declare function readPromptFilesFromInstall(packageName: string, packageVersion: string, migrations: MigrationsJson, migrationsFilePath: string): Promise<Record<string, string> | undefined>;
 export declare function writePromptMigrationFiles(root: string, migrations: {

package/dist/src/command-line/migrate/prompt-files.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AI_MIGRATIONS_DIR = void 0;
+exports.PromptResolutionError = exports.AI_MIGRATIONS_DIR = void 0;
 exports.promptContentKey = promptContentKey;
 exports.validateMigrationEntries = validateMigrationEntries;
+exports.resolvePrompt = resolvePrompt;
 exports.extractPromptFilesFromTarball = extractPromptFilesFromTarball;
 exports.readPromptFilesFromInstall = readPromptFilesFromInstall;
 exports.writePromptMigrationFiles = writePromptMigrationFiles;
@@ -43,15 +44,48 @@ async function resolvePromptFiles(packageName, packageVersion, migrations, migra
         ? resolvedPromptFiles
         : undefined;
 }
-function assertPromptPathWithinMigrationsDir(migrationsDir, promptRelPath, packageName, packageVersion) {
+function isPromptPathWithinMigrationsDir(migrationsDir, promptRelPath) {
     const rel = (0, path_1.relative)(migrationsDir, (0, path_1.join)(migrationsDir, promptRelPath));
-    if ((0, path_1.isAbsolute)(promptRelPath) ||
+    return !((0, path_1.isAbsolute)(promptRelPath) ||
         rel === '..' ||
         rel.startsWith(`..${path_1.sep}`) ||
-        rel.startsWith(`..${path_1.posix.sep}`)) {
+        rel.startsWith(`..${path_1.posix.sep}`));
+}
+function assertPromptPathWithinMigrationsDir(migrationsDir, promptRelPath, packageName, packageVersion) {
+    if (!isPromptPathWithinMigrationsDir(migrationsDir, promptRelPath)) {
         throw new Error(`Invalid prompt path "${promptRelPath}" in package "${packageName}@${packageVersion}": prompt paths must be relative and resolve within the package's migrations directory.`);
     }
 }
+/**
+ * Thrown when the markdown prompt file referenced by a migration cannot be
+ * resolved.
+ */
+class PromptResolutionError extends Error {
+    constructor(promptPath, migrationsDir, options) {
+        super(`Could not resolve prompt "${promptPath}" from "${migrationsDir}".`, options);
+        this.promptPath = promptPath;
+        this.migrationsDir = migrationsDir;
+        this.name = 'PromptResolutionError';
+    }
+}
+exports.PromptResolutionError = PromptResolutionError;
+/**
+ * Resolves a migration prompt file path to an absolute path. Prompt paths are
+ * plain markdown files referenced relative to the directory containing the
+ * `migrations.json` - unlike schemas, they are not resolved through package
+ * exports or `require.resolve`. The path must stay within the migrations
+ * directory and point at an existing file.
+ */
+function resolvePrompt(promptPath, migrationsDir) {
+    if (!isPromptPathWithinMigrationsDir(migrationsDir, promptPath)) {
+        throw new PromptResolutionError(promptPath, migrationsDir);
+    }
+    const resolvedPath = (0, path_1.join)(migrationsDir, promptPath);
+    if (!(0, fs_1.existsSync)(resolvedPath)) {
+        throw new PromptResolutionError(promptPath, migrationsDir);
+    }
+    return resolvedPath;
+}
 function extractPromptFilesFromTarball(packageName, packageVersion, migrations, migrationsFilePath, fullTarballPath, destDir) {
     const migrationsDir = (0, path_1.dirname)(migrationsFilePath);
     return resolvePromptFiles(packageName, packageVersion, migrations, migrationsDir, async (promptRelPath) => {

package/dist/src/config/schema-utils.d.ts

@@ -1,4 +1,25 @@
 import type { ProjectConfiguration } from './workspace-json-project-json';
+/**
+ * Thrown when the schema file of an executor or generator cannot be resolved.
+ */
+export declare class SchemaResolutionError extends Error {
+    readonly schemaPath: string;
+    readonly directory: string;
+    constructor(schemaPath: string, directory: string, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Thrown when the implementation module of an executor or generator cannot be
+ * resolved.
+ */
+export declare class ImplementationResolutionError extends Error {
+    readonly implementationModulePath: string;
+    readonly directory: string;
+    constructor(implementationModulePath: string, directory: string, options?: {
+        cause?: unknown;
+    });
+}
 /**
  * This function is used to get the implementation factory of an executor or generator.
  * @param implementation path to the implementation

package/dist/src/config/schema-utils.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImplementationResolutionError = exports.SchemaResolutionError = void 0;
 exports.getImplementationFactory = getImplementationFactory;
 exports.resolveImplementation = resolveImplementation;
 exports.resolveSchema = resolveSchema;
@@ -9,7 +10,36 @@ const resolve_exports_1 = require("resolve.exports");
 const register_1 = require("../plugins/js/utils/register");
 const packages_1 = require("../plugins/js/utils/packages");
 const typescript_1 = require("../plugins/js/utils/typescript");
+const find_project_for_path_1 = require("../project-graph/utils/find-project-for-path");
+const fileutils_1 = require("../utils/fileutils");
+const package_json_1 = require("../utils/package-json");
 const path_2 = require("../utils/path");
+const workspace_root_1 = require("../utils/workspace-root");
+/**
+ * Thrown when the schema file of an executor or generator cannot be resolved.
+ */
+class SchemaResolutionError extends Error {
+    constructor(schemaPath, directory, options) {
+        super(`Could not resolve schema "${schemaPath}" from "${directory}".`, options);
+        this.schemaPath = schemaPath;
+        this.directory = directory;
+        this.name = 'SchemaResolutionError';
+    }
+}
+exports.SchemaResolutionError = SchemaResolutionError;
+/**
+ * Thrown when the implementation module of an executor or generator cannot be
+ * resolved.
+ */
+class ImplementationResolutionError extends Error {
+    constructor(implementationModulePath, directory, options) {
+        super(`Could not resolve "${implementationModulePath}" from "${directory}".`, options);
+        this.implementationModulePath = implementationModulePath;
+        this.directory = directory;
+        this.name = 'ImplementationResolutionError';
+    }
+}
+exports.ImplementationResolutionError = ImplementationResolutionError;
 /**
  * This function is used to get the implementation factory of an executor or generator.
  * @param implementation path to the implementation
@@ -64,7 +94,7 @@ function resolveImplementation(implementationModulePath, directory, packageName,
         }
         catch { }
     }
-    throw new Error(`Could not resolve "${implementationModulePath}" from "${directory}".`);
+    throw new ImplementationResolutionError(implementationModulePath, directory);
 }
 function resolveSchema(schemaPath, directory, packageName, projects) {
     if (!directory.includes('node_modules')) {
@@ -80,24 +110,63 @@ function resolveSchema(schemaPath, directory, packageName, projects) {
     if ((0, fs_1.existsSync)(maybeSchemaPath)) {
         return maybeSchemaPath;
     }
-    return require.resolve(schemaPath, {
-        paths: [directory],
-    });
+    try {
+        return require.resolve(schemaPath, {
+            paths: [directory],
+        });
+    }
+    catch (e) {
+        throw new SchemaResolutionError(schemaPath, directory, { cause: e });
+    }
+}
+let projectRootMappings;
+function getProjectForDirectory(directory, projects) {
+    projectRootMappings ??=
+        (0, find_project_for_path_1.createProjectRootMappingsFromProjectConfigurations)(projects);
+    const projectName = (0, find_project_for_path_1.findProjectForPath)((0, path_1.relative)(workspace_root_1.workspaceRoot, directory), projectRootMappings);
+    return projectName ? projects[projectName] : null;
 }
-let packageToProjectMap;
+/**
+ * Reads the JS package metadata (package name and exports) for a project
+ * directly from its `package.json`. Used as a fallback when a project's graph
+ * metadata doesn't include the JS metadata.
+ */
+function readJsPackageMetadata(project) {
+    const packageJsonPath = (0, path_1.join)(workspace_root_1.workspaceRoot, project.root, 'package.json');
+    if (!(0, fs_1.existsSync)(packageJsonPath)) {
+        return null;
+    }
+    try {
+        const packageJson = (0, fileutils_1.readJsonFile)(packageJsonPath);
+        return (0, package_json_1.getMetadataFromPackageJson)(packageJson, false).js;
+    }
+    catch {
+        return null;
+    }
+}
+let packageMetadata;
 function tryResolveFromSource(path, directory, packageName, projects) {
-    packageToProjectMap ??=
-        (0, packages_1.getWorkspacePackagesMetadata)(projects).packageToProjectMap;
-    const localProject = packageToProjectMap[packageName];
+    packageMetadata ??= (0, packages_1.getWorkspacePackagesMetadata)(projects);
+    let localProject = packageMetadata.packageToProjectMap[packageName];
+    // The `packageName` might be a path to the collection rather than an actual
+    // package name (e.g. when a generator/executor collection is referenced by
+    // path). In that case, `directory` points inside the local project, so we
+    // find the project that contains it.
+    localProject ??= getProjectForDirectory(directory, projects);
     if (!localProject) {
-        // it doesn't match any of the package names from the local projects
         return null;
     }
+    const js = localProject.metadata?.js ??
+        readJsPackageMetadata(localProject);
+    if (!js) {
+        return null;
+    }
+    const name = js.packageName;
+    const exports = js.packageExports;
     try {
-        const fromExports = (0, resolve_exports_1.resolve)({
-            name: localProject.metadata.js.packageName,
-            exports: localProject.metadata.js.packageExports,
-        }, path, { conditions: (0, typescript_1.getRootTsConfigResolveExportsConditions)() });
+        const fromExports = (0, resolve_exports_1.resolve)({ name, exports }, path, {
+            conditions: (0, typescript_1.getRootTsConfigResolveExportsConditions)(),
+        });
         if (fromExports && fromExports.length) {
             for (const exportPath of fromExports) {
                 if ((0, fs_1.existsSync)((0, path_1.join)(directory, exportPath))) {