@ohos-ports/nx 19.8.4-beta.0

package/src/project-graph/nx-deps-cache.js

@@ -0,0 +1,227 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nxFileMap = exports.nxProjectGraph = void 0;
+exports.ensureCacheDirectory = ensureCacheDirectory;
+exports.readFileMapCache = readFileMapCache;
+exports.readProjectGraphCache = readProjectGraphCache;
+exports.createProjectFileMapCache = createProjectFileMapCache;
+exports.writeCache = writeCache;
+exports.shouldRecomputeWholeGraph = shouldRecomputeWholeGraph;
+exports.extractCachedFileData = extractCachedFileData;
+const node_fs_1 = require("node:fs");
+const path_1 = require("path");
+const perf_hooks_1 = require("perf_hooks");
+const cache_directory_1 = require("../utils/cache-directory");
+const fileutils_1 = require("../utils/fileutils");
+const versions_1 = require("../utils/versions");
+exports.nxProjectGraph = (0, path_1.join)(cache_directory_1.workspaceDataDirectory, 'project-graph.json');
+exports.nxFileMap = (0, path_1.join)(cache_directory_1.workspaceDataDirectory, 'file-map.json');
+function ensureCacheDirectory() {
+    try {
+        if (!(0, node_fs_1.existsSync)(cache_directory_1.workspaceDataDirectory)) {
+            (0, node_fs_1.mkdirSync)(cache_directory_1.workspaceDataDirectory, { recursive: true });
+        }
+    }
+    catch (e) {
+        /*
+         * @jeffbcross: Node JS docs recommend against checking for existence of directory immediately before creating it.
+         * Instead, just try to create the directory and handle the error.
+         *
+         * We ran into race conditions when running scripts concurrently, where multiple scripts were
+         * arriving here simultaneously, checking for directory existence, then trying to create the directory simultaneously.
+         *
+         * In this case, we're creating the directory. If the operation failed, we ensure that the directory
+         * exists before continuing (or raise an exception).
+         */
+        if (!(0, fileutils_1.directoryExists)(cache_directory_1.workspaceDataDirectory)) {
+            throw new Error(`Failed to create directory: ${cache_directory_1.workspaceDataDirectory}`);
+        }
+    }
+}
+function readFileMapCache() {
+    perf_hooks_1.performance.mark('read cache:start');
+    ensureCacheDirectory();
+    let data = null;
+    try {
+        if ((0, fileutils_1.fileExists)(exports.nxFileMap)) {
+            data = (0, fileutils_1.readJsonFile)(exports.nxFileMap);
+        }
+    }
+    catch (error) {
+        console.log(`Error reading '${exports.nxFileMap}'. Continue the process without the cache.`);
+        console.log(error);
+    }
+    perf_hooks_1.performance.mark('read cache:end');
+    perf_hooks_1.performance.measure('read cache', 'read cache:start', 'read cache:end');
+    return data ?? null;
+}
+function readProjectGraphCache() {
+    perf_hooks_1.performance.mark('read project-graph:start');
+    ensureCacheDirectory();
+    let data = null;
+    try {
+        if ((0, fileutils_1.fileExists)(exports.nxProjectGraph)) {
+            data = (0, fileutils_1.readJsonFile)(exports.nxProjectGraph);
+        }
+    }
+    catch (error) {
+        console.log(`Error reading '${exports.nxProjectGraph}'. Continue the process without the cache.`);
+        console.log(error);
+    }
+    perf_hooks_1.performance.mark('read project-graph:end');
+    perf_hooks_1.performance.measure('read cache', 'read project-graph:start', 'read project-graph:end');
+    return data ?? null;
+}
+function createProjectFileMapCache(nxJson, packageJsonDeps, fileMap, tsConfig) {
+    const nxJsonPlugins = getNxJsonPluginsData(nxJson, packageJsonDeps);
+    const newValue = {
+        version: '6.0',
+        nxVersion: versions_1.nxVersion,
+        deps: packageJsonDeps, // TODO(v19): We can remove this in favor of nxVersion
+        // compilerOptions may not exist, especially for package-based repos
+        pathMappings: tsConfig?.compilerOptions?.paths || {},
+        nxJsonPlugins,
+        pluginsConfig: nxJson?.pluginsConfig,
+        fileMap,
+    };
+    return newValue;
+}
+function writeCache(cache, projectGraph) {
+    perf_hooks_1.performance.mark('write cache:start');
+    let retry = 1;
+    let done = false;
+    do {
+        // write first to a unique temporary filename and then do a
+        // rename of the file to the correct filename
+        // this is to avoid any problems with half-written files
+        // in case of crash and/or partially written files due
+        // to multiple parallel processes reading and writing this file
+        const unique = (Math.random().toString(16) + '0000000').slice(2, 10);
+        const tmpProjectGraphPath = `${exports.nxProjectGraph}~${unique}`;
+        const tmpFileMapPath = `${exports.nxFileMap}~${unique}`;
+        try {
+            (0, fileutils_1.writeJsonFile)(tmpProjectGraphPath, projectGraph);
+            (0, node_fs_1.renameSync)(tmpProjectGraphPath, exports.nxProjectGraph);
+            (0, fileutils_1.writeJsonFile)(tmpFileMapPath, cache);
+            (0, node_fs_1.renameSync)(tmpFileMapPath, exports.nxFileMap);
+            done = true;
+        }
+        catch (err) {
+            if (err instanceof Error) {
+                console.log(`ERROR (${retry}) when writing \n${err.message}\n${err.stack}`);
+            }
+            else {
+                console.log(`ERROR  (${retry}) unknown error when writing ${exports.nxProjectGraph} and ${exports.nxFileMap}`);
+            }
+            ++retry;
+        }
+    } while (!done && retry < 5);
+    perf_hooks_1.performance.mark('write cache:end');
+    perf_hooks_1.performance.measure('write cache', 'write cache:start', 'write cache:end');
+}
+function shouldRecomputeWholeGraph(cache, packageJsonDeps, projects, nxJson, tsConfig) {
+    if (cache.version !== '6.0') {
+        return true;
+    }
+    if (cache.nxVersion !== versions_1.nxVersion) {
+        return true;
+    }
+    // we have a cached project that is no longer present
+    const cachedNodes = Object.keys(cache.fileMap.projectFileMap);
+    if (cachedNodes.some((p) => projects[p] === undefined)) {
+        return true;
+    }
+    // a path mapping for an existing project has changed
+    if (Object.keys(cache.pathMappings).some((t) => {
+        const cached = cache.pathMappings && cache.pathMappings[t]
+            ? JSON.stringify(cache.pathMappings[t])
+            : undefined;
+        const notCached = tsConfig?.compilerOptions?.paths && tsConfig?.compilerOptions?.paths[t]
+            ? JSON.stringify(tsConfig.compilerOptions.paths[t])
+            : undefined;
+        return cached !== notCached;
+    })) {
+        return true;
+    }
+    // a new plugin has been added
+    if (JSON.stringify(getNxJsonPluginsData(nxJson, packageJsonDeps)) !==
+        JSON.stringify(cache.nxJsonPlugins)) {
+        return true;
+    }
+    if (JSON.stringify(nxJson?.pluginsConfig) !==
+        JSON.stringify(cache.pluginsConfig)) {
+        return true;
+    }
+    return false;
+}
+/*
+This can only be invoked when the list of projects is either the same
+or new projects have been added, so every project in the cache has a corresponding
+project in fileMap
+*/
+function extractCachedFileData(fileMap, c) {
+    const filesToProcess = {
+        nonProjectFiles: [],
+        projectFileMap: {},
+    };
+    const cachedFileData = {
+        nonProjectFiles: {},
+        projectFileMap: {},
+    };
+    const currentProjects = Object.keys(fileMap.projectFileMap).filter((name) => fileMap.projectFileMap[name].length > 0);
+    currentProjects.forEach((p) => {
+        processProjectNode(p, c.fileMap.projectFileMap, cachedFileData.projectFileMap, filesToProcess.projectFileMap, fileMap);
+    });
+    processNonProjectFiles(c.fileMap.nonProjectFiles, fileMap.nonProjectFiles, filesToProcess.nonProjectFiles, cachedFileData.nonProjectFiles);
+    return {
+        filesToProcess,
+        cachedFileData,
+    };
+}
+function processNonProjectFiles(cachedFiles, nonProjectFiles, filesToProcess, cachedFileData) {
+    const cachedHashMap = new Map(cachedFiles.map((f) => [f.file, f]));
+    for (const f of nonProjectFiles) {
+        const cachedFile = cachedHashMap.get(f.file);
+        if (!cachedFile || cachedFile.hash !== f.hash) {
+            filesToProcess.push(f);
+        }
+        else {
+            cachedFileData[f.file] = cachedFile;
+        }
+    }
+}
+function processProjectNode(projectName, cachedFileMap, cachedFileData, filesToProcess, { projectFileMap }) {
+    if (!cachedFileMap[projectName]) {
+        filesToProcess[projectName] = projectFileMap[projectName];
+        return;
+    }
+    const fileDataFromCache = {};
+    for (let f of cachedFileMap[projectName]) {
+        fileDataFromCache[f.file] = f;
+    }
+    if (!cachedFileData[projectName]) {
+        cachedFileData[projectName] = {};
+    }
+    for (let f of projectFileMap[projectName]) {
+        const fromCache = fileDataFromCache[f.file];
+        if (fromCache && fromCache.hash == f.hash) {
+            cachedFileData[projectName][f.file] = fromCache;
+        }
+        else {
+            if (!filesToProcess[projectName]) {
+                filesToProcess[projectName] = [];
+            }
+            filesToProcess[projectName].push(f);
+        }
+    }
+}
+function getNxJsonPluginsData(nxJson, packageJsonDeps) {
+    return (nxJson?.plugins || []).map((p) => {
+        const [plugin, options] = typeof p === 'string' ? [p] : [p.plugin, p.options];
+        return {
+            name: plugin,
+            version: packageJsonDeps[plugin],
+            options,
+        };
+    });
+}

package/src/project-graph/operators.d.ts

@@ -0,0 +1,12 @@
+import { ProjectGraph, ProjectGraphExternalNode, ProjectGraphProjectNode } from '../config/project-graph';
+/**
+ * Returns a new project graph where all the edges are reversed.
+ *
+ * For instance, if project A depends on B, in the reversed graph
+ * B will depend on A.
+ */
+export declare function reverse(graph: ProjectGraph): ProjectGraph;
+export declare function filterNodes(predicate?: (n: ProjectGraphProjectNode) => boolean): (p: ProjectGraph) => ProjectGraph;
+export declare function isNpmProject(project: ProjectGraphProjectNode | ProjectGraphExternalNode): project is ProjectGraphExternalNode;
+export declare const pruneExternalNodes: (p: ProjectGraph) => ProjectGraph;
+export declare function withDeps(original: ProjectGraph, subsetNodes: ProjectGraphProjectNode[]): ProjectGraph;

package/src/project-graph/operators.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pruneExternalNodes = void 0;
+exports.reverse = reverse;
+exports.filterNodes = filterNodes;
+exports.isNpmProject = isNpmProject;
+exports.withDeps = withDeps;
+const reverseMemo = new Map();
+/**
+ * Returns a new project graph where all the edges are reversed.
+ *
+ * For instance, if project A depends on B, in the reversed graph
+ * B will depend on A.
+ */
+function reverse(graph) {
+    const resultFromMemo = reverseMemo.get(graph);
+    if (resultFromMemo) {
+        return resultFromMemo;
+    }
+    const result = {
+        ...graph,
+        nodes: { ...graph.nodes },
+        externalNodes: { ...graph.externalNodes },
+        dependencies: {},
+    };
+    Object.keys(graph.nodes).forEach((n) => (result.dependencies[n] = []));
+    // we need to keep external node's reverse dependencies to trace our route back
+    if (graph.externalNodes) {
+        Object.keys(graph.externalNodes).forEach((n) => (result.dependencies[n] = []));
+    }
+    Object.values(graph.dependencies).forEach((byProject) => {
+        byProject.forEach((dep) => {
+            const dependency = result.dependencies[dep.target];
+            if (dependency) {
+                dependency.push({
+                    type: dep.type,
+                    source: dep.target,
+                    target: dep.source,
+                });
+            }
+        });
+    });
+    reverseMemo.set(graph, result);
+    reverseMemo.set(result, graph);
+    return result;
+}
+function filterNodes(predicate) {
+    return (original) => {
+        const graph = { nodes: {}, dependencies: {} };
+        const added = new Set();
+        Object.values(original.nodes).forEach((n) => {
+            if (!predicate || predicate(n)) {
+                graph.nodes[n.name] = n;
+                graph.dependencies[n.name] = [];
+                added.add(n.name);
+            }
+        });
+        Object.values(original.dependencies).forEach((ds) => {
+            ds.forEach((d) => {
+                if (added.has(d.source) && added.has(d.target)) {
+                    graph.dependencies[d.source].push(d);
+                }
+            });
+        });
+        return graph;
+    };
+}
+function isNpmProject(project) {
+    return project?.type === 'npm';
+}
+exports.pruneExternalNodes = filterNodes();
+function withDeps(original, subsetNodes) {
+    const res = { nodes: {}, dependencies: {} };
+    const visitedNodes = [];
+    const visitedEdges = [];
+    Object.values(subsetNodes).forEach(recurNodes);
+    Object.values(subsetNodes).forEach(recurEdges);
+    return res;
+    // ---------------------------------------------------------------------------
+    function recurNodes(node) {
+        if (visitedNodes.indexOf(node.name) > -1)
+            return;
+        res.nodes[node.name] = node;
+        if (!res.dependencies[node.name]) {
+            res.dependencies[node.name] = [];
+        }
+        visitedNodes.push(node.name);
+        original.dependencies[node.name].forEach((n) => {
+            if (original.nodes[n.target]) {
+                recurNodes(original.nodes[n.target]);
+            }
+        });
+    }
+    function recurEdges(node) {
+        if (visitedEdges.indexOf(node.name) > -1)
+            return;
+        visitedEdges.push(node.name);
+        const ds = original.dependencies[node.name];
+        ds.forEach((n) => {
+            if (!original.nodes[n.target]) {
+                return;
+            }
+            if (!res.dependencies[n.source]) {
+                res.dependencies[n.source] = [];
+            }
+            res.dependencies[n.source].push(n);
+        });
+        ds.forEach((n) => {
+            if (original.nodes[n.target]) {
+                recurEdges(original.nodes[n.target]);
+            }
+        });
+    }
+}

package/src/project-graph/plugins/index.d.ts

@@ -0,0 +1,3 @@
+export * from './public-api';
+export { readPluginPackageJson, registerPluginTSTranspiler } from './loader';
+export { createNodesFromFiles } from './utils';

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNodesFromFiles = exports.registerPluginTSTranspiler = exports.readPluginPackageJson = void 0;
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./public-api"), exports);
+var loader_1 = require("./loader");
+Object.defineProperty(exports, "readPluginPackageJson", { enumerable: true, get: function () { return loader_1.readPluginPackageJson; } });
+Object.defineProperty(exports, "registerPluginTSTranspiler", { enumerable: true, get: function () { return loader_1.registerPluginTSTranspiler; } });
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "createNodesFromFiles", { enumerable: true, get: function () { return utils_1.createNodesFromFiles; } });

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

@@ -0,0 +1,29 @@
+import { PluginConfiguration } from '../../config/nx-json';
+import { NxPluginV1 } from '../../utils/nx-plugin.deprecated';
+import { CreateDependencies, CreateDependenciesContext, CreateMetadata, CreateMetadataContext, CreateNodesContextV2, CreateNodesResult, NxPluginV2 } from './public-api';
+import { ProjectGraph, ProjectGraphProcessor } from '../../config/project-graph';
+export declare class LoadedNxPlugin {
+    readonly name: string;
+    readonly createNodes?: [
+        filePattern: string,
+        fn: (matchedFiles: string[], context: CreateNodesContextV2) => Promise<Array<readonly [plugin: string, file: string, result: CreateNodesResult]>>
+    ];
+    readonly createDependencies?: (context: CreateDependenciesContext) => ReturnType<CreateDependencies>;
+    readonly createMetadata?: (graph: ProjectGraph, context: CreateMetadataContext) => ReturnType<CreateMetadata>;
+    readonly processProjectGraph?: ProjectGraphProcessor;
+    readonly options?: unknown;
+    readonly include?: string[];
+    readonly exclude?: string[];
+    constructor(plugin: NormalizedPlugin, pluginDefinition: PluginConfiguration);
+}
+export type CreateNodesResultWithContext = CreateNodesResult & {
+    file: string;
+    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

@@ -0,0 +1,134 @@
+"use strict";
+// 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.loadNxPlugins = loadNxPlugins;
+exports.getDefaultPlugins = getDefaultPlugins;
+const path_1 = require("path");
+const workspace_root_1 = require("../../utils/workspace-root");
+const angular_json_1 = require("../../adapter/angular-json");
+const isolation_1 = require("./isolation");
+const loader_1 = require("./loader");
+const utils_1 = require("./utils");
+const error_types_1 = require("../error-types");
+const native_1 = require("../../native");
+class LoadedNxPlugin {
+    constructor(plugin, pluginDefinition) {
+        this.name = plugin.name;
+        if (typeof pluginDefinition !== 'string') {
+            this.options = pluginDefinition.options;
+            this.include = pluginDefinition.include;
+            this.exclude = pluginDefinition.exclude;
+        }
+        if (plugin.createNodes && !plugin.createNodesV2) {
+            this.createNodes = [
+                plugin.createNodes[0],
+                (configFiles, context) => (0, utils_1.createNodesFromFiles)(plugin.createNodes[1], configFiles, this.options, context).then((results) => results.map((r) => [this.name, r[0], r[1]])),
+            ];
+        }
+        if (plugin.createNodesV2) {
+            this.createNodes = [
+                plugin.createNodesV2[0],
+                async (configFiles, context) => {
+                    const result = await plugin.createNodesV2[1](configFiles, this.options, context);
+                    return result.map((r) => [this.name, r[0], r[1]]);
+                },
+            ];
+        }
+        if (this.createNodes) {
+            const inner = this.createNodes[1];
+            this.createNodes[1] = async (...args) => {
+                performance.mark(`${plugin.name}:createNodes - start`);
+                try {
+                    return await inner(...args);
+                }
+                catch (e) {
+                    if ((0, error_types_1.isAggregateCreateNodesError)(e)) {
+                        throw e;
+                    }
+                    // The underlying plugin errored out. We can't know any partial results.
+                    throw new error_types_1.AggregateCreateNodesError([[null, e]], []);
+                }
+                finally {
+                    performance.mark(`${plugin.name}:createNodes - end`);
+                    performance.measure(`${plugin.name}:createNodes`, `${plugin.name}:createNodes - start`, `${plugin.name}:createNodes - end`);
+                }
+            };
+        }
+        if (plugin.createDependencies) {
+            this.createDependencies = (context) => plugin.createDependencies(this.options, context);
+        }
+        if (plugin.createMetadata) {
+            this.createMetadata = (graph, context) => plugin.createMetadata(graph, this.options, context);
+        }
+        this.processProjectGraph = plugin.processProjectGraph;
+    }
+}
+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') {
+        return true;
+    }
+    if (
+    // Explicitly disabled
+    process.env.NX_ISOLATE_PLUGINS === 'false' ||
+        // Isolation is disabled on WASM builds currently.
+        native_1.IS_WASM) {
+        return false;
+    }
+    // Default value
+    return true;
+}
+async function loadNxPlugins(plugins, root = workspace_root_1.workspaceRoot) {
+    performance.mark('loadNxPlugins:start');
+    const loadingMethod = isIsolationEnabled()
+        ? isolation_1.loadNxPluginInIsolation
+        : loader_1.loadNxPlugin;
+    plugins = await normalizePlugins(plugins, root);
+    const result = new Array(plugins?.length);
+    const cleanupFunctions = [];
+    await Promise.all(plugins.map(async (plugin, idx) => {
+        const [loadedPluginPromise, cleanup] = await loadingMethod(plugin, root);
+        result[idx] = loadedPluginPromise;
+        cleanupFunctions.push(cleanup);
+    }));
+    const ret = [
+        await Promise.all(result),
+        () => {
+            for (const fn of cleanupFunctions) {
+                fn();
+            }
+            if (loader_1.unregisterPluginTSTranspiler) {
+                (0, loader_1.unregisterPluginTSTranspiler)();
+            }
+        },
+    ];
+    performance.mark('loadNxPlugins:end');
+    performance.measure('loadNxPlugins', 'loadNxPlugins:start', 'loadNxPlugins:end');
+    return ret;
+}
+async function normalizePlugins(plugins, root) {
+    plugins ??= [];
+    return [
+        ...plugins,
+        // Most of the nx core node plugins go on the end, s.t. it overwrites any other plugins
+        ...(await getDefaultPlugins(root)),
+    ];
+}
+async function getDefaultPlugins(root) {
+    return [
+        (0, path_1.join)(__dirname, '../../plugins/js'),
+        ...((0, angular_json_1.shouldMergeAngularProjects)(root, false)
+            ? [(0, path_1.join)(__dirname, '../../adapter/angular-json')]
+            : []),
+        (0, path_1.join)(__dirname, '../../plugins/package-json'),
+        (0, path_1.join)(__dirname, '../../plugins/project-json/build-nodes/project-json'),
+    ];
+}

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

@@ -0,0 +1,3 @@
+import { PluginConfiguration } from '../../../config/nx-json';
+import { LoadedNxPlugin } from '../internal-api';
+export declare function loadNxPluginInIsolation(plugin: PluginConfiguration, root?: string): Promise<readonly [Promise<LoadedNxPlugin>, () => void]>;

package/src/project-graph/plugins/isolation/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadNxPluginInIsolation = loadNxPluginInIsolation;
+const workspace_root_1 = require("../../../utils/workspace-root");
+const plugin_pool_1 = require("./plugin-pool");
+async function loadNxPluginInIsolation(plugin, root = workspace_root_1.workspaceRoot) {
+    const [loadingPlugin, cleanup] = await (0, plugin_pool_1.loadRemoteNxPlugin)(plugin, root);
+    return [
+        loadingPlugin,
+        () => {
+            cleanup();
+        },
+    ];
+}

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

@@ -0,0 +1,125 @@
+import { ProjectGraph, ProjectGraphProcessorContext } from '../../../config/project-graph';
+import { PluginConfiguration } from '../../../config/nx-json';
+import { CreateDependenciesContext, CreateMetadataContext, CreateNodesContextV2 } from '../public-api';
+import { LoadedNxPlugin } from '../internal-api';
+import { Serializable } from 'child_process';
+import { Socket } from 'net';
+export interface PluginWorkerLoadMessage {
+    type: 'load';
+    payload: {
+        plugin: PluginConfiguration;
+        root: string;
+    };
+}
+export interface PluginWorkerLoadResult {
+    type: 'load-result';
+    payload: {
+        name: string;
+        include?: string[];
+        exclude?: string[];
+        createNodesPattern: string;
+        hasCreateDependencies: boolean;
+        hasProcessProjectGraph: boolean;
+        hasCreateMetadata: boolean;
+        success: true;
+    } | {
+        success: false;
+        error: Error;
+    };
+}
+export interface PluginWorkerCreateNodesMessage {
+    type: 'createNodes';
+    payload: {
+        configFiles: string[];
+        context: CreateNodesContextV2;
+        tx: string;
+    };
+}
+export interface PluginWorkerCreateNodesResult {
+    type: 'createNodesResult';
+    payload: {
+        success: true;
+        result: Awaited<ReturnType<LoadedNxPlugin['createNodes'][1]>>;
+        tx: string;
+    } | {
+        success: false;
+        error: Error;
+        tx: string;
+    };
+}
+export interface PluginCreateDependenciesMessage {
+    type: 'createDependencies';
+    payload: {
+        context: CreateDependenciesContext;
+        tx: string;
+    };
+}
+export interface PluginCreateMetadataMessage {
+    type: 'createMetadata';
+    payload: {
+        graph: ProjectGraph;
+        context: CreateMetadataContext;
+        tx: string;
+    };
+}
+export interface PluginCreateDependenciesResult {
+    type: 'createDependenciesResult';
+    payload: {
+        dependencies: ReturnType<LoadedNxPlugin['createDependencies']>;
+        success: true;
+        tx: string;
+    } | {
+        success: false;
+        error: Error;
+        tx: string;
+    };
+}
+export interface PluginCreateMetadataResult {
+    type: 'createMetadataResult';
+    payload: {
+        metadata: ReturnType<LoadedNxPlugin['createMetadata']>;
+        success: true;
+        tx: string;
+    } | {
+        success: false;
+        error: Error;
+        tx: string;
+    };
+}
+export interface PluginWorkerProcessProjectGraphMessage {
+    type: 'processProjectGraph';
+    payload: {
+        graph: ProjectGraph;
+        ctx: ProjectGraphProcessorContext;
+        tx: string;
+    };
+}
+export interface PluginWorkerProcessProjectGraphResult {
+    type: 'processProjectGraphResult';
+    payload: {
+        graph: ProjectGraph;
+        success: true;
+        tx: string;
+    } | {
+        success: false;
+        error: Error;
+        tx: string;
+    };
+}
+export interface PluginWorkerShutdownMessage {
+    type: 'shutdown';
+    payload: {};
+}
+export type PluginWorkerMessage = PluginWorkerLoadMessage | PluginWorkerShutdownMessage | 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;
+type MaybePromise<T> = T | Promise<T>;
+type MessageHandlerReturn<T extends PluginWorkerMessage | PluginWorkerResult> = T extends PluginWorkerResult ? MaybePromise<PluginWorkerMessage | void> : MaybePromise<PluginWorkerResult | void>;
+export declare function consumeMessage<T extends PluginWorkerMessage | PluginWorkerResult>(socket: Socket, raw: T, handlers: {
+    [K in T['type']]: (payload: Extract<T, {
+        type: K;
+    }>['payload']) => MessageHandlerReturn<T>;
+}): Promise<void>;
+export declare function sendMessageOverSocket(socket: Socket, message: PluginWorkerMessage | PluginWorkerResult): void;
+export {};