nx 23.3.0-beta.7 → 23.3.0-beta.8

package/dist/src/tasks-runner/run-command.js

@@ -25,10 +25,9 @@ const is_ci_1 = require("../utils/is-ci");
 const nx_cloud_utils_1 = require("../utils/nx-cloud-utils");
 const update_manager_1 = require("../nx-cloud/update-manager");
 const logger_1 = require("../utils/logger");
-const outputs_1 = require("../io-snapshots/outputs");
-const overrides_1 = require("../io-snapshots/overrides");
-const report_1 = require("../io-snapshots/report");
-const store_1 = require("../io-snapshots/store");
+const overrides_1 = require("../ultracache/overrides");
+const report_1 = require("../ultracache/report");
+const store_1 = require("../ultracache/store");
 const nx_key_1 = require("../utils/nx-key");
 const output_1 = require("../utils/output");
 const configure_ai_agents_disclaimer_1 = require("../ai/configure-ai-agents-disclaimer");
@@ -89,7 +88,7 @@ async function getTerminalOutputLifeCycle(initiatingProject, initiatingTasks, pr
         process.env.NX_TUI = 'false';
     }
     // Kick off in the background so the URL is ready by the exit report. A brief
-    // sync preamble (git remote + axios load) runs here; the network call does not.
+    // sync preamble (git remote lookup) runs here; the network call does not.
     (0, performance_report_1.prefetchRemoteCacheOnboardingUrl)(nxJson);
     if ((0, is_tui_enabled_1.isTuiEnabled)()) {
         const interceptedNxCloudLogs = [];
@@ -415,7 +414,7 @@ async function runTasksForCommand(taskSelection, currentProjectGraph, { nxJson }
             initiatingProject,
             initiatingTasks,
             planningContext: taskSelection.planningContext,
-            ioSnapshotOutcome: taskSelection.ioSnapshotOutcome,
+            ultracacheConfigurationOutcome: taskSelection.ultracacheConfigurationOutcome,
         });
         await renderIsDone.finally(() => restoreTerminal?.());
         if (printSummary) {
@@ -706,26 +705,22 @@ function setEnvVarsBasedOnArgs(nxArgs, loadDotEnvFiles) {
         process.env.NX_LOAD_DOT_ENV_FILES = 'true';
     }
 }
-async function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nxJson, nxArgs, loadDotEnvFiles, initiatingProject, initiatingTasks, planningContext, ioSnapshotOutcome: loadedIoSnapshotOutcome, }) {
+async function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nxJson, nxArgs, loadDotEnvFiles, initiatingProject, initiatingTasks, planningContext, ultracacheConfigurationOutcome: loadedUltracacheConfigurationOutcome, }) {
     setEnvVarsBasedOnArgs(nxArgs, loadDotEnvFiles);
     // this needs to be done before we start to run the tasks
     const taskDetails = (0, hash_task_1.getTaskDetails)();
     const { tasksRunner, runnerOptions } = getRunner(nxArgs, nxJson);
-    // Must precede hashing: the set is the snapshot source for task hashes,
-    // and observed outputs join the task outputs the hasher and cache see.
-    const ioSnapshotOutcome = loadedIoSnapshotOutcome !== undefined
-        ? loadedIoSnapshotOutcome
-        : await (0, store_1.loadIoSnapshotsForRun)(nxJson, runnerOptions);
-    const ioSnapshots = (0, store_1.snapshotsOf)(ioSnapshotOutcome);
-    if (ioSnapshots) {
-        (0, outputs_1.applyIoSnapshotOutputs)(projectGraph, taskGraph, ioSnapshots);
-    }
-    let hasher = (0, create_task_hasher_1.createTaskHasher)(projectGraph, nxJson, runnerOptions, ioSnapshots, planningContext);
+    // Must precede hashing: the Ultracache configurations are a source for task hashes.
+    const ultracacheConfigurationOutcome = loadedUltracacheConfigurationOutcome !== undefined
+        ? loadedUltracacheConfigurationOutcome
+        : await (0, store_1.loadUltracacheConfigurationsForRun)(nxJson, runnerOptions);
+    const ultracacheConfigurations = (0, store_1.configurationsOf)(ultracacheConfigurationOutcome);
+    let hasher = (0, create_task_hasher_1.createTaskHasher)(projectGraph, nxJson, runnerOptions, ultracacheConfigurations, planningContext);
     // this is used for two reasons: to fetch all remote cache hits AND
     // to submit everything that is known in advance to Nx Cloud to run in
     // a distributed fashion
-    await (0, hash_task_1.hashTasksThatDoNotDependOnOutputsOfOtherTasks)(hasher, projectGraph, taskGraph, nxJson, taskDetails, ioSnapshots);
-    reportIoSnapshots(ioSnapshotOutcome, projectGraph, taskGraph, nxArgs);
+    await (0, hash_task_1.hashTasksThatDoNotDependOnOutputsOfOtherTasks)(hasher, projectGraph, taskGraph, nxJson, taskDetails, ultracacheConfigurations);
+    reportUltracacheConfigurations(ultracacheConfigurationOutcome, projectGraph, taskGraph, nxArgs);
     const taskResultsLifecycle = new task_results_life_cycle_1.TaskResultsLifeCycle();
     const compositedLifeCycle = new life_cycle_1.CompositeLifeCycle([
         ...constructLifeCycles(lifeCycle, taskGraph, nxJson, nxArgs.skipNxCache),
@@ -872,22 +867,22 @@ function loadTasksRunner(modulePath) {
         throw e;
     }
 }
-function reportIoSnapshots(outcome, projectGraph, taskGraph, nxArgs) {
+function reportUltracacheConfigurations(outcome, projectGraph, taskGraph, nxArgs) {
     if (!outcome || outcome.status === 'skipped')
         return;
     if (!nxArgs.verbose && process.env.NX_VERBOSE_LOGGING !== 'true')
         return;
-    const summary = (0, report_1.formatIoSnapshotSummary)((0, overrides_1.buildIoSnapshotOverrides)(projectGraph, taskGraph, outcome.snapshots), outcome.status);
+    const summary = (0, report_1.formatUltracacheSummary)((0, overrides_1.buildUltracacheOverrides)(projectGraph, taskGraph, outcome.configurations), outcome.status);
     output_1.output.note({ title: summary.line, bodyLines: summary.bodyLines });
 }
 /**
  * What affected task selection reads from the runner options, so it plans as
- * the run hashes. The snapshot set is loaded once, for selection and the run.
+ * the run hashes. The Ultracache configurations are loaded once, for selection and the run.
  */
 async function runnerInputsForSelection(nxArgs, nxJson) {
     const { runnerOptions } = getRunner(nxArgs, nxJson);
     return {
-        ioSnapshotOutcome: await (0, store_1.loadIoSnapshotsForRun)(nxJson, runnerOptions),
+        ultracacheConfigurationOutcome: await (0, store_1.loadUltracacheConfigurationsForRun)(nxJson, runnerOptions),
         selectivelyHashTsConfig: runnerOptions?.selectivelyHashTsConfig ?? false,
     };
 }

package/dist/src/ultracache/config.d.ts

@@ -0,0 +1,21 @@
+import type { NxJsonConfiguration } from '../config/nx-json';
+export interface UltracacheCloudOptions {
+    accessToken?: string;
+    nxCloudId?: string;
+    url?: string;
+    cloud?: boolean;
+}
+export interface UltracacheEnv {
+    NX_CLOUD_USE_ULTRACACHE?: string;
+    NX_NO_CLOUD?: string;
+    /** Whether the run's env holds an Nx Cloud token. */
+    hasNxCloudToken?: boolean;
+}
+/**
+ * Off unless a CI run opts in with `NX_CLOUD_USE_ULTRACACHE=true` in a
+ * workspace that uses Nx Cloud, since there is nothing to fetch from otherwise.
+ * `env` defaults to this process's.
+ */
+export declare function isUltracacheConfigurationFetchEnabled(nxJson: NxJsonConfiguration, runnerOptions?: UltracacheCloudOptions, env?: UltracacheEnv): boolean;
+/** The subset of this run's environment the decision reads. */
+export declare function ultracacheEnv(env?: NodeJS.ProcessEnv): UltracacheEnv;

package/dist/src/ultracache/config.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isUltracacheConfigurationFetchEnabled = isUltracacheConfigurationFetchEnabled;
+exports.ultracacheEnv = ultracacheEnv;
+const is_ci_1 = require("../utils/is-ci");
+const nx_cloud_utils_1 = require("../utils/nx-cloud-utils");
+/**
+ * Off unless a CI run opts in with `NX_CLOUD_USE_ULTRACACHE=true` in a
+ * workspace that uses Nx Cloud, since there is nothing to fetch from otherwise.
+ * `env` defaults to this process's.
+ */
+function isUltracacheConfigurationFetchEnabled(nxJson, runnerOptions = {}, env = ultracacheEnv()) {
+    if (env.NX_NO_CLOUD === 'true' ||
+        nxJson.neverConnectToCloud ||
+        runnerOptions.cloud === false ||
+        env.NX_CLOUD_USE_ULTRACACHE !== 'true' ||
+        !(0, is_ci_1.isCI)()) {
+        return false;
+    }
+    return !!env.hasNxCloudToken || (0, nx_cloud_utils_1.isNxCloudConfigured)(nxJson);
+}
+/** The subset of this run's environment the decision reads. */
+function ultracacheEnv(env = process.env) {
+    return {
+        NX_CLOUD_USE_ULTRACACHE: env.NX_CLOUD_USE_ULTRACACHE,
+        NX_NO_CLOUD: env.NX_NO_CLOUD,
+        hasNxCloudToken: !!(env.NX_CLOUD_ACCESS_TOKEN || env.NX_CLOUD_AUTH_TOKEN),
+    };
+}

package/dist/src/ultracache/fetch.d.ts

@@ -0,0 +1,21 @@
+import type { UltracacheCloudOptions } from './config';
+/** The Nx Cloud client's `readUltracacheConfigurations` contract, as far as nx uses it. */
+export interface ReadUltracacheConfigurationsOptions {
+    workspaceRoot?: string;
+    nxCloudOptions?: UltracacheCloudOptions;
+    timeoutMs?: number;
+}
+export interface ReadUltracacheConfiguration {
+    commit: string;
+    inputs: readonly string[];
+    outputs: readonly string[];
+}
+export interface ReadUltracacheConfigurationsResult {
+    configurations: Readonly<Record<string, ReadUltracacheConfiguration>>;
+}
+/**
+ * Reads HEAD's Ultracache configurations from Nx Cloud. Throws with a `code`
+ * saying why it could not: the client's own, or `NO_CLOUD_CLIENT`, `UNSUPPORTED_CLIENT` or
+ * `NO_CONFIGURATIONS`.
+ */
+export declare function fetchUltracacheConfigurations(runnerOptions: UltracacheCloudOptions): Promise<ReadUltracacheConfigurationsResult>;

package/dist/src/{io-snapshots → ultracache}/fetch.js

@@ -1,26 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetchIoSnapshots = fetchIoSnapshots;
+exports.fetchUltracacheConfigurations = fetchUltracacheConfigurations;
 const resolution_helpers_1 = require("../nx-cloud/resolution-helpers");
 const update_manager_1 = require("../nx-cloud/update-manager");
 const workspace_root_1 = require("../utils/workspace-root");
 const READ_TIMEOUT_MS = 10_000;
 /**
- * Reads HEAD's snapshot set from Nx Cloud. Throws with a `code` saying why it
- * could not: the client's own, or `NO_CLOUD_CLIENT`, `UNSUPPORTED_CLIENT` or
- * `NO_SNAPSHOTS`.
+ * Reads HEAD's Ultracache configurations from Nx Cloud. Throws with a `code`
+ * saying why it could not: the client's own, or `NO_CLOUD_CLIENT`, `UNSUPPORTED_CLIENT` or
+ * `NO_CONFIGURATIONS`.
  */
-async function fetchIoSnapshots(runnerOptions) {
+async function fetchUltracacheConfigurations(runnerOptions) {
     const client = await loadCloudClient(runnerOptions).catch((e) => {
         throw codedError('NO_CLOUD_CLIENT', e instanceof Error ? e.message : String(e));
     });
     if (!client) {
         throw codedError('NO_CLOUD_CLIENT', 'The Nx Cloud client could not be loaded');
     }
-    if (typeof client.readIoSnapshots !== 'function') {
-        throw codedError('UNSUPPORTED_CLIENT', 'The installed Nx Cloud client does not expose I/O snapshots; update nx-cloud');
+    if (typeof client.readUltracacheConfigurations !== 'function') {
+        throw codedError('UNSUPPORTED_CLIENT', 'The installed Nx Cloud client does not expose Ultracache configurations; update nx-cloud');
     }
-    const result = await client.readIoSnapshots({
+    const result = await client.readUltracacheConfigurations({
         workspaceRoot: workspace_root_1.workspaceRoot,
         nxCloudOptions: runnerOptions,
         timeoutMs: READ_TIMEOUT_MS,
@@ -28,7 +28,7 @@ async function fetchIoSnapshots(runnerOptions) {
     if (!result) {
         // The client returns `null` only for a `knownUpdatedAt` match, which nx
         // never sends; treat it as nothing to serve rather than a broken reply.
-        throw codedError('NO_SNAPSHOTS', 'Nx Cloud returned no I/O snapshot set');
+        throw codedError('NO_CONFIGURATIONS', 'Nx Cloud returned no Ultracache configurations');
     }
     return result;
 }

package/dist/src/ultracache/overrides.d.ts

@@ -0,0 +1,17 @@
+import type { ProjectGraph } from '../config/project-graph';
+import type { TaskGraph } from '../config/task-graph';
+import { type UltracacheEligibilityOptions, type UltracacheReport, type UltracacheConfigurations, type TaskUltracacheSettings } from '../native';
+/**
+ * Each task's Ultracache settings: all the native eligibility walk reads
+ * from a task. `null`, not `undefined`: the native map drops `undefined` keys.
+ */
+export declare function getUltracacheSettings(taskGraph: TaskGraph): Record<string, TaskUltracacheSettings | null>;
+/** The eligibility walk's view of the run's tasks, as JS resolves it. */
+export declare function ultracacheEligibilityOptions(projectGraph: ProjectGraph, taskGraph: TaskGraph): UltracacheEligibilityOptions;
+/**
+ * Reports which tasks in `taskGraph` hash from `configurations` and why the rest
+ * do not, with the same eligibility walk the planner uses, without building a
+ * planner (no project-graph transfer). Never fetches, never throws. Feeds
+ * the `--verbose` run summary.
+ */
+export declare function buildUltracacheOverrides(projectGraph: ProjectGraph, taskGraph: TaskGraph, configurations: UltracacheConfigurations): UltracacheReport;

package/dist/src/{io-snapshots → ultracache}/overrides.js

@@ -1,16 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getUltraCacheConfig = getUltraCacheConfig;
-exports.ioSnapshotEligibilityOptions = ioSnapshotEligibilityOptions;
-exports.buildIoSnapshotOverrides = buildIoSnapshotOverrides;
+exports.getUltracacheSettings = getUltracacheSettings;
+exports.ultracacheEligibilityOptions = ultracacheEligibilityOptions;
+exports.buildUltracacheOverrides = buildUltracacheOverrides;
 const native_1 = require("../native");
 const project_graph_1 = require("../project-graph/project-graph");
 const utils_1 = require("../tasks-runner/utils");
 const customHasherMemo = new WeakMap();
 /**
- * Tasks whose executor ships a custom hasher; they are never hashed from a
- * snapshot. Detected here because executors are resolved in JS, by the
- * factory's presence only — invoking it would load user modules.
+ * Tasks whose executor ships a custom hasher; they are never hashed from
+ * their Ultracache configuration. Detected here because executors are
+ * resolved in JS, by the factory's presence only — invoking it would load
+ * user modules.
  */
 function customHasherTaskIds(projectGraph, taskGraph) {
     const memoized = customHasherMemo.get(taskGraph);
@@ -25,7 +26,7 @@ function customHasherTaskIds(projectGraph, taskGraph) {
         }
         catch {
             // An unresolvable executor fails later, at execution; it is not a
-            // reason to withhold a snapshot here.
+            // reason to withhold its configuration here.
             return false;
         }
     })
@@ -34,27 +35,27 @@ function customHasherTaskIds(projectGraph, taskGraph) {
     return ids;
 }
 /**
- * Each task's ultracache configuration: all the native eligibility walk reads
+ * Each task's Ultracache settings: all the native eligibility walk reads
  * from a task. `null`, not `undefined`: the native map drops `undefined` keys.
  */
-function getUltraCacheConfig(taskGraph) {
+function getUltracacheSettings(taskGraph) {
     return Object.fromEntries(Object.entries(taskGraph.tasks).map(([id, task]) => [
         id,
         task.ultracache ?? null,
     ]));
 }
 /** The eligibility walk's view of the run's tasks, as JS resolves it. */
-function ioSnapshotEligibilityOptions(projectGraph, taskGraph) {
+function ultracacheEligibilityOptions(projectGraph, taskGraph) {
     return {
         customHasherTaskIds: customHasherTaskIds(projectGraph, taskGraph),
     };
 }
 /**
- * Reports which tasks in `taskGraph` hash from `snapshots` and why the rest
+ * Reports which tasks in `taskGraph` hash from `configurations` and why the rest
  * do not, with the same eligibility walk the planner uses, without building a
  * planner (no project-graph transfer). Never fetches, never throws. Feeds
  * the `--verbose` run summary.
  */
-function buildIoSnapshotOverrides(projectGraph, taskGraph, snapshots) {
-    return (0, native_1.getIoSnapshotReport)(snapshots, getUltraCacheConfig(taskGraph), ioSnapshotEligibilityOptions(projectGraph, taskGraph));
+function buildUltracacheOverrides(projectGraph, taskGraph, configurations) {
+    return (0, native_1.getUltracacheReport)(configurations, getUltracacheSettings(taskGraph), ultracacheEligibilityOptions(projectGraph, taskGraph));
 }

package/dist/src/ultracache/report.d.ts

@@ -0,0 +1,13 @@
+import type { UltracacheReport } from '../native';
+export interface UltracacheSummary {
+    /** The heading, e.g. "Ultracache: 12 tasks hashed from their configuration, 3 fell back". */
+    line: string;
+    /** Per-reason detail under it. */
+    bodyLines: string[];
+}
+/**
+ * Formats the once-per-run verbose summary of a run that resolved Ultracache
+ * configurations: `result` is what hashing used, `status` whether they were
+ * fetched or already stored.
+ */
+export declare function formatUltracacheSummary(result: UltracacheReport, status: 'fetched' | 'cached'): UltracacheSummary;

package/dist/src/{io-snapshots → ultracache}/report.js

@@ -1,26 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatIoSnapshotSummary = formatIoSnapshotSummary;
+exports.formatUltracacheSummary = formatUltracacheSummary;
 /**
- * Formats the once-per-run verbose summary of a run that resolved a set:
- * `result` is what hashing used, `status` whether the set was fetched or
- * already stored.
+ * Formats the once-per-run verbose summary of a run that resolved Ultracache
+ * configurations: `result` is what hashing used, `status` whether they were
+ * fetched or already stored.
  */
-function formatIoSnapshotSummary(result, status) {
+function formatUltracacheSummary(result, status) {
     const used = result.used.length;
-    // `unusable-output` is raised on used tasks, possibly several per task:
-    // count withheld tasks, not diagnostics.
-    const usedTasks = new Set(result.used);
-    const withheld = result.diagnostics.filter((d) => d.taskId != null && !usedTasks.has(d.taskId));
+    const withheld = result.diagnostics.filter((d) => d.taskId != null);
     const byReason = countByReason(withheld);
-    const fellBack = new Set(withheld.map((d) => d.taskId)).size;
+    const fellBack = withheld.length;
     const setLevel = result.diagnostics.find((d) => d.taskId == null);
-    const withOutputs = result.tasksWithOutputs?.length ?? 0;
     const line = setLevel
-        ? `I/O snapshots: none used (unreadable set: ${setLevel.message})`
-        : `I/O snapshots: ${plural(used, 'task')} hashed from snapshot${withOutputs ? ` (${withOutputs} with observed outputs)` : ''}, ${plural(fellBack, 'task')} fell back${fellBack ? ` (${summarizeReasons(byReason)})` : ''}`;
-    const bodyLines = [`set: ${status}`];
-    bodyLines.push(`commit ${result.resolution.requestedCommit}, ${result.resolution.tasks} tasks in set`);
+        ? `Ultracache: none used (unreadable configurations: ${setLevel.message})`
+        : `Ultracache: ${plural(used, 'task')} hashed from their configuration, ${plural(fellBack, 'task')} fell back${fellBack ? ` (${summarizeReasons(byReason)})` : ''}`;
+    const bodyLines = [`configurations: ${status}`];
+    bodyLines.push(`commit ${result.resolution.requestedCommit}, configurations for ${result.resolution.tasks} tasks`);
     for (const d of result.diagnostics) {
         bodyLines.push(describeDiagnostic(d));
     }
@@ -29,7 +25,7 @@ function formatIoSnapshotSummary(result, status) {
 function describeDiagnostic(d) {
     switch (d.reason) {
         case 'unreadable-set':
-            return `unreadable snapshot set: ${d.message}`;
+            return `unreadable Ultracache configurations: ${d.message}`;
         case 'disabled':
             return `${d.taskId}: ultracache.mode is off`;
         case 'autofix-disabled':
@@ -37,13 +33,11 @@ function describeDiagnostic(d) {
         case 'custom-hasher':
             return `${d.taskId}: uses a custom hasher`;
         case 'missing':
-            return `${d.taskId}: no snapshot for this task`;
+            return `${d.taskId}: no Ultracache configuration for this task`;
         case 'invalid-glob':
-            return `${d.taskId}: snapshot glob "${d.glob}" is not a valid files glob`;
+            return `${d.taskId}: configuration glob "${d.glob}" is not a valid files glob`;
         case 'escapes-workspace':
-            return `${d.taskId}: snapshot glob "${d.glob}" escapes the workspace`;
-        case 'unusable-output':
-            return `${d.taskId}: observed write "${d.glob}" is not usable as an output, so it is not cached`;
+            return `${d.taskId}: configuration glob "${d.glob}" escapes the workspace`;
         default:
             return `${d.taskId ? `${d.taskId}: ` : ''}${d.reason}`;
     }

package/dist/src/ultracache/store.d.ts

@@ -0,0 +1,40 @@
+import type { NxJsonConfiguration } from '../config/nx-json';
+import { UltracacheConfigurationStore, type UltracacheConfigurations } from '../native';
+import { type UltracacheCloudOptions, type UltracacheEnv } from './config';
+import { type ReadUltracacheConfigurationsResult } from './fetch';
+/**
+ * What resolving this run's Ultracache configurations came to. Only an
+ * outcome that resolved carries them.
+ */
+export type UltracacheConfigurationOutcome = {
+    status: 'fetched' | 'cached';
+    configurations: UltracacheConfigurations;
+} | {
+    status: 'skipped';
+    reason: string;
+    message: string;
+};
+export declare function skippedUltracacheOutcome(reason: string, message: string): UltracacheConfigurationOutcome;
+/** The configurations an outcome resolved to, if any. */
+export declare function configurationsOf(outcome: UltracacheConfigurationOutcome | null): UltracacheConfigurations | undefined;
+/** The Ultracache configuration store in this process's workspace database. */
+export declare function getUltracacheConfigurationStore(): UltracacheConfigurationStore;
+/**
+ * Stores the configurations the Nx Cloud client read for `requestedCommit` and
+ * returns their handle, for `runDiscreteTasks` and `runContinuousTasks`. Exposed to the
+ * client through `nx/nx-cloud-internals`. Throws with the store's `code`.
+ */
+export declare function importUltracacheConfigurations(requestedCommit: string, configurations: ReadUltracacheConfigurationsResult['configurations']): UltracacheConfigurations;
+/**
+ * The stored version `importUltracacheConfigurations` returned, reopened by its commit and
+ * `resolution.fetchedAt`, so other processes hash from it without importing
+ * it again. `null` when it isn't stored. Exposed through `nx/nx-cloud-internals`.
+ */
+export declare function openUltracacheConfigurations(commit: string, fetchedAt: number): UltracacheConfigurations | null;
+/**
+ * This run's Ultracache configurations for HEAD, in the process that owns the
+ * fetch: the stored ones while they are fresh, otherwise what Nx Cloud reads,
+ * imported into the store. Returns `null` when Ultracache is not enabled for
+ * this workspace; never throws.
+ */
+export declare function loadUltracacheConfigurationsForRun(nxJson: NxJsonConfiguration, runnerOptions: UltracacheCloudOptions, env?: UltracacheEnv): Promise<UltracacheConfigurationOutcome | null>;

package/dist/src/{io-snapshots → ultracache}/store.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.skippedIoSnapshots = skippedIoSnapshots;
-exports.snapshotsOf = snapshotsOf;
-exports.getIoSnapshotStore = getIoSnapshotStore;
-exports.importIoSnapshots = importIoSnapshots;
-exports.openIoSnapshots = openIoSnapshots;
-exports.loadIoSnapshotsForRun = loadIoSnapshotsForRun;
+exports.skippedUltracacheOutcome = skippedUltracacheOutcome;
+exports.configurationsOf = configurationsOf;
+exports.getUltracacheConfigurationStore = getUltracacheConfigurationStore;
+exports.importUltracacheConfigurations = importUltracacheConfigurations;
+exports.openUltracacheConfigurations = openUltracacheConfigurations;
+exports.loadUltracacheConfigurationsForRun = loadUltracacheConfigurationsForRun;
 const path_1 = require("path");
 const native_1 = require("../native");
 const db_connection_1 = require("../utils/db-connection");
@@ -15,13 +15,13 @@ const output_1 = require("../utils/output");
 const workspace_root_1 = require("../utils/workspace-root");
 const config_1 = require("./config");
 const fetch_1 = require("./fetch");
-function skippedIoSnapshots(reason, message) {
+function skippedUltracacheOutcome(reason, message) {
     return { status: 'skipped', reason, message };
 }
-/** The set an outcome resolved to, if any. */
-function snapshotsOf(outcome) {
+/** The configurations an outcome resolved to, if any. */
+function configurationsOf(outcome) {
     return outcome && outcome.status !== 'skipped'
-        ? outcome.snapshots
+        ? outcome.configurations
         : undefined;
 }
 /**
@@ -30,72 +30,72 @@ function snapshotsOf(outcome) {
  */
 const STORED_SET_MAX_AGE_MS = 60 * 60 * 1000;
 // Reasons that indicate misconfiguration rather than an expected offline
-// state or a client that simply predates snapshots.
+// state or a client that simply predates Ultracache.
 const WARNED_REASONS = new Set([
     'unauthorized',
     'invalid-response',
     'write-failed',
 ]);
-/** The snapshot store in this process's workspace database. */
-function getIoSnapshotStore() {
-    return new native_1.IoSnapshotStore((0, db_connection_1.getDbConnection)());
+/** The Ultracache configuration store in this process's workspace database. */
+function getUltracacheConfigurationStore() {
+    return new native_1.UltracacheConfigurationStore((0, db_connection_1.getDbConnection)());
 }
 /**
- * Stores a set the Nx Cloud client read for `requestedCommit` and returns its
- * handle, for `runDiscreteTasks` and `runContinuousTasks`. Exposed to the
+ * Stores the configurations the Nx Cloud client read for `requestedCommit` and
+ * returns their handle, for `runDiscreteTasks` and `runContinuousTasks`. Exposed to the
  * client through `nx/nx-cloud-internals`. Throws with the store's `code`.
  */
-function importIoSnapshots(requestedCommit, snapshots) {
-    return getIoSnapshotStore().import({
+function importUltracacheConfigurations(requestedCommit, configurations) {
+    return getUltracacheConfigurationStore().import({
         requestedCommit,
-        snapshotsJson: JSON.stringify(snapshots),
+        configurationsJson: JSON.stringify(configurations),
     });
 }
 /**
- * The stored version `importIoSnapshots` returned, reopened by its commit and
+ * The stored version `importUltracacheConfigurations` returned, reopened by its commit and
  * `resolution.fetchedAt`, so other processes hash from it without importing
  * it again. `null` when it isn't stored. Exposed through `nx/nx-cloud-internals`.
  */
-function openIoSnapshots(commit, fetchedAt) {
-    return getIoSnapshotStore().getVersion(commit, fetchedAt);
+function openUltracacheConfigurations(commit, fetchedAt) {
+    return getUltracacheConfigurationStore().getVersion(commit, fetchedAt);
 }
 /**
- * This run's I/O snapshot set for HEAD, in the process that owns the fetch:
- * the stored set while it is fresh, otherwise what Nx Cloud reads, imported
- * into the store. Returns `null` when snapshots are not enabled for this
- * workspace; never throws.
+ * This run's Ultracache configurations for HEAD, in the process that owns the
+ * fetch: the stored ones while they are fresh, otherwise what Nx Cloud reads,
+ * imported into the store. Returns `null` when Ultracache is not enabled for
+ * this workspace; never throws.
  */
-async function loadIoSnapshotsForRun(nxJson, runnerOptions, env = (0, config_1.ioSnapshotEnv)()) {
-    if (!(0, config_1.isIoSnapshotFetchEnabled)(nxJson, runnerOptions, env)) {
+async function loadUltracacheConfigurationsForRun(nxJson, runnerOptions, env = (0, config_1.ultracacheEnv)()) {
+    if (!(0, config_1.isUltracacheConfigurationFetchEnabled)(nxJson, runnerOptions, env)) {
         return null;
     }
     const head = (0, git_utils_1.getLatestCommitSha)();
     if (!head) {
-        return reportIoSnapshotResolution(skippedIoSnapshots('not-a-git-repo', 'Could not resolve HEAD'));
+        return reportUltracacheConfigurationResolution(skippedUltracacheOutcome('not-a-git-repo', 'Could not resolve HEAD'));
     }
     try {
-        const store = getIoSnapshotStore();
+        const store = getUltracacheConfigurationStore();
         const cached = () => {
             const stored = store.get(head, STORED_SET_MAX_AGE_MS);
             return (stored &&
-                reportIoSnapshotResolution({
+                reportUltracacheConfigurationResolution({
                     status: 'cached',
-                    snapshots: stored,
+                    configurations: stored,
                 }));
         };
         return (cached() ??
             // Processes that miss together fetch once: the rest find its set.
-            (await withIoSnapshotFetchLock(async () => {
+            (await withUltracacheConfigurationFetchLock(async () => {
                 const stored = cached();
                 if (stored) {
                     return stored;
                 }
-                const result = await (0, fetch_1.fetchIoSnapshots)(runnerOptions);
-                return reportIoSnapshotResolution({
+                const result = await (0, fetch_1.fetchUltracacheConfigurations)(runnerOptions);
+                return reportUltracacheConfigurationResolution({
                     status: 'fetched',
-                    snapshots: store.import({
+                    configurations: store.import({
                         requestedCommit: head,
-                        snapshotsJson: JSON.stringify(result.snapshots),
+                        configurationsJson: JSON.stringify(result.configurations),
                     }),
                 });
             })));
@@ -103,15 +103,15 @@ async function loadIoSnapshotsForRun(nxJson, runnerOptions, env = (0, config_1.i
     catch (e) {
         // No fallback to an older set for this commit: it would hash from a
         // recording the run could not refresh, and CI can hash natively instead.
-        return reportIoSnapshotResolution(skippedIoSnapshots(reasonFromError(e), errorMessage(e)));
+        return reportUltracacheConfigurationResolution(skippedUltracacheOutcome(reasonFromError(e), errorMessage(e)));
     }
 }
 /** Runs `fetch` holding a lock beside the workspace database, across processes. */
-async function withIoSnapshotFetchLock(fetch) {
+async function withUltracacheConfigurationFetchLock(fetch) {
     if (native_1.IS_WASM) {
         return fetch();
     }
-    const lock = new native_1.FileLock((0, path_1.join)((0, db_connection_1.sharedWorkspaceDataDirectory)(workspace_root_1.workspaceRoot), 'io-snapshots.lock'));
+    const lock = new native_1.FileLock((0, path_1.join)((0, db_connection_1.sharedWorkspaceDataDirectory)(workspace_root_1.workspaceRoot), 'ultracache-configuration.lock'));
     while (!lock.tryLock()) {
         await lock.wait();
     }
@@ -143,20 +143,20 @@ function errorMessage(e) {
     return e instanceof Error ? e.message : String(e);
 }
 /** Warns or logs what a resolution came to. */
-function reportIoSnapshotResolution(outcome) {
+function reportUltracacheConfigurationResolution(outcome) {
     if (outcome.status === 'skipped') {
         if (WARNED_REASONS.has(outcome.reason)) {
             output_1.output.warn({
-                title: `Nx Cloud I/O snapshots are unavailable (${outcome.reason})`,
+                title: `Nx Cloud Ultracache configurations are unavailable (${outcome.reason})`,
                 bodyLines: [outcome.message, 'Tasks will be hashed without them.'],
             });
         }
         else {
-            logger_1.logger.verbose(`Skipping Nx Cloud I/O snapshots (${outcome.reason}): ${outcome.message}`);
+            logger_1.logger.verbose(`Skipping Nx Cloud Ultracache configurations (${outcome.reason}): ${outcome.message}`);
         }
         return outcome;
     }
-    const { resolution } = outcome.snapshots;
-    logger_1.logger.verbose(`Nx Cloud I/O snapshots ${outcome.status}: ${resolution.tasks} tasks for ${resolution.requestedCommit.slice(0, 12)}`);
+    const { resolution } = outcome.configurations;
+    logger_1.logger.verbose(`Nx Cloud Ultracache configurations ${outcome.status}: ${resolution.tasks} tasks for ${resolution.requestedCommit.slice(0, 12)}`);
     return outcome;
 }

package/dist/src/utils/ab-testing.js

@@ -9,6 +9,7 @@ const is_ci_1 = require("./is-ci");
 const package_manager_1 = require("./package-manager");
 const get_cloud_options_1 = require("../nx-cloud/utilities/get-cloud-options");
 const terminal_link_1 = require("./terminal-link");
+const http_client_1 = require("./http-client");
 exports.NX_CLOUD_URL = 'https://nx.dev/nx-cloud';
 exports.NX_CLOUD_DEMO_URL = 'https://cloud.nx.app/demo/intro';
 /**
@@ -102,19 +103,17 @@ async function recordStat(opts) {
         if (!shouldRecordStats()) {
             return;
         }
-        const axios = require('axios');
-        await (axios['default'] ?? axios)
-            .create({
-            baseURL: (0, get_cloud_options_1.getCloudUrl)(),
+        await (0, http_client_1.httpRequest)(`${(0, get_cloud_options_1.getCloudUrl)()}/nx-cloud/stats`, {
+            method: 'POST',
             timeout: 400,
-        })
-            .post('/nx-cloud/stats', {
-            command: opts.command,
-            isCI: (0, is_ci_1.isCI)(),
-            useCloud: opts.useCloud,
-            meta: opts.meta
-                ? JSON.stringify({ ...opts.meta, nxVersion: opts.nxVersion })
-                : opts.nxVersion,
+            data: {
+                command: opts.command,
+                isCI: (0, is_ci_1.isCI)(),
+                useCloud: opts.useCloud,
+                meta: opts.meta
+                    ? JSON.stringify({ ...opts.meta, nxVersion: opts.nxVersion })
+                    : opts.nxVersion,
+            },
         });
     }
     catch (e) {