@ohos-ports/nx 19.8.4-beta.0

package/src/project-graph/plugins/loader.js

@@ -0,0 +1,220 @@
+"use strict";
+// This file contains methods and utilities that should **only** be used by the plugin worker.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unregisterPluginTSTranspiler = void 0;
+exports.readPluginPackageJson = readPluginPackageJson;
+exports.resolveLocalNxPlugin = resolveLocalNxPlugin;
+exports.registerPluginTSTranspiler = registerPluginTSTranspiler;
+exports.getPluginPathAndName = getPluginPathAndName;
+exports.loadNxPlugin = loadNxPlugin;
+exports.loadNxPluginAsync = loadNxPluginAsync;
+const posix_1 = require("node:path/posix");
+const installation_directory_1 = require("../../utils/installation-directory");
+const package_json_1 = require("../../utils/package-json");
+const fileutils_1 = require("../../utils/fileutils");
+const workspace_root_1 = require("../../utils/workspace-root");
+const node_fs_1 = require("node:fs");
+const register_1 = require("../../plugins/js/utils/register");
+const find_project_for_path_1 = require("../utils/find-project-for-path");
+const path_1 = require("../../utils/path");
+const logger_1 = require("../../utils/logger");
+const node_path_1 = require("node:path");
+const retrieve_workspace_files_1 = require("../utils/retrieve-workspace-files");
+const utils_1 = require("./utils");
+const internal_api_1 = require("./internal-api");
+const error_types_1 = require("../error-types");
+const path = require("node:path/posix");
+const typescript_1 = require("../../plugins/js/utils/typescript");
+function readPluginPackageJson(pluginName, projects, paths = (0, installation_directory_1.getNxRequirePaths)()) {
+    try {
+        const result = (0, package_json_1.readModulePackageJsonWithoutFallbacks)(pluginName, paths);
+        return {
+            json: result.packageJson,
+            path: result.path,
+        };
+    }
+    catch (e) {
+        if (e.code === 'MODULE_NOT_FOUND') {
+            const localPluginPath = resolveLocalNxPlugin(pluginName, projects);
+            if (localPluginPath) {
+                const localPluginPackageJson = path.join(localPluginPath.path, 'package.json');
+                if (!exports.unregisterPluginTSTranspiler) {
+                    registerPluginTSTranspiler();
+                }
+                return {
+                    path: localPluginPackageJson,
+                    json: (0, fileutils_1.readJsonFile)(localPluginPackageJson),
+                };
+            }
+        }
+        throw e;
+    }
+}
+function resolveLocalNxPlugin(importPath, projects, root = workspace_root_1.workspaceRoot) {
+    return lookupLocalPlugin(importPath, projects, root);
+}
+exports.unregisterPluginTSTranspiler = null;
+/**
+ * Register swc-node or ts-node if they are not currently registered
+ * with some default settings which work well for Nx plugins.
+ */
+function registerPluginTSTranspiler() {
+    // Get the first tsconfig that matches the allowed set
+    const tsConfigName = [
+        (0, posix_1.join)(workspace_root_1.workspaceRoot, 'tsconfig.base.json'),
+        (0, posix_1.join)(workspace_root_1.workspaceRoot, 'tsconfig.json'),
+    ].find((x) => (0, node_fs_1.existsSync)(x));
+    if (!tsConfigName) {
+        return;
+    }
+    const tsConfig = tsConfigName
+        ? (0, typescript_1.readTsConfig)(tsConfigName)
+        : {};
+    const cleanupFns = [
+        (0, register_1.registerTsConfigPaths)(tsConfigName),
+        (0, register_1.registerTranspiler)({
+            experimentalDecorators: true,
+            emitDecoratorMetadata: true,
+            ...tsConfig.options,
+        }, tsConfig.raw),
+    ];
+    exports.unregisterPluginTSTranspiler = () => {
+        cleanupFns.forEach((fn) => fn?.());
+    };
+}
+function lookupLocalPlugin(importPath, projects, root = workspace_root_1.workspaceRoot) {
+    const projectConfig = findNxProjectForImportPath(importPath, projects, root);
+    if (!projectConfig) {
+        return null;
+    }
+    return { path: path.join(root, projectConfig.root), projectConfig };
+}
+function findNxProjectForImportPath(importPath, projects, root = workspace_root_1.workspaceRoot) {
+    const tsConfigPaths = readTsConfigPaths(root);
+    const possiblePaths = tsConfigPaths[importPath]?.map((p) => (0, path_1.normalizePath)(path.relative(root, path.join(root, p))));
+    if (possiblePaths?.length) {
+        const projectRootMappings = new Map();
+        const projectNameMap = new Map();
+        for (const projectRoot in projects) {
+            const project = projects[projectRoot];
+            projectRootMappings.set(project.root, project.name);
+            projectNameMap.set(project.name, project);
+        }
+        for (const tsConfigPath of possiblePaths) {
+            const nxProject = (0, find_project_for_path_1.findProjectForPath)(tsConfigPath, projectRootMappings);
+            if (nxProject) {
+                return projectNameMap.get(nxProject);
+            }
+        }
+        logger_1.logger.verbose('Unable to find local plugin', possiblePaths, projectRootMappings);
+        throw new Error('Unable to resolve local plugin with import path ' + importPath);
+    }
+}
+let tsconfigPaths;
+function readTsConfigPaths(root = workspace_root_1.workspaceRoot) {
+    if (!tsconfigPaths) {
+        const tsconfigPath = ['tsconfig.base.json', 'tsconfig.json']
+            .map((x) => path.join(root, x))
+            .filter((x) => (0, node_fs_1.existsSync)(x))[0];
+        if (!tsconfigPath) {
+            throw new Error('unable to find tsconfig.base.json or tsconfig.json');
+        }
+        const { compilerOptions } = (0, fileutils_1.readJsonFile)(tsconfigPath);
+        tsconfigPaths = compilerOptions?.paths;
+    }
+    return tsconfigPaths ?? {};
+}
+function readPluginMainFromProjectConfiguration(plugin) {
+    const { main } = Object.values(plugin.targets).find((x) => [
+        '@nx/js:tsc',
+        '@nrwl/js:tsc',
+        '@nx/js:swc',
+        '@nrwl/js:swc',
+        '@nx/node:package',
+        '@nrwl/node:package',
+    ].includes(x.executor))?.options ||
+        plugin.targets?.build?.options ||
+        {};
+    return main;
+}
+function getPluginPathAndName(moduleName, paths, projects, root) {
+    let pluginPath;
+    let registerTSTranspiler = false;
+    try {
+        pluginPath = require.resolve(moduleName, {
+            paths,
+        });
+        const extension = path.extname(pluginPath);
+        registerTSTranspiler = extension === '.ts';
+    }
+    catch (e) {
+        if (e.code === 'MODULE_NOT_FOUND') {
+            const plugin = resolveLocalNxPlugin(moduleName, projects, root);
+            if (plugin) {
+                registerTSTranspiler = true;
+                const main = readPluginMainFromProjectConfiguration(plugin.projectConfig);
+                pluginPath = main ? path.join(root, main) : plugin.path;
+            }
+            else {
+                logger_1.logger.error(`Plugin listed in \`nx.json\` not found: ${moduleName}`);
+                throw e;
+            }
+        }
+        else {
+            throw e;
+        }
+    }
+    const packageJsonPath = path.join(pluginPath, 'package.json');
+    // Register the ts-transpiler if we are pointing to a
+    // plain ts file that's not part of a plugin project
+    if (registerTSTranspiler) {
+        registerPluginTSTranspiler();
+    }
+    const { name } = !['.ts', '.js'].some((x) => (0, node_path_1.extname)(moduleName) === x) && // Not trying to point to a ts or js file
+        (0, node_fs_1.existsSync)(packageJsonPath) // plugin has a package.json
+        ? (0, fileutils_1.readJsonFile)(packageJsonPath) // read name from package.json
+        : { name: moduleName };
+    return { pluginPath, name };
+}
+let projectsWithoutInference;
+function loadNxPlugin(plugin, root) {
+    return [
+        loadNxPluginAsync(plugin, (0, installation_directory_1.getNxRequirePaths)(root), root),
+        () => { },
+    ];
+}
+async function loadNxPluginAsync(pluginConfiguration, paths, root) {
+    const moduleName = typeof pluginConfiguration === 'string'
+        ? pluginConfiguration
+        : pluginConfiguration.plugin;
+    try {
+        try {
+            require.resolve(moduleName);
+        }
+        catch {
+            // If a plugin cannot be resolved, we will need projects to resolve it
+            projectsWithoutInference ??=
+                await (0, retrieve_workspace_files_1.retrieveProjectConfigurationsWithoutPluginInference)(root);
+        }
+        performance.mark(`Load Nx Plugin: ${moduleName} - start`);
+        let { pluginPath, name } = await getPluginPathAndName(moduleName, paths, projectsWithoutInference, root);
+        const plugin = (0, utils_1.normalizeNxPlugin)(await importPluginModule(pluginPath));
+        plugin.name ??= name;
+        performance.mark(`Load Nx Plugin: ${moduleName} - end`);
+        performance.measure(`Load Nx Plugin: ${moduleName}`, `Load Nx Plugin: ${moduleName} - start`, `Load Nx Plugin: ${moduleName} - end`);
+        return new internal_api_1.LoadedNxPlugin(plugin, pluginConfiguration);
+    }
+    catch (e) {
+        throw new error_types_1.LoadPluginError(moduleName, e);
+    }
+}
+async function importPluginModule(pluginPath) {
+    const m = await Promise.resolve(`${pluginPath}`).then(s => require(s));
+    if (m.default &&
+        ('createNodes' in m.default ||
+            'createNodesV2' in m.default ||
+            'createDependencies' in m.default)) {
+        return m.default;
+    }
+    return m;
+}

package/src/project-graph/plugins/public-api.d.ts

@@ -0,0 +1,130 @@
+import { NxPluginV1 } from '../../utils/nx-plugin.deprecated';
+import { FileMap, ProjectGraph, ProjectGraphExternalNode } from '../../config/project-graph';
+import { ProjectConfiguration } from '../../config/workspace-json-project-json';
+import { NxJsonConfiguration } from '../../config/nx-json';
+import { RawProjectGraphDependency } from '../project-graph-builder';
+/**
+ * Context for {@link CreateNodesFunction}
+ */
+export interface CreateNodesContext extends CreateNodesContextV2 {
+    /**
+     * The subset of configuration files which match the createNodes pattern
+     */
+    readonly configFiles: readonly string[];
+}
+export interface CreateNodesContextV2 {
+    readonly nxJsonConfiguration: NxJsonConfiguration;
+    readonly workspaceRoot: string;
+}
+/**
+ * A function which parses a configuration file into a set of nodes.
+ * Used for creating nodes for the {@link ProjectGraph}
+ */
+export type CreateNodesFunction<T = unknown> = (projectConfigurationFile: string, options: T | undefined, context: CreateNodesContext) => CreateNodesResult | Promise<CreateNodesResult>;
+export type CreateNodesResultV2 = Array<readonly [configFileSource: string, result: CreateNodesResult]>;
+export type CreateNodesFunctionV2<T = unknown> = (projectConfigurationFiles: readonly string[], options: T | undefined, context: CreateNodesContextV2) => CreateNodesResultV2 | Promise<CreateNodesResultV2>;
+export type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+export interface CreateNodesResult {
+    /**
+     * A map of project root -> project configuration
+     */
+    projects?: Record<string, Optional<ProjectConfiguration, 'root'>>;
+    /**
+     * A map of external node name -> external node. External nodes do not have a root, so the key is their name.
+     */
+    externalNodes?: Record<string, ProjectGraphExternalNode>;
+}
+/**
+ * A pair of file patterns and {@link CreateNodesFunction}
+ *
+ * Nx 19.2+: Both original `CreateNodes` and `CreateNodesV2` are supported. Nx will only invoke `CreateNodesV2` if it is present.
+ * Nx 20.X : The `CreateNodesV2` will be the only supported API. This typing will still exist, but be identical to `CreateNodesV2`.
+             Nx **will not** invoke the original `plugin.createNodes` callback. This should give plugin authors a window to transition.
+             Plugin authors should update their plugin's `createNodes` function to align with `CreateNodesV2` / the updated `CreateNodes`.
+             The plugin should contain something like: `export createNodes = createNodesV2;` during this period. This will allow the plugin
+             to maintain compatibility with Nx 19.2 and up.
+ * Nx 21.X : The `CreateNodesV2` typing will be removed, as it has replaced `CreateNodes`.
+ *
+ * @deprecated Use {@link CreateNodesV2} instead. CreateNodesV2 will replace this API. Read more about the transition above.
+ */
+export type CreateNodes<T = unknown> = readonly [
+    projectFilePattern: string,
+    createNodesFunction: CreateNodesFunction<T>
+];
+/**
+ * A pair of file patterns and {@link CreateNodesFunctionV2}
+ * In Nx 20 {@link CreateNodes} will be replaced with this type. In Nx 21, this type will be removed.
+ */
+export type CreateNodesV2<T = unknown> = readonly [
+    projectFilePattern: string,
+    createNodesFunction: CreateNodesFunctionV2<T>
+];
+/**
+ * Context for {@link CreateDependencies}
+ */
+export interface CreateDependenciesContext {
+    /**
+     * The external nodes that have been added to the graph.
+     */
+    readonly externalNodes: ProjectGraph['externalNodes'];
+    /**
+     * The configuration of each project in the workspace.
+     */
+    readonly projects: Record<string, ProjectConfiguration>;
+    /**
+     * The `nx.json` configuration from the workspace
+     */
+    readonly nxJsonConfiguration: NxJsonConfiguration;
+    /**
+     * All files in the workspace
+     */
+    readonly fileMap: FileMap;
+    /**
+     * Files changes since last invocation
+     */
+    readonly filesToProcess: FileMap;
+    readonly workspaceRoot: string;
+}
+/**
+ * A function which parses files in the workspace to create dependencies in the {@link ProjectGraph}
+ * Use {@link validateDependency} to validate dependencies
+ */
+export type CreateDependencies<T = unknown> = (options: T | undefined, context: CreateDependenciesContext) => RawProjectGraphDependency[] | Promise<RawProjectGraphDependency[]>;
+export type CreateMetadataContext = {
+    readonly nxJsonConfiguration: NxJsonConfiguration;
+    readonly workspaceRoot: string;
+};
+export type ProjectsMetadata = Record<string, Pick<ProjectConfiguration, 'metadata'>>;
+export type CreateMetadata<T = unknown> = (graph: ProjectGraph, options: T | undefined, context: CreateMetadataContext) => ProjectsMetadata | Promise<ProjectsMetadata>;
+/**
+ * A plugin for Nx which creates nodes and dependencies for the {@link ProjectGraph}
+ */
+export type NxPluginV2<TOptions = unknown> = {
+    name: string;
+    /**
+     * Provides a file pattern and function that retrieves configuration info from
+     * those files. e.g. { '**\/*.csproj': buildProjectsFromCsProjFile }
+     *
+     * @deprecated Use {@link createNodesV2} instead. In Nx 20 support for calling createNodes with a single file for the first argument will be removed.
+     */
+    createNodes?: CreateNodes<TOptions>;
+    /**
+     * Provides a file pattern and function that retrieves configuration info from
+     * those files. e.g. { '**\/*.csproj': buildProjectsFromCsProjFiles }
+     *
+     * In Nx 20 {@link createNodes} will be replaced with this property. In Nx 21, this property will be removed.
+     */
+    createNodesV2?: CreateNodesV2<TOptions>;
+    /**
+     * Provides a function to analyze files to create dependencies for the {@link ProjectGraph}
+     */
+    createDependencies?: CreateDependencies<TOptions>;
+    /**
+     * Provides a function to create metadata for the {@link ProjectGraph}
+     */
+    createMetadata?: CreateMetadata<TOptions>;
+};
+/**
+ * A plugin for Nx
+ */
+export type NxPlugin = NxPluginV1 | NxPluginV2;

package/src/project-graph/plugins/public-api.js

@@ -0,0 +1,4 @@
+"use strict";
+// This file represents the public API for plugins which live in nx.json's plugins array.
+// For methods to interact with plugins from within Nx, see `./internal-api.ts`.
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/project-graph/plugins/utils.d.ts

@@ -0,0 +1,8 @@
+import type { NxPluginV1 } from '../../utils/nx-plugin.deprecated';
+import type { LoadedNxPlugin, NormalizedPlugin } from './internal-api';
+import { CreateNodesContextV2, CreateNodesFunction, CreateNodesResult, type NxPlugin, type NxPluginV2 } from './public-api';
+export declare function isNxPluginV2(plugin: NxPlugin): plugin is NxPluginV2;
+export declare function isNxPluginV1(plugin: NxPlugin | LoadedNxPlugin): plugin is NxPluginV1;
+export declare function normalizeNxPlugin(plugin: NxPlugin): NormalizedPlugin;
+export type AsyncFn<T extends Function> = T extends (...args: infer A) => infer R ? (...args: A) => Promise<Awaited<R>> : never;
+export declare function createNodesFromFiles<T = unknown>(createNodes: CreateNodesFunction<T>, configFiles: readonly string[], options: T, context: CreateNodesContextV2): Promise<[file: string, value: CreateNodesResult][]>;

package/src/project-graph/plugins/utils.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNxPluginV2 = isNxPluginV2;
+exports.isNxPluginV1 = isNxPluginV1;
+exports.normalizeNxPlugin = normalizeNxPlugin;
+exports.createNodesFromFiles = createNodesFromFiles;
+const node_path_1 = require("node:path");
+const to_project_name_1 = require("../../config/to-project-name");
+const globs_1 = require("../../utils/globs");
+const error_types_1 = require("../error-types");
+function isNxPluginV2(plugin) {
+    return 'createNodes' in plugin || 'createDependencies' in plugin;
+}
+function isNxPluginV1(plugin) {
+    return 'processProjectGraph' in plugin || 'projectFilePatterns' in plugin;
+}
+function normalizeNxPlugin(plugin) {
+    if (isNxPluginV2(plugin)) {
+        return plugin;
+    }
+    if (isNxPluginV1(plugin) && plugin.projectFilePatterns) {
+        return {
+            ...plugin,
+            createNodes: [
+                `*/**/${(0, globs_1.combineGlobPatterns)(plugin.projectFilePatterns)}`,
+                (configFilePath) => {
+                    const root = (0, node_path_1.dirname)(configFilePath);
+                    return {
+                        projects: {
+                            [root]: {
+                                name: (0, to_project_name_1.toProjectName)(configFilePath),
+                                targets: plugin.registerProjectTargets?.(configFilePath),
+                            },
+                        },
+                    };
+                },
+            ],
+        };
+    }
+    return plugin;
+}
+async function createNodesFromFiles(createNodes, configFiles, options, context) {
+    const results = [];
+    const errors = [];
+    await Promise.all(configFiles.map(async (file) => {
+        try {
+            const value = await createNodes(file, options, {
+                ...context,
+                configFiles,
+            });
+            if (value) {
+                results.push([file, value]);
+            }
+        }
+        catch (e) {
+            errors.push([file, e]);
+        }
+    }));
+    if (errors.length > 0) {
+        throw new error_types_1.AggregateCreateNodesError(errors, results);
+    }
+    return results;
+}

package/src/project-graph/project-graph-builder.d.ts

@@ -0,0 +1,133 @@
+/**
+ * Builder for adding nodes and dependencies to a {@link ProjectGraph}
+ */
+import { DependencyType, FileMap, ProjectFileMap, ProjectGraph, ProjectGraphExternalNode, ProjectGraphProjectNode } from '../config/project-graph';
+import { CreateDependenciesContext } from './plugins';
+/**
+ * A class which builds up a project graph
+ * @deprecated The {@link ProjectGraphProcessor} has been deprecated. Use a {@link CreateNodes} and/or a {@link CreateDependencies} instead. This will be removed in Nx 20.
+ */
+export declare class ProjectGraphBuilder {
+    readonly graph: ProjectGraph;
+    private readonly projectFileMap;
+    private readonly nonProjectFiles;
+    readonly removedEdges: {
+        [source: string]: Set<string>;
+    };
+    constructor(graph?: ProjectGraph, projectFileMap?: ProjectFileMap, nonProjectFiles?: FileMap['nonProjectFiles']);
+    /**
+     * Merges the nodes and dependencies of p into the built project graph.
+     */
+    mergeProjectGraph(p: ProjectGraph): void;
+    /**
+     * Adds a project node to the project graph
+     */
+    addNode(node: ProjectGraphProjectNode): void;
+    /**
+     * Removes a node and all of its dependency edges from the graph
+     */
+    removeNode(name: string): void;
+    /**
+     * Adds a external node to the project graph
+     */
+    addExternalNode(node: ProjectGraphExternalNode): void;
+    /**
+     * Adds static dependency from source project to target project
+     */
+    addStaticDependency(sourceProjectName: string, targetProjectName: string, sourceProjectFile?: string): void;
+    /**
+     * Adds dynamic dependency from source project to target project
+     */
+    addDynamicDependency(sourceProjectName: string, targetProjectName: string, sourceProjectFile: string): void;
+    /**
+     * Adds implicit dependency from source project to target project
+     */
+    addImplicitDependency(sourceProjectName: string, targetProjectName: string): void;
+    /**
+     * Removes a dependency from source project to target project
+     */
+    removeDependency(sourceProjectName: string, targetProjectName: string): void;
+    /**
+     * Add an explicit dependency from a file in source project to target project
+     * @deprecated this method will be removed in v17. Use {@link addStaticDependency} or {@link addDynamicDependency} instead
+     */
+    addExplicitDependency(sourceProjectName: string, sourceProjectFile: string, targetProjectName: string): void;
+    /**
+     * Set version of the project graph
+     */
+    setVersion(version: string): void;
+    getUpdatedProjectGraph(): ProjectGraph;
+    addDependency(source: string, target: string, type: DependencyType, sourceFile?: string): void;
+    private removeDependenciesWithNode;
+    private calculateTargetDepsFromFiles;
+    private calculateAlreadySetTargetDeps;
+}
+/**
+ * A static {@link ProjectGraph} dependency between 2 projects
+ *
+ * This type of dependency indicates the source project ALWAYS load the target project.
+ *
+ * NOTE: {@link StaticDependency#sourceFile} MUST be present unless the source is the name of a {@link ProjectGraphExternalNode}
+ */
+export type StaticDependency = {
+    /**
+     * The name of a {@link ProjectGraphProjectNode} or {@link ProjectGraphExternalNode} depending on the target project
+     */
+    source: string;
+    /**
+     * The name of a {@link ProjectGraphProjectNode} or {@link ProjectGraphExternalNode} that the source project depends on
+     */
+    target: string;
+    /**
+     * The path of a file (relative from the workspace root) where the dependency is made
+     */
+    sourceFile?: string;
+    type: typeof DependencyType.static;
+};
+/**
+ * A dynamic {@link ProjectGraph} dependency between 2 projects
+ *
+ * This type of dependency indicates the source project MAY OR MAY NOT load the target project.
+ */
+export type DynamicDependency = {
+    /**
+     * The name of a {@link ProjectGraphProjectNode} depending on the target project
+     */
+    source: string;
+    /**
+     * The name of a {@link ProjectGraphProjectNode}  that the source project depends on
+     */
+    target: string;
+    /**
+     * The path of a file (relative from the workspace root) where the dependency is made
+     */
+    sourceFile: string;
+    type: typeof DependencyType.dynamic;
+};
+/**
+ * An implicit {@link ProjectGraph} dependency between 2 projects
+ *
+ * This type of dependency indicates a connection without an explicit reference in code
+ */
+export type ImplicitDependency = {
+    /**
+     * The name of a {@link ProjectGraphProjectNode} depending on the target project
+     */
+    source: string;
+    /**
+     * The name of a {@link ProjectGraphProjectNode} that the source project depends on
+     */
+    target: string;
+    type: typeof DependencyType.implicit;
+};
+/**
+ * A {@link ProjectGraph} dependency between 2 projects
+ *
+ * See {@link DynamicDependency}, {@link ImplicitDependency}, or {@link StaticDependency}
+ */
+export type RawProjectGraphDependency = ImplicitDependency | StaticDependency | DynamicDependency;
+/**
+ * A function to validate dependencies in a {@link CreateDependencies} function
+ * @throws If the dependency is invalid.
+ */
+export declare function validateDependency(dependency: RawProjectGraphDependency, ctx: CreateDependenciesContext): void;