nx 19.4.0-beta.0 → 19.4.0-beta.2

package/src/project-graph/plugins/isolation/plugin-worker.js

@@ -3,116 +3,137 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const messaging_1 = require("./messaging");
 const loader_1 = require("../loader");
 const serializable_error_1 = require("../../../utils/serializable-error");
+const net_1 = require("net");
+const consume_messages_from_socket_1 = require("../../../utils/consume-messages-from-socket");
+const fs_1 = require("fs");
 if (process.env.NX_PERF_LOGGING === 'true') {
     require('../../../utils/perf-logging');
 }
 global.NX_GRAPH_CREATION = true;
 let plugin;
-process.on('message', async (message) => {
-    if (!(0, messaging_1.isPluginWorkerMessage)(message)) {
-        return;
-    }
-    return (0, messaging_1.consumeMessage)(message, {
-        load: async ({ plugin: pluginConfiguration, root }) => {
-            process.chdir(root);
-            try {
-                const [promise] = (0, loader_1.loadNxPlugin)(pluginConfiguration, root);
-                plugin = await promise;
-                return {
-                    type: 'load-result',
-                    payload: {
-                        name: plugin.name,
-                        include: plugin.include,
-                        exclude: plugin.exclude,
-                        createNodesPattern: plugin.createNodes?.[0],
-                        hasCreateDependencies: 'createDependencies' in plugin && !!plugin.createDependencies,
-                        hasProcessProjectGraph: 'processProjectGraph' in plugin && !!plugin.processProjectGraph,
-                        hasCreateMetadata: 'createMetadata' in plugin && !!plugin.createMetadata,
-                        success: true,
-                    },
-                };
-            }
-            catch (e) {
-                return {
-                    type: 'load-result',
-                    payload: {
-                        success: false,
-                        error: (0, serializable_error_1.createSerializableError)(e),
-                    },
-                };
-            }
-        },
-        createNodes: async ({ configFiles, context, tx }) => {
-            try {
-                const result = await plugin.createNodes[1](configFiles, context);
-                return {
-                    type: 'createNodesResult',
-                    payload: { result, success: true, tx },
-                };
-            }
-            catch (e) {
-                return {
-                    type: 'createNodesResult',
-                    payload: {
-                        success: false,
-                        error: (0, serializable_error_1.createSerializableError)(e),
-                        tx,
-                    },
-                };
-            }
-        },
-        createDependencies: async ({ context, tx }) => {
-            try {
-                const result = await plugin.createDependencies(context);
-                return {
-                    type: 'createDependenciesResult',
-                    payload: { dependencies: result, success: true, tx },
-                };
-            }
-            catch (e) {
-                return {
-                    type: 'createDependenciesResult',
-                    payload: {
-                        success: false,
-                        error: (0, serializable_error_1.createSerializableError)(e),
-                        tx,
-                    },
-                };
-            }
-        },
-        processProjectGraph: async ({ graph, ctx, tx }) => {
-            try {
-                const result = await plugin.processProjectGraph(graph, ctx);
-                return {
-                    type: 'processProjectGraphResult',
-                    payload: { graph: result, success: true, tx },
-                };
-            }
-            catch (e) {
-                return {
-                    type: 'processProjectGraphResult',
-                    payload: {
-                        success: false,
-                        error: (0, serializable_error_1.createSerializableError)(e),
-                        tx,
-                    },
-                };
-            }
-        },
-        createMetadata: async ({ graph, context, tx }) => {
-            try {
-                const result = await plugin.createMetadata(graph, context);
-                return {
-                    type: 'createMetadataResult',
-                    payload: { metadata: result, success: true, tx },
-                };
-            }
-            catch (e) {
-                return {
-                    type: 'createMetadataResult',
-                    payload: { success: false, error: e.stack, tx },
-                };
-            }
-        },
-    });
+const socketPath = process.argv[2];
+const server = (0, net_1.createServer)((socket) => {
+    socket.on('data', (0, consume_messages_from_socket_1.consumeMessagesFromSocket)((raw) => {
+        const message = JSON.parse(raw.toString());
+        if (!(0, messaging_1.isPluginWorkerMessage)(message)) {
+            return;
+        }
+        return (0, messaging_1.consumeMessage)(socket, message, {
+            load: async ({ plugin: pluginConfiguration, root }) => {
+                process.chdir(root);
+                try {
+                    const [promise] = (0, loader_1.loadNxPlugin)(pluginConfiguration, root);
+                    plugin = await promise;
+                    return {
+                        type: 'load-result',
+                        payload: {
+                            name: plugin.name,
+                            include: plugin.include,
+                            exclude: plugin.exclude,
+                            createNodesPattern: plugin.createNodes?.[0],
+                            hasCreateDependencies: 'createDependencies' in plugin && !!plugin.createDependencies,
+                            hasProcessProjectGraph: 'processProjectGraph' in plugin &&
+                                !!plugin.processProjectGraph,
+                            hasCreateMetadata: 'createMetadata' in plugin && !!plugin.createMetadata,
+                            success: true,
+                        },
+                    };
+                }
+                catch (e) {
+                    return {
+                        type: 'load-result',
+                        payload: {
+                            success: false,
+                            error: (0, serializable_error_1.createSerializableError)(e),
+                        },
+                    };
+                }
+            },
+            createNodes: async ({ configFiles, context, tx }) => {
+                try {
+                    const result = await plugin.createNodes[1](configFiles, context);
+                    return {
+                        type: 'createNodesResult',
+                        payload: { result, success: true, tx },
+                    };
+                }
+                catch (e) {
+                    return {
+                        type: 'createNodesResult',
+                        payload: {
+                            success: false,
+                            error: (0, serializable_error_1.createSerializableError)(e),
+                            tx,
+                        },
+                    };
+                }
+            },
+            createDependencies: async ({ context, tx }) => {
+                try {
+                    const result = await plugin.createDependencies(context);
+                    return {
+                        type: 'createDependenciesResult',
+                        payload: { dependencies: result, success: true, tx },
+                    };
+                }
+                catch (e) {
+                    return {
+                        type: 'createDependenciesResult',
+                        payload: {
+                            success: false,
+                            error: (0, serializable_error_1.createSerializableError)(e),
+                            tx,
+                        },
+                    };
+                }
+            },
+            processProjectGraph: async ({ graph, ctx, tx }) => {
+                try {
+                    const result = await plugin.processProjectGraph(graph, ctx);
+                    return {
+                        type: 'processProjectGraphResult',
+                        payload: { graph: result, success: true, tx },
+                    };
+                }
+                catch (e) {
+                    return {
+                        type: 'processProjectGraphResult',
+                        payload: {
+                            success: false,
+                            error: (0, serializable_error_1.createSerializableError)(e),
+                            tx,
+                        },
+                    };
+                }
+            },
+            createMetadata: async ({ graph, context, tx }) => {
+                try {
+                    const result = await plugin.createMetadata(graph, context);
+                    return {
+                        type: 'createMetadataResult',
+                        payload: { metadata: result, success: true, tx },
+                    };
+                }
+                catch (e) {
+                    return {
+                        type: 'createMetadataResult',
+                        payload: { success: false, error: e.stack, tx },
+                    };
+                }
+            },
+        });
+    }));
 });
+server.listen(socketPath);
+const exitHandler = (exitCode) => () => {
+    server.close();
+    try {
+        (0, fs_1.unlinkSync)(socketPath);
+    }
+    catch (e) { }
+    process.exit(exitCode);
+};
+const events = ['SIGINT', 'SIGTERM', 'SIGQUIT', 'exit'];
+events.forEach((event) => process.once(event, exitHandler(0)));
+process.once('uncaughtException', exitHandler(1));
+process.once('unhandledRejection', exitHandler(1));

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

@@ -110,7 +110,13 @@ async function buildProjectGraphAndSourceMapsWithoutDaemon() {
         }
     }
     finally {
-        cleanup();
+        // When plugins are isolated we don't clean them up during
+        // a single run of the CLI. They are cleaned up when the CLI
+        // process exits. Cleaning them here could cause issues if pending
+        // promises are not resolved.
+        if (process.env.NX_ISOLATE_PLUGINS !== 'true') {
+            cleanup();
+        }
     }
     const { projectGraph, projectFileMapCache } = projectGraphResult;
     perf_hooks_1.performance.mark('build-project-graph-using-project-file-map:end');

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

@@ -1,10 +1,6 @@
 import { ProjectGraphProjectNode } from '../../config/project-graph';
 import { ProjectGraphBuilder } from '../project-graph-builder';
-import { ProjectConfiguration, TargetConfiguration } from '../../config/workspace-json-project-json';
+import { ProjectConfiguration } from '../../config/workspace-json-project-json';
 import { CreateDependenciesContext } from '../plugins';
 export declare function normalizeProjectNodes({ projects }: 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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeImplicitDependencies = exports.normalizeProjectTargets = exports.normalizeProjectNodes = void 0;
+exports.normalizeImplicitDependencies = exports.normalizeProjectNodes = void 0;
 const find_matching_projects_1 = require("../../utils/find-matching-projects");
 async function normalizeProjectNodes({ projects }, builder) {
     // Sorting projects by name to make sure that the order of projects in the graph is deterministic.
@@ -23,7 +23,7 @@ async function normalizeProjectNodes({ projects }, builder) {
     for (const key of sortedProjectNames) {
         const p = projects[key];
         p.implicitDependencies = normalizeImplicitDependencies(key, p.implicitDependencies, partialProjectGraphNodes);
-        p.targets = normalizeProjectTargets(p, key);
+        p.targets ??= {};
         // TODO: remove in v16
         const projectType = p.projectType === 'application'
             ? key.endsWith('-e2e') || key === 'e2e'
@@ -57,21 +57,6 @@ async function normalizeProjectNodes({ projects }, builder) {
     });
 }
 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;
-        }
-    }
-    return targets;
-}
-exports.normalizeProjectTargets = normalizeProjectTargets;
 function normalizeImplicitDependencies(source, implicitDependencies, projects) {
     if (!implicitDependencies?.length) {
         return implicitDependencies ?? [];

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

@@ -293,7 +293,7 @@ function mergeCreateNodesResults(results, errors) {
     const externalNodes = {};
     const configurationSourceMaps = {};
     for (const result of results.flat()) {
-        const [file, pluginName, nodes] = result;
+        const [pluginName, file, nodes] = result;
         const { projects: projectNodes, externalNodes: pluginExternalNodes } = nodes;
         const sourceInfo = [file, pluginName];
         if (result[symbols_1.OVERRIDE_SOURCE_FILE]) {
@@ -436,9 +436,20 @@ function validateAndNormalizeProjectRootMap(projectRootMap) {
         }
         for (const targetName in project.targets) {
             project.targets[targetName] = normalizeTarget(project.targets[targetName], project);
-            if (!project.targets[targetName].executor &&
+            if (
+            // If the target has no executor or command, it doesn't do anything
+            !project.targets[targetName].executor &&
                 !project.targets[targetName].command) {
-                delete project.targets[targetName];
+                // But it may have dependencies that do something
+                if (project.targets[targetName].dependsOn &&
+                    project.targets[targetName].dependsOn.length > 0) {
+                    project.targets[targetName].executor = 'nx:noop';
+                }
+                else {
+                    // If it does nothing, and has no depenencies,
+                    // we can remove it.
+                    delete project.targets[targetName];
+                }
             }
         }
     }

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

@@ -9,12 +9,12 @@ import { LoadedNxPlugin } from '../plugins/internal-api';
  * @param nxJson
  */
 export declare function retrieveWorkspaceFiles(workspaceRoot: string, projectRootMap: Record<string, string>): Promise<{
-    allWorkspaceFiles: import("nx/src/devkit-exports").FileData[];
+    allWorkspaceFiles: import("../file-utils").FileData[];
     fileMap: {
         projectFileMap: ProjectFiles;
-        nonProjectFiles: import("nx/src/native").FileData[];
+        nonProjectFiles: import("../../native").FileData[];
     };
-    rustReferences: import("nx/src/native").NxWorkspaceFilesExternals;
+    rustReferences: import("../../native").NxWorkspaceFilesExternals;
 }>;
 /**
  * Walk through the workspace and return `ProjectConfigurations`. Only use this if the projectFileMap is not needed.

package/src/tasks-runner/default-tasks-runner.js

@@ -13,12 +13,12 @@ const defaultTasksRunner = async (tasks, options, context) => {
         options['parallel'] === '') {
         options['parallel'] = Number(options['maxParallel'] || 3);
     }
-    options.lifeCycle.startCommand();
+    await options.lifeCycle.startCommand();
     try {
         return await runAllTasks(tasks, options, context);
     }
     finally {
-        options.lifeCycle.endCommand();
+        await options.lifeCycle.endCommand();
     }
 };
 exports.defaultTasksRunner = defaultTasksRunner;

package/src/tasks-runner/life-cycle.d.ts

@@ -10,9 +10,9 @@ export interface TaskMetadata {
     groupId: number;
 }
 export interface LifeCycle {
-    startCommand?(): void;
-    endCommand?(): void;
-    scheduleTask?(task: Task): void;
+    startCommand?(): void | Promise<void>;
+    endCommand?(): void | Promise<void>;
+    scheduleTask?(task: Task): void | Promise<void>;
     /**
      * @deprecated use startTasks
      *
@@ -25,19 +25,19 @@ export interface LifeCycle {
      * endTask won't be supported after Nx 14 is released.
      */
     endTask?(task: Task, code: number): void;
-    startTasks?(task: Task[], metadata: TaskMetadata): void;
-    endTasks?(taskResults: TaskResult[], metadata: TaskMetadata): void;
+    startTasks?(task: Task[], metadata: TaskMetadata): void | Promise<void>;
+    endTasks?(taskResults: TaskResult[], metadata: TaskMetadata): void | Promise<void>;
     printTaskTerminalOutput?(task: Task, status: TaskStatus, output: string): void;
 }
 export declare class CompositeLifeCycle implements LifeCycle {
     private readonly lifeCycles;
     constructor(lifeCycles: LifeCycle[]);
-    startCommand(): void;
-    endCommand(): void;
-    scheduleTask(task: Task): void;
+    startCommand(): Promise<void>;
+    endCommand(): Promise<void>;
+    scheduleTask(task: Task): Promise<void>;
     startTask(task: Task): void;
     endTask(task: Task, code: number): void;
-    startTasks(tasks: Task[], metadata: TaskMetadata): void;
-    endTasks(taskResults: TaskResult[], metadata: TaskMetadata): void;
+    startTasks(tasks: Task[], metadata: TaskMetadata): Promise<void>;
+    endTasks(taskResults: TaskResult[], metadata: TaskMetadata): Promise<void>;
     printTaskTerminalOutput(task: Task, status: TaskStatus, output: string): void;
 }

package/src/tasks-runner/life-cycle.js

@@ -5,24 +5,24 @@ class CompositeLifeCycle {
     constructor(lifeCycles) {
         this.lifeCycles = lifeCycles;
     }
-    startCommand() {
+    async startCommand() {
         for (let l of this.lifeCycles) {
             if (l.startCommand) {
-                l.startCommand();
+                await l.startCommand();
             }
         }
     }
-    endCommand() {
+    async endCommand() {
         for (let l of this.lifeCycles) {
             if (l.endCommand) {
-                l.endCommand();
+                await l.endCommand();
             }
         }
     }
-    scheduleTask(task) {
+    async scheduleTask(task) {
         for (let l of this.lifeCycles) {
             if (l.scheduleTask) {
-                l.scheduleTask(task);
+                await l.scheduleTask(task);
             }
         }
     }
@@ -40,20 +40,20 @@ class CompositeLifeCycle {
             }
         }
     }
-    startTasks(tasks, metadata) {
+    async startTasks(tasks, metadata) {
         for (let l of this.lifeCycles) {
             if (l.startTasks) {
-                l.startTasks(tasks, metadata);
+                await l.startTasks(tasks, metadata);
             }
             else if (l.startTask) {
                 tasks.forEach((t) => l.startTask(t));
             }
         }
     }
-    endTasks(taskResults, metadata) {
+    async endTasks(taskResults, metadata) {
         for (let l of this.lifeCycles) {
             if (l.endTasks) {
-                l.endTasks(taskResults, metadata);
+                await l.endTasks(taskResults, metadata);
             }
             else if (l.endTask) {
                 taskResults.forEach((t) => l.endTask(t.task, t.code));

package/src/tasks-runner/life-cycles/task-history-life-cycle.d.ts

@@ -0,0 +1,9 @@
+import { Task } from '../../config/task-graph';
+import { LifeCycle, TaskResult } from '../life-cycle';
+export declare class TaskHistoryLifeCycle implements LifeCycle {
+    private startTimings;
+    private taskRuns;
+    startTasks(tasks: Task[]): void;
+    endTasks(taskResults: TaskResult[]): Promise<void>;
+    endCommand(): Promise<void>;
+}

package/src/tasks-runner/life-cycles/task-history-life-cycle.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskHistoryLifeCycle = void 0;
+const serialize_target_1 = require("../../utils/serialize-target");
+const output_1 = require("../../utils/output");
+const task_history_1 = require("../../utils/task-history");
+class TaskHistoryLifeCycle {
+    constructor() {
+        this.startTimings = {};
+        this.taskRuns = [];
+    }
+    startTasks(tasks) {
+        for (let task of tasks) {
+            this.startTimings[task.id] = new Date().getTime();
+        }
+    }
+    async endTasks(taskResults) {
+        const taskRuns = taskResults.map((taskResult) => ({
+            project: taskResult.task.target.project,
+            target: taskResult.task.target.target,
+            configuration: taskResult.task.target.configuration,
+            hash: taskResult.task.hash,
+            code: taskResult.code.toString(),
+            status: taskResult.status,
+            start: (taskResult.task.startTime ?? this.startTimings[taskResult.task.id]).toString(),
+            end: (taskResult.task.endTime ?? new Date().getTime()).toString(),
+        }));
+        this.taskRuns.push(...taskRuns);
+    }
+    async endCommand() {
+        await (0, task_history_1.writeTaskRunsToHistory)(this.taskRuns);
+        const history = await (0, task_history_1.getHistoryForHashes)(this.taskRuns.map((t) => t.hash));
+        const flakyTasks = [];
+        // check if any hash has different exit codes => flaky
+        for (let hash in history) {
+            if (history[hash].length > 1 &&
+                history[hash].some((run) => run.code !== history[hash][0].code)) {
+                flakyTasks.push((0, serialize_target_1.serializeTarget)(history[hash][0].project, history[hash][0].target, history[hash][0].configuration));
+            }
+        }
+        if (flakyTasks.length > 0) {
+            output_1.output.warn({
+                title: `Nx detected ${flakyTasks.length === 1 ? 'a flaky task' : ' flaky tasks'}`,
+                bodyLines: [
+                    ,
+                    ...flakyTasks.map((t) => `  ${t}`),
+                    '',
+                    `Flaky tasks can disrupt your CI pipeline. Automatically retry them with Nx Cloud. Learn more at https://nx.dev/ci/features/flaky-tasks`,
+                ],
+            });
+        }
+    }
+}
+exports.TaskHistoryLifeCycle = TaskHistoryLifeCycle;

package/src/tasks-runner/run-command.js

@@ -14,6 +14,7 @@ const dynamic_run_many_terminal_output_life_cycle_1 = require("./life-cycles/dyn
 const task_profiling_life_cycle_1 = require("./life-cycles/task-profiling-life-cycle");
 const is_ci_1 = require("../utils/is-ci");
 const dynamic_run_one_terminal_output_life_cycle_1 = require("./life-cycles/dynamic-run-one-terminal-output-life-cycle");
+const nx_json_1 = require("../config/nx-json");
 const create_task_graph_1 = require("./create-task-graph");
 const task_graph_utils_1 = require("./task-graph-utils");
 const params_1 = require("../utils/params");
@@ -21,6 +22,8 @@ const hash_task_1 = require("../hasher/hash-task");
 const client_1 = require("../daemon/client/client");
 const store_run_information_life_cycle_1 = require("./life-cycles/store-run-information-life-cycle");
 const create_task_hasher_1 = require("../hasher/create-task-hasher");
+const task_history_life_cycle_1 = require("./life-cycles/task-history-life-cycle");
+const nx_cloud_utils_1 = require("../utils/nx-cloud-utils");
 async function getTerminalOutputLifeCycle(initiatingProject, projectNames, tasks, nxArgs, nxJson, overrides) {
     const { runnerOptions } = getRunner(nxArgs, nxJson);
     const isRunOne = initiatingProject != null;
@@ -203,6 +206,9 @@ function constructLifeCycles(lifeCycle) {
     if (process.env.NX_PROFILE) {
         lifeCycles.push(new task_profiling_life_cycle_1.TaskProfilingLifeCycle(process.env.NX_PROFILE));
     }
+    if (!(0, nx_cloud_utils_1.isNxCloudUsed)((0, nx_json_1.readNxJson)())) {
+        lifeCycles.push(new task_history_life_cycle_1.TaskHistoryLifeCycle());
+    }
     return lifeCycles;
 }
 function mergeTargetDependencies(defaults, deps) {

package/src/tasks-runner/task-env.d.ts

@@ -6,3 +6,16 @@ export declare function getEnvVariablesForTask(task: Task, taskSpecificEnv: Node
     [x: string]: string;
     TZ?: string;
 };
+/**
+ * This function loads a .env file and expands the variables in it.
+ * It is going to override existing environmentVariables.
+ * @param filename
+ * @param environmentVariables
+ */
+export declare function loadAndExpandDotEnvFile(filename: string, environmentVariables: NodeJS.ProcessEnv, override?: boolean): import("dotenv-expand").DotenvExpandOutput;
+/**
+ * This function unloads a .env file and removes the variables in it from the environmentVariables.
+ * @param filename
+ * @param environmentVariables
+ */
+export declare function unloadDotEnvFile(filename: string, environmentVariables: NodeJS.ProcessEnv, override?: boolean): void;