@ohos-ports/nx 19.8.4-beta.0

package/src/project-graph/utils/retrieve-workspace-files.d.ts

@@ -0,0 +1,30 @@
+import { ProjectConfiguration } from '../../config/workspace-json-project-json';
+import { NxJsonConfiguration } from '../../config/nx-json';
+import { ConfigurationResult } from './project-configuration-utils';
+import { LoadedNxPlugin } from '../plugins/internal-api';
+/**
+ * Walks the workspace directory to create the `projectFileMap`, `ProjectConfigurations` and `allWorkspaceFiles`
+ * @throws
+ * @param workspaceRoot
+ * @param nxJson
+ */
+export declare function retrieveWorkspaceFiles(workspaceRoot: string, projectRootMap: Record<string, string>): Promise<{
+    allWorkspaceFiles: import("../file-utils").FileData[];
+    fileMap: {
+        projectFileMap: ProjectFiles;
+        nonProjectFiles: import("../../native").FileData[];
+    };
+    rustReferences: import("../../native").NxWorkspaceFilesExternals;
+}>;
+/**
+ * Walk through the workspace and return `ProjectConfigurations`. Only use this if the projectFileMap is not needed.
+ */
+export declare function retrieveProjectConfigurations(plugins: LoadedNxPlugin[], workspaceRoot: string, nxJson: NxJsonConfiguration): Promise<ConfigurationResult>;
+export declare function retrieveProjectConfigurationsWithAngularProjects(workspaceRoot: string, nxJson: NxJsonConfiguration): Promise<ConfigurationResult>;
+export declare function retrieveProjectConfigurationPaths(root: string, plugins: Array<{
+    createNodes?: readonly [string, ...unknown[]];
+} & unknown>): Promise<string[]>;
+export declare function retrieveProjectConfigurationsWithoutPluginInference(root: string): Promise<Record<string, ProjectConfiguration>>;
+export declare function configurationGlobs(plugins: Array<{
+    createNodes?: readonly [string, ...unknown[]];
+}>): string[];

package/src/project-graph/utils/retrieve-workspace-files.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.retrieveWorkspaceFiles = retrieveWorkspaceFiles;
+exports.retrieveProjectConfigurations = retrieveProjectConfigurations;
+exports.retrieveProjectConfigurationsWithAngularProjects = retrieveProjectConfigurationsWithAngularProjects;
+exports.retrieveProjectConfigurationPaths = retrieveProjectConfigurationPaths;
+exports.retrieveProjectConfigurationsWithoutPluginInference = retrieveProjectConfigurationsWithoutPluginInference;
+exports.configurationGlobs = configurationGlobs;
+const perf_hooks_1 = require("perf_hooks");
+const angular_json_1 = require("../../adapter/angular-json");
+const nx_json_1 = require("../../config/nx-json");
+const project_configuration_utils_1 = require("./project-configuration-utils");
+const internal_api_1 = require("../plugins/internal-api");
+const workspace_context_1 = require("../../utils/workspace-context");
+const build_all_workspace_files_1 = require("./build-all-workspace-files");
+const path_1 = require("path");
+/**
+ * Walks the workspace directory to create the `projectFileMap`, `ProjectConfigurations` and `allWorkspaceFiles`
+ * @throws
+ * @param workspaceRoot
+ * @param nxJson
+ */
+async function retrieveWorkspaceFiles(workspaceRoot, projectRootMap) {
+    perf_hooks_1.performance.mark('native-file-deps:start');
+    perf_hooks_1.performance.mark('native-file-deps:end');
+    perf_hooks_1.performance.measure('native-file-deps', 'native-file-deps:start', 'native-file-deps:end');
+    perf_hooks_1.performance.mark('get-workspace-files:start');
+    const { projectFileMap, globalFiles, externalReferences } = await (0, workspace_context_1.getNxWorkspaceFilesFromContext)(workspaceRoot, projectRootMap);
+    perf_hooks_1.performance.mark('get-workspace-files:end');
+    perf_hooks_1.performance.measure('get-workspace-files', 'get-workspace-files:start', 'get-workspace-files:end');
+    return {
+        allWorkspaceFiles: (0, build_all_workspace_files_1.buildAllWorkspaceFiles)(projectFileMap, globalFiles),
+        fileMap: {
+            projectFileMap,
+            nonProjectFiles: globalFiles,
+        },
+        rustReferences: externalReferences,
+    };
+}
+/**
+ * Walk through the workspace and return `ProjectConfigurations`. Only use this if the projectFileMap is not needed.
+ */
+async function retrieveProjectConfigurations(plugins, workspaceRoot, nxJson) {
+    const globPatterns = configurationGlobs(plugins);
+    const workspaceFiles = await (0, workspace_context_1.globWithWorkspaceContext)(workspaceRoot, globPatterns);
+    return (0, project_configuration_utils_1.createProjectConfigurations)(workspaceRoot, nxJson, workspaceFiles, plugins);
+}
+async function retrieveProjectConfigurationsWithAngularProjects(workspaceRoot, nxJson) {
+    const pluginsToLoad = nxJson?.plugins ?? [];
+    if ((0, angular_json_1.shouldMergeAngularProjects)(workspaceRoot, true) &&
+        !pluginsToLoad.some((p) => p === angular_json_1.NX_ANGULAR_JSON_PLUGIN_NAME ||
+            (typeof p === 'object' && p.plugin === angular_json_1.NX_ANGULAR_JSON_PLUGIN_NAME))) {
+        pluginsToLoad.push((0, path_1.join)(__dirname, '../../adapter/angular-json'));
+    }
+    const [plugins, cleanup] = await (0, internal_api_1.loadNxPlugins)(nxJson?.plugins ?? [], workspaceRoot);
+    const res = await retrieveProjectConfigurations(plugins, workspaceRoot, nxJson);
+    cleanup();
+    return res;
+}
+function retrieveProjectConfigurationPaths(root, plugins) {
+    const projectGlobPatterns = configurationGlobs(plugins);
+    return (0, workspace_context_1.globWithWorkspaceContext)(root, projectGlobPatterns);
+}
+const projectsWithoutPluginCache = new Map();
+// TODO: This function is called way too often, it should be optimized without this cache
+async function retrieveProjectConfigurationsWithoutPluginInference(root) {
+    const nxJson = (0, nx_json_1.readNxJson)(root);
+    const [plugins, cleanup] = await (0, internal_api_1.loadNxPlugins)([]); // only load default plugins
+    const projectGlobPatterns = await retrieveProjectConfigurationPaths(root, plugins);
+    const cacheKey = root + ',' + projectGlobPatterns.join(',');
+    if (projectsWithoutPluginCache.has(cacheKey)) {
+        return projectsWithoutPluginCache.get(cacheKey);
+    }
+    const projectFiles = (await (0, workspace_context_1.globWithWorkspaceContext)(root, projectGlobPatterns)) ?? [];
+    const { projects } = await (0, project_configuration_utils_1.createProjectConfigurations)(root, nxJson, projectFiles, plugins);
+    projectsWithoutPluginCache.set(cacheKey, projects);
+    cleanup();
+    return projects;
+}
+function configurationGlobs(plugins) {
+    const globPatterns = [];
+    for (const plugin of plugins) {
+        if ('createNodes' in plugin && plugin.createNodes) {
+            globPatterns.push(plugin.createNodes[0]);
+        }
+    }
+    return globPatterns;
+}

package/src/tasks-runner/batch/batch-messages.d.ts

@@ -0,0 +1,33 @@
+import type { TaskResult } from '../../config/misc-interfaces';
+import type { TaskGraph } from '../../config/task-graph';
+export declare enum BatchMessageType {
+    RunTasks = 0,
+    CompleteTask = 1,
+    CompleteBatchExecution = 2
+}
+/**
+ * Results of running the batch. Mapped from task id to results
+ */
+export interface BatchResults {
+    [taskId: string]: TaskResult;
+}
+export interface BatchTaskResult {
+    task: string;
+    result: TaskResult;
+}
+export interface RunTasksMessage {
+    type: BatchMessageType.RunTasks;
+    executorName: string;
+    batchTaskGraph: TaskGraph;
+    fullTaskGraph: TaskGraph;
+}
+export interface CompleteTaskMessage {
+    type: BatchMessageType.CompleteTask;
+    task: string;
+    result: TaskResult;
+}
+export interface CompleteBatchExecutionMessage {
+    type: BatchMessageType.CompleteBatchExecution;
+    results: BatchResults;
+}
+export type BatchMessage = RunTasksMessage | CompleteTaskMessage | CompleteBatchExecutionMessage;

package/src/tasks-runner/batch/batch-messages.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BatchMessageType = void 0;
+var BatchMessageType;
+(function (BatchMessageType) {
+    BatchMessageType[BatchMessageType["RunTasks"] = 0] = "RunTasks";
+    BatchMessageType[BatchMessageType["CompleteTask"] = 1] = "CompleteTask";
+    BatchMessageType[BatchMessageType["CompleteBatchExecution"] = 2] = "CompleteBatchExecution";
+})(BatchMessageType || (exports.BatchMessageType = BatchMessageType = {}));

package/src/tasks-runner/batch/run-batch.d.ts

@@ -0,0 +1 @@
+export {};

package/src/tasks-runner/batch/run-batch.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const batch_messages_1 = require("./batch-messages");
+const workspace_root_1 = require("../../utils/workspace-root");
+const params_1 = require("../../utils/params");
+const project_graph_1 = require("../../project-graph/project-graph");
+const configuration_1 = require("../../config/configuration");
+const async_iterator_1 = require("../../utils/async-iterator");
+const executor_utils_1 = require("../../command-line/run/executor-utils");
+function getBatchExecutor(executorName, projects) {
+    const [nodeModule, exportName] = executorName.split(':');
+    return (0, executor_utils_1.getExecutorInformation)(nodeModule, exportName, workspace_root_1.workspaceRoot, projects);
+}
+async function runTasks(executorName, batchTaskGraph, fullTaskGraph) {
+    const input = {};
+    const projectGraph = await (0, project_graph_1.createProjectGraphAsync)();
+    const projectsConfigurations = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph);
+    const nxJsonConfiguration = (0, configuration_1.readNxJson)();
+    const batchExecutor = getBatchExecutor(executorName, projectsConfigurations.projects);
+    const tasks = Object.values(batchTaskGraph.tasks);
+    const context = {
+        root: workspace_root_1.workspaceRoot,
+        cwd: process.cwd(),
+        projectsConfigurations,
+        nxJsonConfiguration,
+        workspace: { ...projectsConfigurations, ...nxJsonConfiguration },
+        isVerbose: false,
+        projectGraph,
+        taskGraph: fullTaskGraph,
+    };
+    for (const task of tasks) {
+        const projectConfiguration = projectsConfigurations.projects[task.target.project];
+        const targetConfiguration = projectConfiguration.targets[task.target.target];
+        input[task.id] = (0, params_1.combineOptionsForExecutor)(task.overrides, task.target.configuration, targetConfiguration, batchExecutor.schema, null, process.cwd());
+    }
+    try {
+        const results = await batchExecutor.batchImplementationFactory()(batchTaskGraph, input, tasks[0].overrides, context);
+        if (typeof results !== 'object') {
+            throw new Error(`"${executorName} returned invalid results: ${results}`);
+        }
+        if ((0, async_iterator_1.isAsyncIterator)(results)) {
+            const batchResults = {};
+            do {
+                const current = await results.next();
+                if (!current.done) {
+                    batchResults[current.value.task] = current.value.result;
+                    process.send({
+                        type: batch_messages_1.BatchMessageType.CompleteTask,
+                        task: current.value.task,
+                        result: current.value.result,
+                    });
+                }
+                else {
+                    break;
+                }
+            } while (true);
+            return batchResults;
+        }
+        return results;
+    }
+    catch (e) {
+        const isVerbose = tasks[0].overrides.verbose;
+        console.error(isVerbose ? e : e.message);
+        process.exit(1);
+    }
+}
+process.on('message', async (message) => {
+    switch (message.type) {
+        case batch_messages_1.BatchMessageType.RunTasks: {
+            const results = await runTasks(message.executorName, message.batchTaskGraph, message.fullTaskGraph);
+            process.send({
+                type: batch_messages_1.BatchMessageType.CompleteBatchExecution,
+                results,
+            });
+        }
+    }
+});

package/src/tasks-runner/cache.d.ts

@@ -0,0 +1,64 @@
+import { DefaultTasksRunnerOptions, RemoteCache } from './default-tasks-runner';
+import { Task } from '../config/task-graph';
+import { NxJsonConfiguration } from '../config/nx-json';
+export type CachedResult = {
+    terminalOutput: string;
+    outputsPath: string;
+    code: number;
+    remote: boolean;
+};
+export type TaskWithCachedResult = {
+    task: Task;
+    cachedResult: CachedResult;
+};
+export declare function dbCacheEnabled(nxJson?: NxJsonConfiguration): boolean;
+export declare function getCache(options: DefaultTasksRunnerOptions): DbCache | Cache;
+export declare class DbCache {
+    private readonly options;
+    private cache;
+    private remoteCache;
+    private remoteCachePromise;
+    constructor(options: {
+        nxCloudRemoteCache: RemoteCache;
+    });
+    init(): Promise<void>;
+    get(task: Task): Promise<CachedResult | null>;
+    private applyRemoteCacheResults;
+    put(task: Task, terminalOutput: string | null, outputs: string[], code: number): Promise<void>;
+    copyFilesFromCache(_: string, cachedResult: CachedResult, outputs: string[]): Promise<void>;
+    removeOldCacheRecords(): void;
+    temporaryOutputPath(task: Task): string;
+    private getRemoteCache;
+    private _getRemoteCache;
+    private getPowerpackS3Cache;
+    private getPowerpackSharedCache;
+    private getPowerpackCache;
+    private resolvePackage;
+    private assertCacheIsValid;
+}
+/**
+ * @deprecated Use the {@link DbCache} class instead. This will be removed in Nx 21.
+ */
+export declare class Cache {
+    private readonly options;
+    root: string;
+    cachePath: string;
+    terminalOutputsDir: string;
+    private _currentMachineId;
+    constructor(options: DefaultTasksRunnerOptions);
+    removeOldCacheRecords(): void;
+    currentMachineId(): Promise<string>;
+    get(task: Task): Promise<CachedResult | null>;
+    put(task: Task, terminalOutput: string | null, outputs: string[], code: number): Promise<void>;
+    copyFilesFromCache(hash: string, cachedResult: CachedResult, outputs: string[]): Promise<void>;
+    temporaryOutputPath(task: Task): string;
+    private expandOutputsInWorkspace;
+    private expandOutputsInCache;
+    private _expandOutputs;
+    private copy;
+    private remove;
+    private getFromLocalDir;
+    private assertLocalCacheValidity;
+    private createCacheDir;
+    private createTerminalOutputsDir;
+}