@ohos-ports/nx 19.8.4-beta.0

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

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hashTsConfig = hashTsConfig;
+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);
+    }
+}
+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 '../../project-graph/plugins';
+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,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDependencies = exports.createNodes = exports.name = void 0;
+const fs_1 = require("fs");
+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");
+const child_process_1 = require("child_process");
+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 = packageManager !== 'bun'
+            ? (0, fs_1.readFileSync)(lockFilePath).toString()
+            : (0, child_process_1.execSync)(`bun ${lockFilePath}`, {
+                maxBuffer: 1024 * 1024 * 10,
+                windowsHide: true,
+            }).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, context);
+        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.externalNodes) {
+        const lockFilePath = (0, path_1.join)(workspace_root_1.workspaceRoot, (0, lock_file_1.getLockFileName)(packageManager));
+        const lockFileContents = packageManager !== 'bun'
+            ? (0, fs_1.readFileSync)(lockFilePath).toString()
+            : (0, child_process_1.execSync)(`bun ${lockFilePath}`, {
+                maxBuffer: 1024 * 1024 * 10,
+                windowsHide: true,
+            }).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_1.mkdirSync)((0, path_1.dirname)(lockFileHashFile), { recursive: true });
+    (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.workspaceDataDirectory, 'lockfile.hash');
+const cachedParsedLockFile = (0, path_1.join)(cache_directory_1.workspaceDataDirectory, '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, CreateNodesContext } from '../../../project-graph/plugins';
+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, context: CreateNodesContext): 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;

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

@@ -0,0 +1,211 @@
+"use strict";
+/**
+ * This is the main API for accessing the lock file functionality.
+ * It encapsulates the package manager specific logic and implementation details.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LOCKFILES = void 0;
+exports.getLockFileNodes = getLockFileNodes;
+exports.getLockFileDependencies = getLockFileDependencies;
+exports.lockFileExists = lockFileExists;
+exports.getLockFileName = getLockFileName;
+exports.createLockFile = createLockFile;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const package_manager_1 = require("../../../utils/package-manager");
+const workspace_root_1 = require("../../../utils/workspace-root");
+const output_1 = require("../../../utils/output");
+const npm_parser_1 = require("./npm-parser");
+const pnpm_parser_1 = require("./pnpm-parser");
+const yarn_parser_1 = require("./yarn-parser");
+const project_graph_pruning_1 = require("./project-graph-pruning");
+const package_json_1 = require("./utils/package-json");
+const fileutils_1 = require("../../../utils/fileutils");
+const YARN_LOCK_FILE = 'yarn.lock';
+const NPM_LOCK_FILE = 'package-lock.json';
+const PNPM_LOCK_FILE = 'pnpm-lock.yaml';
+const BUN_LOCK_FILE = 'bun.lockb';
+exports.LOCKFILES = [
+    YARN_LOCK_FILE,
+    NPM_LOCK_FILE,
+    PNPM_LOCK_FILE,
+    BUN_LOCK_FILE,
+];
+const YARN_LOCK_PATH = (0, path_1.join)(workspace_root_1.workspaceRoot, YARN_LOCK_FILE);
+const NPM_LOCK_PATH = (0, path_1.join)(workspace_root_1.workspaceRoot, NPM_LOCK_FILE);
+const PNPM_LOCK_PATH = (0, path_1.join)(workspace_root_1.workspaceRoot, PNPM_LOCK_FILE);
+const BUN_LOCK_PATH = (0, path_1.join)(workspace_root_1.workspaceRoot, BUN_LOCK_FILE);
+/**
+ * Parses lock file and maps dependencies and metadata to {@link LockFileGraph}
+ */
+function getLockFileNodes(packageManager, contents, lockFileHash, context) {
+    try {
+        if (packageManager === 'yarn') {
+            const packageJson = (0, fileutils_1.readJsonFile)((0, path_1.join)(context.workspaceRoot, 'package.json'));
+            return (0, yarn_parser_1.getYarnLockfileNodes)(contents, lockFileHash, packageJson);
+        }
+        if (packageManager === 'pnpm') {
+            return (0, pnpm_parser_1.getPnpmLockfileNodes)(contents, lockFileHash);
+        }
+        if (packageManager === 'npm') {
+            return (0, npm_parser_1.getNpmLockfileNodes)(contents, lockFileHash);
+        }
+        if (packageManager === 'bun') {
+            // bun uses yarn v1 for the file format
+            const packageJson = (0, fileutils_1.readJsonFile)('package.json');
+            return (0, yarn_parser_1.getYarnLockfileNodes)(contents, lockFileHash, packageJson);
+        }
+    }
+    catch (e) {
+        if (!isPostInstallProcess()) {
+            output_1.output.error({
+                title: `Failed to parse ${packageManager} lockfile`,
+                bodyLines: errorBodyLines(e),
+            });
+        }
+        throw e;
+    }
+    throw new Error(`Unknown package manager: ${packageManager}`);
+}
+/**
+ * Parses lock file and maps dependencies and metadata to {@link LockFileGraph}
+ */
+function getLockFileDependencies(packageManager, contents, lockFileHash, context) {
+    try {
+        if (packageManager === 'yarn') {
+            return (0, yarn_parser_1.getYarnLockfileDependencies)(contents, lockFileHash, context);
+        }
+        if (packageManager === 'pnpm') {
+            return (0, pnpm_parser_1.getPnpmLockfileDependencies)(contents, lockFileHash, context);
+        }
+        if (packageManager === 'npm') {
+            return (0, npm_parser_1.getNpmLockfileDependencies)(contents, lockFileHash, context);
+        }
+        if (packageManager === 'bun') {
+            // bun uses yarn v1 for the file format
+            return (0, yarn_parser_1.getYarnLockfileDependencies)(contents, lockFileHash, context);
+        }
+    }
+    catch (e) {
+        if (!isPostInstallProcess()) {
+            output_1.output.error({
+                title: `Failed to parse ${packageManager} lockfile`,
+                bodyLines: errorBodyLines(e),
+            });
+        }
+        throw e;
+    }
+    throw new Error(`Unknown package manager: ${packageManager}`);
+}
+function lockFileExists(packageManager) {
+    if (packageManager === 'yarn') {
+        return (0, fs_1.existsSync)(YARN_LOCK_PATH);
+    }
+    if (packageManager === 'pnpm') {
+        return (0, fs_1.existsSync)(PNPM_LOCK_PATH);
+    }
+    if (packageManager === 'npm') {
+        return (0, fs_1.existsSync)(NPM_LOCK_PATH);
+    }
+    if (packageManager === 'bun') {
+        return (0, fs_1.existsSync)(BUN_LOCK_PATH);
+    }
+    throw new Error(`Unknown package manager ${packageManager} or lock file missing`);
+}
+/**
+ * Returns lock file name based on the detected package manager in the root
+ * @param packageManager
+ * @returns
+ */
+function getLockFileName(packageManager) {
+    if (packageManager === 'yarn') {
+        return YARN_LOCK_FILE;
+    }
+    if (packageManager === 'pnpm') {
+        return PNPM_LOCK_FILE;
+    }
+    if (packageManager === 'npm') {
+        return NPM_LOCK_FILE;
+    }
+    if (packageManager === 'bun') {
+        return BUN_LOCK_FILE;
+    }
+    throw new Error(`Unknown package manager: ${packageManager}`);
+}
+function getLockFilePath(packageManager) {
+    if (packageManager === 'yarn') {
+        return YARN_LOCK_PATH;
+    }
+    if (packageManager === 'pnpm') {
+        return PNPM_LOCK_PATH;
+    }
+    if (packageManager === 'npm') {
+        return NPM_LOCK_PATH;
+    }
+    if (packageManager === 'bun') {
+        return BUN_LOCK_PATH;
+    }
+    throw new Error(`Unknown package manager: ${packageManager}`);
+}
+/**
+ * Create lock file based on the root level lock file and (pruned) package.json
+ *
+ * @param packageJson
+ * @param isProduction
+ * @param packageManager
+ * @returns
+ */
+function createLockFile(packageJson, graph, packageManager = (0, package_manager_1.detectPackageManager)(workspace_root_1.workspaceRoot)) {
+    const normalizedPackageJson = (0, package_json_1.normalizePackageJson)(packageJson);
+    const content = (0, fs_1.readFileSync)(getLockFilePath(packageManager), 'utf8');
+    try {
+        if (packageManager === 'yarn') {
+            const prunedGraph = (0, project_graph_pruning_1.pruneProjectGraph)(graph, packageJson);
+            return (0, yarn_parser_1.stringifyYarnLockfile)(prunedGraph, content, normalizedPackageJson);
+        }
+        if (packageManager === 'pnpm') {
+            const prunedGraph = (0, project_graph_pruning_1.pruneProjectGraph)(graph, packageJson);
+            return (0, pnpm_parser_1.stringifyPnpmLockfile)(prunedGraph, content, normalizedPackageJson);
+        }
+        if (packageManager === 'npm') {
+            const prunedGraph = (0, project_graph_pruning_1.pruneProjectGraph)(graph, packageJson);
+            return (0, npm_parser_1.stringifyNpmLockfile)(prunedGraph, content, normalizedPackageJson);
+        }
+        if (packageManager === 'bun') {
+            output_1.output.log({
+                title: "Unable to create bun lock files. Run bun install it's just as quick",
+            });
+        }
+    }
+    catch (e) {
+        if (!isPostInstallProcess()) {
+            const additionalInfo = [
+                'To prevent the build from breaking we are returning the root lock file.',
+            ];
+            if (packageManager === 'npm') {
+                additionalInfo.push('If you run `npm install --package-lock-only` in your output folder it will regenerate the correct pruned lockfile.');
+            }
+            if (packageManager === 'pnpm') {
+                additionalInfo.push('If you run `pnpm install --lockfile-only` in your output folder it will regenerate the correct pruned lockfile.');
+            }
+            output_1.output.error({
+                title: 'An error occured while creating pruned lockfile',
+                bodyLines: errorBodyLines(e, additionalInfo),
+            });
+        }
+        return content;
+    }
+}
+// generate body lines for error message
+function errorBodyLines(originalError, additionalInfo = []) {
+    return [
+        'Please open an issue at `https://github.com/nrwl/nx/issues/new?template=1-bug.yml` and provide a reproduction.',
+        ...additionalInfo,
+        `\nOriginal error: ${originalError.message}\n\n`,
+        originalError.stack,
+    ];
+}
+function isPostInstallProcess() {
+    return (process.env.npm_command === 'install' &&
+        process.env.npm_lifecycle_event === 'postinstall');
+}

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

@@ -0,0 +1,7 @@
+import { NormalizedPackageJson } from './utils/package-json';
+import { RawProjectGraphDependency } from '../../../project-graph/project-graph-builder';
+import { ProjectGraph, ProjectGraphExternalNode } from '../../../config/project-graph';
+import { CreateDependenciesContext } from '../../../project-graph/plugins';
+export declare function getNpmLockfileNodes(lockFileContent: string, lockFileHash: string): Record<string, ProjectGraphExternalNode>;
+export declare function getNpmLockfileDependencies(lockFileContent: string, lockFileHash: string, ctx: CreateDependenciesContext): RawProjectGraphDependency[];
+export declare function stringifyNpmLockfile(graph: ProjectGraph, rootLockFileContent: string, packageJson: NormalizedPackageJson): string;