@prisma/orm-toolchain 0.16.0

package/dist/spaces-DxFj5y8l.d.mts

@@ -0,0 +1,415 @@
+import { t as MigrationOps } from "./package-CfWiDNrr-ZR4HM_Iz.mjs";
+import { t as ContractSpaceHeadRecord } from "./verify-contract-spaces-Cc1u_wJo-BilPJS2S.mjs";
+import { APP_SPACE_ID as APP_SPACE_ID$1, ContractSpace, ContractSpaceHeadRef, ContractSpaceHeadRef as ContractSpaceHeadRef$1 } from "@prisma/orm-framework/components/control";
+import { PreserveEmptyPredicate, StorageSort } from "@prisma/orm-framework/contract/hashing";
+import { Contract } from "@prisma/orm-framework/contract/types";
+//#region ../../../1-framework/3-tooling/migration/dist/exports/spaces.d.mts
+//#region src/assert-descriptor-self-consistency.d.ts
+/**
+ * Inputs the helper needs to recompute the descriptor's storage hash and
+ * compare it to the published `headRef.hash`. Kept structural so the SQL
+ * family (and any future target family) can compose the check without
+ * coupling to its own descriptor types.
+ */
+interface DescriptorSelfConsistencyInputs {
+  readonly extensionId: string;
+  readonly target: string;
+  readonly targetFamily: string;
+  /**
+   * Family-specific storage object. Typed as `unknown` so callers can
+   * pass their own narrow storage shape (e.g. `SqlStorage`) without an
+   * inline cast — the helper canonicalises through `JSON.stringify`
+   * inside {@link computeStorageHash} and only requires a plain
+   * record-shaped value at runtime.
+   */
+  readonly storage: unknown;
+  readonly headRefHash: string;
+  readonly shouldPreserveEmpty?: PreserveEmptyPredicate;
+  readonly sortStorage?: StorageSort;
+}
+/**
+ * Assert that an extension descriptor is self-consistent: the
+ * `headRef.hash` it publishes must match the canonical hash recomputed
+ * from its `contractSpace.contractJson`.
+ *
+ * Recomputes via {@link computeStorageHash} — the same canonical-JSON
+ * pipeline the descriptor's own emit pipeline produced the hash with —
+ * over `(target, targetFamily, storage)`. Mismatch indicates the
+ * extension author bumped `contractJson` without rerunning emit, leaving
+ * the descriptor's `headRef.hash` stale; the consumer-side helpers
+ * (drift detection, on-disk artefact emission, runner marker writes) all
+ * trust `headRef.hash` as the canonical identity, so a stale value would
+ * silently corrupt every downstream boundary.
+ *
+ * Synchronous, pure, no I/O. Throws
+ * `MIGRATION.DESCRIPTOR_HEAD_HASH_MISMATCH` on failure with both the
+ * recomputed and published hashes in `details` so callers can surface a
+ * clear remediation hint without re-deriving them.
+ */
+declare function assertDescriptorSelfConsistency(inputs: DescriptorSelfConsistencyInputs): void;
+//#endregion
+//#region src/read-contract-space-head-ref.d.ts
+/**
+ * Read the head ref (`hash` + `invariants`) for a contract space from
+ * `<projectMigrationsDir>/<spaceId>/refs/head.json`.
+ *
+ * Returns `null` when the file does not exist (first emit). Surfaces
+ * `MIGRATION.INVALID_JSON` / `MIGRATION.INVALID_REF_FILE` on a corrupt
+ * `refs/head.json` so callers can distinguish "no head ref on disk"
+ * (returns `null`) from "head ref present but unreadable" (throws).
+ *
+ * Validates the space id against `[a-z][a-z0-9_-]{0,63}` for the same
+ * filesystem-safety reasons as the rest of the per-space helpers. The
+ * helper is uniform across the app and extension spaces.
+ */
+declare function readContractSpaceHeadRef(projectMigrationsDir: string, spaceId: string): Promise<ContractSpaceHeadRef$1 | null>;
+//#endregion
+//#region src/compute-extension-space-apply-path.d.ts
+/**
+ * Outcome of {@link computeExtensionSpaceApplyPath} — a discriminated union
+ * mirroring {@link import('./migration-graph').FindPathOutcome} so callers
+ * can map structural / invariant failures to their preferred CLI envelope
+ * without re-running pathfinding.
+ */
+type ExtensionSpaceApplyPathOutcome = {
+  readonly kind: 'ok';
+  readonly contractSpaceHeadRef: ContractSpaceHeadRef$1;
+  /**
+   * Sorted, deduplicated invariant ids covered by the walked path.
+   * Mirrors the on-disk `providedInvariants` summed across edges and
+   * canonicalised — what the runner stamps on the marker after apply.
+   */
+  readonly providedInvariants: readonly string[];
+  /**
+   * Path operations in apply order. Empty when the marker is already
+   * at the recorded head (no-op).
+   */
+  readonly pathOps: MigrationOps;
+  /**
+   * Migration directory names walked, in order. Mirrors `pathOps`'s
+   * structure but at the package granularity — useful for surfacing
+   * "applied N migration(s)" messages.
+   */
+  readonly walkedMigrationDirs: readonly string[];
+} | {
+  readonly kind: 'unreachable';
+  readonly contractSpaceHeadRef: ContractSpaceHeadRef$1;
+} | {
+  readonly kind: 'unsatisfiable';
+  readonly contractSpaceHeadRef: ContractSpaceHeadRef$1;
+  readonly missing: readonly string[];
+  readonly structuralPath: readonly {
+    readonly dirName: string;
+    readonly to: string;
+  }[];
+} | {
+  readonly kind: 'contractSpaceHeadRefMissing';
+};
+/**
+ * Inputs to {@link computeExtensionSpaceApplyPath}. The helper is
+ * deliberately framework-neutral and consumes only on-disk state:
+ *
+ * - `projectMigrationsDir` is the project's top-level `migrations/` dir.
+ * - `spaceId` selects the per-space subdirectory under it.
+ * - `currentMarkerHash` / `currentMarkerInvariants` come from the live
+ *   marker row keyed by `space = <spaceId>`. `null` hash = no marker yet
+ *   (the pathfinder treats this as the empty-contract sentinel per ADR
+ *   208).
+ */
+interface ComputeExtensionSpaceApplyPathInputs {
+  readonly projectMigrationsDir: string;
+  readonly spaceId: string;
+  readonly currentMarkerHash: string | null;
+  readonly currentMarkerInvariants: readonly string[];
+}
+/**
+ * Compute the apply path for an extension contract space — the shortest
+ * sequence of on-disk migration packages that walks the live marker
+ * forward to the on-disk head ref hash, covering every required
+ * invariant.
+ *
+ * Reads only on-disk artifacts (`migrations/<spaceId>/refs/head.json`
+ * and the per-space migration packages). **Does not import any
+ * extension descriptor module** — `db init` / `db update` must remain
+ * runnable without the descriptor source on disk.
+ *
+ * Behaviour:
+ * - Returns `{ kind: 'ok', pathOps: [], … }` when the marker is already
+ *   at the recorded head and no required invariants are missing.
+ * - Returns `{ kind: 'unreachable' }` when the marker hash is not
+ *   structurally connected to the recorded head in the graph.
+ * - Returns `{ kind: 'unsatisfiable', missing, … }` when the marker is
+ *   reachable but no path covers the required invariants.
+ * - Returns `{ kind: 'contractSpaceHeadRefMissing' }` when the per-space
+ *   `refs/head.json` is absent — the precheck verifier should already
+ *   have rejected this case, but the helper is defensive so callers can
+ *   surface a coherent error rather than throw.
+ */
+declare function computeExtensionSpaceApplyPath(inputs: ComputeExtensionSpaceApplyPathInputs): Promise<ExtensionSpaceApplyPathOutcome>;
+//#endregion
+//#region src/concatenate-space-apply-inputs.d.ts
+/**
+ * Per-space input the runner consumes when applying a migration.
+ *
+ * The shape is target-agnostic: callers (today the SQL family; later
+ * any other family) bind `TOp` to their own per-target operation type
+ * (e.g. `SqlMigrationPlanOperation<TTargetDetails>` for the SQL family)
+ * and the helper preserves it through the concatenation.
+ *
+ * - `migrationDirectory` is the on-disk migration directory for the
+ *   space — `<projectRoot>/migrations/<space-id>` (uniform; the app
+ *   subspaces under its own `<APP_SPACE_ID>/` directory).
+ * - `currentMarkerHash` and `currentMarkerInvariants` are the values
+ *   read from the `prisma_contract.marker` row keyed by `space = <space-id>`
+ *   (T1.1). `null` hash = no marker row yet.
+ * - `path` is the per-space operation list resolved from
+ *   `findPathWithDecision(currentMarker, ref.hash, effectiveRequired)`
+ *   per ADR 208, materialised against the on-disk migration packages.
+ *
+ * @see specs/framework-mechanism.spec.md § 4 — Runner.
+ */
+interface SpaceApplyInput<TOp> {
+  readonly spaceId: string;
+  readonly migrationDirectory: string;
+  readonly currentMarkerHash: string | null;
+  readonly currentMarkerInvariants: readonly string[];
+  readonly path: readonly TOp[];
+}
+//#endregion
+//#region src/contract-space-from-json.d.ts
+/**
+ * Materialise a typed {@link ContractSpace} from the JSON artefacts a
+ * contract-space extension package emits to disk.
+ *
+ * Extension descriptors wire `contract.json`, per-migration
+ * `migration.json` / `ops.json`, and `refs/head.json` to the framework's
+ * typed surfaces. TypeScript widens JSON imports to a structural record
+ * that does not preserve readonly modifiers or branded scalars (e.g.
+ * `StorageHashBase<'abc123...'>`), so authoring the descriptor inline
+ * forces every wiring site to cast through `unknown`. This helper
+ * encapsulates the single narrowing point: descriptor sources stay
+ * cast-free, and the (necessary) coercion is colocated with the
+ * documentation explaining why it is safe.
+ *
+ * Safety: the JSON files passed here are produced by the framework's own
+ * emit pipeline (`prisma-next contract emit` and `MigrationCLI.run`)
+ * and re-validated downstream by the runner / verifier. The descriptor
+ * is a pass-through wiring layer — no descriptor consumer treats the
+ * narrowed types as a stronger guarantee than "these came from the
+ * canonical emit pipeline".
+ *
+ * The helper does not introspect or schema-validate the inputs; runtime
+ * validation is the responsibility of `family.deserializeContract`
+ * (codec-aware, invoked at control-stack construction) and the
+ * per-migration `readMigrationPackage` reader used when loading
+ * from disk. JSON-imported packages flow through the descriptor without
+ * a disk read, so the equivalent runtime guarantee comes from the emit
+ * pipeline that produced the JSON in the first place.
+ */
+declare function contractSpaceFromJson<TContract extends Contract = Contract>(inputs: {
+  readonly contractJson: unknown;
+  readonly migrations: ReadonlyArray<{
+    readonly dirName: string;
+    readonly metadata: unknown;
+    readonly ops: unknown;
+  }>;
+  readonly headRef: ContractSpaceHeadRef;
+}): ContractSpace<TContract>;
+//#endregion
+//#region src/emit-contract-space-artifacts.d.ts
+/**
+ * Inputs for {@link emitContractSpaceArtifacts}.
+ *
+ * - `contract` is the canonical contract value the framework just emitted
+ *   for the space; it is serialised through {@link canonicalizeJson}, so
+ *   it must be a JSON-compatible value (objects / arrays / primitives).
+ *   Typed as `unknown` rather than the SQL-family `Contract<SqlStorage>`
+ *   to keep `migration-tools` framework-neutral; SQL-family callers pass
+ *   their typed value through unchanged.
+ *
+ * - `contractDts` is the pre-rendered `.d.ts` text. Rendering happens in
+ *   the SQL family (which owns the codec / typemap input the renderer
+ *   needs), so this helper accepts the text verbatim and writes it out
+ *   without further transformation.
+ *
+ * - `headRef` is the head reference for the space.
+ *   `invariants` are sorted alphabetically before serialisation so two
+ *   callers passing the same set in different orders produce
+ *   byte-identical `refs/head.json`.
+ */
+interface ContractSpaceArtifactInputs {
+  readonly contract: unknown;
+  readonly contractDts: string;
+  readonly headRef: ContractSpaceHeadRef$1;
+}
+/**
+ * Emit the per-space artifacts — the head contract snapshot (written into
+ * the migrations-root-wide `snapshots/` store, keyed by `headRef.hash`) and
+ * `refs/head.json` — under `<projectMigrationsDir>/<spaceId>/`.
+ *
+ * The head contract snapshot is write-if-absent (see
+ * {@link writeContractSnapshot}): a changed extension contract has a new
+ * hash, so it lands as a new store entry; an unchanged hash means identical
+ * canonical content already sits there. `refs/head.json` stays
+ * always-overwrite: the framework owns it, so running `migrate` twice with
+ * the same inputs is a no-op observably (idempotent), but the helper does
+ * not check pre-existing contents — re-emit always wins.
+ *
+ * Path layout matches the convention in
+ * [`spaceMigrationDirectory`](./space-layout.ts). The space id is
+ * validated against `[a-z][a-z0-9_-]{0,63}` via
+ * {@link assertValidSpaceId} for filesystem-safety reasons; the helper
+ * accepts every space uniformly (including the app space, default
+ * `'app'`).
+ *
+ * The migrations directory and space subdirectory are created if they
+ * do not yet exist (`mkdir { recursive: true }`).
+ */
+declare function emitContractSpaceArtifacts(projectMigrationsDir: string, spaceId: string, inputs: ContractSpaceArtifactInputs): Promise<void>;
+//#endregion
+//#region src/gather-disk-contract-space-state.d.ts
+/**
+ * Disk-side inputs to {@link import('./verify-contract-spaces').verifyContractSpaces}
+ * — gathered without touching the live database. The caller composes
+ * this with the marker rows it reads from the runtime to invoke the
+ * verifier.
+ */
+interface DiskContractSpaceState {
+  /** Contract-space directory names observed under `<projectMigrationsDir>/`. */
+  readonly spaceDirsOnDisk: readonly string[];
+  /** Head-ref `(hash, invariants)` per extension space. */
+  readonly headRefsBySpace: ReadonlyMap<string, ContractSpaceHeadRecord>;
+}
+/**
+ * Read the on-disk state the per-space verifier needs:
+ *
+ * - The list of contract-space directories under
+ *   `<projectMigrationsDir>/` (via
+ *   {@link import('./verify-contract-spaces').listContractSpaceDirectories}).
+ * - The on-disk head ref `(hash, invariants)` for each declared extension space
+ *   (via {@link readContractSpaceHeadRef}; missing on-disk artefacts are simply
+ *   omitted — the verifier reports them as `declaredButUnmigrated`).
+ *
+ * Synchronous in spirit but async due to filesystem reads. Reads only
+ * the user's repo. **Does not import any extension descriptor module.**
+ *
+ * Composition convention: pure target-agnostic primitive in
+ * `1-framework`; the SQL family (and any future target family) wires
+ * it into its `dbInit` / `verify` flows alongside its own marker-row
+ * read before invoking `verifyContractSpaces`.
+ */
+declare function gatherDiskContractSpaceState(args: {
+  readonly projectMigrationsDir: string;
+  /**
+   * Set of space ids the project declares: `'app'` plus each entry in
+   * `extensions` whose descriptor exposes a `contractSpace`. The
+   * helper reads on-disk head data only for the extension spaces.
+   */
+  readonly loadedSpaceIds: ReadonlySet<string>;
+}): Promise<DiskContractSpaceState>;
+//#endregion
+//#region src/plan-all-spaces.d.ts
+/**
+ * Per-space input for {@link planAllSpaces}. One entry per loaded
+ * contract space (the application's `'app'` plus each extension that
+ * exposes a `contractSpace`).
+ *
+ * - `priorContract` is `null` for a space that has never been emitted
+ *   (no `migrations/<space-id>/contract.json` on disk yet); otherwise it
+ *   is the canonical contract value emitted for that space.
+ * - `newContract` is the canonical contract value the planner is about
+ *   to emit for that space — for app-space, the just-emitted root
+ *   `contract.json`; for an extension space, the descriptor's
+ *   `contractSpace.contractJson`.
+ */
+interface SpacePlanInput<TContract> {
+  readonly spaceId: string;
+  readonly priorContract: TContract | null;
+  readonly newContract: TContract;
+}
+interface SpacePlanOutput<TPackage> {
+  readonly spaceId: string;
+  readonly migrationPackages: readonly TPackage[];
+}
+/**
+ * Iterate the per-space planner across a set of loaded contract spaces
+ * and return a deterministic shape regardless of declaration order.
+ *
+ * Behaviour:
+ *
+ * - The output is sorted alphabetically by `spaceId`. Two callers
+ *   passing the same set of inputs in different orders observe
+ *   byte-identical outputs.
+ * - The per-space planner (`planSpace`) is called exactly once per
+ *   input, in alphabetical-by-spaceId order. Its return value is
+ *   attached to the corresponding output entry verbatim.
+ * - Duplicate `spaceId`s in the input array throw
+ *   `MIGRATION.DUPLICATE_SPACE_ID` before any `planSpace` call runs,
+ *   keeping the planner pure when the input is malformed.
+ *
+ * The signature is generic over `TContract` and `TPackage` because the
+ * shape is framework-neutral (SQL family today, Mongo family
+ * eventually). Callers wire in whatever contract value and migration
+ * package shape their family already speaks.
+ *
+ * Synchronous: the underlying per-space planner (target's
+ * `MigrationPlanner.plan(...)`) is synchronous; callers that need to
+ * resolve async I/O (e.g. reading on-disk `contract.json` from disk)
+ * resolve it before calling `planAllSpaces` and pass the materialised
+ * inputs through.
+ */
+declare function planAllSpaces<TContract, TPackage>(inputs: readonly SpacePlanInput<TContract>[], planSpace: (input: SpacePlanInput<TContract>) => readonly TPackage[]): readonly SpacePlanOutput<TPackage>[];
+//#endregion
+//#region src/space-layout.d.ts
+/**
+ * Branded string carrying a compile-time guarantee that the value has
+ * been validated by {@link assertValidSpaceId}. Downstream filesystem
+ * helpers (e.g. {@link spaceMigrationDirectory}) accept this type to
+ * make "validated" tracking visible at the type level rather than
+ * relying purely on a runtime check.
+ */
+type ValidSpaceId = string & {
+  readonly __brand: 'ValidSpaceId';
+};
+declare function isValidSpaceId(spaceId: string): spaceId is ValidSpaceId;
+declare function assertValidSpaceId(spaceId: string): asserts spaceId is ValidSpaceId;
+/**
+ * Resolve the migrations subdirectory for a given contract space.
+ *
+ * Every contract space — including the app space (default `'app'`) —
+ * lands under `<projectMigrationsDir>/<spaceId>/`. The space id is
+ * validated against {@link SPACE_ID_PATTERN} because it becomes a
+ * filesystem directory name verbatim.
+ *
+ * `projectMigrationsDir` is the project's top-level `migrations/`
+ * directory; the helper does not assume anything about its absolute /
+ * relative shape and is symmetric with `pathe.join`.
+ */
+declare function spaceMigrationDirectory(projectMigrationsDir: string, spaceId: string): string;
+/**
+ * Per-space subdirectory name reserved for the ref store
+ * (`migrations/<space>/<SPACE_REFS_DIRNAME>/*.json`). Single source of
+ * truth: every helper that composes a per-space refs path imports this
+ * constant, and the enumerator uses it (via
+ * {@link RESERVED_SPACE_SUBDIR_NAMES}) to exclude reserved names from
+ * the contract-space candidate list.
+ */
+declare const SPACE_REFS_DIRNAME = "refs";
+/**
+ * Names reserved under `migrations/` that must never be enumerated as a
+ * phantom contract space: `SPACE_REFS_DIRNAME` (e.g. a top-level
+ * `migrations/refs/` left in the wrong place) and
+ * `CONTRACT_SNAPSHOTS_DIRNAME` (the migrations-root-wide contract
+ * snapshot store, `migrations/snapshots/`).
+ */
+declare const RESERVED_SPACE_SUBDIR_NAMES: ReadonlySet<string>;
+/**
+ * Resolve the per-space refs directory for `spaceMigrationsDir`
+ * (typically the value returned by {@link spaceMigrationDirectory}).
+ * Composes the canonical {@link SPACE_REFS_DIRNAME} so callers do not
+ * hard-code the literal.
+ */
+declare function spaceRefsDirectory(spaceMigrationsDir: string): string;
+//#endregion
+export { spaceMigrationDirectory as C, readContractSpaceHeadRef as S, contractSpaceFromJson as _, DescriptorSelfConsistencyInputs as a, isValidSpaceId as b, RESERVED_SPACE_SUBDIR_NAMES as c, SpacePlanInput as d, SpacePlanOutput as f, computeExtensionSpaceApplyPath as g, assertValidSpaceId as h, ContractSpaceHeadRef$1 as i, SPACE_REFS_DIRNAME as l, assertDescriptorSelfConsistency as m, ComputeExtensionSpaceApplyPathInputs as n, DiskContractSpaceState as o, ValidSpaceId as p, ContractSpaceArtifactInputs as r, ExtensionSpaceApplyPathOutcome as s, APP_SPACE_ID$1 as t, SpaceApplyInput as u, emitContractSpaceArtifacts as v, spaceRefsDirectory as w, planAllSpaces as x, gatherDiskContractSpaceState as y };
+//# sourceMappingURL=spaces-DxFj5y8l.d.mts.map

package/dist/spaces-DxFj5y8l.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spaces-DxFj5y8l.d.mts","names":[],"sources":["../../../../1-framework/3-tooling/migration/dist/exports/spaces.d.mts"],"mappings":";;;;;;;;;;;;;UAYU;WACC;WACA;WACA;;;;;;;;WAQA;WACA;WACA,sBAAsB;WACtB,cAAc;;;;;;;;;;;;;;;;;;;;;iBAqBR,gCAAgC,QAAQ;;;;;;;;;;;;;;;;iBAgBxC,yBAAyB,8BAA8B,kBAAkB,QAAQ;;;;;;;;;KAS7F;WACM;WACA,sBAAsB;;;;;;WAMtB;;;;;WAKA,SAAS;;;;;;WAMT;;WAEA;WACA,sBAAsB;;WAEtB;WACA,sBAAsB;WACtB;WACA;aACE;aACA;;;WAGF;;;;;;;;;;;;;UAaD;WACC;WACA;WACA;WACA;;;;;;;;;;;;;;;;;;;;;;;;;iBAyBM,+BAA+B,QAAQ,uCAAuC,QAAQ;;;;;;;;;;;;;;;;;;;;;;;UAuB7F,gBAAgB;WACf;WACA;WACA;WACA;WACA,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiCT,sBAAsB,kBAAkB,WAAW,UAAU;WACnE;WACA,YAAY;aACV;aACA;aACA;;WAEF,SAAS;IAChB,cAAc;;;;;;;;;;;;;;;;;;;;;;;UAuBR;WACC;WACA;WACA,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;iBAyBH,2BAA2B,8BAA8B,iBAAiB,QAAQ,8BAA8B;;;;;;;;;UASvH;;WAEC;;WAEA,iBAAiB,oBAAoB;;;;;;;;;;;;;;;;;;;;iBAoB/B,6BAA6B;WACnC;;;;;;WAMA,gBAAgB;IACvB,QAAQ;;;;;;;;;;;;;;;;UAgBF,eAAe;WACd;WACA,eAAe;WACf,aAAa;;UAEd,gBAAgB;WACf;WACA,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6BtB,cAAc,WAAW,UAAU,iBAAiB,eAAe,cAAc,YAAY,OAAO,eAAe,wBAAwB,sBAAsB,gBAAgB;;;;;;;;;;KAU7L;WACM;;iBAEM,eAAe,kBAAkB,WAAW;iBAC5C,mBAAmB,0BAA0B,WAAW;;;;;;;;;;;;;iBAaxD,wBAAwB,8BAA8B;;;;;;;;;cASzD;;;;;;;;cAQA,6BAA6B;;;;;;;iBAO1B,mBAAmB"}

package/dist/telemetry-CmbCa3Ld-CmE5zcIG.mjs

@@ -0,0 +1,120 @@
+import { P as formatCommandHelp, Y as isCI$1, ct as setCommandExamples, et as parseGlobalFlags, o as createTerminalUI, r as addGlobalOptions, st as setCommandDescriptions, tt as parseGlobalFlagsOrExit } from "./command-helpers-CAoXqAY9-DWUBcTXM.mjs";
+import { a as resolveGating, d as writeUserConfig, i as readUserConfig, u as userConfigPath } from "./exports-BN0vFTxG.mjs";
+import { Command } from "commander";
+//#region ../../../1-framework/3-tooling/cli/dist/telemetry-CmbCa3Ld.mjs
+/**
+* Resolves the same gate the runtime uses (CI check + `resolveGating`) and
+* projects it into a user-facing status. Pure read: never mints, never
+* writes. The `installationId` value itself is never surfaced — only its
+* presence — so `status` discloses nothing identifying.
+*/
+function resolveTelemetryStatus(inputs) {
+	const config = readUserConfig();
+	const configPath = userConfigPath();
+	const installationIdStored = typeof config.installationId === "string" && config.installationId.length > 0;
+	if (inputs.inCI) return {
+		enabled: false,
+		reason: "ci",
+		configPath,
+		installationIdStored
+	};
+	const gating = resolveGating({
+		env: inputs.env,
+		config
+	});
+	if (!gating.enabled) return {
+		enabled: false,
+		reason: gating.reason === "env-override" ? "env-opt-out" : "stored-opt-out",
+		configPath,
+		installationIdStored
+	};
+	return {
+		enabled: true,
+		reason: config.enableTelemetry === true ? "stored-opt-in" : "default-on",
+		configPath,
+		installationIdStored
+	};
+}
+const REASON_EXPLANATION = {
+	ci: "CI environment detected — telemetry is hard-disabled.",
+	"env-opt-out": "an environment opt-out is set (DO_NOT_TRACK / PRISMA_NEXT_DISABLE_TELEMETRY).",
+	"stored-opt-out": "\"enableTelemetry\": false is stored in your config.",
+	"stored-opt-in": "\"enableTelemetry\": true is stored in your config.",
+	"default-on": "no explicit choice is stored, so the opt-out default applies."
+};
+function formatTelemetryStatusLines(status) {
+	return [
+		`Telemetry is ${status.enabled ? "enabled" : "disabled"}: ${REASON_EXPLANATION[status.reason]}`,
+		`Config file: ${status.configPath}`,
+		`Installation ID: ${status.installationIdStored ? "stored" : "not stored"}`
+	];
+}
+function createTelemetryStatusCommand() {
+	const command = new Command("status");
+	setCommandDescriptions(command, "Show whether anonymous CLI telemetry is enabled and why", "Reports whether telemetry is currently enabled or disabled and the reason\n(default-on, stored opt-out, environment opt-out, or CI), the path to your\nuser-level config file, and whether an installation ID has been stored.\nRead-only: never sends an event, never mints an ID, never writes anything.");
+	return addGlobalOptions(command).action((options) => {
+		const flags = parseGlobalFlagsOrExit(options);
+		const ui = createTerminalUI(flags);
+		const status = resolveTelemetryStatus({
+			env: process.env,
+			inCI: isCI$1()
+		});
+		if (flags.json) ui.output(JSON.stringify(status));
+		else for (const line of formatTelemetryStatusLines(status)) ui.output(line);
+		process.exit(0);
+	});
+}
+function createTelemetryEnableCommand() {
+	const command = new Command("enable");
+	setCommandDescriptions(command, "Enable anonymous CLI telemetry", "Stores \"enableTelemetry\": true in your user-level config and mints an\ninstallation ID if one is not already stored.");
+	return addGlobalOptions(command).action((options) => {
+		const flags = parseGlobalFlagsOrExit(options);
+		writeUserConfig({ enableTelemetry: true });
+		const ui = createTerminalUI(flags);
+		if (flags.json) ui.output(JSON.stringify({
+			enableTelemetry: true,
+			configPath: userConfigPath()
+		}));
+		else ui.output(`Telemetry enabled. Preference stored in ${userConfigPath()}.`);
+		process.exit(0);
+	});
+}
+function createTelemetryDisableCommand() {
+	const command = new Command("disable");
+	setCommandDescriptions(command, "Disable anonymous CLI telemetry", "Stores \"enableTelemetry\": false in your user-level config. No installation\nID is minted and no event is sent.");
+	return addGlobalOptions(command).action((options) => {
+		const flags = parseGlobalFlagsOrExit(options);
+		writeUserConfig({ enableTelemetry: false });
+		const ui = createTerminalUI(flags);
+		if (flags.json) ui.output(JSON.stringify({
+			enableTelemetry: false,
+			configPath: userConfigPath()
+		}));
+		else ui.output(`Telemetry disabled. Preference stored in ${userConfigPath()}.`);
+		process.exit(0);
+	});
+}
+function createTelemetryCommand() {
+	const command = new Command("telemetry");
+	setCommandDescriptions(command, "Inspect and change anonymous CLI telemetry", "Show telemetry status, or enable / disable anonymous CLI usage data.\nTelemetry is on by default (opt-out); see https://prisma-next.dev/docs/cli/telemetry\nfor what is collected and why.");
+	setCommandExamples(command, [
+		"prisma-next telemetry status",
+		"prisma-next telemetry disable",
+		"prisma-next telemetry enable"
+	]);
+	command.configureHelp({
+		formatHelp: (cmd) => formatCommandHelp({
+			command: cmd,
+			flags: parseGlobalFlags({})
+		}),
+		subcommandDescription: () => ""
+	});
+	command.addCommand(createTelemetryStatusCommand());
+	command.addCommand(createTelemetryEnableCommand());
+	command.addCommand(createTelemetryDisableCommand());
+	return command;
+}
+//#endregion
+export { createTelemetryCommand as t };
+
+//# sourceMappingURL=telemetry-CmbCa3Ld-CmE5zcIG.mjs.map

package/dist/telemetry-CmbCa3Ld-CmE5zcIG.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"telemetry-CmbCa3Ld-CmE5zcIG.mjs","names":["isCI"],"sources":["../../../../1-framework/3-tooling/cli/dist/telemetry-CmbCa3Ld.mjs"],"sourcesContent":["import { D as isCI, O as formatCommandHelp, _ as createTerminalUI, g as parseGlobalFlagsOrExit, h as parseGlobalFlags, l as setCommandDescriptions, t as addGlobalOptions, u as setCommandExamples } from \"./command-helpers-CAoXqAY9.mjs\";\nimport { Command } from \"commander\";\nimport { readUserConfig, resolveGating, userConfigPath, writeUserConfig } from \"@internal/cli-telemetry\";\n//#region src/commands/telemetry/status.ts\n/**\n* Resolves the same gate the runtime uses (CI check + `resolveGating`) and\n* projects it into a user-facing status. Pure read: never mints, never\n* writes. The `installationId` value itself is never surfaced — only its\n* presence — so `status` discloses nothing identifying.\n*/\nfunction resolveTelemetryStatus(inputs) {\n\tconst config = readUserConfig();\n\tconst configPath = userConfigPath();\n\tconst installationIdStored = typeof config.installationId === \"string\" && config.installationId.length > 0;\n\tif (inputs.inCI) return {\n\t\tenabled: false,\n\t\treason: \"ci\",\n\t\tconfigPath,\n\t\tinstallationIdStored\n\t};\n\tconst gating = resolveGating({\n\t\tenv: inputs.env,\n\t\tconfig\n\t});\n\tif (!gating.enabled) return {\n\t\tenabled: false,\n\t\treason: gating.reason === \"env-override\" ? \"env-opt-out\" : \"stored-opt-out\",\n\t\tconfigPath,\n\t\tinstallationIdStored\n\t};\n\treturn {\n\t\tenabled: true,\n\t\treason: config.enableTelemetry === true ? \"stored-opt-in\" : \"default-on\",\n\t\tconfigPath,\n\t\tinstallationIdStored\n\t};\n}\nconst REASON_EXPLANATION = {\n\tci: \"CI environment detected — telemetry is hard-disabled.\",\n\t\"env-opt-out\": \"an environment opt-out is set (DO_NOT_TRACK / PRISMA_NEXT_DISABLE_TELEMETRY).\",\n\t\"stored-opt-out\": \"\\\"enableTelemetry\\\": false is stored in your config.\",\n\t\"stored-opt-in\": \"\\\"enableTelemetry\\\": true is stored in your config.\",\n\t\"default-on\": \"no explicit choice is stored, so the opt-out default applies.\"\n};\nfunction formatTelemetryStatusLines(status) {\n\treturn [\n\t\t`Telemetry is ${status.enabled ? \"enabled\" : \"disabled\"}: ${REASON_EXPLANATION[status.reason]}`,\n\t\t`Config file: ${status.configPath}`,\n\t\t`Installation ID: ${status.installationIdStored ? \"stored\" : \"not stored\"}`\n\t];\n}\n//#endregion\n//#region src/commands/telemetry/index.ts\nfunction createTelemetryStatusCommand() {\n\tconst command = new Command(\"status\");\n\tsetCommandDescriptions(command, \"Show whether anonymous CLI telemetry is enabled and why\", \"Reports whether telemetry is currently enabled or disabled and the reason\\n(default-on, stored opt-out, environment opt-out, or CI), the path to your\\nuser-level config file, and whether an installation ID has been stored.\\nRead-only: never sends an event, never mints an ID, never writes anything.\");\n\treturn addGlobalOptions(command).action((options) => {\n\t\tconst flags = parseGlobalFlagsOrExit(options);\n\t\tconst ui = createTerminalUI(flags);\n\t\tconst status = resolveTelemetryStatus({\n\t\t\tenv: process.env,\n\t\t\tinCI: isCI()\n\t\t});\n\t\tif (flags.json) ui.output(JSON.stringify(status));\n\t\telse for (const line of formatTelemetryStatusLines(status)) ui.output(line);\n\t\tprocess.exit(0);\n\t});\n}\nfunction createTelemetryEnableCommand() {\n\tconst command = new Command(\"enable\");\n\tsetCommandDescriptions(command, \"Enable anonymous CLI telemetry\", \"Stores \\\"enableTelemetry\\\": true in your user-level config and mints an\\ninstallation ID if one is not already stored.\");\n\treturn addGlobalOptions(command).action((options) => {\n\t\tconst flags = parseGlobalFlagsOrExit(options);\n\t\twriteUserConfig({ enableTelemetry: true });\n\t\tconst ui = createTerminalUI(flags);\n\t\tif (flags.json) ui.output(JSON.stringify({\n\t\t\tenableTelemetry: true,\n\t\t\tconfigPath: userConfigPath()\n\t\t}));\n\t\telse ui.output(`Telemetry enabled. Preference stored in ${userConfigPath()}.`);\n\t\tprocess.exit(0);\n\t});\n}\nfunction createTelemetryDisableCommand() {\n\tconst command = new Command(\"disable\");\n\tsetCommandDescriptions(command, \"Disable anonymous CLI telemetry\", \"Stores \\\"enableTelemetry\\\": false in your user-level config. No installation\\nID is minted and no event is sent.\");\n\treturn addGlobalOptions(command).action((options) => {\n\t\tconst flags = parseGlobalFlagsOrExit(options);\n\t\twriteUserConfig({ enableTelemetry: false });\n\t\tconst ui = createTerminalUI(flags);\n\t\tif (flags.json) ui.output(JSON.stringify({\n\t\t\tenableTelemetry: false,\n\t\t\tconfigPath: userConfigPath()\n\t\t}));\n\t\telse ui.output(`Telemetry disabled. Preference stored in ${userConfigPath()}.`);\n\t\tprocess.exit(0);\n\t});\n}\nfunction createTelemetryCommand() {\n\tconst command = new Command(\"telemetry\");\n\tsetCommandDescriptions(command, \"Inspect and change anonymous CLI telemetry\", \"Show telemetry status, or enable / disable anonymous CLI usage data.\\nTelemetry is on by default (opt-out); see https://prisma-next.dev/docs/cli/telemetry\\nfor what is collected and why.\");\n\tsetCommandExamples(command, [\n\t\t\"prisma-next telemetry status\",\n\t\t\"prisma-next telemetry disable\",\n\t\t\"prisma-next telemetry enable\"\n\t]);\n\tcommand.configureHelp({\n\t\tformatHelp: (cmd) => formatCommandHelp({\n\t\t\tcommand: cmd,\n\t\t\tflags: parseGlobalFlags({})\n\t\t}),\n\t\tsubcommandDescription: () => \"\"\n\t});\n\tcommand.addCommand(createTelemetryStatusCommand());\n\tcommand.addCommand(createTelemetryEnableCommand());\n\tcommand.addCommand(createTelemetryDisableCommand());\n\treturn command;\n}\n//#endregion\nexport { createTelemetryCommand as t };\n\n//# sourceMappingURL=telemetry-CmbCa3Ld.mjs.map"],"mappings":"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"}