@prisma-next/cli 0.11.0-dev.6 → 0.11.0-dev.61

package/src/utils/integrity-violation-to-check-failure.ts

@@ -0,0 +1,130 @@
+import type { IntegrityViolation } from '@prisma-next/migration-tools/aggregate';
+import { join, relative } from 'pathe';
+
+export interface CheckFailure {
+  readonly pnCode: string;
+  readonly where: string;
+  readonly why: string;
+  readonly fix: string;
+}
+
+function migrationPathRelative(dirPath: string): string {
+  return relative(process.cwd(), dirPath);
+}
+
+function migrationFileRelative(dirPath: string, fileName: string): string {
+  return join(migrationPathRelative(dirPath), fileName);
+}
+
+/**
+ * Map one {@link IntegrityViolation} onto a `migration check` failure row.
+ * Sole catalogue mapping from integrity violations to `PN-MIG-CHECK-*`.
+ */
+export function integrityViolationToCheckFailure(
+  violation: IntegrityViolation,
+  migrationsDir: string,
+): CheckFailure {
+  const spaceRelative = (spaceId: string): string =>
+    migrationPathRelative(join(migrationsDir, spaceId));
+  const packageRelative = (spaceId: string, dirName: string): string =>
+    migrationPathRelative(join(migrationsDir, spaceId, dirName));
+  const refRelative = (spaceId: string, refName: string): string =>
+    migrationPathRelative(join(migrationsDir, spaceId, 'refs', `${refName}.json`));
+
+  switch (violation.kind) {
+    case 'hashMismatch':
+      return {
+        pnCode: 'PN-MIG-CHECK-001',
+        where: migrationFileRelative(
+          join(migrationsDir, violation.spaceId, violation.dirName),
+          'migration.json',
+        ),
+        why: `Stored hash ${violation.stored} does not match recomputed hash ${violation.computed}`,
+        fix: 'Re-emit the migration package or restore from version control.',
+      };
+    case 'providedInvariantsMismatch':
+      return {
+        pnCode: 'PN-MIG-CHECK-002',
+        where: packageRelative(violation.spaceId, violation.dirName),
+        why: `Migration "${violation.dirName}" providedInvariants in migration.json disagrees with ops.json.`,
+        fix: 'Re-emit the migration package so migration.json and ops.json agree.',
+      };
+    case 'packageUnloadable':
+      return {
+        pnCode: 'PN-MIG-CHECK-002',
+        where: packageRelative(violation.spaceId, violation.dirName),
+        why: `Migration "${violation.dirName}" could not be loaded: ${violation.detail}`,
+        fix: 'Re-emit the migration package or restore from version control.',
+      };
+    case 'sameSourceAndTarget':
+      return {
+        pnCode: 'PN-MIG-CHECK-007',
+        where: packageRelative(violation.spaceId, violation.dirName),
+        why: `Migration "${violation.dirName}" in space "${violation.spaceId}" has source equal to target (${violation.hash}) with no data invariant — a true no-op self-edge.`,
+        fix: 'Add a data operation if this self-edge was meant to carry a data invariant, or delete the migration if it is a true no-op.',
+      };
+    case 'orphanSpaceDir':
+      return {
+        pnCode: 'PN-MIG-CHECK-008',
+        where: spaceRelative(violation.spaceId),
+        why: `Contract-space directory "${violation.spaceId}" exists on disk but no extension declares it.`,
+        fix: 'Remove the orphan directory, or declare the extension in `extensionPacks`.',
+      };
+    case 'declaredButUnmigrated':
+      return {
+        pnCode: 'PN-MIG-CHECK-009',
+        where: spaceRelative(violation.spaceId),
+        why: `Extension "${violation.spaceId}" is declared in \`extensionPacks\` but has no on-disk migrations directory.`,
+        fix: 'Re-emit the extension contract-space artefacts with `prisma-next contract emit` and migration planning, or remove the extension from `extensionPacks` if it is unused.',
+      };
+    case 'headRefMissing':
+      return {
+        pnCode: 'PN-MIG-CHECK-010',
+        where: refRelative(violation.spaceId, 'head'),
+        why: `Head ref \`refs/head.json\` is missing for contract space "${violation.spaceId}".`,
+        fix: 'Re-emit the contract-space migrations and head ref artefacts, or restore `refs/head.json` from version control.',
+      };
+    case 'headRefNotInGraph':
+      return {
+        pnCode: 'PN-MIG-CHECK-011',
+        where: refRelative(violation.spaceId, 'head'),
+        why: `Head ref ${violation.hash} for contract space "${violation.spaceId}" is not present in its migration graph.`,
+        fix: 'Re-emit the contract space migrations, or restore the missing migration package.',
+      };
+    case 'refUnreadable':
+      return {
+        pnCode: 'PN-MIG-CHECK-012',
+        where: refRelative(violation.spaceId, violation.refName),
+        why: `Ref "${violation.refName}" for contract space "${violation.spaceId}" is unreadable: ${violation.detail}`,
+        fix: 'Repair or remove the corrupt ref file.',
+      };
+    case 'targetMismatch':
+      return {
+        pnCode: 'PN-MIG-CHECK-013',
+        where: spaceRelative(violation.spaceId),
+        why: `Contract space "${violation.spaceId}" targets "${violation.actual}" but the project targets "${violation.expected}".`,
+        fix: 'Update the extension to target the configured database, or change the project target.',
+      };
+    case 'disjointness':
+      return {
+        pnCode: 'PN-MIG-CHECK-014',
+        where: migrationPathRelative(migrationsDir),
+        why: `Storage element "${violation.element}" is claimed by multiple contract spaces: ${violation.claimedBy.join(', ')}.`,
+        fix: 'Update the contracts so each storage element is owned by exactly one contract space.',
+      };
+    case 'contractUnreadable':
+      return {
+        pnCode: 'PN-MIG-CHECK-015',
+        where: migrationFileRelative(join(migrationsDir, violation.spaceId), 'contract.json'),
+        why: `Contract for space "${violation.spaceId}" is unreadable: ${violation.detail}`,
+        fix: 'Re-emit the extension contract artefacts, or fix the descriptor producing the invalid contract.',
+      };
+    case 'duplicateMigrationHash':
+      return {
+        pnCode: 'PN-MIG-CHECK-016',
+        where: spaceRelative(violation.spaceId),
+        why: `Multiple migrations in space "${violation.spaceId}" share migrationHash "${violation.migrationHash}" (${violation.dirNames.join(', ')}).`,
+        fix: 'Re-emit one of the conflicting packages so each migrationHash is unique.',
+      };
+  }
+}

package/src/utils/plan-resolution.ts

@@ -0,0 +1,258 @@
+import type { Contract } from '@prisma-next/contract/types';
+import type { ContractSpaceMember } from '@prisma-next/migration-tools/aggregate';
+import { MigrationToolsError } from '@prisma-next/migration-tools/errors';
+import type { MigrationGraph } from '@prisma-next/migration-tools/graph';
+import {
+  assertHashIsGraphNode,
+  findLatestMigration,
+  isGraphNode,
+} from '@prisma-next/migration-tools/migration-graph';
+import type { ContractRef } from '@prisma-next/migration-tools/ref-resolution';
+import { parseContractRef } from '@prisma-next/migration-tools/ref-resolution';
+import type { Refs } from '@prisma-next/migration-tools/refs';
+import { notOk, ok, type Result } from '@prisma-next/utils/result';
+import {
+  CliStructuredError,
+  errorPlanForgotTheFlag,
+  errorSnapshotMissing,
+  mapRefResolutionError,
+} from './cli-errors';
+import { mapContractAtError } from './contract-at-errors';
+
+const FULL_HASH_PATTERN = /^sha256:([0-9a-f]{64}|empty)$/;
+
+export function looksLikeFullHash(input: string): boolean {
+  return FULL_HASH_PATTERN.test(input);
+}
+
+export type FromResolution =
+  | { kind: 'greenfield'; fromHash: null; fromContract: null }
+  | { kind: 'graph-node'; fromHash: string; fromContract: Contract; sourceDir: string }
+  | {
+      kind: 'snapshot';
+      fromHash: string;
+      fromContract: Contract;
+      contractDts: string;
+      contractJson: unknown;
+    }
+  | {
+      kind: 'auto-baseline';
+      fromHash: string;
+      fromContract: Contract;
+      contractDts: string;
+      contractJson: unknown;
+    };
+
+export interface ResolveFromForPlanInput {
+  readonly optionsFrom?: string | undefined;
+  readonly member: ContractSpaceMember;
+}
+
+function graphIsEmpty(member: ContractSpaceMember): boolean {
+  return member.packages.length === 0;
+}
+
+function getReachableRefs(
+  refs: Refs,
+  graph: MigrationGraph,
+): ReadonlyArray<{ name: string; hash: string }> {
+  return Object.entries(refs)
+    .flatMap(([name, entry]) =>
+      entry && isGraphNode(entry.hash, graph) ? [{ name, hash: entry.hash }] : [],
+    )
+    .sort((a, b) => a.name.localeCompare(b.name));
+}
+
+export function assertFromIsGraphNode(
+  fromHash: string,
+  graph: MigrationGraph,
+  refs: Refs,
+  graphTipHash: string | null,
+): void {
+  try {
+    assertHashIsGraphNode(fromHash, graph);
+  } catch (error) {
+    if (MigrationToolsError.is(error) && error.code === 'MIGRATION.HASH_NOT_IN_GRAPH') {
+      throw errorPlanForgotTheFlag(fromHash, getReachableRefs(refs, graph), graphTipHash);
+    }
+    throw error;
+  }
+}
+
+type RefContractResolution =
+  | {
+      kind: 'snapshot';
+      hash: string;
+      contract: Contract;
+      contractJson: unknown;
+      contractDts: string;
+    }
+  | {
+      kind: 'graph-node';
+      hash: string;
+      contract: Contract;
+      contractJson: unknown;
+      contractDts: string;
+      sourceDir: string;
+    };
+
+async function resolveContractRef(
+  parsed: ContractRef,
+  member: ContractSpaceMember,
+  options?: { readonly explicitLabel?: string; readonly artifactRole?: 'from' | 'to' },
+): Promise<Result<RefContractResolution, CliStructuredError>> {
+  const { hash, provenance } = parsed;
+  const refName = provenance.kind === 'ref' ? provenance.refName : undefined;
+
+  try {
+    const at = await member.contractAt(hash, refName !== undefined ? { refName } : undefined);
+
+    if (at.provenance === 'snapshot') {
+      return ok({
+        kind: 'snapshot',
+        hash: at.hash,
+        contract: at.contract,
+        contractJson: at.contractJson,
+        contractDts: at.contractDts,
+      });
+    }
+
+    return ok({
+      kind: 'graph-node',
+      hash: at.hash,
+      contract: at.contract,
+      contractJson: at.contractJson,
+      contractDts: at.contractDts,
+      sourceDir: at.sourceDir,
+    });
+  } catch (error) {
+    return mapContractAtError(
+      error,
+      options?.artifactRole !== undefined ? { artifactRole: options.artifactRole } : undefined,
+    );
+  }
+}
+
+async function resolveFromPolicy(
+  parsed: ContractRef,
+  input: ResolveFromForPlanInput,
+  refs: Refs,
+  explicitFromLabel?: string,
+): Promise<Result<FromResolution, CliStructuredError>> {
+  const resolution = await resolveContractRef(parsed, input.member, {
+    ...(explicitFromLabel !== undefined ? { explicitLabel: explicitFromLabel } : {}),
+    artifactRole: 'from',
+  });
+  if (!resolution.ok) {
+    return resolution;
+  }
+
+  if (resolution.value.kind === 'graph-node') {
+    return ok({
+      kind: 'graph-node',
+      fromHash: resolution.value.hash,
+      fromContract: resolution.value.contract,
+      sourceDir: resolution.value.sourceDir,
+    });
+  }
+
+  const { hash, contract, contractJson, contractDts } = resolution.value;
+  if (graphIsEmpty(input.member)) {
+    return ok({
+      kind: 'auto-baseline',
+      fromHash: hash,
+      fromContract: contract,
+      contractDts,
+      contractJson,
+    });
+  }
+
+  const graph = input.member.graph();
+  const graphTip = findLatestMigration(graph)?.to ?? null;
+  try {
+    assertFromIsGraphNode(hash, graph, refs, graphTip);
+  } catch (error) {
+    if (CliStructuredError.is(error)) {
+      return notOk(error);
+    }
+    throw error;
+  }
+  return ok({
+    kind: 'snapshot',
+    fromHash: hash,
+    fromContract: contract,
+    contractDts,
+    contractJson,
+  });
+}
+
+export async function resolveFromForPlan(
+  input: ResolveFromForPlanInput,
+): Promise<Result<FromResolution, CliStructuredError>> {
+  const { optionsFrom, member } = input;
+  const graph = member.graph();
+  const refs = member.refs;
+
+  if (optionsFrom === undefined) {
+    const dbRef = refs['db'];
+    if (!dbRef) {
+      return ok({ kind: 'greenfield', fromHash: null, fromContract: null });
+    }
+    return resolveFromPolicy(
+      { hash: dbRef.hash, provenance: { kind: 'ref', refName: 'db' } },
+      input,
+      refs,
+    );
+  }
+
+  const refResult = parseContractRef(optionsFrom, { graph, refs });
+  if (!refResult.ok) {
+    if (looksLikeFullHash(optionsFrom)) {
+      const empty = graphIsEmpty(member);
+      const graphTip = findLatestMigration(graph)?.to ?? null;
+      if (empty) {
+        return notOk(errorSnapshotMissing(optionsFrom, { viaRef: false }));
+      }
+      return notOk(errorPlanForgotTheFlag(optionsFrom, getReachableRefs(refs, graph), graphTip));
+    }
+    return notOk(mapRefResolutionError(refResult.failure));
+  }
+
+  return resolveFromPolicy(refResult.value, input, refs, optionsFrom);
+}
+
+export interface ResolveToForPlanInput {
+  readonly member: ContractSpaceMember;
+}
+
+export interface ResolvedContractRef {
+  readonly hash: string;
+  readonly contract: Contract;
+  readonly contractJson: unknown;
+  readonly contractDts: string;
+}
+
+export async function resolveToForPlan(
+  optionsTo: string,
+  input: ResolveToForPlanInput,
+): Promise<Result<ResolvedContractRef, CliStructuredError>> {
+  const { member } = input;
+  const graph = member.graph();
+  const refs = member.refs;
+
+  const refResult = parseContractRef(optionsTo, { graph, refs });
+  if (!refResult.ok) {
+    return notOk(mapRefResolutionError(refResult.failure));
+  }
+
+  const resolution = await resolveContractRef(refResult.value, member, {
+    explicitLabel: optionsTo,
+    artifactRole: 'to',
+  });
+  if (!resolution.ok) {
+    return resolution;
+  }
+
+  const { hash, contract, contractJson, contractDts } = resolution.value;
+  return ok({ hash, contract, contractJson, contractDts });
+}

package/src/utils/ref-advancement.ts

@@ -0,0 +1,68 @@
+import { readFile } from 'node:fs/promises';
+import type { ContractIR } from '@prisma-next/migration-tools/refs';
+import { writeRefPaired } from '@prisma-next/migration-tools/refs';
+import { ifDefined } from '@prisma-next/utils/defined';
+
+export interface RefAdvancementFields {
+  readonly advancedRef: { readonly name: string; readonly hash: string } | null;
+  readonly plannedAdvanceRef: { readonly name: string; readonly hash: string } | null;
+}
+
+export function computeRefAdvancementName(options: {
+  readonly advanceRef?: string;
+  readonly db?: string;
+}): string | null {
+  if (options.advanceRef !== undefined) {
+    return options.advanceRef;
+  }
+  if (options.db === undefined) {
+    return 'db';
+  }
+  return null;
+}
+
+export async function readContractIR(
+  contractJson: Record<string, unknown>,
+  contractJsonPath: string,
+): Promise<ContractIR> {
+  const contractDtsPath = contractJsonPath.replace(/\.json$/i, '.d.ts');
+  const contractDts = await readFile(contractDtsPath, 'utf-8');
+  return { contract: contractJson, contractDts };
+}
+
+export async function executeRefAdvancement(
+  refsDir: string,
+  name: string,
+  hash: string,
+  contractIR: ContractIR,
+): Promise<{ name: string; hash: string }> {
+  await writeRefPaired(refsDir, name, { hash, invariants: [] }, contractIR);
+  return { name, hash };
+}
+
+export async function buildRefAdvancementFields(options: {
+  readonly advanceRef?: string;
+  readonly db?: string;
+  readonly refsDir: string;
+  readonly contractIR: ContractIR;
+  readonly mode: 'plan' | 'apply';
+  readonly hash: string;
+}): Promise<RefAdvancementFields> {
+  const name = computeRefAdvancementName({
+    ...ifDefined('advanceRef', options.advanceRef),
+    ...ifDefined('db', options.db),
+  });
+  if (name === null) {
+    return { advancedRef: null, plannedAdvanceRef: null };
+  }
+  if (options.mode === 'plan') {
+    return { advancedRef: null, plannedAdvanceRef: { name, hash: options.hash } };
+  }
+  const advancedRef = await executeRefAdvancement(
+    options.refsDir,
+    name,
+    options.hash,
+    options.contractIR,
+  );
+  return { advancedRef, plannedAdvanceRef: null };
+}

package/src/utils/terminal-ui.ts

@@ -1,8 +1,11 @@
 import * as clack from '@clack/prompts';
 import { bold, cyan, dim, green, red, yellow } from 'colorette';
 import type { GlobalFlags } from './global-flags';
+import { detectGlyphMode, type GlyphMode, type GlyphModeInput } from './glyph-mode';
 import { shutdownSignal } from './shutdown';
 
+export interface TerminalUIRuntime extends GlyphModeInput {}
+
 /**
  * Composable CLI output abstraction.
  *
@@ -36,17 +39,50 @@ export class TerminalUI {
    */
   readonly forcePretty: boolean;
 
+  /**
+   * Whether stdout is a TTY — used for migration-list graph glyph detection.
+   */
+  readonly stdoutIsTTY: boolean;
+
+  /**
+   * Process environment snapshot for locale-aware glyph detection.
+   */
+  readonly env: Readonly<Record<string, string | undefined>>;
+
   private static readonly stderrOpts = { output: process.stderr } as const;
 
   constructor(options?: {
     readonly color?: boolean | undefined;
     readonly interactive?: boolean | undefined;
     readonly forcePretty?: boolean | undefined;
+    readonly stdoutIsTTY?: boolean | undefined;
+    readonly env?: Readonly<Record<string, string | undefined>> | undefined;
   }) {
     // --interactive/--no-interactive override TTY detection
     this.isInteractive = options?.interactive ?? !!process.stdout.isTTY;
     this.forcePretty = options?.forcePretty ?? false;
     this.useColor = options?.color ?? (this.isInteractive || this.forcePretty);
+    this.stdoutIsTTY = options?.stdoutIsTTY ?? !!process.stdout.isTTY;
+    this.env = options?.env ?? process.env;
+  }
+
+  get isTTY(): boolean {
+    return this.stdoutIsTTY;
+  }
+
+  /**
+   * Resolve graph glyph mode for `migration list --graph`. `--ascii` forces
+   * ASCII; otherwise delegates to the pure {@link detectGlyphMode} helper.
+   */
+  resolveGlyphMode(forceAscii: boolean): GlyphMode {
+    if (forceAscii) {
+      return 'ascii';
+    }
+    return detectGlyphMode(this.glyphModeInput());
+  }
+
+  glyphModeInput(): GlyphModeInput {
+    return { isTTY: this.stdoutIsTTY, env: this.env };
   }
 
   private get shouldDecorate(): boolean {
@@ -288,10 +324,15 @@ export class TerminalUI {
   }
 }
 
-export function createTerminalUI(flags: GlobalFlags): TerminalUI {
+export function createTerminalUI(
+  flags: GlobalFlags,
+  runtime?: Partial<TerminalUIRuntime>,
+): TerminalUI {
   return new TerminalUI({
     color: flags.color,
     interactive: flags.interactive,
     forcePretty: flags.format === 'pretty' && flags.explicitFormat,
+    stdoutIsTTY: runtime?.isTTY,
+    env: runtime?.env,
   });
 }

package/dist/cli-errors-Czmx92Zy.d.mts

@@ -1,3 +0,0 @@
-import { CliStructuredError as CliStructuredError$1 } from "@prisma-next/errors/control";
-import { MigrationToolsError } from "@prisma-next/migration-tools/errors";
-export { CliStructuredError$1 as t };

package/dist/cli-errors-Djtz98Vm.mjs

@@ -1,71 +0,0 @@
-import { CliStructuredError as CliStructuredError$1, errorConfigValidation as errorConfigValidation$1, errorContractConfigMissing as errorContractConfigMissing$1, errorContractValidationFailed, errorDatabaseConnectionRequired, errorDriverRequired, errorFileNotFound, errorInvalidOutputFormat, errorMigrationPlanningFailed, errorOutputFormatMutex, errorTargetMigrationNotSupported, errorUnexpected as errorUnexpected$1 } from "@prisma-next/errors/control";
-import { ERROR_CODE_DESTRUCTIVE_CHANGES, errorDestructiveChanges, errorHashMismatch, errorMarkerMissing, errorRunnerFailed, errorRuntime, errorRuntime as errorRuntime$1, errorTargetMismatch } from "@prisma-next/errors/execution";
-import "@prisma-next/errors/migration";
-//#region src/utils/cli-errors.ts
-/**
-* Maps a `MigrationToolsError` raised by the migration-tools loader/graph
-* surface (`readMigrationPackage`, `readMigrationsDir`, `readRefs`,
-* `resolveRef`, `reconstructGraph`, ...) into a CLI `errorRuntime` envelope.
-*
-* The full `error.details` payload is forwarded into `meta` so machine
-* consumers (`--json`) see structural fields like `dir`, `storedHash`,
-* `computedHash` (for `MIGRATION.HASH_MISMATCH`) alongside the stable
-* `code`. The user-visible `summary`/`why`/`fix` text is unchanged.
-*
-* Callers are expected to gate on `MigrationToolsError.is(error)` first
-* (mirroring the original inline pattern); non-`MigrationToolsError`
-* values are caller-classified (rethrow, wrap with command-specific
-* `errorUnexpected`, etc.).
-*/
-function mapMigrationToolsError(error) {
-	return errorRuntime(error.message, {
-		why: error.why,
-		fix: error.fix,
-		meta: {
-			code: error.code,
-			...error.details ?? {}
-		}
-	});
-}
-/**
-* Maps a `RefResolutionError` from the contract/migration reference
-* resolver into a CLI structured error envelope.
-*/
-function mapRefResolutionError(error) {
-	switch (error.kind) {
-		case "not-found": return errorRuntime(`Not a known ${error.grammar} reference: "${error.input}"`, {
-			why: `No ${error.grammar} matching "${error.input}" exists in the migration graph or refs index.`,
-			fix: error.grammar === "contract" ? "Provide a valid contract hash, ref name, or migration directory name." : "Provide a valid migration directory name or migration hash.",
-			meta: {
-				input: error.input,
-				grammar: error.grammar
-			}
-		});
-		case "ambiguous": return errorRuntime(`Ambiguous ${error.grammar} reference: "${error.input}"`, {
-			why: `"${error.input}" matches multiple ${error.grammar}s: ${error.candidates.join(", ")}`,
-			fix: "Provide a longer prefix or use the full hash to disambiguate.",
-			meta: {
-				input: error.input,
-				candidates: error.candidates,
-				grammar: error.grammar
-			}
-		});
-		case "wrong-grammar": return errorRuntime(error.message, {
-			why: error.message,
-			fix: error.fix,
-			meta: {
-				input: error.input,
-				expectedGrammar: error.expectedGrammar
-			}
-		});
-		case "invalid-format": return errorRuntime(`Invalid reference format: "${error.input}"`, {
-			why: error.reason,
-			fix: "Provide a valid contract hash, ref name, or migration directory name.",
-			meta: { input: error.input }
-		});
-	}
-}
-//#endregion
-export { errorTargetMigrationNotSupported as _, errorContractValidationFailed as a, mapMigrationToolsError as b, errorDriverRequired as c, errorInvalidOutputFormat as d, errorMarkerMissing as f, errorRuntime$1 as g, errorRunnerFailed as h, errorContractConfigMissing$1 as i, errorFileNotFound as l, errorOutputFormatMutex as m, ERROR_CODE_DESTRUCTIVE_CHANGES as n, errorDatabaseConnectionRequired as o, errorMigrationPlanningFailed as p, errorConfigValidation$1 as r, errorDestructiveChanges as s, CliStructuredError$1 as t, errorHashMismatch as u, errorTargetMismatch as v, mapRefResolutionError as x, errorUnexpected$1 as y };
-
-//# sourceMappingURL=cli-errors-Djtz98Vm.mjs.map

package/dist/cli-errors-Djtz98Vm.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"cli-errors-Djtz98Vm.mjs","names":[],"sources":["../src/utils/cli-errors.ts"],"sourcesContent":["/**\n * Re-export all domain error factories from @prisma-next/errors for convenience.\n * CLI-specific errors (e.g., Commander argument validation in the main CLI, or\n * clipanion parse errors in the migration-file CLI) can be added here if needed.\n */\nexport type { CliErrorConflict, CliErrorEnvelope } from '@prisma-next/errors/control';\n\nimport {\n  CliStructuredError,\n  errorConfigFileNotFound,\n  errorConfigValidation,\n  errorContractConfigMissing,\n  errorContractMissingExtensionPacks,\n  errorContractValidationFailed,\n  errorDatabaseConnectionRequired,\n  errorDriverRequired,\n  errorFamilyReadMarkerSqlRequired,\n  errorFileNotFound,\n  errorInvalidOutputFormat,\n  errorMigrationCliInvalidConfigArg,\n  errorMigrationCliUnknownFlag,\n  errorMigrationPlanningFailed,\n  errorOutputFormatMutex,\n  errorQueryRunnerFactoryRequired,\n  errorTargetMigrationNotSupported,\n  errorUnexpected,\n} from '@prisma-next/errors/control';\nimport { errorRuntime } from '@prisma-next/errors/execution';\nimport type { MigrationToolsError } from '@prisma-next/migration-tools/errors';\nimport type { RefResolutionError } from '@prisma-next/migration-tools/ref-resolution';\n\nexport {\n  ERROR_CODE_DESTRUCTIVE_CHANGES,\n  errorDestructiveChanges,\n  errorHashMismatch,\n  errorMarkerMissing,\n  errorMarkerRequired,\n  errorRunnerFailed,\n  errorRuntime,\n  errorSchemaVerificationFailed,\n  errorTargetMismatch,\n} from '@prisma-next/errors/execution';\nexport {\n  errorMigrationFileMissing,\n  errorMigrationInvalidDefaultExport,\n  errorMigrationPlanNotArray,\n  errorUnfilledPlaceholder,\n  placeholder,\n} from '@prisma-next/errors/migration';\nexport {\n  CliStructuredError,\n  errorConfigFileNotFound,\n  errorConfigValidation,\n  errorContractConfigMissing,\n  errorContractMissingExtensionPacks,\n  errorContractValidationFailed,\n  errorDatabaseConnectionRequired,\n  errorDriverRequired,\n  errorFamilyReadMarkerSqlRequired,\n  errorFileNotFound,\n  errorInvalidOutputFormat,\n  errorMigrationCliInvalidConfigArg,\n  errorMigrationCliUnknownFlag,\n  errorMigrationPlanningFailed,\n  errorOutputFormatMutex,\n  errorQueryRunnerFactoryRequired,\n  errorTargetMigrationNotSupported,\n  errorUnexpected,\n};\n\n/**\n * Maps a `MigrationToolsError` raised by the migration-tools loader/graph\n * surface (`readMigrationPackage`, `readMigrationsDir`, `readRefs`,\n * `resolveRef`, `reconstructGraph`, ...) into a CLI `errorRuntime` envelope.\n *\n * The full `error.details` payload is forwarded into `meta` so machine\n * consumers (`--json`) see structural fields like `dir`, `storedHash`,\n * `computedHash` (for `MIGRATION.HASH_MISMATCH`) alongside the stable\n * `code`. The user-visible `summary`/`why`/`fix` text is unchanged.\n *\n * Callers are expected to gate on `MigrationToolsError.is(error)` first\n * (mirroring the original inline pattern); non-`MigrationToolsError`\n * values are caller-classified (rethrow, wrap with command-specific\n * `errorUnexpected`, etc.).\n */\nexport function mapMigrationToolsError(error: MigrationToolsError): CliStructuredError {\n  return errorRuntime(error.message, {\n    why: error.why,\n    fix: error.fix,\n    meta: { code: error.code, ...(error.details ?? {}) },\n  });\n}\n\n/**\n * Maps a `RefResolutionError` from the contract/migration reference\n * resolver into a CLI structured error envelope.\n */\nexport function mapRefResolutionError(error: RefResolutionError): CliStructuredError {\n  switch (error.kind) {\n    case 'not-found':\n      return errorRuntime(`Not a known ${error.grammar} reference: \"${error.input}\"`, {\n        why: `No ${error.grammar} matching \"${error.input}\" exists in the migration graph or refs index.`,\n        fix:\n          error.grammar === 'contract'\n            ? 'Provide a valid contract hash, ref name, or migration directory name.'\n            : 'Provide a valid migration directory name or migration hash.',\n        meta: { input: error.input, grammar: error.grammar },\n      });\n    case 'ambiguous':\n      return errorRuntime(`Ambiguous ${error.grammar} reference: \"${error.input}\"`, {\n        why: `\"${error.input}\" matches multiple ${error.grammar}s: ${error.candidates.join(', ')}`,\n        fix: 'Provide a longer prefix or use the full hash to disambiguate.',\n        meta: { input: error.input, candidates: error.candidates, grammar: error.grammar },\n      });\n    case 'wrong-grammar':\n      return errorRuntime(error.message, {\n        why: error.message,\n        fix: error.fix,\n        meta: { input: error.input, expectedGrammar: error.expectedGrammar },\n      });\n    case 'invalid-format':\n      return errorRuntime(`Invalid reference format: \"${error.input}\"`, {\n        why: error.reason,\n        fix: 'Provide a valid contract hash, ref name, or migration directory name.',\n        meta: { input: error.input },\n      });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAqFA,SAAgB,uBAAuB,OAAgD;CACrF,OAAO,aAAa,MAAM,SAAS;EACjC,KAAK,MAAM;EACX,KAAK,MAAM;EACX,MAAM;GAAE,MAAM,MAAM;GAAM,GAAI,MAAM,WAAW,EAAE;GAAG;EACrD,CAAC;;;;;;AAOJ,SAAgB,sBAAsB,OAA+C;CACnF,QAAQ,MAAM,MAAd;EACE,KAAK,aACH,OAAO,aAAa,eAAe,MAAM,QAAQ,eAAe,MAAM,MAAM,IAAI;GAC9E,KAAK,MAAM,MAAM,QAAQ,aAAa,MAAM,MAAM;GAClD,KACE,MAAM,YAAY,aACd,0EACA;GACN,MAAM;IAAE,OAAO,MAAM;IAAO,SAAS,MAAM;IAAS;GACrD,CAAC;EACJ,KAAK,aACH,OAAO,aAAa,aAAa,MAAM,QAAQ,eAAe,MAAM,MAAM,IAAI;GAC5E,KAAK,IAAI,MAAM,MAAM,qBAAqB,MAAM,QAAQ,KAAK,MAAM,WAAW,KAAK,KAAK;GACxF,KAAK;GACL,MAAM;IAAE,OAAO,MAAM;IAAO,YAAY,MAAM;IAAY,SAAS,MAAM;IAAS;GACnF,CAAC;EACJ,KAAK,iBACH,OAAO,aAAa,MAAM,SAAS;GACjC,KAAK,MAAM;GACX,KAAK,MAAM;GACX,MAAM;IAAE,OAAO,MAAM;IAAO,iBAAiB,MAAM;IAAiB;GACrE,CAAC;EACJ,KAAK,kBACH,OAAO,aAAa,8BAA8B,MAAM,MAAM,IAAI;GAChE,KAAK,MAAM;GACX,KAAK;GACL,MAAM,EAAE,OAAO,MAAM,OAAO;GAC7B,CAAC"}