@ohos-ports/nx 23.2.0-beta.0 → 23.2.1-beta.0

package/dist/src/hasher/hash-task.js

@@ -1,191 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTaskDetails = getTaskDetails;
-exports.hashTasksThatDoNotDependOnOutputsOfOtherTasks = hashTasksThatDoNotDependOnOutputsOfOtherTasks;
-exports.hashTask = hashTask;
-exports.hashTasks = hashTasks;
-const nx_json_1 = require("../config/nx-json");
-const native_1 = require("../native");
-const project_graph_1 = require("../project-graph/project-graph");
-const task_io_service_1 = require("../tasks-runner/task-io-service");
-const task_env_1 = require("../tasks-runner/task-env");
-const utils_1 = require("../tasks-runner/utils");
-const db_connection_1 = require("../utils/db-connection");
-const task_hasher_1 = require("./task-hasher");
-let taskDetails;
-function getTaskDetails() {
-    // TODO: Remove when wasm supports sqlite
-    if (native_1.IS_WASM) {
-        return null;
-    }
-    if (!taskDetails) {
-        taskDetails = new native_1.TaskDetails((0, db_connection_1.getDbConnection)());
-    }
-    return taskDetails;
-}
-async function hashTasksThatDoNotDependOnOutputsOfOtherTasks(hasher, projectGraph, taskGraph, nxJson, tasksDetails) {
-    performance.mark('hashMultipleTasks:start');
-    const projects = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph).projects;
-    const tasks = Object.values(taskGraph.tasks);
-    const tasksWithHashers = await Promise.all(tasks.map(async (task) => {
-        const customHasher = (0, utils_1.getCustomHasher)(task, projects);
-        return { task, customHasher };
-    }));
-    const tasksToHash = tasksWithHashers
-        .filter(({ task, customHasher }) => {
-        // If a task has a custom hasher, it might depend on the outputs of other tasks
-        if (customHasher) {
-            return false;
-        }
-        return !(taskGraph.dependencies[task.id].length > 0 &&
-            (0, task_hasher_1.getInputs)(task, projectGraph, nxJson).depsOutputs.length > 0);
-    })
-        .map((t) => t.task);
-    const perTaskEnvs = {};
-    for (const task of tasksToHash) {
-        perTaskEnvs[task.id] = (0, task_env_1.getTaskSpecificEnv)(task, projectGraph);
-    }
-    const hashes = await hasher.hashTasks(tasksToHash, taskGraph, perTaskEnvs);
-    const ioService = (0, task_io_service_1.getTaskIOService)();
-    const hasInputSubscribers = ioService.hasTaskInputSubscribers();
-    for (let i = 0; i < tasksToHash.length; i++) {
-        tasksToHash[i].hash = hashes[i].value;
-        tasksToHash[i].hashDetails = hashes[i].details;
-        // Notify TaskIOService of hash inputs
-        if (hasInputSubscribers && hashes[i].inputs) {
-            ioService.notifyTaskInputs(tasksToHash[i].id, hashes[i].inputs);
-        }
-    }
-    if (tasksDetails?.recordTaskDetails) {
-        tasksDetails.recordTaskDetails(tasksToHash.map((task) => ({
-            hash: task.hash,
-            project: task.target.project,
-            target: task.target.target,
-            configuration: task.target.configuration,
-        })));
-    }
-    performance.mark('hashMultipleTasks:end');
-    performance.measure('hashMultipleTasks', 'hashMultipleTasks:start', 'hashMultipleTasks:end');
-}
-async function hashTask(hasher, projectGraph, taskGraph, task, env, taskDetails) {
-    performance.mark('hashSingleTask:start');
-    const projectsConfigurations = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph);
-    const customHasher = (0, utils_1.getCustomHasher)(task, projectsConfigurations.projects);
-    const { value, details, inputs } = await (customHasher
-        ? customHasher(task, {
-            hasher,
-            projectGraph,
-            taskGraph,
-            workspaceConfig: projectsConfigurations, // to make the change non-breaking. Remove after v19
-            projectsConfigurations,
-            nxJsonConfiguration: (0, nx_json_1.readNxJson)(),
-            env,
-        })
-        : hasher.hashTask(task, taskGraph, env));
-    task.hash = value;
-    task.hashDetails = details;
-    // Notify TaskIOService of hash inputs
-    const ioService = (0, task_io_service_1.getTaskIOService)();
-    if (ioService.hasTaskInputSubscribers() && inputs) {
-        ioService.notifyTaskInputs(task.id, inputs);
-    }
-    if (taskDetails?.recordTaskDetails) {
-        taskDetails.recordTaskDetails([
-            {
-                hash: task.hash,
-                project: task.target.project,
-                target: task.target.target,
-                configuration: task.target.configuration,
-            },
-        ]);
-    }
-    performance.mark('hashSingleTask:end');
-    performance.measure('hashSingleTask', 'hashSingleTask:start', 'hashSingleTask:end');
-}
-/**
- * Batch-hash `tasks`. `perTaskEnvs` must contain an entry keyed by
- * `task.id` for every task — the per-task env is what each task's
- * custom hasher sees and what the built-in hasher reads
- * `HashInstruction::Environment` inputs against. Callers that
- * genuinely want to hash against a single shared env should build
- * `{ [task.id]: env }` for every task.
- */
-async function hashTasks(hasher, projectGraph, taskGraph, perTaskEnvs, taskDetails, tasksToHashOverride) {
-    performance.mark('hashMultipleTasks:start');
-    const projectsConfigurations = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph);
-    const nxJson = (0, nx_json_1.readNxJson)();
-    const tasks = (tasksToHashOverride ?? Object.values(taskGraph.tasks)).filter((task) => !task.hash);
-    // Separate tasks with custom hashers from those without
-    const tasksWithCustomHashers = [];
-    const tasksWithoutCustomHashers = [];
-    for (const task of tasks) {
-        const customHasher = (0, utils_1.getCustomHasher)(task, projectsConfigurations.projects);
-        if (customHasher) {
-            tasksWithCustomHashers.push(task);
-        }
-        else {
-            tasksWithoutCustomHashers.push(task);
-        }
-    }
-    // Hash tasks with custom hashers individually
-    const ioService = (0, task_io_service_1.getTaskIOService)();
-    const hasInputSubscribers = ioService.hasTaskInputSubscribers();
-    const customHasherPromises = tasksWithCustomHashers.map(async (task) => {
-        const customHasher = (0, utils_1.getCustomHasher)(task, projectsConfigurations.projects);
-        const { value, details, inputs } = await customHasher(task, {
-            hasher,
-            projectGraph,
-            taskGraph,
-            workspaceConfig: projectsConfigurations,
-            projectsConfigurations,
-            nxJsonConfiguration: nxJson,
-            env: perTaskEnvs[task.id],
-        });
-        task.hash = value;
-        task.hashDetails = details;
-        // Notify TaskIOService of hash inputs
-        if (hasInputSubscribers && inputs) {
-            ioService.notifyTaskInputs(task.id, inputs);
-        }
-    });
-    // Hash tasks without custom hashers in batch
-    let batchHashPromise = Promise.resolve();
-    if (tasksWithoutCustomHashers.length > 0) {
-        batchHashPromise = hasher
-            .hashTasks(tasksWithoutCustomHashers, taskGraph, perTaskEnvs)
-            .then((hashes) => {
-            for (let i = 0; i < tasksWithoutCustomHashers.length; i++) {
-                tasksWithoutCustomHashers[i].hash = hashes[i].value;
-                tasksWithoutCustomHashers[i].hashDetails = hashes[i].details;
-                // Notify TaskIOService of hash inputs
-                if (hasInputSubscribers && hashes[i].inputs) {
-                    ioService.notifyTaskInputs(tasksWithoutCustomHashers[i].id, hashes[i].inputs);
-                }
-            }
-        });
-    }
-    await Promise.all([...customHasherPromises, batchHashPromise]);
-    if (taskDetails?.recordTaskDetails) {
-        // Guard against a custom hasher resolving with a falsy value —
-        // the built-in batch hasher always produces a hash, but user-written
-        // custom hashers are untrusted and an empty/undefined hash would
-        // violate the task_details schema downstream.
-        const hashedTasks = [];
-        for (const t of tasks) {
-            if (!t.hash) {
-                continue;
-            }
-            hashedTasks.push({
-                hash: t.hash,
-                project: t.target.project,
-                target: t.target.target,
-                configuration: t.target.configuration,
-            });
-        }
-        if (hashedTasks.length > 0) {
-            taskDetails.recordTaskDetails(hashedTasks);
-        }
-    }
-    performance.mark('hashMultipleTasks:end');
-    performance.measure('hashMultipleTasks', 'hashMultipleTasks:start', 'hashMultipleTasks:end');
-}

package/dist/src/hasher/native-task-hasher-impl.d.ts

@@ -1,18 +0,0 @@
-import { NxJsonConfiguration } from '../config/nx-json';
-import { ProjectGraph } from '../config/project-graph';
-import { Task, TaskGraph } from '../config/task-graph';
-import { ExternalObject, FileData, HasherOptions, HashPlanner, ProjectGraph as NativeProjectGraph, NxWorkspaceFilesExternals, TaskHasher } from '../native';
-import { PartialHash, TaskHasherImpl } from './task-hasher';
-export declare class NativeTaskHasherImpl implements TaskHasherImpl {
-    hasher: TaskHasher;
-    planner: HashPlanner;
-    projectGraphRef: ExternalObject<NativeProjectGraph>;
-    allWorkspaceFilesRef: ExternalObject<FileData[]>;
-    projectFileMapRef: ExternalObject<Record<string, FileData[]>>;
-    options: HasherOptions | undefined;
-    constructor(workspaceRoot: string, nxJson: NxJsonConfiguration, projectGraph: ProjectGraph, externals: NxWorkspaceFilesExternals, options: {
-        selectivelyHashTsConfig: boolean;
-    });
-    hashTask(task: Task, taskGraph: TaskGraph, env: NodeJS.ProcessEnv, cwd?: string, collectInputs?: boolean): Promise<PartialHash>;
-    hashTasks(tasks: Task[], taskGraph: TaskGraph, perTaskEnvs: Record<string, NodeJS.ProcessEnv>, cwd?: string, collectInputs?: boolean): Promise<PartialHash[]>;
-}

package/dist/src/hasher/native-task-hasher-impl.js

@@ -1,38 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NativeTaskHasherImpl = void 0;
-const native_1 = require("../native");
-const transform_objects_1 = require("../native/transform-objects");
-const typescript_1 = require("../plugins/js/utils/typescript");
-const task_io_service_1 = require("../tasks-runner/task-io-service");
-const fileutils_1 = require("../utils/fileutils");
-class NativeTaskHasherImpl {
-    constructor(workspaceRoot, nxJson, projectGraph, externals, options) {
-        this.projectGraphRef = (0, native_1.transferProjectGraph)((0, transform_objects_1.transformProjectGraphForRust)(projectGraph));
-        this.allWorkspaceFilesRef = externals.allWorkspaceFiles;
-        this.projectFileMapRef = externals.projectFiles;
-        let tsconfig = {};
-        let paths = {};
-        let rootTsConfigPath = (0, typescript_1.getRootTsConfigPath)();
-        if (rootTsConfigPath) {
-            tsconfig = (0, fileutils_1.readJsonFile)((0, typescript_1.getRootTsConfigPath)());
-            paths = tsconfig.compilerOptions?.paths ?? {};
-            if (tsconfig.compilerOptions?.paths) {
-                delete tsconfig.compilerOptions.paths;
-            }
-        }
-        this.planner = new native_1.HashPlanner(nxJson, this.projectGraphRef);
-        this.hasher = new native_1.TaskHasher(workspaceRoot, this.projectGraphRef, this.projectFileMapRef, this.allWorkspaceFilesRef, Buffer.from(JSON.stringify(tsconfig)), paths, rootTsConfigPath, options);
-    }
-    async hashTask(task, taskGraph, env, cwd, collectInputs) {
-        const hashes = await this.hashTasks([task], taskGraph, { [task.id]: env }, cwd, collectInputs);
-        return hashes[0];
-    }
-    async hashTasks(tasks, taskGraph, perTaskEnvs, cwd, collectInputs) {
-        const plans = this.planner.getPlansReference(tasks.map((t) => t.id), taskGraph);
-        const shouldCollectInputs = collectInputs ?? (0, task_io_service_1.getTaskIOService)().hasTaskInputSubscribers();
-        const hashes = this.hasher.hashPlans(plans, perTaskEnvs, cwd ?? process.cwd(), shouldCollectInputs);
-        return tasks.map((t) => hashes[t.id]);
-    }
-}
-exports.NativeTaskHasherImpl = NativeTaskHasherImpl;

package/dist/src/hasher/task-hasher.d.ts

@@ -1,160 +0,0 @@
-import { FileData, ProjectGraph, ProjectGraphProjectNode } from '../config/project-graph';
-import { NxJsonConfiguration } from '../config/nx-json';
-import { Task, TaskGraph } from '../config/task-graph';
-import { DaemonClient } from '../daemon/client/client';
-import { InputDefinition } from '../config/workspace-json-project-json';
-import { HashInputs, NxWorkspaceFilesExternals } from '../native';
-export { HashInputs };
-/**
- * A data structure returned by the default hasher.
- */
-export interface PartialHash {
-    value: string;
-    details: {
-        [name: string]: string;
-    };
-    inputs: HashInputs;
-}
-/**
- * A data structure returned by the default hasher.
- */
-export interface Hash {
-    value: string;
-    details: {
-        command: string;
-        nodes: {
-            [name: string]: string;
-        };
-        implicitDeps?: {
-            [fileName: string]: string;
-        };
-        runtime?: {
-            [input: string]: string;
-        };
-    };
-    inputs?: HashInputs;
-}
-export interface TaskHasher {
-    /**
-     * @deprecated use hashTask(task:Task, taskGraph: TaskGraph, env: NodeJS.ProcessEnv) instead. This will be removed in v20
-     * @param task
-     */
-    hashTask(task: Task): Promise<Hash>;
-    /**
-     * @deprecated use hashTask(task:Task, taskGraph: TaskGraph, env: NodeJS.ProcessEnv) instead. This will be removed in v20
-     */
-    hashTask(task: Task, taskGraph: TaskGraph): Promise<Hash>;
-    hashTask(task: Task, taskGraph: TaskGraph, env: NodeJS.ProcessEnv, cwd?: string): Promise<Hash>;
-    /**
-     * @deprecated pass `perTaskEnvs` keyed by `task.id` instead — hashing
-     * every task against one shared env produces the wrong cache key when
-     * tasks have per-project/target `.env` files or custom hashers that
-     * read env. Will be removed in v22.
-     */
-    hashTasks(tasks: Task[], taskGraph: TaskGraph, env: NodeJS.ProcessEnv, cwd?: string): Promise<Hash[]>;
-    /**
-     * Hash `tasks`. `perTaskEnvs` must contain an entry keyed by `task.id`
-     * for every task in `tasks` — task-specific env (per-project/target
-     * `.env` files, custom-hasher env reads) participates in the hash, so
-     * a shared env across tasks would compute the wrong cache key when
-     * tasks actually differ.
-     */
-    hashTasks(tasks: Task[], taskGraph: TaskGraph, perTaskEnvs: Record<string, NodeJS.ProcessEnv>, cwd?: string): Promise<Hash[]>;
-}
-export interface TaskHasherImpl {
-    /**
-     * Hash `tasks` where each task is keyed in `perTaskEnvs` by `task.id`.
-     * Every task must have an entry — callers who want to hash against a
-     * single shared env should construct `{ [task.id]: env }` for every
-     * task.
-     */
-    hashTasks(tasks: Task[], taskGraph: TaskGraph, perTaskEnvs: Record<string, NodeJS.ProcessEnv>, cwd?: string, collectInputs?: boolean): Promise<PartialHash[]>;
-    hashTask(task: Task, taskGraph: TaskGraph, env: NodeJS.ProcessEnv, cwd?: string, collectInputs?: boolean): Promise<PartialHash>;
-}
-export type Hasher = TaskHasher;
-export declare class DaemonBasedTaskHasher implements TaskHasher {
-    private readonly daemonClient;
-    private readonly runnerOptions;
-    constructor(daemonClient: DaemonClient, runnerOptions: any);
-    hashTasks(tasks: Task[], taskGraph: TaskGraph, envOrPerTaskEnvs: NodeJS.ProcessEnv | Record<string, NodeJS.ProcessEnv>): Promise<Hash[]>;
-    hashTask(task: Task, taskGraph?: TaskGraph, env?: NodeJS.ProcessEnv): Promise<Hash>;
-}
-export declare class InProcessTaskHasher implements TaskHasher {
-    private readonly projectGraph;
-    private readonly nxJson;
-    private readonly externalRustReferences;
-    private readonly options;
-    private taskHasher;
-    constructor(projectGraph: ProjectGraph, nxJson: NxJsonConfiguration, externalRustReferences: NxWorkspaceFilesExternals | null, options: any);
-    hashTasks(tasks: Task[], taskGraph: TaskGraph, envOrPerTaskEnvs: NodeJS.ProcessEnv | Record<string, NodeJS.ProcessEnv>, cwd?: string, collectInputs?: boolean): Promise<Hash[]>;
-    hashTask(task: Task, taskGraph?: TaskGraph, env?: NodeJS.ProcessEnv, cwd?: string, collectInputs?: boolean): Promise<Hash>;
-    private createHashDetails;
-    private hashCommand;
-}
-export type ExpandedSelfInput = {
-    fileset: string;
-} | {
-    runtime: string;
-} | {
-    env: string;
-} | {
-    externalDependencies: string[];
-};
-export type ExpandedDepsOutput = {
-    dependentTasksOutputFiles: string;
-    transitive?: boolean;
-};
-export type ExpandedInput = ExpandedSelfInput | ExpandedDepsOutput;
-export declare function getNamedInputs(nxJson: NxJsonConfiguration, project: ProjectGraphProjectNode): {
-    default: {
-        fileset: string;
-    }[];
-};
-export declare function getTargetInputs(nxJson: NxJsonConfiguration, projectNode: ProjectGraphProjectNode, target: string): {
-    selfInputs: string[];
-    dependencyInputs: string[];
-};
-export declare function extractPatternsFromFileSets(inputs: readonly ExpandedInput[]): string[];
-export declare function getInputs(task: Task, projectGraph: ProjectGraph, nxJson: NxJsonConfiguration): {
-    selfInputs: ExpandedSelfInput[];
-    depsInputs: {
-        input: string;
-        dependencies: true;
-    }[];
-    depsOutputs: ExpandedDepsOutput[];
-    projectInputs: {
-        input: string;
-        projects: string[];
-    }[];
-    depsFilesets: {
-        fileset: string;
-        dependencies: true;
-    }[];
-};
-export declare function splitInputsIntoSelfAndDependencies(inputs: ReadonlyArray<InputDefinition | string>, namedInputs: {
-    [inputName: string]: ReadonlyArray<InputDefinition | string>;
-}): {
-    depsInputs: {
-        input: string;
-        dependencies: true;
-    }[];
-    projectInputs: {
-        input: string;
-        projects: string[];
-    }[];
-    selfInputs: ExpandedSelfInput[];
-    depsOutputs: ExpandedDepsOutput[];
-    depsFilesets: {
-        fileset: string;
-        dependencies: true;
-    }[];
-};
-export declare function isSelfInput(input: ExpandedInput): input is ExpandedSelfInput;
-export declare function isDepsOutput(input: ExpandedInput): input is ExpandedDepsOutput;
-export declare function expandSingleProjectInputs(inputs: ReadonlyArray<InputDefinition | string>, namedInputs: {
-    [inputName: string]: ReadonlyArray<InputDefinition | string>;
-}): ExpandedInput[];
-export declare function expandNamedInput(input: string, namedInputs: {
-    [inputName: string]: ReadonlyArray<InputDefinition | string>;
-}): ExpandedInput[];
-export declare function filterUsingGlobPatterns(root: string, files: FileData[], patterns: string[]): FileData[];