nx 19.4.0-canary.20240626-3a2e8d4 → 19.4.0-rc.0

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/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;

package/src/tasks-runner/task-env.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getEnvVariablesForTask = exports.getTaskSpecificEnv = exports.getEnvVariablesForBatchProcess = void 0;
+exports.unloadDotEnvFile = exports.loadAndExpandDotEnvFile = exports.getEnvVariablesForTask = exports.getTaskSpecificEnv = exports.getEnvVariablesForBatchProcess = void 0;
 const dotenv_1 = require("dotenv");
 const dotenv_expand_1 = require("dotenv-expand");
 const workspace_root_1 = require("../utils/workspace-root");
@@ -75,9 +75,42 @@ function getNxEnvVariablesForTask(task, forceColor, skipNxCache, captureStderr,
         ...env,
     };
 }
-function loadDotEnvFilesForTask(task, environmentVariables) {
+/**
+ * This function loads a .env file and expands the variables in it.
+ * It is going to override existing environmentVariables.
+ * @param filename
+ * @param environmentVariables
+ */
+function loadAndExpandDotEnvFile(filename, environmentVariables, override = false) {
+    const myEnv = (0, dotenv_1.config)({
+        path: filename,
+        processEnv: environmentVariables,
+        override,
+    });
+    return (0, dotenv_expand_1.expand)({
+        ...myEnv,
+        processEnv: environmentVariables,
+    });
+}
+exports.loadAndExpandDotEnvFile = loadAndExpandDotEnvFile;
+/**
+ * This function unloads a .env file and removes the variables in it from the environmentVariables.
+ * @param filename
+ * @param environmentVariables
+ */
+function unloadDotEnvFile(filename, environmentVariables, override = false) {
+    const parsedDotEnvFile = {};
+    loadAndExpandDotEnvFile(filename, parsedDotEnvFile, override);
+    Object.keys(parsedDotEnvFile).forEach((envVarKey) => {
+        if (environmentVariables[envVarKey] === parsedDotEnvFile[envVarKey]) {
+            delete environmentVariables[envVarKey];
+        }
+    });
+}
+exports.unloadDotEnvFile = unloadDotEnvFile;
+function getEnvFilesForTask(task) {
     // Collect dot env files that may pertain to a task
-    const dotEnvFiles = [
+    return [
         // Load DotEnv Files for a configuration in the project root
         ...(task.target.configuration
             ? [
@@ -122,35 +155,17 @@ function loadDotEnvFilesForTask(task, environmentVariables) {
         `.env.local`,
         `.env`,
     ];
+}
+function loadDotEnvFilesForTask(task, environmentVariables) {
+    const dotEnvFiles = getEnvFilesForTask(task);
     for (const file of dotEnvFiles) {
-        const myEnv = (0, dotenv_1.config)({
-            path: file,
-            processEnv: environmentVariables,
-            // Do not override existing env variables as we load
-            override: false,
-        });
-        environmentVariables = {
-            ...(0, dotenv_expand_1.expand)({
-                ...myEnv,
-                ignoreProcessEnv: true, // Do not override existing env variables as we load
-            }).parsed,
-            ...environmentVariables,
-        };
+        loadAndExpandDotEnvFile(file, environmentVariables);
     }
     return environmentVariables;
 }
 function unloadDotEnvFiles(environmentVariables) {
-    const unloadDotEnvFile = (filename) => {
-        let parsedDotEnvFile = {};
-        (0, dotenv_1.config)({ path: filename, processEnv: parsedDotEnvFile });
-        Object.keys(parsedDotEnvFile).forEach((envVarKey) => {
-            if (environmentVariables[envVarKey] === parsedDotEnvFile[envVarKey]) {
-                delete environmentVariables[envVarKey];
-            }
-        });
-    };
     for (const file of ['.env', '.local.env', '.env.local']) {
-        unloadDotEnvFile(file);
+        unloadDotEnvFile(file, environmentVariables);
     }
     return environmentVariables;
 }

package/src/utils/git-utils.d.ts

@@ -1,4 +1,4 @@
 export declare function getGithubSlugOrNull(): string | null;
 export declare function extractUserAndRepoFromGitHubUrl(gitRemotes: string): string | null;
-export declare function commitChanges(commitMessage: string): string | null;
+export declare function commitChanges(commitMessage: string, directory?: string): string | null;
 export declare function getLatestCommitSha(): string | null;

package/src/utils/git-utils.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getLatestCommitSha = exports.commitChanges = exports.extractUserAndRepoFromGitHubUrl = exports.getGithubSlugOrNull = void 0;
 const child_process_1 = require("child_process");
+const devkit_exports_1 = require("../devkit-exports");
 function getGithubSlugOrNull() {
     try {
         const gitRemote = (0, child_process_1.execSync)('git remote -v').toString();
@@ -38,17 +39,27 @@ function parseGitHubUrl(url) {
     }
     return null;
 }
-function commitChanges(commitMessage) {
+function commitChanges(commitMessage, directory) {
     try {
         (0, child_process_1.execSync)('git add -A', { encoding: 'utf8', stdio: 'pipe' });
         (0, child_process_1.execSync)('git commit --no-verify -F -', {
             encoding: 'utf8',
             stdio: 'pipe',
             input: commitMessage,
+            cwd: directory,
         });
     }
     catch (err) {
-        throw new Error(`Error committing changes:\n${err.stderr}`);
+        if (directory) {
+            // We don't want to throw during create-nx-workspace
+            // because maybe there was an error when setting up git
+            // initially.
+            devkit_exports_1.logger.verbose(`Git may not be set up correctly for this new workspace.
+        ${err}`);
+        }
+        else {
+            throw new Error(`Error committing changes:\n${err.stderr}`);
+        }
     }
     return getLatestCommitSha();
 }

package/src/utils/is-ci.js

@@ -10,6 +10,7 @@ function isCI() {
         process.env.CIRRUS_CI === 'true' ||
         process.env.TRAVIS === 'true' ||
         !!process.env['bamboo.buildKey'] ||
+        !!process.env['bamboo_buildKey'] ||
         !!process.env.CODEBUILD_BUILD_ID ||
         !!process.env.GITLAB_CI ||
         !!process.env.HEROKU_TEST_RUN_ID ||

package/src/utils/nx-cloud-utils.d.ts

@@ -1,4 +1,4 @@
 import { NxJsonConfiguration } from '../config/nx-json';
-export declare function isNxCloudUsed(nxJson: NxJsonConfiguration): string | boolean;
+export declare function isNxCloudUsed(nxJson: NxJsonConfiguration): boolean;
 export declare function getNxCloudUrl(nxJson: NxJsonConfiguration): string;
 export declare function getNxCloudToken(nxJson: NxJsonConfiguration): string;

package/src/utils/nx-cloud-utils.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getNxCloudToken = exports.getNxCloudUrl = exports.isNxCloudUsed = void 0;
 function isNxCloudUsed(nxJson) {
-    return (process.env.NX_CLOUD_ACCESS_TOKEN ||
+    return (!!process.env.NX_CLOUD_ACCESS_TOKEN ||
         !!nxJson.nxCloudAccessToken ||
         !!Object.values(nxJson.tasksRunnerOptions ?? {}).find((r) => r.runner == '@nrwl/nx-cloud' || r.runner == 'nx-cloud'));
 }