nx 19.8.10 → 19.8.12

package/bin/nx.js

@@ -16,6 +16,7 @@ const assert_supported_platform_1 = require("../src/native/assert-supported-plat
 const perf_hooks_1 = require("perf_hooks");
 const workspace_context_1 = require("../src/utils/workspace-context");
 const client_1 = require("../src/daemon/client/client");
+const db_connection_1 = require("../src/utils/db-connection");
 function main() {
     if (process.argv[2] !== 'report' &&
         process.argv[2] !== '--version' &&
@@ -223,4 +224,11 @@ const getLatestVersionOfNx = ((fn) => {
     let cache = null;
     return () => cache || (cache = fn());
 })(_getLatestVersionOfNx);
+function nxCleanup() {
+    (0, db_connection_1.removeDbConnections)();
+}
+process.on('exit', nxCleanup);
+process.on('SIGINT', nxCleanup);
+process.on('SIGTERM', nxCleanup);
+process.on('SIGHUP', nxCleanup);
 main();

package/bin/post-install.js

@@ -10,14 +10,14 @@ const update_manager_1 = require("../src/nx-cloud/update-manager");
 const get_cloud_options_1 = require("../src/nx-cloud/utilities/get-cloud-options");
 const nx_cloud_utils_1 = require("../src/utils/nx-cloud-utils");
 const nx_json_1 = require("../src/config/nx-json");
-const workspace_context_1 = require("../src/utils/workspace-context");
 const logger_1 = require("../src/utils/logger");
+const workspace_context_1 = require("../src/utils/workspace-context");
 (async () => {
     const start = new Date();
     try {
-        (0, workspace_context_1.setupWorkspaceContext)(workspace_root_1.workspaceRoot);
         if (isMainNxPackage() && (0, fileutils_1.fileExists)((0, path_1.join)(workspace_root_1.workspaceRoot, 'nx.json'))) {
             (0, assert_supported_platform_1.assertSupportedPlatform)();
+            (0, workspace_context_1.setupWorkspaceContext)(workspace_root_1.workspaceRoot);
             try {
                 await client_1.daemonClient.stop();
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "19.8.10",
+  "version": "19.8.12",
   "private": false,
   "description": "The core Nx plugin contains the core functionality of Nx like the project graph, nx commands and task orchestration.",
   "repository": {
@@ -67,7 +67,7 @@
     "yargs-parser": "21.1.1",
     "node-machine-id": "1.1.12",
     "ora": "5.3.0",
-    "@nrwl/tao": "19.8.10"
+    "@nrwl/tao": "19.8.12"
   },
   "peerDependencies": {
     "@swc-node/register": "^1.8.0",
@@ -82,16 +82,16 @@
     }
   },
   "optionalDependencies": {
-    "@nx/nx-darwin-x64": "19.8.10",
-    "@nx/nx-darwin-arm64": "19.8.10",
-    "@nx/nx-linux-x64-gnu": "19.8.10",
-    "@nx/nx-linux-x64-musl": "19.8.10",
-    "@nx/nx-win32-x64-msvc": "19.8.10",
-    "@nx/nx-linux-arm64-gnu": "19.8.10",
-    "@nx/nx-linux-arm64-musl": "19.8.10",
-    "@nx/nx-linux-arm-gnueabihf": "19.8.10",
-    "@nx/nx-win32-arm64-msvc": "19.8.10",
-    "@nx/nx-freebsd-x64": "19.8.10"
+    "@nx/nx-darwin-x64": "19.8.12",
+    "@nx/nx-darwin-arm64": "19.8.12",
+    "@nx/nx-linux-x64-gnu": "19.8.12",
+    "@nx/nx-linux-x64-musl": "19.8.12",
+    "@nx/nx-win32-x64-msvc": "19.8.12",
+    "@nx/nx-linux-arm64-gnu": "19.8.12",
+    "@nx/nx-linux-arm64-musl": "19.8.12",
+    "@nx/nx-linux-arm-gnueabihf": "19.8.12",
+    "@nx/nx-win32-arm64-msvc": "19.8.12",
+    "@nx/nx-freebsd-x64": "19.8.12"
   },
   "nx-migrations": {
     "migrations": "./migrations.json",

package/src/daemon/server/shutdown-utils.js

@@ -15,6 +15,7 @@ const socket_utils_1 = require("../socket-utils");
 const cache_1 = require("../cache");
 const plugins_1 = require("./plugins");
 const error_types_1 = require("../../project-graph/error-types");
+const db_connection_1 = require("../../utils/db-connection");
 exports.SERVER_INACTIVITY_TIMEOUT_MS = 10800000; // 10800000 ms = 3 hours
 let watcherInstance;
 function storeWatcherInstance(instance) {
@@ -50,6 +51,7 @@ async function handleServerProcessTermination({ server, reason, sockets, }) {
         }
         (0, cache_1.deleteDaemonJsonProcessCache)();
         (0, plugins_1.cleanupPlugins)();
+        (0, db_connection_1.removeDbConnections)();
         logger_1.serverLogger.log(`Server stopped because: "${reason}"`);
     }
     finally {

package/src/native/index.d.ts

@@ -97,6 +97,8 @@ export interface CachedResult {
   outputsPath: string
 }
 
+export declare export function closeDbConnection(connection: ExternalObject<NxDbConnection>): void
+
 export declare export function connectToNxDb(cacheDir: string, nxVersion: string, dbName?: string | undefined | null): ExternalObject<NxDbConnection>
 
 export declare export function copy(src: string, dest: string): void

package/src/native/native-bindings.js

@@ -371,6 +371,7 @@ module.exports.TaskDetails = nativeBinding.TaskDetails
 module.exports.TaskHasher = nativeBinding.TaskHasher
 module.exports.Watcher = nativeBinding.Watcher
 module.exports.WorkspaceContext = nativeBinding.WorkspaceContext
+module.exports.closeDbConnection = nativeBinding.closeDbConnection
 module.exports.connectToNxDb = nativeBinding.connectToNxDb
 module.exports.copy = nativeBinding.copy
 module.exports.EventType = nativeBinding.EventType

package/src/project-graph/plugins/internal-api.d.ts

@@ -21,9 +21,5 @@ export type CreateNodesResultWithContext = CreateNodesResult & {
     pluginName: string;
 };
 export type NormalizedPlugin = NxPluginV2 & Pick<NxPluginV1, 'processProjectGraph'>;
-export declare const nxPluginCache: Map<unknown, [
-    Promise<LoadedNxPlugin>,
-    () => void
-]>;
 export declare function loadNxPlugins(plugins: PluginConfiguration[], root?: string): Promise<readonly [LoadedNxPlugin[], () => void]>;
 export declare function getDefaultPlugins(root: string): Promise<string[]>;

package/src/project-graph/plugins/internal-api.js

@@ -2,7 +2,7 @@
 // This file contains the bits and bobs of the internal API for loading and interacting with Nx plugins.
 // For the public API, used by plugin authors, see `./public-api.ts`.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.nxPluginCache = exports.LoadedNxPlugin = void 0;
+exports.LoadedNxPlugin = void 0;
 exports.loadNxPlugins = loadNxPlugins;
 exports.getDefaultPlugins = getDefaultPlugins;
 const path_1 = require("path");
@@ -66,11 +66,6 @@ class LoadedNxPlugin {
     }
 }
 exports.LoadedNxPlugin = LoadedNxPlugin;
-// Short lived cache (cleared between cmd runs)
-// holding resolved nx plugin objects.
-// Allows loaded plugins to not be reloaded when
-// referenced multiple times.
-exports.nxPluginCache = new Map();
 function isIsolationEnabled() {
     // Explicitly enabled, regardless of further conditions
     if (process.env.NX_ISOLATE_PLUGINS === 'true') {

package/src/project-graph/plugins/isolation/messaging.d.ts

@@ -106,11 +106,7 @@ export interface PluginWorkerProcessProjectGraphResult {
         tx: string;
     };
 }
-export interface PluginWorkerShutdownMessage {
-    type: 'shutdown';
-    payload: {};
-}
-export type PluginWorkerMessage = PluginWorkerLoadMessage | PluginWorkerShutdownMessage | PluginWorkerCreateNodesMessage | PluginCreateDependenciesMessage | PluginWorkerProcessProjectGraphMessage | PluginCreateMetadataMessage;
+export type PluginWorkerMessage = PluginWorkerLoadMessage | PluginWorkerCreateNodesMessage | PluginCreateDependenciesMessage | PluginWorkerProcessProjectGraphMessage | PluginCreateMetadataMessage;
 export type PluginWorkerResult = PluginWorkerLoadResult | PluginWorkerCreateNodesResult | PluginCreateDependenciesResult | PluginWorkerProcessProjectGraphResult | PluginCreateMetadataResult;
 export declare function isPluginWorkerMessage(message: Serializable): message is PluginWorkerMessage;
 export declare function isPluginWorkerResult(message: Serializable): message is PluginWorkerResult;

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

@@ -4,12 +4,8 @@ exports.loadRemoteNxPlugin = loadRemoteNxPlugin;
 const child_process_1 = require("child_process");
 const path = require("path");
 const net_1 = require("net");
-// TODO (@AgentEnder): After scoped verbose logging is implemented, re-add verbose logs here.
-// import { logger } from '../../utils/logger';
-const internal_api_1 = require("../internal-api");
 const socket_utils_1 = require("../../../daemon/socket-utils");
 const consume_messages_from_socket_1 = require("../../../utils/consume-messages-from-socket");
-const exit_codes_1 = require("../../../utils/exit-codes");
 const messaging_1 = require("./messaging");
 const cleanupFunctions = new Set();
 const pluginNames = new Map();
@@ -29,7 +25,6 @@ async function loadRemoteNxPlugin(plugin, root) {
     const exitHandler = createWorkerExitHandler(worker, pendingPromises);
     const cleanupFunction = () => {
         worker.off('exit', exitHandler);
-        shutdownPluginWorker(socket);
         socket.destroy();
         nxPluginWorkerCache.delete(cacheKey);
     };
@@ -55,9 +50,6 @@ async function loadRemoteNxPlugin(plugin, root) {
     nxPluginWorkerCache.set(cacheKey, pluginPromise);
     return [pluginPromise, cleanupFunction];
 }
-function shutdownPluginWorker(socket) {
-    (0, messaging_1.sendMessageOverSocket)(socket, { type: 'shutdown', payload: {} });
-}
 /**
  * Creates a message handler for the given worker.
  * @param worker Instance of plugin-worker
@@ -195,20 +187,6 @@ function createWorkerExitHandler(worker, pendingPromises) {
         }
     };
 }
-let cleanedUp = false;
-const exitHandler = () => {
-    internal_api_1.nxPluginCache.clear();
-    for (const fn of cleanupFunctions) {
-        fn();
-    }
-    cleanedUp = true;
-};
-process.on('exit', exitHandler);
-process.on('SIGINT', () => {
-    exitHandler();
-    process.exit((0, exit_codes_1.signalToCode)('SIGINT'));
-});
-process.on('SIGTERM', exitHandler);
 function registerPendingPromise(tx, pending, callback, context) {
     let resolver, rejector, timeout;
     const promise = new Promise((res, rej) => {

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

@@ -49,21 +49,6 @@ const server = (0, net_1.createServer)((socket) => {
                     };
                 }
             },
-            shutdown: async () => {
-                // Stops accepting new connections, but existing connections are
-                // not closed immediately.
-                server.close(() => {
-                    try {
-                        (0, fs_1.unlinkSync)(socketPath);
-                    }
-                    catch (e) { }
-                    process.exit(0);
-                });
-                // Closes existing connection.
-                socket.end();
-                // Destroys the socket once it's fully closed.
-                socket.destroySoon();
-            },
             createNodes: async ({ configFiles, context, tx }) => {
                 try {
                     const result = await plugin.createNodes[1](configFiles, context);
@@ -142,6 +127,22 @@ const server = (0, net_1.createServer)((socket) => {
             },
         });
     }));
+    // There should only ever be one host -> worker connection
+    // since the worker is spawned per host process. As such,
+    // we can safely close the worker when the host disconnects.
+    socket.on('end', () => {
+        // Stops accepting new connections, but existing connections are
+        // not closed immediately.
+        server.close(() => {
+            try {
+                (0, fs_1.unlinkSync)(socketPath);
+            }
+            catch (e) { }
+            process.exit(0);
+        });
+        // Destroys the socket once it's fully closed.
+        socket.destroySoon();
+    });
 });
 server.listen(socketPath);
 const exitHandler = (exitCode) => () => {

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

@@ -253,8 +253,10 @@ plugins) {
                 else {
                     errorBodyLines.push(`  - ${e.message}`);
                 }
-                const innerStackTrace = '    ' + e.stack.split('\n').join('\n    ');
-                errorBodyLines.push(innerStackTrace);
+                if (e.stack) {
+                    const innerStackTrace = '    ' + e.stack.split('\n')?.join('\n    ');
+                    errorBodyLines.push(innerStackTrace);
+                }
             }
             error.stack = errorBodyLines.join('\n');
             // This represents a single plugin erroring out with a hard error.

package/src/tasks-runner/create-task-graph.d.ts

@@ -22,22 +22,19 @@ export declare class ProcessTasks {
     createTask(id: string, project: ProjectGraphProjectNode, target: string, resolvedConfiguration: string | undefined, overrides: Object): Task;
     resolveConfiguration(project: ProjectGraphProjectNode, target: string, configuration: string | undefined): string;
     getId(project: string, target: string, configuration: string | undefined): string;
-    /**
-     * this function is used to get the non dummy dependencies of a task recursively
-     * For example, when we have the following dependencies:
-     * {
-     *   'app1:compile': [ 'app2:__nx_dummy_task__' ],
-     *   'app2:__nx_dummy_task__': [ 'app3:__nx_dummy_task__' ],
-     *   'app3:__nx_dummy_task__': [ 'app4:precompile' ],
-     *   'app4:precompile': []
-     * }
-     * getNonDummyDeps('app1:compile') will return ['app1:compile']
-     * getNonDummyDeps('app2:__nx_dummy_task__') will return ['app4:precompile']
-     * getNonDummyDeps('app3:__nx_dummy_task__') will return ['app4:precompile']
-     * getNonDummyDeps('app4:precompile') will return ['app4:precompile']
-     */
-    private getNonDummyDeps;
-    private filterDummyTasks;
 }
 export declare function createTaskGraph(projectGraph: ProjectGraph, extraTargetDependencies: TargetDependencies, projectNames: string[], targets: string[], configuration: string | undefined, overrides: Object, excludeTaskDependencies?: boolean): TaskGraph;
 export declare function mapTargetDefaultsToDependencies(defaults: TargetDefaults | undefined): TargetDependencies;
+/**
+ * This function is used to filter out the dummy tasks from the dependencies
+ * It will manipulate the dependencies object in place
+ */
+export declare function filterDummyTasks(dependencies: {
+    [k: string]: string[];
+}): void;
+/**
+ * this function is used to get the non dummy dependencies of a task recursively
+ */
+export declare function getNonDummyDeps(currentTask: string, dependencies: {
+    [k: string]: string[];
+}, cycles?: Set<string>, seen?: Set<string>): string[];

package/src/tasks-runner/create-task-graph.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProcessTasks = void 0;
 exports.createTaskGraph = createTaskGraph;
 exports.mapTargetDefaultsToDependencies = mapTargetDefaultsToDependencies;
+exports.filterDummyTasks = filterDummyTasks;
+exports.getNonDummyDeps = getNonDummyDeps;
 const utils_1 = require("./utils");
 const project_graph_utils_1 = require("../utils/project-graph-utils");
 const output_1 = require("../utils/output");
@@ -54,7 +56,7 @@ class ProcessTasks {
                 this.dependencies[d] = this.dependencies[d].filter((dd) => !!initialTasks[dd]);
             }
         }
-        this.filterDummyTasks();
+        filterDummyTasks(this.dependencies);
         for (const taskId of Object.keys(this.dependencies)) {
             if (this.dependencies[taskId].length > 0) {
                 this.dependencies[taskId] = [
@@ -138,7 +140,7 @@ class ProcessTasks {
                 }
             }
             else {
-                const dummyId = this.getId(depProject.name, DUMMY_TASK_TARGET, undefined);
+                const dummyId = this.getId(depProject.name, task.target.target + DUMMY_TASK_TARGET, undefined);
                 this.dependencies[task.id].push(dummyId);
                 this.dependencies[dummyId] ??= [];
                 const noopTask = this.createDummyTask(dummyId, task);
@@ -189,52 +191,6 @@ class ProcessTasks {
         }
         return id;
     }
-    /**
-     * this function is used to get the non dummy dependencies of a task recursively
-     * For example, when we have the following dependencies:
-     * {
-     *   'app1:compile': [ 'app2:__nx_dummy_task__' ],
-     *   'app2:__nx_dummy_task__': [ 'app3:__nx_dummy_task__' ],
-     *   'app3:__nx_dummy_task__': [ 'app4:precompile' ],
-     *   'app4:precompile': []
-     * }
-     * getNonDummyDeps('app1:compile') will return ['app1:compile']
-     * getNonDummyDeps('app2:__nx_dummy_task__') will return ['app4:precompile']
-     * getNonDummyDeps('app3:__nx_dummy_task__') will return ['app4:precompile']
-     * getNonDummyDeps('app4:precompile') will return ['app4:precompile']
-     */
-    getNonDummyDeps(currentTask, originalTask, cycle) {
-        if (currentTask === originalTask) {
-            return [];
-        }
-        else if (currentTask.endsWith(DUMMY_TASK_TARGET)) {
-            if (cycle?.length && cycle?.includes(currentTask)) {
-                return [];
-            }
-            // if not a cycle, recursively get the non dummy dependencies
-            return (this.dependencies[currentTask]?.flatMap((dep) => this.getNonDummyDeps(dep, originalTask, cycle)) ?? []);
-        }
-        else {
-            return [currentTask];
-        }
-    }
-    filterDummyTasks() {
-        const cycle = (0, task_graph_utils_1.findCycle)({ dependencies: this.dependencies });
-        for (const [key, deps] of Object.entries(this.dependencies)) {
-            if (!key.endsWith(DUMMY_TASK_TARGET)) {
-                const normalizedDeps = [];
-                for (const dep of deps) {
-                    normalizedDeps.push(...this.getNonDummyDeps(dep, key, cycle));
-                }
-                this.dependencies[key] = normalizedDeps;
-            }
-        }
-        for (const key of Object.keys(this.dependencies)) {
-            if (key.endsWith(DUMMY_TASK_TARGET)) {
-                delete this.dependencies[key];
-            }
-        }
-    }
 }
 exports.ProcessTasks = ProcessTasks;
 function createTaskGraph(projectGraph, extraTargetDependencies, projectNames, targets, configuration, overrides, excludeTaskDependencies = false) {
@@ -268,3 +224,43 @@ function interpolateOverrides(args, projectName, project) {
     });
     return interpolatedArgs;
 }
+/**
+ * This function is used to filter out the dummy tasks from the dependencies
+ * It will manipulate the dependencies object in place
+ */
+function filterDummyTasks(dependencies) {
+    const cycles = (0, task_graph_utils_1.findCycles)({ dependencies });
+    for (const [key, deps] of Object.entries(dependencies)) {
+        if (!key.endsWith(DUMMY_TASK_TARGET)) {
+            const normalizedDeps = [];
+            for (const dep of deps) {
+                normalizedDeps.push(...getNonDummyDeps(dep, dependencies, cycles, new Set([key])));
+            }
+            dependencies[key] = normalizedDeps;
+        }
+    }
+    for (const key of Object.keys(dependencies)) {
+        if (key.endsWith(DUMMY_TASK_TARGET)) {
+            delete dependencies[key];
+        }
+    }
+}
+/**
+ * this function is used to get the non dummy dependencies of a task recursively
+ */
+function getNonDummyDeps(currentTask, dependencies, cycles, seen = new Set()) {
+    if (seen.has(currentTask)) {
+        return [];
+    }
+    seen.add(currentTask);
+    if (currentTask.endsWith(DUMMY_TASK_TARGET)) {
+        if (cycles?.has(currentTask)) {
+            return [];
+        }
+        // if not a cycle, recursively get the non dummy dependencies
+        return (dependencies[currentTask]?.flatMap((dep) => getNonDummyDeps(dep, dependencies, cycles, seen)) ?? []);
+    }
+    else {
+        return [currentTask];
+    }
+}

package/src/tasks-runner/task-graph-utils.d.ts

@@ -1,8 +1,19 @@
 import { ProjectGraph } from '../config/project-graph';
 import { TaskGraph } from '../config/task-graph';
+/**
+ * This function finds a cycle in the graph.
+ * @returns the first cycle found, or null if no cycle is found.
+ */
 export declare function findCycle(graph: {
     dependencies: Record<string, string[]>;
 }): string[] | null;
+/**
+ * This function finds all cycles in the graph.
+ * @returns a list of unique task ids in all cycles found, or null if no cycle is found.
+ */
+export declare function findCycles(graph: {
+    dependencies: Record<string, string[]>;
+}): Set<string> | null;
 export declare function makeAcyclic(graph: {
     roots: string[];
     dependencies: Record<string, string[]>;

package/src/tasks-runner/task-graph-utils.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.findCycle = findCycle;
+exports.findCycles = findCycles;
 exports.makeAcyclic = makeAcyclic;
 exports.validateNoAtomizedTasks = validateNoAtomizedTasks;
 const output_1 = require("../utils/output");
@@ -17,6 +18,10 @@ function _findCycle(graph, id, visited, path) {
     }
     return null;
 }
+/**
+ * This function finds a cycle in the graph.
+ * @returns the first cycle found, or null if no cycle is found.
+ */
 function findCycle(graph) {
     const visited = {};
     for (const t of Object.keys(graph.dependencies)) {
@@ -29,6 +34,24 @@ function findCycle(graph) {
     }
     return null;
 }
+/**
+ * This function finds all cycles in the graph.
+ * @returns a list of unique task ids in all cycles found, or null if no cycle is found.
+ */
+function findCycles(graph) {
+    const visited = {};
+    const cycles = new Set();
+    for (const t of Object.keys(graph.dependencies)) {
+        visited[t] = false;
+    }
+    for (const t of Object.keys(graph.dependencies)) {
+        const cycle = _findCycle(graph, t, visited, [t]);
+        if (cycle) {
+            cycle.forEach((t) => cycles.add(t));
+        }
+    }
+    return cycles.size ? cycles : null;
+}
 function _makeAcyclic(graph, id, visited, path) {
     if (visited[id])
         return;

package/src/utils/db-connection.d.ts

@@ -3,3 +3,4 @@ export declare function getDbConnection(opts?: {
     directory?: string;
     dbName?: string;
 }): ExternalObject<NxDbConnection>;
+export declare function removeDbConnections(): void;

package/src/utils/db-connection.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getDbConnection = getDbConnection;
+exports.removeDbConnections = removeDbConnections;
 const native_1 = require("../native");
 const cache_directory_1 = require("./cache-directory");
 const package_json_1 = require("../../package.json");
@@ -11,6 +12,12 @@ function getDbConnection(opts = {}) {
     const connection = getEntryOrSet(dbConnectionMap, key, () => (0, native_1.connectToNxDb)(opts.directory, package_json_1.version, opts.dbName));
     return connection;
 }
+function removeDbConnections() {
+    for (const connection of dbConnectionMap.values()) {
+        (0, native_1.closeDbConnection)(connection);
+    }
+    dbConnectionMap.clear();
+}
 function getEntryOrSet(map, key, defaultValue) {
     const existing = map.get(key);
     if (existing) {