@ohos-ports/nx 17.3.2-beta.0

package/src/nx-cloud/nx-cloud-tasks-runner-shell.d.ts

@@ -0,0 +1,15 @@
+import { DefaultTasksRunnerOptions } from '../tasks-runner/default-tasks-runner';
+import { TasksRunner } from '../tasks-runner/tasks-runner';
+export interface CloudTaskRunnerOptions extends DefaultTasksRunnerOptions {
+    accessToken?: string;
+    canTrackAnalytics?: boolean;
+    encryptionKey?: string;
+    maskedProperties?: string[];
+    showUsageWarnings?: boolean;
+    customProxyConfigPath?: string;
+    useLatestApi?: boolean;
+    url?: string;
+    useLightClient?: boolean;
+    clientVersion?: string;
+}
+export declare const nxCloudTasksRunnerShell: TasksRunner<CloudTaskRunnerOptions>;

package/src/nx-cloud/nx-cloud-tasks-runner-shell.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nxCloudTasksRunnerShell = void 0;
+const resolution_helpers_1 = require("./resolution-helpers");
+const update_manager_1 = require("./update-manager");
+const default_tasks_runner_1 = require("../tasks-runner/default-tasks-runner");
+const output_1 = require("../utils/output");
+const nxCloudTasksRunnerShell = async (tasks, options, context) => {
+    try {
+        const { nxCloudClient, version } = await (0, update_manager_1.verifyOrUpdateNxCloudClient)(options);
+        options.clientVersion = version;
+        const paths = (0, resolution_helpers_1.findAncestorNodeModules)(__dirname, []);
+        nxCloudClient.configureLightClientRequire()(paths);
+        return nxCloudClient.nxCloudTasksRunner(tasks, options, context);
+    }
+    catch (e) {
+        const body = e instanceof update_manager_1.NxCloudEnterpriseOutdatedError
+            ? [
+                'If you are an Nx Enterprise customer, please reach out to your assigned Developer Productivity Engineer.',
+                'If you are NOT an Nx Enterprise customer but are seeing this message, please reach out to cloud-support@nrwl.io.',
+            ]
+            : e instanceof update_manager_1.NxCloudClientUnavailableError
+                ? [
+                    'You might be offline. Nx Cloud will be re-enabled when you are back online.',
+                ]
+                : [];
+        if (e instanceof update_manager_1.NxCloudEnterpriseOutdatedError) {
+            output_1.output.warn({
+                title: e.message,
+                bodyLines: ['Nx Cloud will not used for this command.', ...body],
+            });
+        }
+        const results = await (0, default_tasks_runner_1.defaultTasksRunner)(tasks, options, context);
+        output_1.output.warn({
+            title: e.message,
+            bodyLines: ['Nx Cloud was not used for this command.', ...body],
+        });
+        return results;
+    }
+};
+exports.nxCloudTasksRunnerShell = nxCloudTasksRunnerShell;

package/src/nx-cloud/resolution-helpers.d.ts

@@ -0,0 +1 @@
+export declare function findAncestorNodeModules(startPath: any, collector: any): any;

package/src/nx-cloud/resolution-helpers.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findAncestorNodeModules = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+function findAncestorNodeModules(startPath, collector) {
+    let currentPath = (0, path_1.isAbsolute)(startPath) ? startPath : (0, path_1.resolve)(startPath);
+    while (currentPath !== (0, path_1.dirname)(currentPath)) {
+        const potentialNodeModules = (0, path_1.join)(currentPath, 'node_modules');
+        if ((0, fs_1.existsSync)(potentialNodeModules)) {
+            collector.push(potentialNodeModules);
+        }
+        if ((0, fs_1.existsSync)((0, path_1.join)(currentPath, 'nx.json'))) {
+            break;
+        }
+        currentPath = (0, path_1.dirname)(currentPath);
+    }
+    return collector;
+}
+exports.findAncestorNodeModules = findAncestorNodeModules;

package/src/nx-cloud/update-manager.d.ts

@@ -0,0 +1,17 @@
+import type { CloudTaskRunnerOptions } from './nx-cloud-tasks-runner-shell';
+import { TasksRunner } from '../tasks-runner/tasks-runner';
+export declare class NxCloudEnterpriseOutdatedError extends Error {
+    constructor(url: string);
+}
+export declare class NxCloudClientUnavailableError extends Error {
+    constructor();
+}
+export interface NxCloudClient {
+    configureLightClientRequire: () => (paths: string[]) => void;
+    commands: Record<string, () => Promise<void>>;
+    nxCloudTasksRunner: TasksRunner<CloudTaskRunnerOptions>;
+}
+export declare function verifyOrUpdateNxCloudClient(options: CloudTaskRunnerOptions): Promise<{
+    nxCloudClient: NxCloudClient;
+    version: string;
+} | null>;

package/src/nx-cloud/update-manager.js

@@ -0,0 +1,240 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyOrUpdateNxCloudClient = exports.NxCloudClientUnavailableError = exports.NxCloudEnterpriseOutdatedError = void 0;
+const fs_1 = require("fs");
+const zlib_1 = require("zlib");
+const path_1 = require("path");
+const axios_1 = require("./utilities/axios");
+const debug_logger_1 = require("./debug-logger");
+const tar = require("tar-stream");
+const cache_directory_1 = require("../utils/cache-directory");
+const crypto_1 = require("crypto");
+class NxCloudEnterpriseOutdatedError extends Error {
+    constructor(url) {
+        super(`Nx Cloud instance hosted at ${url} is outdated`);
+    }
+}
+exports.NxCloudEnterpriseOutdatedError = NxCloudEnterpriseOutdatedError;
+class NxCloudClientUnavailableError extends Error {
+    constructor() {
+        super('No existing Nx Cloud client and failed to download new version');
+    }
+}
+exports.NxCloudClientUnavailableError = NxCloudClientUnavailableError;
+async function verifyOrUpdateNxCloudClient(options) {
+    (0, debug_logger_1.debugLog)('Verifying current cloud bundle');
+    const currentBundle = getLatestInstalledRunnerBundle();
+    if (shouldVerifyInstalledRunnerBundle(currentBundle)) {
+        const axios = (0, axios_1.createApiAxiosInstance)(options);
+        let verifyBundleResponse;
+        try {
+            verifyBundleResponse = await verifyCurrentBundle(axios, currentBundle);
+        }
+        catch (e) {
+            // Enterprise image compatibility, to be removed
+            if (e.message === 'Request failed with status code 404' && options.url) {
+                throw new NxCloudEnterpriseOutdatedError(options.url);
+            }
+            (0, debug_logger_1.debugLog)('Could not verify bundle. Resetting validation timer and using previously installed or default runner. Error: ', e);
+            writeBundleVerificationLock();
+            if (currentBundle === null) {
+                throw new NxCloudClientUnavailableError();
+            }
+            if (currentBundle.version === 'NX_ENTERPRISE_OUTDATED_IMAGE') {
+                throw new NxCloudEnterpriseOutdatedError(options.url);
+            }
+            const nxCloudClient = require(currentBundle.fullPath);
+            if (nxCloudClient.commands === undefined) {
+                throw new NxCloudEnterpriseOutdatedError(options.url);
+            }
+            return {
+                version: currentBundle.version,
+                nxCloudClient,
+            };
+        }
+        if (verifyBundleResponse.data.valid) {
+            (0, debug_logger_1.debugLog)('Currently installed bundle is valid');
+            writeBundleVerificationLock();
+            return {
+                version: currentBundle.version,
+                nxCloudClient: require(currentBundle.fullPath),
+            };
+        }
+        const { version, url } = verifyBundleResponse.data;
+        (0, debug_logger_1.debugLog)('Currently installed bundle is invalid, downloading version', version, ' from ', url);
+        if (version === 'NX_ENTERPRISE_OUTDATED_IMAGE') {
+            throw new NxCloudEnterpriseOutdatedError(options.url);
+        }
+        const fullPath = await downloadAndExtractClientBundle(axios, runnerBundleInstallDirectory, version, url);
+        (0, debug_logger_1.debugLog)('Done: ', fullPath);
+        const nxCloudClient = require(fullPath);
+        if (nxCloudClient.commands === undefined) {
+            throw new NxCloudEnterpriseOutdatedError(options.url);
+        }
+        return { version, nxCloudClient };
+    }
+    if (currentBundle === null) {
+        throw new NxCloudClientUnavailableError();
+    }
+    (0, debug_logger_1.debugLog)('Done: ', currentBundle.fullPath);
+    return {
+        version: currentBundle.version,
+        nxCloudClient: require(currentBundle.fullPath),
+    };
+}
+exports.verifyOrUpdateNxCloudClient = verifyOrUpdateNxCloudClient;
+const runnerBundleInstallDirectory = (0, path_1.join)(cache_directory_1.cacheDir, 'cloud');
+function getLatestInstalledRunnerBundle() {
+    if (!(0, fs_1.existsSync)(runnerBundleInstallDirectory)) {
+        (0, fs_1.mkdirSync)(runnerBundleInstallDirectory, { recursive: true });
+    }
+    try {
+        const installedBundles = (0, fs_1.readdirSync)(runnerBundleInstallDirectory)
+            .filter((potentialDirectory) => {
+            return (0, fs_1.statSync)((0, path_1.join)(runnerBundleInstallDirectory, potentialDirectory)).isDirectory();
+        })
+            .map((fileOrDirectory) => ({
+            version: fileOrDirectory,
+            fullPath: (0, path_1.join)(runnerBundleInstallDirectory, fileOrDirectory),
+        }));
+        if (installedBundles.length === 0) {
+            // No installed bundles
+            return null;
+        }
+        return installedBundles[0];
+    }
+    catch (e) {
+        console.log('Could not read runner bundle path:', e.message);
+        return null;
+    }
+}
+function shouldVerifyInstalledRunnerBundle(currentBundle) {
+    if (process.env.NX_CLOUD_FORCE_REVALIDATE === 'true') {
+        return true;
+    }
+    // No bundle, need to download anyway
+    if (currentBundle != null) {
+        (0, debug_logger_1.debugLog)('A local bundle currently exists: ', currentBundle);
+        const lastVerification = getLatestBundleVerificationTimestamp();
+        // Never been verified, need to verify
+        if (lastVerification != null) {
+            // If last verification was less than 30 minutes ago, return the current installed bundle
+            const THIRTY_MINUTES = 30 * 60 * 1000;
+            if (Date.now() - lastVerification < THIRTY_MINUTES) {
+                (0, debug_logger_1.debugLog)('Last verification was within the past 30 minutes, will not verify this time');
+                return false;
+            }
+            (0, debug_logger_1.debugLog)('Last verification was more than 30 minutes ago, verifying bundle is still valid');
+        }
+    }
+    return true;
+}
+async function verifyCurrentBundle(axios, currentBundle) {
+    return axios.get('/nx-cloud/client/verify', {
+        params: currentBundle
+            ? {
+                version: currentBundle.version,
+                contentHash: getBundleContentHash(currentBundle),
+            }
+            : {},
+    });
+}
+function getLatestBundleVerificationTimestamp() {
+    const lockfilePath = (0, path_1.join)(runnerBundleInstallDirectory, 'verify.lock');
+    if ((0, fs_1.existsSync)(lockfilePath)) {
+        const timestampAsString = (0, fs_1.readFileSync)(lockfilePath, 'utf-8');
+        let timestampAsNumber;
+        try {
+            timestampAsNumber = Number(timestampAsString);
+            return timestampAsNumber;
+        }
+        catch (e) {
+            return null;
+        }
+    }
+    return null;
+}
+function writeBundleVerificationLock() {
+    const lockfilePath = (0, path_1.join)(runnerBundleInstallDirectory, 'verify.lock');
+    (0, fs_1.writeFileSync)(lockfilePath, new Date().getTime().toString(), 'utf-8');
+}
+function getBundleContentHash(bundle) {
+    if (bundle == null) {
+        return null;
+    }
+    return hashDirectory(bundle.fullPath);
+}
+function hashDirectory(dir) {
+    const files = (0, fs_1.readdirSync)(dir).sort();
+    const hashes = files.map((file) => {
+        const filePath = (0, path_1.join)(dir, file);
+        const stat = (0, fs_1.statSync)(filePath);
+        // If the current path is a directory, recursively hash the contents
+        if (stat.isDirectory()) {
+            return hashDirectory(filePath);
+        }
+        // If it's a file, hash the file contents
+        const content = (0, fs_1.readFileSync)(filePath);
+        return (0, crypto_1.createHash)('sha256').update(content).digest('hex');
+    });
+    // Hash the combined hashes of the directory's contents
+    const combinedHashes = hashes.sort().join('');
+    return (0, crypto_1.createHash)('sha256').update(combinedHashes).digest('hex');
+}
+async function downloadAndExtractClientBundle(axios, runnerBundleInstallDirectory, version, url) {
+    let resp;
+    try {
+        resp = await axios.get(url, {
+            responseType: 'stream',
+        });
+    }
+    catch (e) {
+        console.error('Error while updating Nx Cloud client bundle');
+        throw e;
+    }
+    const bundleExtractLocation = (0, path_1.join)(runnerBundleInstallDirectory, version);
+    if (!(0, fs_1.existsSync)(bundleExtractLocation)) {
+        (0, fs_1.mkdirSync)(bundleExtractLocation);
+    }
+    return new Promise((res, rej) => {
+        const extract = tar.extract();
+        extract.on('entry', function (headers, stream, next) {
+            if (headers.type === 'directory') {
+                const directoryPath = (0, path_1.join)(bundleExtractLocation, headers.name);
+                if (!(0, fs_1.existsSync)(directoryPath)) {
+                    (0, fs_1.mkdirSync)(directoryPath, { recursive: true });
+                }
+                next();
+                stream.resume();
+            }
+            else if (headers.type === 'file') {
+                const outputFilePath = (0, path_1.join)(bundleExtractLocation, headers.name);
+                const writeStream = (0, fs_1.createWriteStream)(outputFilePath);
+                stream.pipe(writeStream);
+                // Continue the tar stream after the write stream closes
+                writeStream.on('close', () => {
+                    next();
+                });
+                stream.resume();
+            }
+        });
+        extract.on('error', (e) => {
+            rej(e);
+        });
+        extract.on('finish', function () {
+            removeOldClientBundles(version);
+            writeBundleVerificationLock();
+            res(bundleExtractLocation);
+        });
+        resp.data.pipe((0, zlib_1.createGunzip)()).pipe(extract);
+    });
+}
+function removeOldClientBundles(currentInstallVersion) {
+    const filesAndFolders = (0, fs_1.readdirSync)(runnerBundleInstallDirectory);
+    for (let fileOrFolder of filesAndFolders) {
+        const fileOrFolderPath = (0, path_1.join)(runnerBundleInstallDirectory, fileOrFolder);
+        if (fileOrFolder !== currentInstallVersion) {
+            (0, fs_1.rmSync)(fileOrFolderPath, { recursive: true });
+        }
+    }
+}

package/src/nx-cloud/utilities/axios.d.ts

@@ -0,0 +1,2 @@
+import { CloudTaskRunnerOptions } from '../nx-cloud-tasks-runner-shell';
+export declare function createApiAxiosInstance(options: CloudTaskRunnerOptions): any;

package/src/nx-cloud/utilities/axios.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createApiAxiosInstance = void 0;
+const path_1 = require("path");
+const environment_1 = require("./environment");
+const axios = require('axios');
+function createApiAxiosInstance(options) {
+    let axiosConfigBuilder = (axiosConfig) => axiosConfig;
+    const baseUrl = process.env.NX_CLOUD_API || options.url || 'https://cloud.nx.app';
+    const accessToken = environment_1.ACCESS_TOKEN ? environment_1.ACCESS_TOKEN : options.accessToken;
+    if (!accessToken) {
+        throw new Error(`Unable to authenticate. Either define accessToken in nx.json or set the NX_CLOUD_ACCESS_TOKEN env variable.`);
+    }
+    if (options.customProxyConfigPath) {
+        const { nxCloudProxyConfig } = require((0, path_1.join)(process.cwd(), options.customProxyConfigPath));
+        axiosConfigBuilder = nxCloudProxyConfig ?? axiosConfigBuilder;
+    }
+    return axios.create(axiosConfigBuilder({
+        baseURL: baseUrl,
+        timeout: environment_1.NX_CLOUD_NO_TIMEOUTS ? environment_1.UNLIMITED_TIMEOUT : 10000,
+        headers: { authorization: accessToken },
+    }));
+}
+exports.createApiAxiosInstance = createApiAxiosInstance;

package/src/nx-cloud/utilities/environment.d.ts

@@ -0,0 +1,3 @@
+export declare const UNLIMITED_TIMEOUT = 9999999;
+export declare let ACCESS_TOKEN: any;
+export declare let NX_CLOUD_NO_TIMEOUTS: any;

package/src/nx-cloud/utilities/environment.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NX_CLOUD_NO_TIMEOUTS = exports.ACCESS_TOKEN = exports.UNLIMITED_TIMEOUT = void 0;
+const dotenv = require("dotenv");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const is_ci_1 = require("../../utils/is-ci");
+const workspace_root_1 = require("../../utils/workspace-root");
+// Set once
+exports.UNLIMITED_TIMEOUT = 9999999;
+process.env.NX_CLOUD_AGENT_TIMEOUT_MS
+    ? Number(process.env.NX_CLOUD_AGENT_TIMEOUT_MS)
+    : 3600000;
+// 60 minutes
+process.env.NX_CLOUD_ORCHESTRATOR_TIMEOUT_MS
+    ? Number(process.env.NX_CLOUD_ORCHESTRATOR_TIMEOUT_MS)
+    : 3600000;
+// 60 minutes
+process.env.NX_CLOUD_DISTRIBUTED_EXECUTION_AGENT_COUNT
+    ? Number(process.env.NX_CLOUD_DISTRIBUTED_EXECUTION_AGENT_COUNT)
+    : null;
+process.env.NX_CLOUD_NUMBER_OF_RETRIES
+    ? Number(process.env.NX_CLOUD_NUMBER_OF_RETRIES)
+    : (0, is_ci_1.isCI)()
+        ? 10
+        : 1;
+loadEnvVars();
+function parseEnv() {
+    try {
+        const envContents = (0, fs_1.readFileSync)((0, path_1.join)(workspace_root_1.workspaceRoot, 'nx-cloud.env'));
+        return dotenv.parse(envContents);
+    }
+    catch (e) {
+        return {};
+    }
+}
+function loadEnvVars() {
+    const parsed = parseEnv();
+    exports.ACCESS_TOKEN =
+        process.env.NX_CLOUD_AUTH_TOKEN ||
+            process.env.NX_CLOUD_ACCESS_TOKEN ||
+            parsed.NX_CLOUD_AUTH_TOKEN ||
+            parsed.NX_CLOUD_ACCESS_TOKEN;
+    exports.NX_CLOUD_NO_TIMEOUTS =
+        process.env.NX_CLOUD_NO_TIMEOUTS === 'true' ||
+            parsed.NX_CLOUD_NO_TIMEOUTS === 'true';
+}

package/src/nx-cloud/utilities/get-cloud-options.d.ts

@@ -0,0 +1,2 @@
+import { CloudTaskRunnerOptions } from '../nx-cloud-tasks-runner-shell';
+export declare function getCloudOptions(): CloudTaskRunnerOptions;

package/src/nx-cloud/utilities/get-cloud-options.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCloudOptions = void 0;
+const nx_json_1 = require("../../config/nx-json");
+const run_command_1 = require("../../tasks-runner/run-command");
+function getCloudOptions() {
+    const nxJson = (0, nx_json_1.readNxJson)();
+    // TODO: The default is not always cloud? But it's not handled at the moment
+    return (0, run_command_1.getRunnerOptions)('default', nxJson, {}, true);
+}
+exports.getCloudOptions = getCloudOptions;

package/src/plugins/js/hasher/hasher.d.ts

@@ -0,0 +1,5 @@
+import { ProjectGraphProjectNode } from '../../../config/project-graph';
+import { ProjectRootMappings } from '../../../project-graph/utils/find-project-for-path';
+export declare function hashTsConfig(p: ProjectGraphProjectNode, projectRootMappings: ProjectRootMappings, { selectivelyHashTsConfig }: {
+    selectivelyHashTsConfig: boolean;
+}): string;

package/src/plugins/js/hasher/hasher.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hashTsConfig = void 0;
+const fileutils_1 = require("../../../utils/fileutils");
+const typescript_1 = require("../utils/typescript");
+const find_project_for_path_1 = require("../../../project-graph/utils/find-project-for-path");
+function readTsConfigJson() {
+    try {
+        const res = (0, fileutils_1.readJsonFile)((0, typescript_1.getRootTsConfigPath)());
+        res.compilerOptions.paths ??= {};
+        return res;
+    }
+    catch {
+        return {
+            compilerOptions: { paths: {} },
+        };
+    }
+}
+let tsConfigJson;
+function hashTsConfig(p, projectRootMappings, { selectivelyHashTsConfig }) {
+    if (!tsConfigJson) {
+        tsConfigJson = readTsConfigJson();
+    }
+    if (selectivelyHashTsConfig) {
+        return removeOtherProjectsPathRecords(p, tsConfigJson, projectRootMappings);
+    }
+    else {
+        return JSON.stringify(tsConfigJson);
+    }
+}
+exports.hashTsConfig = hashTsConfig;
+function removeOtherProjectsPathRecords(p, tsConfigJson, projectRootMapping) {
+    const { paths, ...compilerOptions } = tsConfigJson.compilerOptions;
+    const filteredPaths = {};
+    if (!paths) {
+        return '';
+    }
+    for (const [key, files] of Object.entries(paths)) {
+        for (const filePath of files) {
+            if (p.name === (0, find_project_for_path_1.findProjectForPath)(filePath, projectRootMapping)) {
+                filteredPaths[key] = files;
+                break;
+            }
+        }
+    }
+    return JSON.stringify({
+        compilerOptions: {
+            ...compilerOptions,
+            paths: filteredPaths,
+        },
+    });
+}

package/src/plugins/js/index.d.ts

@@ -0,0 +1,4 @@
+import { CreateDependencies, CreateNodes } from '../../utils/nx-plugin';
+export declare const name = "nx/js/dependencies-and-lockfile";
+export declare const createNodes: CreateNodes;
+export declare const createDependencies: CreateDependencies;

package/src/plugins/js/index.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDependencies = exports.createNodes = exports.name = void 0;
+const fs_1 = require("fs");
+const fs_extra_1 = require("fs-extra");
+const path_1 = require("path");
+const perf_hooks_1 = require("perf_hooks");
+const cache_directory_1 = require("../../utils/cache-directory");
+const globs_1 = require("../../utils/globs");
+const lock_file_1 = require("./lock-file/lock-file");
+const build_dependencies_1 = require("./project-graph/build-dependencies/build-dependencies");
+const config_1 = require("./utils/config");
+const file_hasher_1 = require("../../hasher/file-hasher");
+const package_manager_1 = require("../../utils/package-manager");
+const workspace_root_1 = require("../../utils/workspace-root");
+const versions_1 = require("../../utils/versions");
+exports.name = 'nx/js/dependencies-and-lockfile';
+let parsedLockFile = {};
+exports.createNodes = [
+    // Look for all lockfiles
+    (0, globs_1.combineGlobPatterns)(lock_file_1.LOCKFILES),
+    (lockFile, _, context) => {
+        const pluginConfig = (0, config_1.jsPluginConfig)(context.nxJsonConfiguration);
+        if (!pluginConfig.analyzeLockfile) {
+            return {};
+        }
+        const packageManager = (0, package_manager_1.detectPackageManager)(workspace_root_1.workspaceRoot);
+        // Only process the correct lockfile
+        if (lockFile !== (0, lock_file_1.getLockFileName)(packageManager)) {
+            return {};
+        }
+        const lockFilePath = (0, path_1.join)(workspace_root_1.workspaceRoot, lockFile);
+        const lockFileContents = (0, fs_1.readFileSync)(lockFilePath).toString();
+        const lockFileHash = getLockFileHash(lockFileContents);
+        if (!lockFileNeedsReprocessing(lockFileHash)) {
+            const nodes = readCachedParsedLockFile().externalNodes;
+            parsedLockFile.externalNodes = nodes;
+            return {
+                externalNodes: nodes,
+            };
+        }
+        const externalNodes = (0, lock_file_1.getLockFileNodes)(packageManager, lockFileContents, lockFileHash);
+        parsedLockFile.externalNodes = externalNodes;
+        return {
+            externalNodes,
+        };
+    },
+];
+const createDependencies = (_, ctx) => {
+    const pluginConfig = (0, config_1.jsPluginConfig)(ctx.nxJsonConfiguration);
+    const packageManager = (0, package_manager_1.detectPackageManager)(workspace_root_1.workspaceRoot);
+    let lockfileDependencies = [];
+    // lockfile may not exist yet
+    if (pluginConfig.analyzeLockfile &&
+        (0, lock_file_1.lockFileExists)(packageManager) &&
+        parsedLockFile) {
+        const lockFilePath = (0, path_1.join)(workspace_root_1.workspaceRoot, (0, lock_file_1.getLockFileName)(packageManager));
+        const lockFileContents = (0, fs_1.readFileSync)(lockFilePath).toString();
+        const lockFileHash = getLockFileHash(lockFileContents);
+        if (!lockFileNeedsReprocessing(lockFileHash)) {
+            lockfileDependencies = readCachedParsedLockFile().dependencies ?? [];
+        }
+        else {
+            lockfileDependencies = (0, lock_file_1.getLockFileDependencies)(packageManager, lockFileContents, lockFileHash, ctx);
+            parsedLockFile.dependencies = lockfileDependencies;
+            writeLastProcessedLockfileHash(lockFileHash, parsedLockFile);
+        }
+    }
+    perf_hooks_1.performance.mark('build typescript dependencies - start');
+    const explicitProjectDependencies = (0, build_dependencies_1.buildExplicitDependencies)(pluginConfig, ctx);
+    perf_hooks_1.performance.mark('build typescript dependencies - end');
+    perf_hooks_1.performance.measure('build typescript dependencies', 'build typescript dependencies - start', 'build typescript dependencies - end');
+    return lockfileDependencies.concat(explicitProjectDependencies);
+};
+exports.createDependencies = createDependencies;
+function getLockFileHash(lockFileContents) {
+    return (0, file_hasher_1.hashArray)([versions_1.nxVersion, lockFileContents]);
+}
+function lockFileNeedsReprocessing(lockHash) {
+    try {
+        return (0, fs_1.readFileSync)(lockFileHashFile).toString() !== lockHash;
+    }
+    catch {
+        return true;
+    }
+}
+function writeLastProcessedLockfileHash(hash, lockFile) {
+    (0, fs_extra_1.ensureDirSync)((0, path_1.dirname)(lockFileHashFile));
+    (0, fs_1.writeFileSync)(cachedParsedLockFile, JSON.stringify(lockFile, null, 2));
+    (0, fs_1.writeFileSync)(lockFileHashFile, hash);
+}
+function readCachedParsedLockFile() {
+    return JSON.parse((0, fs_1.readFileSync)(cachedParsedLockFile).toString());
+}
+const lockFileHashFile = (0, path_1.join)(cache_directory_1.projectGraphCacheDirectory, 'lockfile.hash');
+const cachedParsedLockFile = (0, path_1.join)(cache_directory_1.projectGraphCacheDirectory, 'parsed-lock-file.json');

package/src/plugins/js/lock-file/lock-file.d.ts

@@ -0,0 +1,34 @@
+/**
+ * This is the main API for accessing the lock file functionality.
+ * It encapsulates the package manager specific logic and implementation details.
+ */
+import { PackageManager } from '../../../utils/package-manager';
+import { ProjectGraph, ProjectGraphExternalNode } from '../../../config/project-graph';
+import { RawProjectGraphDependency } from '../../../project-graph/project-graph-builder';
+import { PackageJson } from '../../../utils/package-json';
+import { CreateDependenciesContext } from '../../../utils/nx-plugin';
+export declare const LOCKFILES: string[];
+/**
+ * Parses lock file and maps dependencies and metadata to {@link LockFileGraph}
+ */
+export declare function getLockFileNodes(packageManager: PackageManager, contents: string, lockFileHash: string): Record<string, ProjectGraphExternalNode>;
+/**
+ * Parses lock file and maps dependencies and metadata to {@link LockFileGraph}
+ */
+export declare function getLockFileDependencies(packageManager: PackageManager, contents: string, lockFileHash: string, context: CreateDependenciesContext): RawProjectGraphDependency[];
+export declare function lockFileExists(packageManager: PackageManager): boolean;
+/**
+ * Returns lock file name based on the detected package manager in the root
+ * @param packageManager
+ * @returns
+ */
+export declare function getLockFileName(packageManager: PackageManager): string;
+/**
+ * Create lock file based on the root level lock file and (pruned) package.json
+ *
+ * @param packageJson
+ * @param isProduction
+ * @param packageManager
+ * @returns
+ */
+export declare function createLockFile(packageJson: PackageJson, graph: ProjectGraph, packageManager?: PackageManager): string;