@prisma-next/cli 0.4.1 → 0.4.2

package/src/commands/migration-ref.ts

@@ -1,17 +1,22 @@
+import type { RefEntry } from '@prisma-next/migration-tools/refs';
 import {
+  deleteRef,
+  readRef,
   readRefs,
-  resolveRef,
   validateRefName,
   validateRefValue,
-  writeRefs,
+  writeRef,
 } from '@prisma-next/migration-tools/refs';
 import { MigrationToolsError } from '@prisma-next/migration-tools/types';
 import { notOk, ok, type Result } from '@prisma-next/utils/result';
 import { Command } from 'commander';
-import { resolve } from 'pathe';
 import { loadConfig } from '../config-loader';
 import { CliStructuredError, errorRuntime, errorUnexpected } from '../utils/cli-errors';
-import { addGlobalOptions, setCommandDescriptions } from '../utils/command-helpers';
+import {
+  addGlobalOptions,
+  resolveMigrationPaths,
+  setCommandDescriptions,
+} from '../utils/command-helpers';
 import { formatCommandHelp } from '../utils/formatters/help';
 import { parseGlobalFlags } from '../utils/global-flags';
 import { handleResult } from '../utils/result-handler';
@@ -21,12 +26,14 @@ interface RefSetResult {
   readonly ok: true;
   readonly ref: string;
   readonly hash: string;
+  readonly invariants: readonly string[];
 }
 
 interface RefGetResult {
   readonly ok: true;
   readonly ref: string;
   readonly hash: string;
+  readonly invariants: readonly string[];
 }
 
 interface RefDeleteResult {
@@ -37,12 +44,7 @@ interface RefDeleteResult {
 
 interface RefListResult {
   readonly ok: true;
-  readonly refs: Record<string, string>;
-}
-
-function resolveRefsPath(configPath?: string, config?: { migrations?: { dir?: string } }): string {
-  const base = configPath ? resolve(configPath, '..') : process.cwd();
-  return resolve(base, config?.migrations?.dir ?? 'migrations', 'refs.json');
+  readonly refs: Record<string, RefEntry>;
 }
 
 function mapError(error: unknown): CliStructuredError {
@@ -70,13 +72,6 @@ function cliErrorInvalidRefValue(hash: string): CliStructuredError {
   });
 }
 
-function errorRefNotFound(name: string): CliStructuredError {
-  return errorRuntime(`Ref "${name}" does not exist`, {
-    why: `No ref named "${name}" found in refs.json`,
-    fix: `Run \`prisma-next migration ref list\` to see available refs, or \`prisma-next migration ref set ${name} <hash>\` to create it`,
-  });
-}
-
 async function executeRefSetCommand(
   name: string,
   hash: string,
@@ -91,11 +86,10 @@ async function executeRefSetCommand(
 
   try {
     const config = await loadConfig(options.config);
-    const refsPath = resolveRefsPath(options.config, config);
-    const refs = await readRefs(refsPath);
-    const updated = { ...refs, [name]: hash };
-    await writeRefs(refsPath, updated);
-    return ok({ ok: true as const, ref: name, hash });
+    const { refsDir } = resolveMigrationPaths(options.config, config);
+    const entry: RefEntry = { hash, invariants: [] };
+    await writeRef(refsDir, name, entry);
+    return ok({ ok: true as const, ref: name, hash, invariants: [] });
   } catch (error) {
     if (error instanceof CliStructuredError) return notOk(error);
     return notOk(mapError(error));
@@ -108,10 +102,9 @@ async function executeRefGetCommand(
 ): Promise<Result<RefGetResult, CliStructuredError>> {
   try {
     const config = await loadConfig(options.config);
-    const refsPath = resolveRefsPath(options.config, config);
-    const refs = await readRefs(refsPath);
-    const hash = resolveRef(refs, name);
-    return ok({ ok: true as const, ref: name, hash });
+    const { refsDir } = resolveMigrationPaths(options.config, config);
+    const entry = await readRef(refsDir, name);
+    return ok({ ok: true as const, ref: name, hash: entry.hash, invariants: entry.invariants });
   } catch (error) {
     if (error instanceof CliStructuredError) return notOk(error);
     return notOk(mapError(error));
@@ -124,13 +117,8 @@ async function executeRefDeleteCommand(
 ): Promise<Result<RefDeleteResult, CliStructuredError>> {
   try {
     const config = await loadConfig(options.config);
-    const refsPath = resolveRefsPath(options.config, config);
-    const refs = await readRefs(refsPath);
-    if (!Object.hasOwn(refs, name)) {
-      return notOk(errorRefNotFound(name));
-    }
-    const { [name]: _, ...remaining } = refs;
-    await writeRefs(refsPath, remaining);
+    const { refsDir } = resolveMigrationPaths(options.config, config);
+    await deleteRef(refsDir, name);
     return ok({ ok: true as const, ref: name, deleted: true as const });
   } catch (error) {
     if (error instanceof CliStructuredError) return notOk(error);
@@ -143,8 +131,8 @@ async function executeRefListCommand(options: {
 }): Promise<Result<RefListResult, CliStructuredError>> {
   try {
     const config = await loadConfig(options.config);
-    const refsPath = resolveRefsPath(options.config, config);
-    const refs = await readRefs(refsPath);
+    const { refsDir } = resolveMigrationPaths(options.config, config);
+    const refs = await readRefs(refsDir);
     return ok({ ok: true as const, refs });
   } catch (error) {
     if (error instanceof CliStructuredError) return notOk(error);
@@ -157,7 +145,7 @@ function createRefSetCommand(): Command {
   setCommandDescriptions(
     command,
     'Set a ref to a contract hash',
-    'Sets a named ref to point to a contract hash in migrations/refs.json.',
+    'Sets a named ref to point to a contract hash in migrations/refs/.',
   );
   addGlobalOptions(command)
     .argument('<name>', 'Ref name (e.g., staging, production)')
@@ -190,7 +178,7 @@ function createRefGetCommand(): Command {
   setCommandDescriptions(
     command,
     'Get the hash for a ref',
-    'Reads a named ref from migrations/refs.json and prints its contract hash.',
+    'Reads a named ref from migrations/refs/ and prints its contract hash.',
   );
   addGlobalOptions(command)
     .argument('<name>', 'Ref name to look up')
@@ -218,7 +206,7 @@ function createRefGetCommand(): Command {
 
 function createRefDeleteCommand(): Command {
   const command = new Command('delete');
-  setCommandDescriptions(command, 'Delete a ref', 'Removes a named ref from migrations/refs.json.');
+  setCommandDescriptions(command, 'Delete a ref', 'Removes a named ref from migrations/refs/.');
   addGlobalOptions(command)
     .argument('<name>', 'Ref name to delete')
     .option('--config <path>', 'Path to prisma-next.config.ts')
@@ -245,11 +233,7 @@ function createRefDeleteCommand(): Command {
 
 function createRefListCommand(): Command {
   const command = new Command('list');
-  setCommandDescriptions(
-    command,
-    'List all refs',
-    'Lists all named refs from migrations/refs.json.',
-  );
+  setCommandDescriptions(command, 'List all refs', 'Lists all named refs from migrations/refs/.');
   addGlobalOptions(command)
     .option('--config <path>', 'Path to prisma-next.config.ts')
     .action(async (options: { config?: string; json?: string | boolean; quiet?: boolean }) => {
@@ -264,8 +248,10 @@ function createRefListCommand(): Command {
           if (entries.length === 0) {
             ui.output('No refs defined');
           } else {
-            for (const [refName, hash] of entries) {
-              ui.output(`${refName} → ${hash}`);
+            for (const [refName, entry] of entries) {
+              const invariantsSuffix =
+                entry.invariants.length > 0 ? ` [invariants: ${entry.invariants.join(', ')}]` : '';
+              ui.output(`${refName} → ${entry.hash}${invariantsSuffix}`);
             }
           }
         }
@@ -282,7 +268,6 @@ export {
   executeRefListCommand,
   cliErrorInvalidRefName,
   cliErrorInvalidRefValue,
-  errorRefNotFound,
 };
 
 export function createMigrationRefCommand(): Command {
@@ -290,7 +275,7 @@ export function createMigrationRefCommand(): Command {
   setCommandDescriptions(
     command,
     'Manage migration refs',
-    'Manage named refs in migrations/refs.json. Refs map logical environment\n' +
+    'Manage named refs in migrations/refs/. Refs map logical environment\n' +
       'names (e.g., staging, production) to contract hashes.',
   );
   addGlobalOptions(command).configureHelp({

package/src/commands/migration-status.ts

@@ -345,7 +345,7 @@ async function executeMigrationStatusCommand(
   ui: TerminalUI,
 ): Promise<Result<MigrationStatusResult, CliStructuredError>> {
   const config = await loadConfig(options.config);
-  const { configPath, migrationsDir, migrationsRelative, refsPath } = resolveMigrationPaths(
+  const { configPath, migrationsDir, migrationsRelative, refsDir } = resolveMigrationPaths(
     options.config,
     config,
   );
@@ -357,7 +357,7 @@ async function executeMigrationStatusCommand(
   let activeRefHash: string | undefined;
   let allRefs: Refs = {};
   try {
-    allRefs = await readRefs(refsPath);
+    allRefs = await readRefs(refsDir);
   } catch (error) {
     if (MigrationToolsError.is(error)) {
       return notOk(
@@ -373,30 +373,25 @@ async function executeMigrationStatusCommand(
 
   if (options.ref) {
     activeRefName = options.ref;
-    const refHash = allRefs[activeRefName];
-    if (refHash) {
-      activeRefHash = refHash;
-    } else {
-      try {
-        activeRefHash = resolveRef(allRefs, activeRefName);
-      } catch (error) {
-        if (MigrationToolsError.is(error)) {
-          return notOk(
-            errorRuntime(error.message, {
-              why: error.why,
-              fix: error.fix,
-              meta: { code: error.code },
-            }),
-          );
-        }
-        throw error;
+    try {
+      activeRefHash = resolveRef(allRefs, activeRefName).hash;
+    } catch (error) {
+      if (MigrationToolsError.is(error)) {
+        return notOk(
+          errorRuntime(error.message, {
+            why: error.why,
+            fix: error.fix,
+            meta: { code: error.code },
+          }),
+        );
       }
+      throw error;
     }
   }
 
-  const statusRefs: StatusRef[] = Object.entries(allRefs).map(([name, hash]) => ({
+  const statusRefs: StatusRef[] = Object.entries(allRefs).map(([name, entry]) => ({
     name,
-    hash,
+    hash: entry.hash,
     active: name === activeRefName,
   }));
 

package/src/exports/init-output.ts

@@ -0,0 +1,10 @@
+/**
+ * Public re-export of the `init --json` success-document schema (FR1.5).
+ *
+ * Imported as `@prisma-next/cli/init-output`. The shared error envelope is
+ * exported separately from `@prisma-next/errors`; consumers should branch
+ * on the `ok` discriminator (success documents carry `ok: true`, error
+ * envelopes carry `ok: false`) per the
+ * [Style Guide § JSON Semantics](../../../../../../../docs/CLI%20Style%20Guide.md#json-semantics).
+ */
+export { type InitOutput, InitOutputSchema } from '../commands/init/output';

package/src/migration-cli.ts

@@ -0,0 +1,254 @@
+/**
+ * The migration-file CLI interface: the actor invoked when the author runs
+ * `node migration.ts` directly.
+ *
+ * Naming: this is *not* a "migration runner" in the apply-time sense. The
+ * apply-time runner is the thing `prisma-next migration apply` uses to
+ * execute migration JSON ops against a database. `MigrationCLI` is the
+ * tiny CLI surface owned by an authored `migration.ts` file: parse the
+ * file's argv, load the project's `prisma-next.config.ts`, assemble a
+ * `ControlStack`, instantiate the migration class, and serialize.
+ *
+ * The user authors a migration class, then calls
+ * `MigrationCLI.run(import.meta.url, MigrationClass)` at module scope
+ * after the class definition. When the file is invoked as a node
+ * entrypoint (`node migration.ts`), the CLI:
+ *
+ * 1. Detects whether the file is the direct entrypoint (no-op when imported).
+ * 2. Parses CLI args (`--help`, `--dry-run`, `--config <path>`).
+ * 3. Loads the project's `prisma-next.config.ts` via the same `loadConfig`
+ *    the CLI commands use, walking up from the migration file's directory.
+ * 4. Probe-instantiates the migration class without a stack so it can read
+ *    `targetId` and verify it matches `config.target.targetId`
+ *    (`PN-MIG-2006` on mismatch) before any stack-driven adapter
+ *    construction runs.
+ * 5. Assembles a `ControlStack` from the loaded config descriptors and
+ *    constructs the migration with that stack.
+ * 6. Reads any previously-scaffolded `migration.json`, then calls
+ *    `buildMigrationArtifacts` from `@prisma-next/migration-tools` to
+ *    produce in-memory `ops.json` + `migration.json` content. Persists
+ *    the result to disk (or prints in dry-run mode).
+ *
+ * File I/O lives here, in `@prisma-next/cli`: this is the only place
+ * that legitimately combines config loading, stack assembly, and
+ * on-disk persistence. `@prisma-next/migration-tools` owns the pure
+ * conversion from a `Migration` instance to artifact strings; `Migration`
+ * stays a pure abstract class.
+ */
+
+import { readFileSync, writeFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { CliStructuredError, errorMigrationCliInvalidConfigArg } from '@prisma-next/errors/control';
+import { errorMigrationTargetMismatch } from '@prisma-next/errors/migration';
+import { createControlStack } from '@prisma-next/framework-components/control';
+import {
+  buildMigrationArtifacts,
+  isDirectEntrypoint,
+  type Migration,
+  printMigrationHelp,
+} from '@prisma-next/migration-tools/migration';
+import type { MigrationManifest } from '@prisma-next/migration-tools/types';
+import { dirname, join } from 'pathe';
+import { loadConfig } from './config-loader';
+
+/**
+ * Constructor shape accepted by `MigrationCLI.run`. `Migration` subclasses
+ * accept an optional `ControlStack` in their constructor (each subclass
+ * narrows the stack to its own family/target generics); the CLI always
+ * passes one assembled from the loaded config. We use a rest-args `any[]`
+ * constructor signature so that subclass constructors with narrower
+ * parameter types remain assignable - constructor type compatibility in
+ * TS is contravariant in the parameter, and a wider `unknown` parameter
+ * on the alias side would reject any narrower subclass signature.
+ *
+ * The CLI only ever passes one argument (`new MigrationClass(stack)`);
+ * the rest-arity is purely a type-compatibility concession for subclass
+ * constructors that declare narrower parameter types, not an extension
+ * point for additional construction arguments.
+ */
+// biome-ignore lint/suspicious/noExplicitAny: see JSDoc - rest args with any are the idiomatic TS pattern for accepting arbitrary subclass constructor signatures
+export type MigrationConstructor = new (...args: any[]) => Migration;
+
+interface ParsedArgs {
+  readonly help: boolean;
+  readonly dryRun: boolean;
+  readonly configPath: string | undefined;
+}
+
+/**
+ * Parse the subset of `process.argv` that `MigrationCLI.run` cares about.
+ * Recognised flags: `--help`, `--dry-run`, `--config <path>` /
+ * `--config=<path>`. Unknown flags are ignored to keep the surface
+ * forgiving for ad-hoc tooling that wraps a migration file.
+ *
+ * Throws `errorMigrationCliInvalidConfigArg` (`PN-CLI-4012`) when
+ * `--config` is missing its path argument or is followed by another flag
+ * (e.g. `--config --dry-run`); silently consuming the next flag would
+ * either drop dry-run handling or serialize against the wrong project.
+ *
+ * NOTE: this hand-rolled parser is a known wart, tracked separately by
+ * TML-2318 ("Migration CLI: replace handrolled arg parser with shared
+ * CLI library"). Until that lands the surface is intentionally tiny.
+ */
+function parseArgs(argv: readonly string[]): ParsedArgs {
+  let help = false;
+  let dryRun = false;
+  let configPath: string | undefined;
+
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i]!;
+    if (arg === '--help' || arg === '-h') {
+      help = true;
+    } else if (arg === '--dry-run') {
+      dryRun = true;
+    } else if (arg === '--config') {
+      const next = argv[i + 1];
+      if (next === undefined) {
+        throw errorMigrationCliInvalidConfigArg();
+      }
+      if (next.startsWith('-')) {
+        throw errorMigrationCliInvalidConfigArg({ nextToken: next });
+      }
+      configPath = next;
+      i++;
+    } else if (arg.startsWith('--config=')) {
+      configPath = arg.slice('--config='.length);
+    }
+  }
+
+  return { help, dryRun, configPath };
+}
+
+/**
+ * The CLI surface invoked by an authored `migration.ts` file. Exposed as
+ * a class with a static `run` method (rather than a free function) to
+ * give the concept a stable identity in the ubiquitous language: this is
+ * the "migration-file CLI", distinct from the apply-time runner that
+ * executes migration JSON ops.
+ *
+ * Currently a single static method. Future surface (e.g. a programmatic
+ * `MigrationCLI.serializeOnly(...)` for tests, or extra subcommands) can
+ * land here without changing the import shape used by every authored
+ * migration.
+ */
+// biome-ignore lint/complexity/noStaticOnlyClass: see JSDoc - intentional class facade for the migration-file CLI surface; future methods will share state derived from argv/config.
+export class MigrationCLI {
+  /**
+   * Orchestrates a class-flow `migration.ts` script run. Awaitable:
+   * callers may `await MigrationCLI.run(...)` to surface async failures
+   * from config loading, but the typical usage pattern (top-level call
+   * after the class definition) does not require awaiting because
+   * node's module evaluation keeps the promise alive until completion.
+   *
+   * Any throwable inside this function must surface through the internal
+   * try/catch — script callers do not await, so an unhandled rejection
+   * would silently exit 0. Treat the try/catch as load-bearing for the
+   * no-await usage pattern.
+   */
+  static async run(importMetaUrl: string, MigrationClass: MigrationConstructor): Promise<void> {
+    if (!importMetaUrl) return;
+    if (!isDirectEntrypoint(importMetaUrl)) return;
+
+    try {
+      const args = parseArgs(process.argv.slice(2));
+
+      if (args.help) {
+        printMigrationHelp();
+        return;
+      }
+
+      const migrationFile = fileURLToPath(importMetaUrl);
+      const migrationDir = dirname(migrationFile);
+
+      const config = await loadConfig(args.configPath);
+
+      // Probe-instantiate without a stack so we can read `targetId` before
+      // any target-specific constructor side effects (e.g.
+      // `PostgresMigration`'s `stack.adapter.create(stack)`) run. Concrete
+      // subclasses are required to accept the no-arg form; the abstract
+      // `Migration` constructor declares `stack?` and target subclasses
+      // (Postgres, Mongo) propagate that optionality. This makes the
+      // target-mismatch guard fail fast with `PN-MIG-2006` before any
+      // stack-driven adapter construction begins, even if the wrong-target
+      // adapter's `create` would otherwise succeed and silently misshapen
+      // the stored adapter cast.
+      const probe = new MigrationClass();
+
+      if (probe.targetId !== config.target.targetId) {
+        throw errorMigrationTargetMismatch({
+          migrationTargetId: probe.targetId,
+          configTargetId: config.target.targetId,
+        });
+      }
+
+      const stack = createControlStack(config);
+      const instance = new MigrationClass(stack);
+
+      serializeMigrationToDisk(instance, migrationDir, args.dryRun);
+    } catch (err) {
+      if (CliStructuredError.is(err)) {
+        process.stderr.write(`${err.message}: ${err.why}\n`);
+      } else {
+        process.stderr.write(`${err instanceof Error ? err.message : String(err)}\n`);
+      }
+      process.exitCode = 1;
+    }
+  }
+}
+
+/**
+ * Read a previously-scaffolded `migration.json` from disk, returning
+ * `null` when the file is missing or unparseable. The CLI feeds this into
+ * `buildMigrationArtifacts` so the pure builder can preserve fields owned
+ * by `migration plan` (contract bookends, hints, labels, `createdAt`)
+ * across re-emits.
+ */
+function readExistingManifest(manifestPath: string): Partial<MigrationManifest> | null {
+  let raw: string;
+  try {
+    raw = readFileSync(manifestPath, 'utf-8');
+  } catch {
+    return null;
+  }
+  try {
+    return JSON.parse(raw) as Partial<MigrationManifest>;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Persist a migration instance's artifacts to `migrationDir`. In
+ * `dryRun` mode the artifacts are printed to stdout (with the same
+ * `--- migration.json --- / --- ops.json ---` framing the legacy
+ * `serializeMigration` helper used) and no files are written. Otherwise
+ * `ops.json` and `migration.json` are written next to `migration.ts` and
+ * a confirmation line is printed.
+ *
+ * File I/O lives in the CLI rather than `@prisma-next/migration-tools`
+ * so the migration-tools package stays focused on the pure
+ * `Migration` → in-memory artifact conversion. The CLI is the only
+ * legitimate site for combining config loading, stack assembly, and
+ * filesystem persistence.
+ */
+function serializeMigrationToDisk(
+  instance: Migration,
+  migrationDir: string,
+  dryRun: boolean,
+): void {
+  const manifestPath = join(migrationDir, 'migration.json');
+  const existing = readExistingManifest(manifestPath);
+  const { opsJson, manifestJson } = buildMigrationArtifacts(instance, existing);
+
+  if (dryRun) {
+    process.stdout.write(`--- migration.json ---\n${manifestJson}\n`);
+    process.stdout.write('--- ops.json ---\n');
+    process.stdout.write(`${opsJson}\n`);
+    return;
+  }
+
+  writeFileSync(join(migrationDir, 'ops.json'), opsJson);
+  writeFileSync(manifestPath, manifestJson);
+
+  process.stdout.write(`Wrote ops.json + migration.json to ${migrationDir}\n`);
+}

package/src/utils/cli-errors.ts

@@ -14,6 +14,7 @@ export {
   errorDriverRequired,
   errorFamilyReadMarkerSqlRequired,
   errorFileNotFound,
+  errorMigrationCliInvalidConfigArg,
   errorMigrationPlanningFailed,
   errorQueryRunnerFactoryRequired,
   errorTargetMigrationNotSupported,

package/src/utils/command-helpers.ts

@@ -85,7 +85,7 @@ export function resolveMigrationPaths(
   configPath: string;
   migrationsDir: string;
   migrationsRelative: string;
-  refsPath: string;
+  refsDir: string;
 } {
   const configPath = configOption
     ? relative(process.cwd(), resolve(configOption))
@@ -95,8 +95,8 @@ export function resolveMigrationPaths(
     config.migrations?.dir ?? 'migrations',
   );
   const migrationsRelative = relative(process.cwd(), migrationsDir);
-  const refsPath = resolve(migrationsDir, 'refs.json');
-  return { configPath, migrationsDir, migrationsRelative, refsPath };
+  const refsDir = resolve(migrationsDir, 'refs');
+  return { configPath, migrationsDir, migrationsRelative, refsDir };
 }
 
 /**

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

@@ -1,4 +0,0 @@
-import { CliStructuredError } from "@prisma-next/errors/control";
-import "@prisma-next/errors/execution";
-import "@prisma-next/errors/migration";
-export { CliStructuredError as t };

package/dist/contract-emit-304WZtZJ.mjs

@@ -1,4 +0,0 @@
-import "./config-loader-_xQZsw0i.mjs";
-import { t as executeContractEmit } from "./contract-emit-DgeWdonT.mjs";
-
-export { executeContractEmit };

package/dist/contract-emit-mU1_B_m9.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"contract-emit-mU1_B_m9.mjs","names":["lines: string[]","exhaustive: never","config: Awaited<ReturnType<typeof loadConfig>>","errorUnexpected","outputPaths: ReturnType<typeof getEmittedArtifactPaths>"],"sources":["../src/utils/formatters/emit.ts","../src/commands/contract-emit.ts"],"sourcesContent":["import { ifDefined } from '@prisma-next/utils/defined';\nimport { relative } from 'pathe';\n\nimport type { GlobalFlags } from '../global-flags';\nimport { isVerbose } from './helpers';\n\n// EmitContractResult type for CLI output formatting (includes file paths)\nexport interface EmitContractResult {\n  readonly storageHash: string;\n  readonly executionHash?: string;\n  readonly profileHash: string;\n  readonly outDir: string;\n  readonly files: {\n    readonly json: string;\n    readonly dts: string;\n  };\n  readonly timings: {\n    readonly total: number;\n  };\n}\n\n/**\n * Formats human-readable output for contract emit.\n */\nexport function formatEmitOutput(result: EmitContractResult, flags: GlobalFlags): string {\n  if (flags.quiet) {\n    return '';\n  }\n\n  const lines: string[] = [];\n\n  // Convert absolute paths to relative paths from cwd\n  const jsonPath = relative(process.cwd(), result.files.json);\n  const dtsPath = relative(process.cwd(), result.files.dts);\n\n  lines.push(`✔ Emitted contract.json → ${jsonPath}`);\n  lines.push(`✔ Emitted contract.d.ts → ${dtsPath}`);\n  lines.push(`  storageHash: ${result.storageHash}`);\n  if (result.executionHash) {\n    lines.push(`  executionHash: ${result.executionHash}`);\n  }\n  if (result.profileHash) {\n    lines.push(`  profileHash: ${result.profileHash}`);\n  }\n  if (isVerbose(flags, 1)) {\n    lines.push(`  Total time: ${result.timings.total}ms`);\n  }\n\n  return lines.join('\\n');\n}\n\n/**\n * Formats JSON output for contract emit.\n */\nexport function formatEmitJson(result: EmitContractResult): string {\n  const output = {\n    ok: true,\n    storageHash: result.storageHash,\n    ...ifDefined('executionHash', result.executionHash),\n    ...(result.profileHash ? { profileHash: result.profileHash } : {}),\n    outDir: result.outDir,\n    files: result.files,\n    timings: result.timings,\n  };\n\n  return JSON.stringify(output, null, 2);\n}\n","import { mkdirSync, writeFileSync } from 'node:fs';\nimport { getEmittedArtifactPaths } from '@prisma-next/emitter';\nimport { errorContractConfigMissing } from '@prisma-next/errors/control';\nimport { notOk, ok, type Result } from '@prisma-next/utils/result';\nimport { Command } from 'commander';\nimport { dirname, relative, resolve } from 'pathe';\nimport { loadConfig } from '../config-loader';\nimport { createControlClient } from '../control-api/client';\nimport type { EmitFailure } from '../control-api/types';\nimport {\n  CliStructuredError,\n  errorContractValidationFailed,\n  errorRuntime,\n  errorUnexpected,\n} from '../utils/cli-errors';\nimport {\n  addGlobalOptions,\n  setCommandDescriptions,\n  setCommandExamples,\n} from '../utils/command-helpers';\nimport {\n  type EmitContractResult,\n  formatEmitJson,\n  formatEmitOutput,\n} from '../utils/formatters/emit';\nimport { formatStyledHeader, formatSuccessMessage } from '../utils/formatters/styled';\nimport type { CommonCommandOptions } from '../utils/global-flags';\nimport { type GlobalFlags, parseGlobalFlags } from '../utils/global-flags';\nimport { createProgressAdapter } from '../utils/progress-adapter';\nimport { handleResult } from '../utils/result-handler';\nimport { TerminalUI } from '../utils/terminal-ui';\n\ninterface ContractEmitOptions extends CommonCommandOptions {\n  readonly config?: string;\n}\n\nfunction mapDiagnosticsToIssues(\n  failure: EmitFailure,\n): ReadonlyArray<{ kind: string; message: string }> {\n  const diagnostics = failure.diagnostics?.diagnostics ?? [];\n  return diagnostics.map((diagnostic) => {\n    const location =\n      diagnostic.sourceId && diagnostic.span\n        ? ` (${diagnostic.sourceId}:${diagnostic.span.start.line}:${diagnostic.span.start.column})`\n        : diagnostic.sourceId\n          ? ` (${diagnostic.sourceId})`\n          : '';\n    return {\n      kind: diagnostic.code,\n      message: `${diagnostic.message}${location}`,\n    };\n  });\n}\n\n/**\n * Maps an EmitFailure to a CliStructuredError for consistent error handling.\n */\nfunction mapEmitFailure(\n  failure: EmitFailure,\n  context?: { readonly configPath?: string },\n): CliStructuredError {\n  if (failure.code === 'CONTRACT_SOURCE_INVALID') {\n    const issues = mapDiagnosticsToIssues(failure);\n    return errorRuntime(failure.summary, {\n      why: failure.why ?? 'Contract source provider failed',\n      fix: 'Check your contract source provider in prisma-next.config.ts and ensure it returns Result<Contract, Diagnostics>',\n      ...(issues.length > 0 ? { meta: { issues } } : {}),\n    });\n  }\n\n  if (failure.code === 'CONTRACT_VALIDATION_FAILED') {\n    return errorContractValidationFailed(\n      failure.why ?? 'Contract validation failed while emitting',\n      context?.configPath ? { where: { path: context.configPath } } : undefined,\n    );\n  }\n\n  if (failure.code === 'EMIT_FAILED') {\n    return errorRuntime(failure.summary, {\n      why: failure.why ?? 'Failed to emit contract',\n      fix: 'Check your contract configuration and ensure the source is valid',\n    });\n  }\n\n  // Exhaustive check - TypeScript will error if a new code is added but not handled\n  const exhaustive: never = failure.code;\n  throw new Error(`Unhandled EmitFailure code: ${exhaustive}`);\n}\n\n/**\n * Executes the contract emit command and returns a structured Result.\n */\nasync function executeContractEmitCommand(\n  options: ContractEmitOptions,\n  flags: GlobalFlags,\n  ui: TerminalUI,\n  startTime: number,\n): Promise<Result<EmitContractResult, CliStructuredError>> {\n  // Load config\n  let config: Awaited<ReturnType<typeof loadConfig>>;\n  try {\n    config = await loadConfig(options.config);\n  } catch (error) {\n    // Convert thrown CliStructuredError to Result\n    if (error instanceof CliStructuredError) {\n      return notOk(error);\n    }\n    return notOk(\n      errorUnexpected(error instanceof Error ? error.message : String(error), {\n        why: 'Failed to load config',\n      }),\n    );\n  }\n\n  const configPath = options.config\n    ? relative(process.cwd(), resolve(options.config))\n    : 'prisma-next.config.ts';\n\n  // Resolve contract from config\n  if (!config.contract) {\n    return notOk(\n      errorContractConfigMissing({\n        why: 'Config.contract is required for emit. Define it in your config: contract: { source: ..., output: ... }',\n      }),\n    );\n  }\n\n  // Contract config is already normalized by defineConfig() with defaults applied\n  const contractConfig = config.contract;\n\n  // Resolve artifact paths from config (already normalized by defineConfig() with defaults)\n  if (!contractConfig.output) {\n    return notOk(\n      errorContractConfigMissing({\n        why: 'Contract config must have output path. This should not happen if defineConfig() was used.',\n      }),\n    );\n  }\n  let outputPaths: ReturnType<typeof getEmittedArtifactPaths>;\n  try {\n    outputPaths = getEmittedArtifactPaths(contractConfig.output);\n  } catch (error) {\n    return notOk(\n      errorContractConfigMissing({\n        why: error instanceof Error ? error.message : String(error),\n      }),\n    );\n  }\n  const { jsonPath: outputJsonPath, dtsPath: outputDtsPath } = outputPaths;\n\n  // Output header to stderr (decoration)\n  if (!flags.json && !flags.quiet) {\n    const contractPath = relative(process.cwd(), outputJsonPath);\n    const typesPath = relative(process.cwd(), outputDtsPath);\n    const header = formatStyledHeader({\n      command: 'contract emit',\n      description: 'Emit your contract artifacts',\n      url: 'https://pris.ly/contract-emit',\n      details: [\n        { label: 'config', value: configPath },\n        { label: 'contract', value: contractPath },\n        { label: 'types', value: typesPath },\n      ],\n      flags,\n    });\n    ui.stderr(header);\n  }\n\n  // Create control client (no driver needed for emit)\n  const client = createControlClient({\n    family: config.family,\n    target: config.target,\n    adapter: config.adapter,\n    extensionPacks: config.extensionPacks ?? [],\n  });\n\n  // Create progress adapter\n  const onProgress = createProgressAdapter({ ui, flags });\n\n  try {\n    // Call emit with progress callback\n    const result = await client.emit({\n      contractConfig: {\n        source: contractConfig.source,\n        output: outputJsonPath,\n      },\n      onProgress,\n    });\n\n    // Handle failures by mapping to CLI structured error\n    if (!result.ok) {\n      return notOk(mapEmitFailure(result.failure, { configPath }));\n    }\n\n    // Create directories if needed\n    mkdirSync(dirname(outputJsonPath), { recursive: true });\n    mkdirSync(dirname(outputDtsPath), { recursive: true });\n\n    // Write the results to files\n    writeFileSync(outputJsonPath, result.value.contractJson, 'utf-8');\n    writeFileSync(outputDtsPath, result.value.contractDts, 'utf-8');\n\n    // Validate that contract.d.ts type imports are resolvable\n    const { validateContractDeps } = await import('../utils/validate-contract-deps');\n    const depsValidation = validateContractDeps(result.value.contractDts, dirname(outputDtsPath));\n    if (depsValidation.warning) {\n      ui.warn(depsValidation.warning);\n    }\n\n    // Convert success result to CLI output format\n    const emitResult: EmitContractResult = {\n      storageHash: result.value.storageHash,\n      ...(result.value.executionHash ? { executionHash: result.value.executionHash } : {}),\n      profileHash: result.value.profileHash,\n      outDir: dirname(outputJsonPath),\n      files: {\n        json: outputJsonPath,\n        dts: outputDtsPath,\n      },\n      timings: { total: Date.now() - startTime },\n    };\n\n    return ok(emitResult);\n  } catch (error) {\n    // Use static type guard to work across module boundaries\n    if (CliStructuredError.is(error)) {\n      return notOk(error);\n    }\n\n    // Wrap unexpected errors\n    return notOk(\n      errorUnexpected('Unexpected error during contract emit', {\n        why: error instanceof Error ? error.message : String(error),\n      }),\n    );\n  } finally {\n    await client.close();\n  }\n}\n\nexport function createContractEmitCommand(): Command {\n  const command = new Command('emit');\n  setCommandDescriptions(\n    command,\n    'Emit your contract artifacts',\n    'Reads your contract source (TypeScript or Prisma schema) and emits contract.json and\\n' +\n      'contract.d.ts. The contract.json contains the canonical contract structure, and\\n' +\n      'contract.d.ts provides TypeScript types for type-safe query building.',\n  );\n  setCommandExamples(command, [\n    'prisma-next contract emit',\n    'prisma-next contract emit --config ./custom-config.ts',\n  ]);\n  addGlobalOptions(command)\n    .option('--config <path>', 'Path to prisma-next.config.ts')\n    .action(async (options: ContractEmitOptions) => {\n      const flags = parseGlobalFlags(options);\n      const ui = new TerminalUI({ color: flags.color, interactive: flags.interactive });\n      const startTime = Date.now();\n\n      const result = await executeContractEmitCommand(options, flags, ui, startTime);\n\n      // Handle result - formats output and returns exit code\n      const exitCode = handleResult(result, flags, ui, (emitResult) => {\n        if (flags.json) {\n          ui.output(formatEmitJson(emitResult));\n        } else {\n          const output = formatEmitOutput(emitResult, flags);\n          if (output) {\n            ui.log(output);\n          }\n          if (!flags.quiet) {\n            ui.success(formatSuccessMessage(flags));\n          }\n        }\n      });\n      process.exit(exitCode);\n    });\n\n  return command;\n}\n"],"mappings":"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"}