@ohos-ports/nx 17.3.2-beta.0

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

@@ -0,0 +1,188 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProjectGraphAndSourceMapsAsync = exports.createProjectGraphAsync = exports.buildProjectGraphAndSourceMapsWithoutDaemon = exports.readProjectsConfigurationFromProjectGraph = exports.readCachedProjectConfiguration = exports.readCachedProjectGraph = void 0;
+const nx_deps_cache_1 = require("./nx-deps-cache");
+const build_project_graph_1 = require("./build-project-graph");
+const output_1 = require("../utils/output");
+const tmp_dir_1 = require("../daemon/tmp-dir");
+const strip_indents_1 = require("../utils/strip-indents");
+const client_1 = require("../daemon/client/client");
+const fileutils_1 = require("../utils/fileutils");
+const workspace_root_1 = require("../utils/workspace-root");
+const perf_hooks_1 = require("perf_hooks");
+const retrieve_workspace_files_1 = require("./utils/retrieve-workspace-files");
+const nx_json_1 = require("../config/nx-json");
+const nx_plugin_1 = require("../utils/nx-plugin");
+/**
+ * Synchronously reads the latest cached copy of the workspace's ProjectGraph.
+ * @throws {Error} if there is no cached ProjectGraph to read from
+ */
+function readCachedProjectGraph() {
+    const projectGraphCache = (0, nx_deps_cache_1.readProjectGraphCache)();
+    if (!projectGraphCache) {
+        const angularSpecificError = (0, fileutils_1.fileExists)(`${workspace_root_1.workspaceRoot}/angular.json`)
+            ? (0, strip_indents_1.stripIndents) `
+      Make sure invoke 'node ./decorate-angular-cli.js' in your postinstall script.
+      The decorated CLI will compute the project graph.
+      'ng --help' should say 'Smart Monorepos · Fast CI'.
+      `
+            : '';
+        throw new Error((0, strip_indents_1.stripIndents) `
+      [readCachedProjectGraph] ERROR: No cached ProjectGraph is available.
+
+      If you are leveraging \`readCachedProjectGraph()\` directly then you will need to refactor your usage to first ensure that
+      the ProjectGraph is created by calling \`await createProjectGraphAsync()\` somewhere before attempting to read the data.
+
+      If you encounter this error as part of running standard \`nx\` commands then please open an issue on https://github.com/nrwl/nx
+
+      ${angularSpecificError}
+    `);
+    }
+    return projectGraphCache;
+}
+exports.readCachedProjectGraph = readCachedProjectGraph;
+function readCachedProjectConfiguration(projectName) {
+    const graph = readCachedProjectGraph();
+    const node = graph.nodes[projectName];
+    try {
+        return node.data;
+    }
+    catch (e) {
+        throw new Error(`Cannot find project: '${projectName}' in your workspace.`);
+    }
+}
+exports.readCachedProjectConfiguration = readCachedProjectConfiguration;
+/**
+ * Get the {@link ProjectsConfigurations} from the {@link ProjectGraph}
+ */
+function readProjectsConfigurationFromProjectGraph(projectGraph) {
+    return {
+        projects: Object.fromEntries(Object.entries(projectGraph.nodes).map(([project, { data }]) => [
+            project,
+            data,
+        ])),
+        version: 2,
+    };
+}
+exports.readProjectsConfigurationFromProjectGraph = readProjectsConfigurationFromProjectGraph;
+async function buildProjectGraphAndSourceMapsWithoutDaemon() {
+    const nxJson = (0, nx_json_1.readNxJson)();
+    perf_hooks_1.performance.mark('retrieve-project-configurations:start');
+    const { projects, externalNodes, sourceMaps, projectRootMap } = await (0, retrieve_workspace_files_1.retrieveProjectConfigurations)(workspace_root_1.workspaceRoot, nxJson);
+    perf_hooks_1.performance.mark('retrieve-project-configurations:end');
+    perf_hooks_1.performance.mark('retrieve-workspace-files:start');
+    const { allWorkspaceFiles, fileMap, rustReferences } = await (0, retrieve_workspace_files_1.retrieveWorkspaceFiles)(workspace_root_1.workspaceRoot, projectRootMap);
+    perf_hooks_1.performance.mark('retrieve-workspace-files:end');
+    const cacheEnabled = process.env.NX_CACHE_PROJECT_GRAPH !== 'false';
+    perf_hooks_1.performance.mark('build-project-graph-using-project-file-map:start');
+    const projectGraph = (await (0, build_project_graph_1.buildProjectGraphUsingProjectFileMap)(projects, externalNodes, fileMap, allWorkspaceFiles, rustReferences, cacheEnabled ? (0, nx_deps_cache_1.readFileMapCache)() : null, cacheEnabled)).projectGraph;
+    perf_hooks_1.performance.mark('build-project-graph-using-project-file-map:end');
+    (0, nx_plugin_1.unregisterPluginTSTranspiler)();
+    return { projectGraph, sourceMaps };
+}
+exports.buildProjectGraphAndSourceMapsWithoutDaemon = buildProjectGraphAndSourceMapsWithoutDaemon;
+function handleProjectGraphError(opts, e) {
+    if (opts.exitOnError) {
+        const lines = e.message.split('\n');
+        output_1.output.error({
+            title: lines[0],
+            bodyLines: lines.slice(1),
+        });
+        if (process.env.NX_VERBOSE_LOGGING === 'true') {
+            console.error(e);
+        }
+        process.exit(1);
+    }
+    else {
+        throw e;
+    }
+}
+/**
+ * Computes and returns a ProjectGraph.
+ *
+ * Nx will compute the graph either in a daemon process or in the current process.
+ *
+ * Nx will compute it in the current process if:
+ * * The process is running in CI (CI env variable is to true or other common variables used by CI providers are set).
+ * * It is running in the docker container.
+ * * The daemon process is disabled because of the previous error when starting the daemon.
+ * * `NX_DAEMON` is set to `false`.
+ * * `useDaemonProcess` is set to false in the options of the tasks runner inside `nx.json`
+ *
+ * `NX_DAEMON` env variable takes precedence:
+ * * If it is set to true, the daemon will always be used.
+ * * If it is set to false, the graph will always be computed in the current process.
+ *
+ * Tip: If you want to debug project graph creation, run your command with NX_DAEMON=false.
+ *
+ * Nx uses two layers of caching: the information about explicit dependencies stored on the disk and the information
+ * stored in the daemon process. To reset both run: `nx reset`.
+ */
+async function createProjectGraphAsync(opts = {
+    exitOnError: false,
+    resetDaemonClient: false,
+}) {
+    const projectGraphAndSourceMaps = await createProjectGraphAndSourceMapsAsync(opts);
+    return projectGraphAndSourceMaps.projectGraph;
+}
+exports.createProjectGraphAsync = createProjectGraphAsync;
+async function createProjectGraphAndSourceMapsAsync(opts = {
+    exitOnError: false,
+    resetDaemonClient: false,
+}) {
+    perf_hooks_1.performance.mark('create-project-graph-async:start');
+    if (!client_1.daemonClient.enabled()) {
+        try {
+            const res = await buildProjectGraphAndSourceMapsWithoutDaemon();
+            perf_hooks_1.performance.measure('create-project-graph-async >> retrieve-project-configurations', 'retrieve-project-configurations:start', 'retrieve-project-configurations:end');
+            perf_hooks_1.performance.measure('create-project-graph-async >> retrieve-workspace-files', 'retrieve-workspace-files:start', 'retrieve-workspace-files:end');
+            perf_hooks_1.performance.measure('create-project-graph-async >> build-project-graph-using-project-file-map', 'build-project-graph-using-project-file-map:start', 'build-project-graph-using-project-file-map:end');
+            perf_hooks_1.performance.mark('create-project-graph-async:end');
+            perf_hooks_1.performance.measure('create-project-graph-async', 'create-project-graph-async:start', 'create-project-graph-async:end');
+            return res;
+        }
+        catch (e) {
+            handleProjectGraphError(opts, e);
+        }
+    }
+    else {
+        try {
+            const projectGraphAndSourceMaps = await client_1.daemonClient.getProjectGraphAndSourceMaps();
+            if (opts.resetDaemonClient) {
+                client_1.daemonClient.reset();
+            }
+            perf_hooks_1.performance.mark('create-project-graph-async:end');
+            perf_hooks_1.performance.measure('create-project-graph-async', 'create-project-graph-async:start', 'create-project-graph-async:end');
+            return projectGraphAndSourceMaps;
+        }
+        catch (e) {
+            if (e.message.indexOf('inotify_add_watch') > -1) {
+                // common errors with the daemon due to OS settings (cannot watch all the files available)
+                output_1.output.note({
+                    title: `Unable to start Nx Daemon due to the limited amount of inotify watches, continuing without the daemon.`,
+                    bodyLines: [
+                        'For more information read: https://askubuntu.com/questions/1088272/inotify-add-watch-failed-no-space-left-on-device',
+                        'Nx Daemon is going to be disabled until you run "nx reset".',
+                    ],
+                });
+                (0, tmp_dir_1.markDaemonAsDisabled)();
+                return buildProjectGraphAndSourceMapsWithoutDaemon();
+            }
+            if (e.internalDaemonError) {
+                const errorLogFile = (0, tmp_dir_1.writeDaemonLogs)(e.message);
+                output_1.output.warn({
+                    title: `Nx Daemon was not able to compute the project graph.`,
+                    bodyLines: [
+                        `Log file with the error: ${errorLogFile}`,
+                        `Please file an issue at https://github.com/nrwl/nx`,
+                        'Nx Daemon is going to be disabled until you run "nx reset".',
+                    ],
+                });
+                (0, tmp_dir_1.markDaemonAsDisabled)();
+                return buildProjectGraphAndSourceMapsWithoutDaemon();
+            }
+            handleProjectGraphError(opts, e);
+        }
+    }
+}
+exports.createProjectGraphAndSourceMapsAsync = createProjectGraphAndSourceMapsAsync;

package/src/project-graph/utils/build-all-workspace-files.d.ts

@@ -0,0 +1,2 @@
+import { FileData, ProjectFileMap } from '../../config/project-graph';
+export declare function buildAllWorkspaceFiles(projectFileMap: ProjectFileMap, globalFiles: FileData[]): FileData[];

package/src/project-graph/utils/build-all-workspace-files.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildAllWorkspaceFiles = void 0;
+const perf_hooks_1 = require("perf_hooks");
+function buildAllWorkspaceFiles(projectFileMap, globalFiles) {
+    perf_hooks_1.performance.mark('get-all-workspace-files:start');
+    let fileData = Object.values(projectFileMap).flat();
+    fileData = fileData
+        .concat(globalFiles)
+        .sort((a, b) => a.file.localeCompare(b.file));
+    perf_hooks_1.performance.mark('get-all-workspace-files:end');
+    perf_hooks_1.performance.measure('get-all-workspace-files', 'get-all-workspace-files:start', 'get-all-workspace-files:end');
+    return fileData;
+}
+exports.buildAllWorkspaceFiles = buildAllWorkspaceFiles;

package/src/project-graph/utils/find-project-for-path.d.ts

@@ -0,0 +1,20 @@
+import { ProjectGraphProjectNode } from '../../config/project-graph';
+import { ProjectConfiguration } from '../../config/workspace-json-project-json';
+export type ProjectRootMappings = Map<string, string>;
+/**
+ * This creates a map of project roots to project names to easily look up the project of a file
+ * @param projects This is the map of project configurations commonly found in "workspace.json"
+ */
+export declare function createProjectRootMappingsFromProjectConfigurations(projects: Record<string, ProjectConfiguration>): ProjectRootMappings;
+/**
+ * This creates a map of project roots to project names to easily look up the project of a file
+ * @param nodes This is the nodes from the project graph
+ */
+export declare function createProjectRootMappings(nodes: Record<string, ProjectGraphProjectNode>): ProjectRootMappings;
+/**
+ * Locates a project in projectRootMap based on a file within it
+ * @param filePath path that is inside of projectName. This should be relative from the workspace root
+ * @param projectRootMap Map<projectRoot, projectName> Use {@link createProjectRootMappings} to create this
+ */
+export declare function findProjectForPath(filePath: string, projectRootMap: ProjectRootMappings): string | null;
+export declare function normalizeProjectRoot(root: string): string;

package/src/project-graph/utils/find-project-for-path.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeProjectRoot = exports.findProjectForPath = exports.createProjectRootMappings = exports.createProjectRootMappingsFromProjectConfigurations = void 0;
+const path_1 = require("path");
+const path_2 = require("../../utils/path");
+/**
+ * This creates a map of project roots to project names to easily look up the project of a file
+ * @param projects This is the map of project configurations commonly found in "workspace.json"
+ */
+function createProjectRootMappingsFromProjectConfigurations(projects) {
+    const projectRootMappings = new Map();
+    for (const projectName of Object.keys(projects)) {
+        const root = projects[projectName].root;
+        projectRootMappings.set(normalizeProjectRoot(root), projectName);
+    }
+    return projectRootMappings;
+}
+exports.createProjectRootMappingsFromProjectConfigurations = createProjectRootMappingsFromProjectConfigurations;
+/**
+ * This creates a map of project roots to project names to easily look up the project of a file
+ * @param nodes This is the nodes from the project graph
+ */
+function createProjectRootMappings(nodes) {
+    const projectRootMappings = new Map();
+    for (const projectName of Object.keys(nodes)) {
+        let root = nodes[projectName].data.root;
+        projectRootMappings.set(normalizeProjectRoot(root), projectName);
+    }
+    return projectRootMappings;
+}
+exports.createProjectRootMappings = createProjectRootMappings;
+/**
+ * Locates a project in projectRootMap based on a file within it
+ * @param filePath path that is inside of projectName. This should be relative from the workspace root
+ * @param projectRootMap Map<projectRoot, projectName> Use {@link createProjectRootMappings} to create this
+ */
+function findProjectForPath(filePath, projectRootMap) {
+    /**
+     * Project Mappings are in UNIX-style file paths
+     * Windows may pass Win-style file paths
+     * Ensure filePath is in UNIX-style
+     */
+    let currentPath = (0, path_2.normalizePath)(filePath);
+    for (; currentPath != (0, path_1.dirname)(currentPath); currentPath = (0, path_1.dirname)(currentPath)) {
+        const p = projectRootMap.get(currentPath);
+        if (p) {
+            return p;
+        }
+    }
+    return projectRootMap.get(currentPath);
+}
+exports.findProjectForPath = findProjectForPath;
+function normalizeProjectRoot(root) {
+    root = root === '' ? '.' : root;
+    return root && root.endsWith('/') ? root.substring(0, root.length - 1) : root;
+}
+exports.normalizeProjectRoot = normalizeProjectRoot;

package/src/project-graph/utils/implicit-project-dependencies.d.ts

@@ -0,0 +1,3 @@
+import { ProjectConfiguration } from '../../config/workspace-json-project-json';
+import { ProjectGraphBuilder } from '../project-graph-builder';
+export declare function applyImplicitDependencies(projects: Record<string, ProjectConfiguration>, builder: ProjectGraphBuilder): void;

package/src/project-graph/utils/implicit-project-dependencies.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyImplicitDependencies = void 0;
+function applyImplicitDependencies(projects, builder) {
+    Object.keys(projects).forEach((source) => {
+        const p = projects[source];
+        if (p.implicitDependencies && p.implicitDependencies.length > 0) {
+            p.implicitDependencies.forEach((target) => {
+                if (target.startsWith('!')) {
+                    builder.removeDependency(source, target.slice(1));
+                }
+                else {
+                    builder.addImplicitDependency(source, target);
+                }
+            });
+        }
+    });
+}
+exports.applyImplicitDependencies = applyImplicitDependencies;

package/src/project-graph/utils/normalize-project-nodes.d.ts

@@ -0,0 +1,10 @@
+import { ProjectGraphProjectNode } from '../../config/project-graph';
+import { ProjectGraphBuilder } from '../project-graph-builder';
+import { ProjectConfiguration, TargetConfiguration } from '../../config/workspace-json-project-json';
+import { CreateDependenciesContext } from '../../utils/nx-plugin';
+export declare function normalizeProjectNodes(ctx: CreateDependenciesContext, builder: ProjectGraphBuilder): Promise<void>;
+/**
+ * Apply target defaults and normalization
+ */
+export declare function normalizeProjectTargets(project: ProjectConfiguration, projectName: string): Record<string, TargetConfiguration>;
+export declare function normalizeImplicitDependencies(source: string, implicitDependencies: ProjectConfiguration['implicitDependencies'], projects: Record<string, ProjectGraphProjectNode>): string[];

package/src/project-graph/utils/normalize-project-nodes.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeImplicitDependencies = exports.normalizeProjectTargets = exports.normalizeProjectNodes = void 0;
+const find_matching_projects_1 = require("../../utils/find-matching-projects");
+const project_configuration_utils_1 = require("../utils/project-configuration-utils");
+async function normalizeProjectNodes(ctx, builder) {
+    const toAdd = [];
+    // Sorting projects by name to make sure that the order of projects in the graph is deterministic.
+    // This is important to ensure that expanded properties referencing projects (e.g. implicit dependencies)
+    // are also deterministic, and thus don't cause the calculated project configuration hash to shift.
+    const projects = Object.keys(ctx.projects).sort();
+    // Used for expanding implicit dependencies (e.g. `@proj/*` or `tag:foo`)
+    const partialProjectGraphNodes = projects.reduce((graph, project) => {
+        const projectConfiguration = ctx.projects[project];
+        graph[project] = {
+            name: project,
+            type: projectConfiguration.projectType === 'library' ? 'lib' : 'app', // missing fallback to `e2e`
+            data: {
+                ...projectConfiguration,
+            },
+        };
+        return graph;
+    }, {});
+    for (const key of projects) {
+        const p = ctx.projects[key];
+        p.implicitDependencies = normalizeImplicitDependencies(key, p.implicitDependencies, partialProjectGraphNodes);
+        p.targets = normalizeProjectTargets(p, key);
+        // TODO: remove in v16
+        const projectType = p.projectType === 'application'
+            ? key.endsWith('-e2e') || key === 'e2e'
+                ? 'e2e'
+                : 'app'
+            : 'lib';
+        const tags = ctx.projects?.[key]?.tags || [];
+        toAdd.push({
+            name: key,
+            type: projectType,
+            data: {
+                ...p,
+                tags,
+            },
+        });
+    }
+    // Sort by root directory length (do we need this?)
+    toAdd.sort((a, b) => {
+        if (!a.data.root)
+            return -1;
+        if (!b.data.root)
+            return -1;
+        return a.data.root.length > b.data.root.length ? -1 : 1;
+    });
+    toAdd.forEach((n) => {
+        builder.addNode({
+            name: n.name,
+            type: n.type,
+            data: n.data,
+        });
+    });
+}
+exports.normalizeProjectNodes = normalizeProjectNodes;
+/**
+ * Apply target defaults and normalization
+ */
+function normalizeProjectTargets(project, projectName) {
+    // Any node on the graph will have a targets object, it just may be empty
+    const targets = project.targets ?? {};
+    for (const target in targets) {
+        if (!targets[target].command && !targets[target].executor) {
+            delete targets[target];
+            continue;
+        }
+        targets[target].options = (0, project_configuration_utils_1.resolveNxTokensInOptions)(targets[target].options, project, `${projectName}:${target}`);
+        targets[target].configurations ??= {};
+        for (const configuration in targets[target].configurations) {
+            targets[target].configurations[configuration] = (0, project_configuration_utils_1.resolveNxTokensInOptions)(targets[target].configurations[configuration], project, `${projectName}:${target}:${configuration}`);
+        }
+    }
+    return targets;
+}
+exports.normalizeProjectTargets = normalizeProjectTargets;
+function normalizeImplicitDependencies(source, implicitDependencies, projects) {
+    if (!implicitDependencies?.length) {
+        return implicitDependencies ?? [];
+    }
+    const matches = (0, find_matching_projects_1.findMatchingProjects)(implicitDependencies, projects);
+    return (matches
+        .filter((x) => x !== source)
+        // implicit dependencies that start with ! should hang around, to be processed by
+        // implicit-project-dependencies.ts after explicit deps are added to graph.
+        .concat(implicitDependencies.filter((x) => x.startsWith('!'))));
+}
+exports.normalizeImplicitDependencies = normalizeImplicitDependencies;

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

@@ -0,0 +1,53 @@
+import { NxJsonConfiguration, TargetDefaults } from '../../config/nx-json';
+import { ProjectGraphExternalNode } from '../../config/project-graph';
+import { ProjectConfiguration, TargetConfiguration } from '../../config/workspace-json-project-json';
+import { LoadedNxPlugin } from '../../utils/nx-plugin';
+import { ONLY_MODIFIES_EXISTING_TARGET } from '../../plugins/target-defaults/target-defaults-plugin';
+export type SourceInformation = [file: string, plugin: string];
+export type ConfigurationSourceMaps = Record<string, Record<string, SourceInformation>>;
+export declare function mergeProjectConfigurationIntoRootMap(projectRootMap: Map<string, ProjectConfiguration>, project: ProjectConfiguration & {
+    targets?: Record<string, TargetConfiguration & {
+        [ONLY_MODIFIES_EXISTING_TARGET]?: boolean;
+    }>;
+}, configurationSourceMaps?: ConfigurationSourceMaps, sourceInformation?: SourceInformation, skipCommandNormalization?: boolean): void;
+export type ConfigurationResult = {
+    projects: Record<string, ProjectConfiguration>;
+    externalNodes: Record<string, ProjectGraphExternalNode>;
+    rootMap: Record<string, string>;
+    sourceMaps: ConfigurationSourceMaps;
+};
+/**
+ * Transforms a list of project paths into a map of project configurations.
+ *
+ * @param nxJson The NxJson configuration
+ * @param projectFiles A list of files identified as projects
+ * @param plugins The plugins that should be used to infer project configuration
+ * @param root The workspace root
+ */
+export declare function buildProjectsConfigurationsFromProjectPathsAndPlugins(nxJson: NxJsonConfiguration, projectFiles: string[], // making this parameter allows devkit to pick up newly created projects
+plugins: LoadedNxPlugin[], root?: string): Promise<ConfigurationResult>;
+export declare function readProjectConfigurationsFromRootMap(projectRootMap: Map<string, ProjectConfiguration>): Record<string, ProjectConfiguration>;
+/**
+ * Merges two targets.
+ *
+ * Most properties from `target` will overwrite any properties from `baseTarget`.
+ * Options and configurations are treated differently - they are merged together if the executor definition is compatible.
+ *
+ * @param target The target definition with higher priority
+ * @param baseTarget The target definition that should be overwritten. Can be undefined, in which case the target is returned as-is.
+ * @param projectConfigSourceMap The source map to be filled with metadata about where each property came from
+ * @param sourceInformation The metadata about where the new target was defined
+ * @param targetIdentifier The identifier for the target to merge, used for source map
+ * @returns A merged target configuration
+ */
+export declare function mergeTargetConfigurations(target: TargetConfiguration, baseTarget?: TargetConfiguration, projectConfigSourceMap?: Record<string, SourceInformation>, sourceInformation?: SourceInformation, targetIdentifier?: string): TargetConfiguration;
+/**
+ * Checks if targets options are compatible - used when merging configurations
+ * to avoid merging options for @nx/js:tsc into something like @nx/webpack:webpack.
+ *
+ * If the executors are both specified and don't match, the options aren't considered
+ * "compatible" and shouldn't be merged.
+ */
+export declare function isCompatibleTarget(a: TargetConfiguration, b: TargetConfiguration): boolean;
+export declare function resolveNxTokensInOptions<T extends Object | Array<unknown>>(object: T, project: ProjectConfiguration, key: string): T;
+export declare function readTargetDefaultsForTarget(targetName: string, targetDefaults: TargetDefaults, executor?: string): TargetDefaults[string];