nx 20.8.4 → 22.7.7

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

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectHasTarget = projectHasTarget;
+exports.projectHasTargetAndConfiguration = projectHasTargetAndConfiguration;
+exports.getSourceDirOfDependentProjects = getSourceDirOfDependentProjects;
+exports.findAllProjectNodeDependencies = findAllProjectNodeDependencies;
+exports.getProjectSourceRoot = getProjectSourceRoot;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const project_graph_1 = require("../project-graph/project-graph");
+function projectHasTarget(project, target) {
+    return !!(project.data &&
+        project.data.targets &&
+        project.data.targets[target]);
+}
+function projectHasTargetAndConfiguration(project, target, configuration) {
+    return (projectHasTarget(project, target) &&
+        project.data.targets[target].configurations &&
+        project.data.targets[target].configurations[configuration]);
+}
+function getSourceDirOfDependentProjects(projectName, projectGraph = (0, project_graph_1.readCachedProjectGraph)()) {
+    if (!projectGraph.nodes[projectName]) {
+        throw new Error(`Couldn't find project "${projectName}" in this Nx workspace`);
+    }
+    const nodeNames = findAllProjectNodeDependencies(projectName, projectGraph);
+    return nodeNames.reduce((result, nodeName) => {
+        const sourceRoot = getProjectSourceRoot(projectGraph.nodes[nodeName].data);
+        result[0].push(sourceRoot);
+        return result;
+    }, [[], []]);
+}
+/**
+ * Find all internal project dependencies.
+ * All the external (npm) dependencies will be filtered out unless includeExternalDependencies is set to true
+ * @param {string} parentNodeName
+ * @param {ProjectGraph} projectGraph
+ * @param includeExternalDependencies
+ * @returns {string[]}
+ */
+function findAllProjectNodeDependencies(parentNodeName, projectGraph = (0, project_graph_1.readCachedProjectGraph)(), includeExternalDependencies = false) {
+    const dependencyNodeNames = new Set();
+    collectDependentProjectNodesNames(projectGraph, dependencyNodeNames, parentNodeName, includeExternalDependencies);
+    return Array.from(dependencyNodeNames);
+}
+// Recursively get all the dependencies of the node
+function collectDependentProjectNodesNames(nxDeps, dependencyNodeNames, parentNodeName, includeExternalDependencies) {
+    const dependencies = nxDeps.dependencies[parentNodeName];
+    if (!dependencies) {
+        // no dependencies for the given node, so silently return,
+        // as we probably wouldn't want to throw here
+        return;
+    }
+    for (const dependency of dependencies) {
+        const dependencyName = dependency.target;
+        // skip dependencies already added (avoid circular dependencies)
+        if (dependencyNodeNames.has(dependencyName)) {
+            continue;
+        }
+        // we're only interested in internal nodes, not external
+        if (nxDeps.externalNodes?.[dependencyName]) {
+            if (includeExternalDependencies) {
+                dependencyNodeNames.add(dependencyName);
+            }
+            else {
+                continue;
+            }
+        }
+        dependencyNodeNames.add(dependencyName);
+        // Get the dependencies of the dependencies
+        collectDependentProjectNodesNames(nxDeps, dependencyNodeNames, dependencyName, includeExternalDependencies);
+    }
+}
+function getProjectSourceRoot(project) {
+    return (project.sourceRoot ??
+        ((0, node_fs_1.existsSync)(node_path_1.posix.join(project.root, 'src'))
+            ? node_path_1.posix.join(project.root, 'src')
+            : project.root));
+}

package/dist/src/utils/provenance.d.ts

@@ -0,0 +1,47 @@
+export declare function ensurePackageHasProvenance(packageName: string, packageVersion: string): Promise<void>;
+export declare class ProvenanceError extends Error {
+    constructor(packageName: string, packageVersion: string, error?: string);
+}
+export declare function getNxPackageGroup(): string[];
+export type DecodedAttestationPayload = {
+    _type: 'https://in-toto.io/Statement/v1';
+    subject: unknown[];
+    predicateType: 'https://slsa.dev/provenance/v1';
+    predicate: {
+        buildDefinition: {
+            buildType: string;
+            externalParameters: Record<string, any>;
+            internalParameters?: Record<string, any>;
+            resolvedDependencies?: ResourceDescriptor[];
+        };
+        runDetails: {
+            builder: {
+                id: string;
+                builderDependencies?: ResourceDescriptor[];
+                version?: Record<string, string>;
+            };
+            metadata?: {
+                invocationId?: string;
+                startedOn?: string;
+                finishedOn?: string;
+            };
+            byproducts?: ResourceDescriptor[];
+        };
+    };
+};
+export interface ResourceDescriptor {
+    uri?: string;
+    digest?: {
+        sha256?: string;
+        sha512?: string;
+        gitCommit?: string;
+        [key: string]: string | undefined;
+    };
+    name?: string;
+    downloadLocation?: string;
+    mediaType?: string;
+    content?: string;
+    annotations?: {
+        [key: string]: any;
+    };
+}

package/dist/src/utils/provenance.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProvenanceError = void 0;
+exports.ensurePackageHasProvenance = ensurePackageHasProvenance;
+exports.getNxPackageGroup = getNxPackageGroup;
+const child_process_1 = require("child_process");
+const module_1 = require("module");
+const fileutils_1 = require("./fileutils");
+const package_manager_1 = require("./package-manager");
+/*
+ * Verifies that the given npm package has provenance attestations
+ * generated by the GitHub Actions workflow at .github/workflows/publish.yml
+ * in the nrwl/nx repository.
+ *
+ * Will throw if the package does not have valid provenance.
+ */
+async function ensurePackageHasProvenance(packageName, packageVersion) {
+    // this is used for locally released versions without provenance
+    // do not set this for other reasons or you might be exposed to security risks
+    if (process.env.NX_SKIP_PROVENANCE_CHECK) {
+        return;
+    }
+    try {
+        const result = await (0, package_manager_1.packageRegistryView)(packageName, packageVersion, '--json --silent');
+        const npmViewResult = JSON.parse(result);
+        const attURL = npmViewResult.dist?.attestations?.url;
+        if (!attURL)
+            throw new ProvenanceError(packageName, packageVersion, 'No attestation URL found');
+        const response = await fetch(attURL);
+        if (!response.ok) {
+            throw new ProvenanceError(packageName, packageVersion, `HTTP ${response.status}: ${response.statusText}`);
+        }
+        const attestations = (await response.json());
+        const provenanceAttestation = attestations?.attestations?.find((a) => a.predicateType === 'https://slsa.dev/provenance/v1');
+        const dsseEnvelopePayload = JSON.parse(Buffer.from(provenanceAttestation.bundle.dsseEnvelope.payload, 'base64').toString());
+        const workflowParameters = dsseEnvelopePayload?.predicate?.buildDefinition?.externalParameters
+            ?.workflow;
+        // verify that provenance was actually generated from the right publishing workflow
+        if (!workflowParameters) {
+            throw new ProvenanceError(packageName, packageVersion, 'Missing workflow parameters in attestation');
+        }
+        if (workflowParameters.repository !== 'https://github.com/nrwl/nx') {
+            throw new ProvenanceError(packageName, packageVersion, 'Repository does not match nrwl/nx');
+        }
+        if (workflowParameters.path !== '.github/workflows/publish.yml') {
+            throw new ProvenanceError(packageName, packageVersion, 'Publishing workflow does not match .github/workflows/publish.yml');
+        }
+        if (workflowParameters.ref !== `refs/tags/${npmViewResult.version}`) {
+            throw new ProvenanceError(packageName, packageVersion, `Version ref does not match refs/tags/${npmViewResult.version}`);
+        }
+        // verify that provenance was generated from the exact same artifact as the one we are installing
+        const distSha = Buffer.from(npmViewResult.dist.integrity.replace('sha512-', ''), 'base64').toString('hex');
+        const attestationSha = dsseEnvelopePayload.subject[0].digest.sha512;
+        if (distSha !== attestationSha) {
+            throw new ProvenanceError(packageName, packageVersion, 'Integrity hash does not match attestation hash');
+        }
+        return;
+    }
+    catch (error) {
+        if (error instanceof ProvenanceError) {
+            throw error;
+        }
+        throw new ProvenanceError(packageName, packageVersion, error.message || error);
+    }
+}
+class ProvenanceError extends Error {
+    constructor(packageName, packageVersion, error) {
+        let customRegistry = undefined;
+        try {
+            const packageManager = (0, package_manager_1.detectPackageManager)();
+            const commands = (0, package_manager_1.getPackageManagerCommand)(packageManager);
+            // Try to get registry from current package manager, fall back to npm
+            const registryCommand = commands.getRegistryUrl ?? 'npm config get registry';
+            const registry = (0, child_process_1.execSync)(registryCommand, {
+                timeout: 5000,
+                windowsHide: true,
+                encoding: 'utf-8',
+            }).trim();
+            // Only consider it custom if it's not the default npm registry
+            if (registry &&
+                registry !== 'undefined' &&
+                !registry.includes('registry.npmjs.org')) {
+                customRegistry = registry;
+            }
+        }
+        catch {
+            // If we can't determine the registry, proceed with default error message
+        }
+        const registryNote = customRegistry
+            ? `This might be due to a custom registry configuration (${customRegistry}). Please check whether provenance is correctly configured for your registry.`
+            : `This could indicate a security risk. Please double check https://www.npmjs.com/package/${packageName} to see if the package is published correctly or file an issue at https://github.com/nrwl/nx/issues.`;
+        super(`An error occurred while checking the provenance of ${packageName}@${packageVersion}. ${registryNote} To disable this check at your own risk, you can set the NX_SKIP_PROVENANCE_CHECK environment variable to true. \n Error: ${error ?? ''}`);
+    }
+}
+exports.ProvenanceError = ProvenanceError;
+function getNxPackageGroup() {
+    const packageJsonPath = (0, module_1.createRequire)(__filename).resolve('nx/package.json');
+    const packageJson = (0, fileutils_1.readJsonFile)(packageJsonPath);
+    if (!packageJson['nx-migrations']?.packageGroup) {
+        return ['nx'];
+    }
+    const packages = packageJson['nx-migrations'].packageGroup.filter((dep) => typeof dep === 'string' && dep.startsWith('@nx/'));
+    packages.push('nx');
+    return packages;
+}

package/dist/src/utils/require-nx-key.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireNxKey = requireNxKey;
+const child_process_1 = require("child_process");
+const package_manager_1 = require("./package-manager");
+const handle_import_1 = require("./handle-import");
+async function requireNxKey() {
+    // @ts-ignore
+    return (0, handle_import_1.handleImport)('@nx/key').catch(async (e) => {
+        if ('code' in e && e.code === 'MODULE_NOT_FOUND') {
+            try {
+                (0, child_process_1.execSync)(`${(0, package_manager_1.getPackageManagerCommand)().addDev} @nx/key@latest`, {
+                    windowsHide: true,
+                });
+                // @ts-ignore
+                return await (0, handle_import_1.handleImport)('@nx/key');
+            }
+            catch (e) {
+                throw new Error('Failed to install @nx/key. Please install @nx/key and try again.');
+            }
+        }
+    });
+}

package/dist/src/utils/serialize-overrides-into-command-line.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeOverridesIntoCommandLine = serializeOverridesIntoCommandLine;
+const flat_1 = require("flat");
+const shell_quoting_1 = require("./shell-quoting");
+function serializeOverridesIntoCommandLine(options) {
+    const unparsed = options._ ? [...options._] : [];
+    for (const key of Object.keys(options)) {
+        const value = options[key];
+        if (key !== '_') {
+            serializeOption(key, value, unparsed);
+        }
+    }
+    return unparsed;
+}
+function serializeOption(key, value, unparsed) {
+    if (value === true) {
+        unparsed.push(`--${key}`);
+    }
+    else if (value === false) {
+        unparsed.push(`--no-${key}`);
+    }
+    else if (Array.isArray(value)) {
+        value.forEach((item) => serializeOption(key, item, unparsed));
+    }
+    else if (Object.prototype.toString.call(value) === '[object Object]') {
+        const flattened = (0, flat_1.flatten)(value, { safe: true });
+        for (const flattenedKey in flattened) {
+            serializeOption(`${key}.${flattenedKey}`, flattened[flattenedKey], unparsed);
+        }
+    }
+    else if (typeof value === 'string' &&
+        (0, shell_quoting_1.needsShellQuoting)(value) &&
+        !(0, shell_quoting_1.isAlreadyQuoted)(value)) {
+        const sanitized = value.replace(/"/g, String.raw `\"`);
+        unparsed.push(`--${key}="${sanitized}"`);
+    }
+    else if (value != null) {
+        unparsed.push(`--${key}=${value}`);
+    }
+}

package/dist/src/utils/shell-quoting.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Check if a string contains shell metacharacters that require quoting.
+ * These characters have special meaning in shell and would be interpreted
+ * incorrectly if not quoted (e.g., | for pipe, & for background, etc.)
+ */
+export declare function needsShellQuoting(str: string): boolean;
+/**
+ * Check if a string is already wrapped in matching quotes (single or double).
+ */
+export declare function isAlreadyQuoted(str: string): boolean;

package/dist/src/utils/shell-quoting.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.needsShellQuoting = needsShellQuoting;
+exports.isAlreadyQuoted = isAlreadyQuoted;
+/**
+ * Shell metacharacters that have special meaning and require quoting.
+ *
+ * Characters included:
+ * - | - pipe
+ * - & - background/AND
+ * - ; - command separator
+ * - < > - redirections
+ * - ( ) - subshell
+ * - $ - variable expansion
+ * - ` - command substitution
+ * - \ - escape
+ * - " ' - quotes
+ * - * ? [ ] - globbing
+ * - { } - brace expansion
+ * - ~ - home directory
+ * - # - comment
+ * - ! - history expansion
+ * - \s - whitespace (spaces, tabs, newlines)
+ */
+const SHELL_META_CHARS = /[|&;<>()$`\\!"'*?[\]{}~#\s]/;
+/**
+ * Check if a string contains shell metacharacters that require quoting.
+ * These characters have special meaning in shell and would be interpreted
+ * incorrectly if not quoted (e.g., | for pipe, & for background, etc.)
+ */
+function needsShellQuoting(str) {
+    return SHELL_META_CHARS.test(str);
+}
+/**
+ * Check if a string is already wrapped in matching quotes (single or double).
+ */
+function isAlreadyQuoted(str) {
+    return (str.length >= 2 &&
+        ((str[0] === "'" && str[str.length - 1] === "'") ||
+            (str[0] === '"' && str[str.length - 1] === '"')));
+}

package/dist/src/utils/spinner.d.ts

@@ -0,0 +1,12 @@
+export declare const SHOULD_SHOW_SPINNERS: boolean;
+declare class SpinnerManager {
+    #private;
+    start(text?: string, prefix?: string): SpinnerManager;
+    succeed(text?: string): void;
+    stop(): void;
+    fail(text?: string): void;
+    updateText(text?: string): void;
+    isSpinning(): boolean;
+}
+export declare const globalSpinner: SpinnerManager;
+export {};

package/dist/src/utils/spinner.js

@@ -0,0 +1,61 @@
+"use strict";
+var _SpinnerManager_instances, _SpinnerManager_ora, _SpinnerManager_prefix, _SpinnerManager_createOra;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.globalSpinner = exports.SHOULD_SHOW_SPINNERS = void 0;
+const tslib_1 = require("tslib");
+const ora_1 = tslib_1.__importDefault(require("ora"));
+const is_ci_1 = require("./is-ci");
+exports.SHOULD_SHOW_SPINNERS = process.stdout.isTTY && !(0, is_ci_1.isCI)();
+class SpinnerManager {
+    constructor() {
+        _SpinnerManager_instances.add(this);
+        _SpinnerManager_ora.set(this, void 0);
+        _SpinnerManager_prefix.set(this, void 0);
+    }
+    start(text, prefix) {
+        if (!exports.SHOULD_SHOW_SPINNERS) {
+            return this;
+        }
+        if (prefix !== undefined) {
+            tslib_1.__classPrivateFieldSet(this, _SpinnerManager_prefix, prefix, "f");
+        }
+        if (tslib_1.__classPrivateFieldGet(this, _SpinnerManager_ora, "f")) {
+            tslib_1.__classPrivateFieldGet(this, _SpinnerManager_ora, "f").text = text;
+            tslib_1.__classPrivateFieldGet(this, _SpinnerManager_ora, "f").prefixText = tslib_1.__classPrivateFieldGet(this, _SpinnerManager_prefix, "f");
+        }
+        else {
+            tslib_1.__classPrivateFieldGet(this, _SpinnerManager_instances, "m", _SpinnerManager_createOra).call(this, text);
+        }
+        tslib_1.__classPrivateFieldGet(this, _SpinnerManager_ora, "f").start();
+        return this;
+    }
+    succeed(text) {
+        tslib_1.__classPrivateFieldGet(this, _SpinnerManager_ora, "f")?.succeed(text);
+    }
+    stop() {
+        tslib_1.__classPrivateFieldGet(this, _SpinnerManager_ora, "f")?.stop();
+    }
+    fail(text) {
+        tslib_1.__classPrivateFieldGet(this, _SpinnerManager_ora, "f")?.fail(text);
+    }
+    updateText(text) {
+        if (tslib_1.__classPrivateFieldGet(this, _SpinnerManager_ora, "f")) {
+            tslib_1.__classPrivateFieldGet(this, _SpinnerManager_ora, "f").text = text;
+        }
+        else if (exports.SHOULD_SHOW_SPINNERS) {
+            tslib_1.__classPrivateFieldGet(this, _SpinnerManager_instances, "m", _SpinnerManager_createOra).call(this, text);
+        }
+    }
+    isSpinning() {
+        return tslib_1.__classPrivateFieldGet(this, _SpinnerManager_ora, "f")?.isSpinning ?? false;
+    }
+}
+_SpinnerManager_ora = new WeakMap(), _SpinnerManager_prefix = new WeakMap(), _SpinnerManager_instances = new WeakSet(), _SpinnerManager_createOra = function _SpinnerManager_createOra(text) {
+    tslib_1.__classPrivateFieldSet(this, _SpinnerManager_ora, (0, ora_1.default)({
+        text: text,
+        prefixText: tslib_1.__classPrivateFieldGet(this, _SpinnerManager_prefix, "f"),
+        hideCursor: false,
+        discardStdin: false,
+    }), "f");
+};
+exports.globalSpinner = new SpinnerManager();

package/dist/src/utils/split-target.d.ts

@@ -0,0 +1,15 @@
+import { ProjectGraph, ProjectGraphProjectNode } from '../config/project-graph';
+import { ProjectConfiguration } from '../config/workspace-json-project-json';
+export interface SplitTargetOptions {
+    silent?: boolean;
+    currentProject?: string;
+}
+export declare function splitTargetFromNodes(s: string, nodes: Record<string, ProjectGraphProjectNode>, options?: SplitTargetOptions): [project: string, target?: string, configuration?: string];
+/**
+ * Splits a colon-delimited target specifier using a name-keyed
+ * `Record<string, ProjectConfiguration>` — the format used during
+ * the merge phase before the full project graph is available.
+ */
+export declare function splitTargetFromConfigurations(s: string, configs: Record<string, ProjectConfiguration>, options?: SplitTargetOptions): [project: string, target?: string, configuration?: string];
+export declare function splitTarget(s: string, projectGraph: ProjectGraph, options?: SplitTargetOptions): [project: string, target?: string, configuration?: string];
+export declare function splitByColons(s: string): [string, ...string[]];