@depup/nx 22.6.4-depup.2 → 23.1.0-depup.0

package/dist/src/project-graph/error-types.js

@@ -0,0 +1,419 @@
+"use strict";
+var _ProjectGraphError_partialProjectGraph, _ProjectGraphError_partialSourceMaps;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoadPluginError = exports.DaemonProjectGraphError = exports.AggregateProjectGraphError = exports.WorkspaceValidityError = exports.ProcessDependenciesError = exports.CreateMetadataError = exports.MergeNodesError = exports.AggregateCreateNodesError = exports.ProjectConfigurationsError = exports.ProjectWithNoNameError = exports.ProjectsWithNoNameError = exports.ProjectWithExistingNameError = exports.MultipleProjectsWithSameNameError = exports.ProjectGraphError = exports.StaleProjectGraphCacheError = void 0;
+exports.isProjectWithExistingNameError = isProjectWithExistingNameError;
+exports.isMultipleProjectsWithSameNameError = isMultipleProjectsWithSameNameError;
+exports.isProjectsWithNoNameError = isProjectsWithNoNameError;
+exports.isProjectWithNoNameError = isProjectWithNoNameError;
+exports.isProjectConfigurationsError = isProjectConfigurationsError;
+exports.formatAggregateCreateNodesError = formatAggregateCreateNodesError;
+exports.isWorkspaceValidityError = isWorkspaceValidityError;
+exports.isAggregateProjectGraphError = isAggregateProjectGraphError;
+exports.isCreateMetadataError = isCreateMetadataError;
+exports.isAggregateCreateNodesError = isAggregateCreateNodesError;
+exports.isMergeNodesError = isMergeNodesError;
+const tslib_1 = require("tslib");
+class StaleProjectGraphCacheError extends Error {
+    constructor() {
+        super('The project graph cache was stale. Ensure that it has been recently created before using `readCachedProjectGraph`.');
+    }
+}
+exports.StaleProjectGraphCacheError = StaleProjectGraphCacheError;
+class ProjectGraphError extends Error {
+    constructor(errors, partialProjectGraph, partialSourceMaps) {
+        const messageFragments = ['Failed to process project graph.'];
+        const mergeNodesErrors = [];
+        const unknownErrors = [];
+        // Lets us throw aggregate errors without special handling,
+        // to avoid cases where users fix an error and get hit with another one
+        // which was already there but not reported.
+        let flat = errors.flatMap((e) => e instanceof AggregateError ? e.errors : e);
+        for (const e of flat) {
+            if (
+            // Known errors that are self-explanatory
+            isAggregateCreateNodesError(e) ||
+                isCreateMetadataError(e) ||
+                isProcessDependenciesError(e) ||
+                isProjectsWithNoNameError(e) ||
+                isMultipleProjectsWithSameNameError(e) ||
+                isWorkspaceValidityError(e)) {
+            }
+            else if (
+            // Known error type, but unlikely to be caused by the user
+            isMergeNodesError(e)) {
+                mergeNodesErrors.push(e);
+            }
+            else {
+                unknownErrors.push(e);
+            }
+        }
+        if (mergeNodesErrors.length > 0) {
+            messageFragments.push(`This type of error most likely points to an issue within Nx. Please report it.`);
+        }
+        if (unknownErrors.length > 0) {
+            messageFragments.push(`If the error cause is not obvious from the below error messages, running "nx reset" may fix it. Please report the issue if you keep seeing it.`);
+        }
+        super(messageFragments.join(' '));
+        this.errors = errors;
+        _ProjectGraphError_partialProjectGraph.set(this, void 0);
+        _ProjectGraphError_partialSourceMaps.set(this, void 0);
+        this.name = this.constructor.name;
+        this.errors = errors;
+        tslib_1.__classPrivateFieldSet(this, _ProjectGraphError_partialProjectGraph, partialProjectGraph, "f");
+        tslib_1.__classPrivateFieldSet(this, _ProjectGraphError_partialSourceMaps, partialSourceMaps, "f");
+        this.stack = errors
+            .map((error) => indentString(formatErrorStackAndCause(error), 2))
+            .join('\n');
+    }
+    /**
+     * The daemon cannot throw errors which contain methods as they are not serializable.
+     *
+     * This method creates a new {@link ProjectGraphError} from a {@link DaemonProjectGraphError} with the methods based on the same serialized data.
+     */
+    static fromDaemonProjectGraphError(e) {
+        return new ProjectGraphError(e.errors, e.projectGraph, e.sourceMaps);
+    }
+    /**
+     * This gets the partial project graph despite the errors which occurred.
+     * This partial project graph may be missing nodes, properties of nodes, or dependencies.
+     * This is useful mostly for visualization/debugging. It should not be used for running tasks.
+     */
+    getPartialProjectGraph() {
+        return tslib_1.__classPrivateFieldGet(this, _ProjectGraphError_partialProjectGraph, "f");
+    }
+    getPartialSourcemaps() {
+        return tslib_1.__classPrivateFieldGet(this, _ProjectGraphError_partialSourceMaps, "f");
+    }
+    getErrors() {
+        return this.errors;
+    }
+}
+exports.ProjectGraphError = ProjectGraphError;
+_ProjectGraphError_partialProjectGraph = new WeakMap(), _ProjectGraphError_partialSourceMaps = new WeakMap();
+class MultipleProjectsWithSameNameError extends Error {
+    constructor(conflicts, projects) {
+        super([
+            `The following projects are defined in multiple locations:`,
+            ...Array.from(conflicts.entries()).map(([project, roots]) => [`- ${project}: `, ...roots.map((r) => `  - ${r}`)].join('\n')),
+            '',
+            "To fix this, set a unique name for each project in a project.json inside the project's root. If the project does not currently have a project.json, you can create one that contains only a name.",
+        ].join('\n'));
+        this.conflicts = conflicts;
+        this.projects = projects;
+        this.name = this.constructor.name;
+    }
+}
+exports.MultipleProjectsWithSameNameError = MultipleProjectsWithSameNameError;
+class ProjectWithExistingNameError extends Error {
+    constructor(projectName, projectRoot) {
+        super(`The project "${projectName}" is defined in multiple locations.`);
+        this.projectName = projectName;
+        this.projectRoot = projectRoot;
+        this.name = this.constructor.name;
+    }
+}
+exports.ProjectWithExistingNameError = ProjectWithExistingNameError;
+function isProjectWithExistingNameError(e) {
+    return (e instanceof ProjectWithExistingNameError ||
+        (typeof e === 'object' &&
+            'name' in e &&
+            e?.name === ProjectWithExistingNameError.name));
+}
+function isMultipleProjectsWithSameNameError(e) {
+    return (e instanceof MultipleProjectsWithSameNameError ||
+        (typeof e === 'object' &&
+            'name' in e &&
+            e?.name === MultipleProjectsWithSameNameError.name));
+}
+class ProjectsWithNoNameError extends Error {
+    constructor(projectRoots, projects) {
+        super(`The projects in the following directories have no name provided:\n  - ${projectRoots.join('\n  - ')}`);
+        this.projectRoots = projectRoots;
+        this.projects = projects;
+        this.name = this.constructor.name;
+    }
+}
+exports.ProjectsWithNoNameError = ProjectsWithNoNameError;
+function isProjectsWithNoNameError(e) {
+    return (e instanceof ProjectsWithNoNameError ||
+        (typeof e === 'object' &&
+            'name' in e &&
+            e?.name === ProjectsWithNoNameError.name));
+}
+class ProjectWithNoNameError extends Error {
+    constructor(projectRoot) {
+        super(`The project in ${projectRoot} has no name provided.`);
+        this.projectRoot = projectRoot;
+        this.name = this.constructor.name;
+    }
+}
+exports.ProjectWithNoNameError = ProjectWithNoNameError;
+function isProjectWithNoNameError(e) {
+    return (e instanceof ProjectWithNoNameError ||
+        (typeof e === 'object' &&
+            'name' in e &&
+            e?.name === ProjectWithNoNameError.name));
+}
+class ProjectConfigurationsError extends Error {
+    constructor(errors, partialProjectConfigurationsResult) {
+        const messageFragments = ['Failed to create project configurations.'];
+        const mergeNodesErrors = [];
+        const unknownErrors = [];
+        for (const e of errors) {
+            if (
+            // Known error type, but unlikely to be caused by the user
+            isMergeNodesError(e)) {
+                mergeNodesErrors.push(e);
+            }
+            else if (
+            // Known errors that are self-explanatory
+            !isAggregateCreateNodesError(e) &&
+                !isProjectsWithNoNameError(e) &&
+                !isMultipleProjectsWithSameNameError(e)) {
+                unknownErrors.push(e);
+            }
+        }
+        if (mergeNodesErrors.length > 0) {
+            messageFragments.push(`This type of error most likely points to an issue within Nx. Please report it.`);
+        }
+        if (unknownErrors.length > 0) {
+            messageFragments.push(`If the error cause is not obvious from the below error messages, running "nx reset" may fix it. Please report the issue if you keep seeing it.`);
+        }
+        super(messageFragments.join(' '));
+        this.errors = errors;
+        this.partialProjectConfigurationsResult = partialProjectConfigurationsResult;
+        this.name = this.constructor.name;
+        this.errors = errors;
+        this.stack = errors
+            .map((error) => indentString(formatErrorStackAndCause(error), 2))
+            .join('\n');
+    }
+}
+exports.ProjectConfigurationsError = ProjectConfigurationsError;
+function isProjectConfigurationsError(e) {
+    return (e instanceof ProjectConfigurationsError ||
+        (typeof e === 'object' &&
+            'name' in e &&
+            e?.name === ProjectConfigurationsError.name));
+}
+/**
+ * This error should be thrown when a `createNodesV2` function hits a recoverable error.
+ * It allows Nx to recieve partial results and continue processing for better UX.
+ */
+class AggregateCreateNodesError extends Error {
+    /**
+     * Throwing this error from a `createNodesV2` function will allow Nx to continue processing and recieve partial results from your plugin.
+     * @example
+     * export async function createNodesV2(
+     *  files: string[],
+     * ) {
+     *   const partialResults = [];
+     *   const errors = [];
+     *   await Promise.all(files.map(async (file) => {
+     *     try {
+     *        const result = await createNodes(file);
+     *        partialResults.push(result);
+     *     } catch (e) {
+     *        errors.push([file, e]);
+     *     }
+     *   }));
+     *  if (errors.length > 0) {
+     *     throw new AggregateCreateNodesError(errors, partialResults);
+     *   }
+     *   return partialResults;
+     * }
+     *
+     * @param errors An array of tuples that represent errors encountered when processing a given file. An example entry might look like ['path/to/project.json', [Error: 'Invalid JSON. Unexpected token 'a' in JSON at position 0]]
+     * @param partialResults The partial results of the `createNodesV2` function. This should be the results for each file that didn't encounter an issue.
+     */
+    constructor(errors, partialResults) {
+        super('Failed to create nodes');
+        this.errors = errors;
+        this.partialResults = partialResults;
+        this.name = this.constructor.name;
+        if (
+        // Errors should be an array
+        !Array.isArray(errors) ||
+            !errors.every(
+            // Where every element is a tuple
+            (errorTuple) => Array.isArray(errorTuple) &&
+                // That has a length of 2
+                errorTuple.length === 2)) {
+            throw new Error('AggregateCreateNodesError must be constructed with an array of tuples where the first element is a filename or undefined and the second element is the underlying error.');
+        }
+    }
+}
+exports.AggregateCreateNodesError = AggregateCreateNodesError;
+function formatAggregateCreateNodesError(error, pluginName) {
+    const errorCount = error.errors.length > 1 ? `${error.errors.length} errors` : 'An error';
+    const pluginLocation = error.pluginIndex
+        ? ` (Defined at nx.json#plugins[${error.pluginIndex}])`
+        : '';
+    const errorBodyLines = [
+        `${errorCount} occurred while processing files for the ${pluginName} plugin${pluginLocation}.`,
+    ];
+    const errorStackLines = [];
+    // Group errors by file so repeated file paths aren't printed multiple times
+    const groupedErrors = new Map();
+    for (const [file, e] of error.errors) {
+        const key = file ?? null;
+        if (!groupedErrors.has(key)) {
+            groupedErrors.set(key, []);
+        }
+        groupedErrors.get(key).push(e);
+    }
+    for (const [file, errors] of groupedErrors) {
+        if (file) {
+            errorBodyLines.push(`  - ${file}:`);
+            errorStackLines.push(` - ${file}:`);
+        }
+        for (const e of errors) {
+            const messageLines = e.message.split('\n');
+            const stackLines = e.stack.split('\n');
+            if (file) {
+                errorBodyLines.push(...messageLines.map((line) => `      ${line}`));
+                errorStackLines.push(...stackLines.map((line) => `     ${line}`));
+            }
+            else {
+                errorBodyLines.push(`  - ${messageLines[0]}`, ...messageLines.slice(1).map((line) => `    ${line}`));
+                errorStackLines.push(` - ${stackLines[0]}`, ...stackLines.slice(1).map((line) => `   ${line}`));
+            }
+            if (e.stack && process.env.NX_VERBOSE_LOGGING === 'true') {
+                const verboseIndent = file ? '       ' : '     ';
+                const innerStackTrace = e.stack
+                    .split('\n')
+                    .map((line) => `${verboseIndent}${line}`)
+                    .join('\n');
+                errorStackLines.push(innerStackTrace);
+            }
+        }
+    }
+    error.stack = errorStackLines.join('\n');
+    error.message = errorBodyLines.join('\n');
+}
+class MergeNodesError extends Error {
+    constructor({ file, pluginName, error, pluginIndex, }) {
+        const msg = `The nodes created from ${file} by the "${pluginName}" ${pluginIndex === undefined
+            ? ''
+            : `at index ${pluginIndex} in nx.json#plugins `}could not be merged into the project graph.`;
+        super(msg, { cause: error });
+        this.name = this.constructor.name;
+        this.file = file;
+        this.pluginName = pluginName;
+        this.pluginIndex = pluginIndex;
+        this.stack = `${this.message}\n${indentString(formatErrorStackAndCause(error), 2)}`;
+    }
+}
+exports.MergeNodesError = MergeNodesError;
+class CreateMetadataError extends Error {
+    constructor(error, plugin) {
+        super(`The "${plugin}" plugin threw an error while creating metadata: ${error.message}`, {
+            cause: error,
+        });
+        this.error = error;
+        this.plugin = plugin;
+        this.name = this.constructor.name;
+    }
+}
+exports.CreateMetadataError = CreateMetadataError;
+class ProcessDependenciesError extends Error {
+    constructor(pluginName, { cause }) {
+        super(`The "${pluginName}" plugin threw an error while creating dependencies: ${cause.message}`, {
+            cause,
+        });
+        this.pluginName = pluginName;
+        this.name = this.constructor.name;
+        this.stack = `${this.message}\n  ${cause.stack.split('\n').join('\n  ')}`;
+    }
+}
+exports.ProcessDependenciesError = ProcessDependenciesError;
+function isProcessDependenciesError(e) {
+    return (e instanceof ProcessDependenciesError ||
+        (typeof e === 'object' &&
+            'name' in e &&
+            e?.name === ProcessDependenciesError.name));
+}
+class WorkspaceValidityError extends Error {
+    constructor(message) {
+        super(message);
+        this.message = message;
+        this.message = `[Configuration Error]:\n${message}`;
+        this.name = this.constructor.name;
+    }
+    toString() {
+        return this.message;
+    }
+}
+exports.WorkspaceValidityError = WorkspaceValidityError;
+function isWorkspaceValidityError(e) {
+    return (e instanceof WorkspaceValidityError ||
+        (typeof e === 'object' &&
+            'name' in e &&
+            e?.name === WorkspaceValidityError.name));
+}
+class AggregateProjectGraphError extends Error {
+    constructor(errors, partialProjectGraph) {
+        super('Failed to create project graph. See above for errors');
+        this.errors = errors;
+        this.partialProjectGraph = partialProjectGraph;
+        this.name = this.constructor.name;
+    }
+}
+exports.AggregateProjectGraphError = AggregateProjectGraphError;
+function isAggregateProjectGraphError(e) {
+    return (e instanceof AggregateProjectGraphError ||
+        (typeof e === 'object' &&
+            'name' in e &&
+            e?.name === AggregateProjectGraphError.name));
+}
+function isCreateMetadataError(e) {
+    return (e instanceof CreateMetadataError ||
+        (typeof e === 'object' &&
+            'name' in e &&
+            e?.name === CreateMetadataError.name));
+}
+function isAggregateCreateNodesError(e) {
+    return (e instanceof AggregateCreateNodesError ||
+        (typeof e === 'object' &&
+            'name' in e &&
+            e?.name === AggregateCreateNodesError.name));
+}
+function isMergeNodesError(e) {
+    return (e instanceof MergeNodesError ||
+        (typeof e === 'object' && 'name' in e && e?.name === MergeNodesError.name));
+}
+class DaemonProjectGraphError extends Error {
+    constructor(errors, projectGraph, sourceMaps) {
+        super(`The Daemon Process threw an error while calculating the project graph. Convert this error to a ProjectGraphError to get more information.`);
+        this.errors = errors;
+        this.projectGraph = projectGraph;
+        this.sourceMaps = sourceMaps;
+        this.name = this.constructor.name;
+    }
+}
+exports.DaemonProjectGraphError = DaemonProjectGraphError;
+class LoadPluginError extends Error {
+    constructor(plugin, cause) {
+        super(`Could not load plugin ${plugin}`, {
+            cause,
+        });
+        this.plugin = plugin;
+        this.name = this.constructor.name;
+    }
+}
+exports.LoadPluginError = LoadPluginError;
+function indentString(str, indent) {
+    return (' '.repeat(indent) +
+        str
+            .split('\n')
+            .map((line) => ' '.repeat(indent) + line)
+            .join('\n'));
+}
+function formatErrorStackAndCause(error) {
+    const cause = error.cause && error.cause instanceof Error ? error.cause : null;
+    return (error.stack +
+        (cause
+            ? `\nCaused by: \n${indentString(cause.stack ?? cause.message, 2)}`
+            : ''));
+}

package/dist/src/project-graph/file-map-utils.d.ts

@@ -0,0 +1,18 @@
+import type { FileData, FileMap, ProjectFileMap, ProjectGraph } from '../config/project-graph';
+import type { ProjectConfiguration, ProjectsConfigurations } from '../config/workspace-json-project-json';
+import { NxWorkspaceFilesExternals } from '../native';
+export interface WorkspaceFileMap {
+    fileMap: FileMap;
+    /**
+     * @deprecated Derived from `fileMap.projectFileMap` + `fileMap.nonProjectFiles`.
+     * Will be removed in a future major. Compute it locally if needed.
+     */
+    allWorkspaceFiles?: FileData[];
+}
+export declare function createProjectFileMapUsingProjectGraph(graph: ProjectGraph): Promise<ProjectFileMap>;
+export declare function createFileMapUsingProjectGraph(graph: ProjectGraph): Promise<WorkspaceFileMap>;
+export declare function createFileMap(projectsConfigurations: ProjectsConfigurations, allWorkspaceFiles: FileData[]): WorkspaceFileMap;
+export declare function updateFileMap(projectsConfigurations: Record<string, ProjectConfiguration>, rustReferences: NxWorkspaceFilesExternals, updatedFiles: Record<string, string>, deletedFiles: string[]): {
+    fileMap: import("../native").FileMap;
+    rustReferences: NxWorkspaceFilesExternals;
+};

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

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProjectFileMapUsingProjectGraph = createProjectFileMapUsingProjectGraph;
+exports.createFileMapUsingProjectGraph = createFileMapUsingProjectGraph;
+exports.createFileMap = createFileMap;
+exports.updateFileMap = updateFileMap;
+const workspace_context_1 = require("../utils/workspace-context");
+const workspace_root_1 = require("../utils/workspace-root");
+const project_graph_1 = require("./project-graph");
+const build_all_workspace_files_1 = require("./utils/build-all-workspace-files");
+const find_project_for_path_1 = require("./utils/find-project-for-path");
+async function createProjectFileMapUsingProjectGraph(graph) {
+    return (await createFileMapUsingProjectGraph(graph)).fileMap.projectFileMap;
+}
+// TODO: refactor this to pull straight from the rust context instead of creating the file map in JS
+async function createFileMapUsingProjectGraph(graph) {
+    const configs = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(graph);
+    let files = await (0, workspace_context_1.getAllFileDataInContext)(workspace_root_1.workspaceRoot);
+    return createFileMap(configs, files);
+}
+function createFileMap(projectsConfigurations, allWorkspaceFiles) {
+    const projectFileMap = {};
+    const projectRootMappings = (0, find_project_for_path_1.createProjectRootMappingsFromProjectConfigurations)(projectsConfigurations.projects);
+    const nonProjectFiles = [];
+    for (const projectName of Object.keys(projectsConfigurations.projects)) {
+        projectFileMap[projectName] ??= [];
+    }
+    for (const f of allWorkspaceFiles) {
+        const projectFileMapKey = (0, find_project_for_path_1.findProjectForPath)(f.file, projectRootMappings);
+        if (projectFileMapKey) {
+            const matchingProjectFiles = projectFileMap[projectFileMapKey];
+            if (matchingProjectFiles) {
+                matchingProjectFiles.push(f);
+            }
+        }
+        else {
+            nonProjectFiles.push(f);
+        }
+    }
+    const result = {
+        fileMap: {
+            projectFileMap,
+            nonProjectFiles,
+        },
+    };
+    Object.defineProperty(result, 'allWorkspaceFiles', {
+        enumerable: false,
+        configurable: true,
+        get() {
+            return (0, build_all_workspace_files_1.buildAllWorkspaceFiles)(result.fileMap.projectFileMap, result.fileMap.nonProjectFiles);
+        },
+    });
+    return result;
+}
+function updateFileMap(projectsConfigurations, rustReferences, updatedFiles, deletedFiles) {
+    const updates = (0, workspace_context_1.updateProjectFiles)(Object.fromEntries((0, find_project_for_path_1.createProjectRootMappingsFromProjectConfigurations)(projectsConfigurations)), rustReferences, updatedFiles, deletedFiles);
+    return {
+        fileMap: updates.fileMap,
+        rustReferences: updates.externalReferences,
+    };
+}

package/dist/src/project-graph/file-utils.d.ts

@@ -0,0 +1,31 @@
+import type { FileData } from '../config/project-graph';
+import type { NxArgs } from '../utils/command-line-utils';
+export interface Change {
+    type: string;
+}
+export interface FileChange<T extends Change = Change> {
+    file: string;
+    getChanges: () => T[];
+}
+export declare class WholeFileChange implements Change {
+    type: string;
+}
+export declare class DeletedFileChange implements Change {
+    type: string;
+}
+export declare class LockFileChange implements Change {
+    baseContent: string;
+    headContent: string;
+    type: string;
+    constructor(baseContent: string, headContent: string);
+}
+export declare function isWholeFileChange(change: Change): change is WholeFileChange;
+export declare function isDeletedFileChange(change: Change): change is DeletedFileChange;
+export declare function isLockFileChange(change: Change): change is LockFileChange;
+export declare function calculateFileChanges(files: string[], nxArgs?: NxArgs, readFileAtRevision?: {
+    (f: string, r: string | void): string;
+}, ignore?: ReturnType<typeof ignore>): FileChange[];
+export declare const TEN_MEGABYTES: number;
+export declare function defaultFileRead(filePath: string): string | null;
+export declare function readPackageJson(root?: string): any;
+export { FileData };