nx 20.8.4 → 22.7.7

package/src/hasher/task-hasher.js

@@ -1,240 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InProcessTaskHasher = exports.DaemonBasedTaskHasher = void 0;
-exports.getNamedInputs = getNamedInputs;
-exports.getTargetInputs = getTargetInputs;
-exports.extractPatternsFromFileSets = extractPatternsFromFileSets;
-exports.getInputs = getInputs;
-exports.isSelfInput = isSelfInput;
-exports.isDepsOutput = isDepsOutput;
-exports.expandSingleProjectInputs = expandSingleProjectInputs;
-exports.expandNamedInput = expandNamedInput;
-exports.filterUsingGlobPatterns = filterUsingGlobPatterns;
-const file_hasher_1 = require("./file-hasher");
-const minimatch_1 = require("minimatch");
-const native_task_hasher_impl_1 = require("./native-task-hasher-impl");
-const workspace_root_1 = require("../utils/workspace-root");
-class DaemonBasedTaskHasher {
-    constructor(daemonClient, runnerOptions) {
-        this.daemonClient = daemonClient;
-        this.runnerOptions = runnerOptions;
-    }
-    async hashTasks(tasks, taskGraph, env) {
-        return this.daemonClient.hashTasks(this.runnerOptions, tasks, taskGraph, env ?? process.env);
-    }
-    async hashTask(task, taskGraph, env) {
-        return (await this.daemonClient.hashTasks(this.runnerOptions, [task], taskGraph, env ?? process.env))[0];
-    }
-}
-exports.DaemonBasedTaskHasher = DaemonBasedTaskHasher;
-class InProcessTaskHasher {
-    constructor(projectGraph, nxJson, externalRustReferences, options) {
-        this.projectGraph = projectGraph;
-        this.nxJson = nxJson;
-        this.externalRustReferences = externalRustReferences;
-        this.options = options;
-        this.taskHasher = new native_task_hasher_impl_1.NativeTaskHasherImpl(workspace_root_1.workspaceRoot, this.nxJson, this.projectGraph, this.externalRustReferences, {
-            selectivelyHashTsConfig: this.options?.selectivelyHashTsConfig ?? false,
-        });
-    }
-    async hashTasks(tasks, taskGraph, env) {
-        const hashes = await this.taskHasher.hashTasks(tasks, taskGraph, env ?? process.env);
-        return tasks.map((task, index) => this.createHashDetails(task, hashes[index]));
-    }
-    async hashTask(task, taskGraph, env) {
-        const res = await this.taskHasher.hashTask(task, taskGraph, env ?? process.env);
-        return this.createHashDetails(task, res);
-    }
-    createHashDetails(task, res) {
-        const command = this.hashCommand(task);
-        return {
-            value: (0, file_hasher_1.hashArray)([res.value, command]),
-            details: {
-                command,
-                nodes: res.details,
-                implicitDeps: {},
-                runtime: {},
-            },
-        };
-    }
-    hashCommand(task) {
-        const overrides = { ...task.overrides };
-        delete overrides['__overrides_unparsed__'];
-        const sortedOverrides = {};
-        for (let k of Object.keys(overrides).sort()) {
-            sortedOverrides[k] = overrides[k];
-        }
-        return (0, file_hasher_1.hashArray)([
-            task.target.project ?? '',
-            task.target.target ?? '',
-            task.target.configuration ?? '',
-            JSON.stringify(sortedOverrides),
-        ]);
-    }
-}
-exports.InProcessTaskHasher = InProcessTaskHasher;
-const DEFAULT_INPUTS = [
-    {
-        fileset: '{projectRoot}/**/*',
-    },
-    {
-        dependencies: true,
-        input: 'default',
-    },
-];
-function getNamedInputs(nxJson, project) {
-    return {
-        default: [{ fileset: '{projectRoot}/**/*' }],
-        ...nxJson.namedInputs,
-        ...project.data.namedInputs,
-    };
-}
-function getTargetInputs(nxJson, projectNode, target) {
-    const namedInputs = getNamedInputs(nxJson, projectNode);
-    const targetData = projectNode.data.targets[target];
-    const targetDefaults = (nxJson.targetDefaults || {})[target];
-    const inputs = splitInputsIntoSelfAndDependencies(targetData.inputs || targetDefaults?.inputs || DEFAULT_INPUTS, namedInputs);
-    const selfInputs = extractPatternsFromFileSets(inputs.selfInputs);
-    const dependencyInputs = extractPatternsFromFileSets(inputs.depsInputs.map((s) => expandNamedInput(s.input, namedInputs)).flat());
-    return { selfInputs, dependencyInputs };
-}
-function extractPatternsFromFileSets(inputs) {
-    return inputs
-        .filter((c) => !!c['fileset'])
-        .map((c) => c['fileset']);
-}
-function getInputs(task, projectGraph, nxJson) {
-    const projectNode = projectGraph.nodes[task.target.project];
-    const namedInputs = getNamedInputs(nxJson, projectNode);
-    const targetData = projectNode.data.targets[task.target.target];
-    const targetDefaults = (nxJson.targetDefaults || {})[task.target.target];
-    const { selfInputs, depsInputs, depsOutputs, projectInputs } = splitInputsIntoSelfAndDependencies(targetData.inputs || targetDefaults?.inputs || DEFAULT_INPUTS, namedInputs);
-    return { selfInputs, depsInputs, depsOutputs, projectInputs };
-}
-function splitInputsIntoSelfAndDependencies(inputs, namedInputs) {
-    const depsInputs = [];
-    const projectInputs = [];
-    const selfInputs = [];
-    for (const d of inputs) {
-        if (typeof d === 'string') {
-            if (d.startsWith('^')) {
-                depsInputs.push({ input: d.substring(1), dependencies: true });
-            }
-            else {
-                selfInputs.push(d);
-            }
-        }
-        else {
-            if (('dependencies' in d && d.dependencies) ||
-                // Todo(@AgentEnder): Remove check in v17
-                ('projects' in d &&
-                    typeof d.projects === 'string' &&
-                    d.projects === 'dependencies')) {
-                depsInputs.push({
-                    input: d.input,
-                    dependencies: true,
-                });
-            }
-            else if ('projects' in d &&
-                d.projects &&
-                // Todo(@AgentEnder): Remove check in v17
-                !(d.projects === 'self')) {
-                projectInputs.push({
-                    input: d.input,
-                    projects: Array.isArray(d.projects) ? d.projects : [d.projects],
-                });
-            }
-            else {
-                selfInputs.push(d);
-            }
-        }
-    }
-    const expandedInputs = expandSingleProjectInputs(selfInputs, namedInputs);
-    return {
-        depsInputs,
-        projectInputs,
-        selfInputs: expandedInputs.filter(isSelfInput),
-        depsOutputs: expandedInputs.filter(isDepsOutput),
-    };
-}
-function isSelfInput(input) {
-    return !('dependentTasksOutputFiles' in input);
-}
-function isDepsOutput(input) {
-    return 'dependentTasksOutputFiles' in input;
-}
-function expandSingleProjectInputs(inputs, namedInputs) {
-    const expanded = [];
-    for (const d of inputs) {
-        if (typeof d === 'string') {
-            if (d.startsWith('^'))
-                throw new Error(`namedInputs definitions cannot start with ^`);
-            if (namedInputs[d]) {
-                expanded.push(...expandNamedInput(d, namedInputs));
-            }
-            else {
-                expanded.push({ fileset: d });
-            }
-        }
-        else {
-            if (d.projects || d.dependencies) {
-                throw new Error(`namedInputs definitions can only refer to other namedInputs definitions within the same project.`);
-            }
-            if (d.fileset ||
-                d.env ||
-                d.runtime ||
-                d.externalDependencies ||
-                d.dependentTasksOutputFiles) {
-                expanded.push(d);
-            }
-            else {
-                expanded.push(...expandNamedInput(d.input, namedInputs));
-            }
-        }
-    }
-    return expanded;
-}
-function expandNamedInput(input, namedInputs) {
-    namedInputs ||= {};
-    if (!namedInputs[input])
-        throw new Error(`Input '${input}' is not defined`);
-    return expandSingleProjectInputs(namedInputs[input], namedInputs);
-}
-function filterUsingGlobPatterns(root, files, patterns) {
-    const filesetWithExpandedProjectRoot = patterns
-        .map((f) => f.replace('{projectRoot}', root))
-        .map((r) => {
-        // handling root level projects that create './' pattern that doesn't work with minimatch
-        if (r.startsWith('./'))
-            return r.substring(2);
-        if (r.startsWith('!./'))
-            return '!' + r.substring(3);
-        return r;
-    });
-    const positive = [];
-    const negative = [];
-    for (const p of filesetWithExpandedProjectRoot) {
-        if (p.startsWith('!')) {
-            negative.push(p);
-        }
-        else {
-            positive.push(p);
-        }
-    }
-    if (positive.length === 0 && negative.length === 0) {
-        return files;
-    }
-    return files.filter((f) => {
-        let matchedPositive = false;
-        if (positive.length === 0 ||
-            (positive.length === 1 && positive[0] === `${root}/**/*`)) {
-            matchedPositive = true;
-        }
-        else {
-            matchedPositive = positive.some((pattern) => (0, minimatch_1.minimatch)(f.file, pattern));
-        }
-        if (!matchedPositive)
-            return false;
-        return negative.every((pattern) => (0, minimatch_1.minimatch)(f.file, pattern));
-    });
-}

package/src/migrations/update-17-0-0/move-cache-directory.js

@@ -1,35 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = moveCacheDirectory;
-const ignore_1 = require("ignore");
-function moveCacheDirectory(tree) {
-    // If nx.json doesn't exist the repo can't utilize
-    // caching, so .nx/cache is less relevant. Lerna users
-    // that don't want to fully opt in to Nx at this time
-    // may also be caught off guard by the appearance of
-    // a .nx directory, so we are going to special case
-    // this for the time being.
-    if (tree.exists('lerna.json') && !tree.exists('nx.json')) {
-        return;
-    }
-    updateGitIgnore(tree);
-    if (tree.exists('.prettierignore')) {
-        const ignored = tree.read('.prettierignore', 'utf-8');
-        if (!ignored.includes('.nx/cache')) {
-            tree.write('.prettierignore', [ignored, '/.nx/cache'].join('\n'));
-        }
-    }
-}
-function updateGitIgnore(tree) {
-    const gitignore = tree.exists('.gitignore')
-        ? tree.read('.gitignore', 'utf-8')
-        : '';
-    const ig = (0, ignore_1.default)();
-    ig.add(gitignore);
-    if (!ig.ignores('.nx/cache')) {
-        const updatedLines = gitignore.length
-            ? [gitignore, '.nx/cache']
-            : ['.nx/cache'];
-        tree.write('.gitignore', updatedLines.join('\n'));
-    }
-}

package/src/migrations/update-17-2-0/move-default-base.js

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = update;
-/* eslint-disable @typescript-eslint/no-unused-vars */
-const nx_json_1 = require("../../generators/utils/nx-json");
-const format_changed_files_with_prettier_if_available_1 = require("../../generators/internal-utils/format-changed-files-with-prettier-if-available");
-/**
- * Updates existing workspaces to move nx.json's affected.defaultBase to nx.json's base.
- */
-async function update(host) {
-    const nxJson = (0, nx_json_1.readNxJson)(host);
-    if (nxJson?.affected?.defaultBase) {
-        nxJson.defaultBase = nxJson.affected.defaultBase;
-        delete nxJson.affected.defaultBase;
-        if (Object.keys(nxJson.affected).length === 0) {
-            delete nxJson.affected;
-        }
-        (0, nx_json_1.updateNxJson)(host, nxJson);
-    }
-    await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(host);
-}

package/src/native/index.d.ts

@@ -1,311 +0,0 @@
-/* auto-generated by NAPI-RS */
-/* eslint-disable */
-
-export declare class ExternalObject<T> {
-  readonly '': {
-    readonly '': unique symbol
-    [K: symbol]: T
-  }
-}
-export declare class ChildProcess {
-  kill(): void
-  onExit(callback: (message: string) => void): void
-  onOutput(callback: (message: string) => void): void
-}
-
-export declare class FileLock {
-  locked: boolean
-  constructor(lockFilePath: string)
-  unlock(): void
-  check(): boolean
-  wait(): Promise<void>
-  lock(): void
-}
-
-export declare class HashPlanner {
-  constructor(nxJson: NxJson, projectGraph: ExternalObject<ProjectGraph>)
-  getPlans(taskIds: Array<string>, taskGraph: TaskGraph): Record<string, string[]>
-  getPlansReference(taskIds: Array<string>, taskGraph: TaskGraph): ExternalObject<Record<string, Array<HashInstruction>>>
-}
-
-export declare class HttpRemoteCache {
-  constructor()
-  retrieve(hash: string, cacheDirectory: string): Promise<CachedResult | null>
-  store(hash: string, cacheDirectory: string, terminalOutput: string, code: number): Promise<boolean>
-}
-
-export declare class ImportResult {
-  file: string
-  sourceProject: string
-  dynamicImportExpressions: Array<string>
-  staticImportExpressions: Array<string>
-}
-
-export declare class NxCache {
-  cacheDirectory: string
-  constructor(workspaceRoot: string, cachePath: string, dbConnection: ExternalObject<NxDbConnection>, linkTaskDetails?: boolean | undefined | null, maxCacheSize?: number | undefined | null)
-  get(hash: string): CachedResult | null
-  put(hash: string, terminalOutput: string, outputs: Array<string>, code: number): void
-  applyRemoteCacheResults(hash: string, result: CachedResult, outputs?: Array<string> | undefined | null): void
-  getTaskOutputsPath(hash: string): string
-  getCacheSize(): number
-  copyFilesFromCache(cachedResult: CachedResult, outputs: Array<string>): number
-  removeOldCacheRecords(): void
-  checkCacheFsInSync(): boolean
-}
-
-export declare class NxTaskHistory {
-  constructor(db: ExternalObject<NxDbConnection>)
-  recordTaskRuns(taskRuns: Array<TaskRun>): void
-  getFlakyTasks(hashes: Array<string>): Array<string>
-  getEstimatedTaskTimings(targets: Array<TaskTarget>): Record<string, number>
-}
-
-export declare class RustPseudoTerminal {
-  constructor()
-  runCommand(command: string, commandDir?: string | undefined | null, jsEnv?: Record<string, string> | undefined | null, execArgv?: Array<string> | undefined | null, quiet?: boolean | undefined | null, tty?: boolean | undefined | null): ChildProcess
-  /**
-   * This allows us to run a pseudoterminal with a fake node ipc channel
-   * this makes it possible to be backwards compatible with the old implementation
-   */
-  fork(id: string, forkScript: string, pseudoIpcPath: string, commandDir: string | undefined | null, jsEnv: Record<string, string> | undefined | null, execArgv: Array<string> | undefined | null, quiet: boolean): ChildProcess
-}
-
-export declare class TaskDetails {
-  constructor(db: ExternalObject<NxDbConnection>)
-  recordTaskDetails(tasks: Array<HashedTask>): void
-}
-
-export declare class TaskHasher {
-  constructor(workspaceRoot: string, projectGraph: ExternalObject<ProjectGraph>, projectFileMap: ExternalObject<ProjectFiles>, allWorkspaceFiles: ExternalObject<Array<FileData>>, tsConfig: Buffer, tsConfigPaths: Record<string, Array<string>>, options?: HasherOptions | undefined | null)
-  hashPlans(hashPlans: ExternalObject<Record<string, Array<HashInstruction>>>, jsEnv: Record<string, string>): NapiDashMap
-}
-
-export declare class Watcher {
-  origin: string
-  /**
-   * Creates a new Watcher instance.
-   * Will always ignore the following directories:
-   * * .git/
-   * * node_modules/
-   * * .nx/
-   */
-  constructor(origin: string, additionalGlobs?: Array<string> | undefined | null, useIgnore?: boolean | undefined | null)
-  watch(callback: (err: string | null, events: WatchEvent[]) => void): void
-  stop(): Promise<void>
-}
-
-export declare class WorkspaceContext {
-  workspaceRoot: string
-  constructor(workspaceRoot: string, cacheDir: string)
-  getWorkspaceFiles(projectRootMap: Record<string, string>): NxWorkspaceFiles
-  glob(globs: Array<string>, exclude?: Array<string> | undefined | null): Array<string>
-  /**
-   * Performs multiple glob pattern matches against workspace files in parallel
-   * @returns An array of arrays, where each inner array contains the file paths
-   * that matched the corresponding glob pattern in the input. The outer array maintains the same order
-   * as the input globs.
-   */
-  multiGlob(globs: Array<string>, exclude?: Array<string> | undefined | null): Array<Array<string>>
-  hashFilesMatchingGlobs(globGroups: Array<Array<string>>): Array<string>
-  hashFilesMatchingGlob(globs: Array<string>, exclude?: Array<string> | undefined | null): string
-  incrementalUpdate(updatedFiles: Array<string>, deletedFiles: Array<string>): Record<string, string>
-  updateProjectFiles(projectRootMappings: ProjectRootMappings, projectFiles: ExternalObject<ProjectFiles>, globalFiles: ExternalObject<Array<FileData>>, updatedFiles: Record<string, string>, deletedFiles: Array<string>): UpdatedWorkspaceFiles
-  allFileData(): Array<FileData>
-  getFilesInDirectory(directory: string): Array<string>
-}
-
-export interface CachedResult {
-  code: number
-  terminalOutput?: string
-  outputsPath: string
-  size?: number
-}
-
-export declare export declare function closeDbConnection(connection: ExternalObject<NxDbConnection>): void
-
-export declare export declare function connectToNxDb(cacheDir: string, nxVersion: string, dbName?: string | undefined | null): ExternalObject<NxDbConnection>
-
-export declare export declare function copy(src: string, dest: string): number
-
-export interface DepsOutputsInput {
-  dependentTasksOutputFiles: string
-  transitive?: boolean
-}
-
-export interface EnvironmentInput {
-  env: string
-}
-
-export declare const enum EventType {
-  delete = 'delete',
-  update = 'update',
-  create = 'create'
-}
-
-export declare export declare function expandOutputs(directory: string, entries: Array<string>): Array<string>
-
-export interface ExternalDependenciesInput {
-  externalDependencies: Array<string>
-}
-
-export interface ExternalNode {
-  packageName?: string
-  version: string
-  hash?: string
-}
-
-export interface FileData {
-  file: string
-  hash: string
-}
-
-export interface FileMap {
-  projectFileMap: ProjectFiles
-  nonProjectFiles: Array<FileData>
-}
-
-export interface FileSetInput {
-  fileset: string
-}
-
-export declare export declare function findImports(projectFileMap: Record<string, Array<string>>): Array<ImportResult>
-
-export declare export declare function getBinaryTarget(): string
-
-export declare export declare function getDefaultMaxCacheSize(cachePath: string): number
-
-/**
- * Expands the given outputs into a list of existing files.
- * This is used when hashing outputs
- */
-export declare export declare function getFilesForOutputs(directory: string, entries: Array<string>): Array<string>
-
-export declare export declare function getTransformableOutputs(outputs: Array<string>): Array<string>
-
-export declare export declare function hashArray(input: Array<string | undefined | null>): string
-
-export interface HashDetails {
-  value: string
-  details: Record<string, string>
-}
-
-export interface HashedTask {
-  hash: string
-  project: string
-  target: string
-  configuration?: string
-}
-
-export interface HasherOptions {
-  selectivelyHashTsConfig: boolean
-}
-
-export declare export declare function hashFile(file: string): string | null
-
-export interface InputsInput {
-  input: string
-  dependencies?: boolean
-  projects?: string | Array<string>
-}
-
-export const IS_WASM: boolean
-
-/** Stripped version of the NxJson interface for use in rust */
-export interface NxJson {
-  namedInputs?: Record<string, Array<JsInputs>>
-}
-
-export interface NxWorkspaceFiles {
-  projectFileMap: ProjectFiles
-  globalFiles: Array<FileData>
-  externalReferences?: NxWorkspaceFilesExternals
-}
-
-export interface NxWorkspaceFilesExternals {
-  projectFiles: ExternalObject<ProjectFiles>
-  globalFiles: ExternalObject<Array<FileData>>
-  allWorkspaceFiles: ExternalObject<Array<FileData>>
-}
-
-export interface Project {
-  root: string
-  namedInputs?: Record<string, Array<JsInputs>>
-  tags?: Array<string>
-  targets: Record<string, Target>
-}
-
-export interface ProjectGraph {
-  nodes: Record<string, Project>
-  dependencies: Record<string, Array<string>>
-  externalNodes: Record<string, ExternalNode>
-}
-
-export declare export declare function remove(src: string): void
-
-export interface RuntimeInput {
-  runtime: string
-}
-
-export interface Target {
-  executor?: string
-  inputs?: Array<JsInputs>
-  outputs?: Array<string>
-  options?: string
-  configurations?: string
-  parallelism?: boolean
-}
-
-export interface Task {
-  id: string
-  target: TaskTarget
-  outputs: Array<string>
-  projectRoot?: string
-}
-
-export interface TaskGraph {
-  roots: Array<string>
-  tasks: Record<string, Task>
-  dependencies: Record<string, Array<string>>
-}
-
-export interface TaskRun {
-  hash: string
-  status: string
-  code: number
-  start: number
-  end: number
-}
-
-export interface TaskTarget {
-  project: string
-  target: string
-  configuration?: string
-}
-
-export declare export declare function testOnlyTransferFileMap(projectFiles: Record<string, Array<FileData>>, nonProjectFiles: Array<FileData>): NxWorkspaceFilesExternals
-
-/**
- * Transfer the project graph from the JS world to the Rust world, so that we can pass the project graph via memory quicker
- * This wont be needed once the project graph is created in Rust
- */
-export declare export declare function transferProjectGraph(projectGraph: ProjectGraph): ExternalObject<ProjectGraph>
-
-export interface UpdatedWorkspaceFiles {
-  fileMap: FileMap
-  externalReferences: NxWorkspaceFilesExternals
-}
-
-export declare export declare function validateOutputs(outputs: Array<string>): void
-
-export interface WatchEvent {
-  path: string
-  type: EventType
-}
-
-/** Public NAPI error codes that are for Node */
-export declare const enum WorkspaceErrors {
-  ParseError = 'ParseError',
-  Generic = 'Generic'
-}
-