@prisma-next/cli 0.4.0-dev.6 → 0.4.0-dev.7

package/dist/migration-emit-Du4DBMqz.mjs

@@ -0,0 +1,125 @@
+import { f as errorMigrationFileMissing, g as errorTargetMigrationNotSupported } from "./cli-errors-BUuJr6py.mjs";
+import { errorTargetHasIncompleteMigrationCapabilities } from "@prisma-next/errors/migration";
+import { readMigrationPackage, writeMigrationOps } from "@prisma-next/migration-tools/io";
+import assert from "node:assert/strict";
+import { attestMigration } from "@prisma-next/migration-tools/attestation";
+import { evaluateMigrationTs, hasMigrationTs } from "@prisma-next/migration-tools/migration-ts";
+
+//#region src/lib/migration-strategy.ts
+/**
+* Migration authoring strategy selector.
+*
+* Targets currently use one of two strategies to author `migration.ts`:
+*
+*  - **Descriptor flow** — the planner produces an `OperationDescriptor[]`
+*    and `migration.ts` is a `export default () => [...]` file that the CLI
+*    later replays through `resolveDescriptors` at emit time. Postgres uses
+*    this today.
+*  - **Class flow** — the planner produces a `MigrationPlanWithAuthoringSurface`
+*    that renders itself as a `class M extends Migration { ... }` file. The
+*    CLI dispatches to the target's `emit` capability at emit time. Mongo
+*    uses this today.
+*
+* The two are mutually exclusive at the target level: a migrations capability
+* either implements the descriptor-flow trio (`planWithDescriptors`,
+* `resolveDescriptors`, `renderDescriptorTypeScript`) or the class-flow
+* `emit` hook. `migrationStrategy` discriminates between them by observing
+* which hooks are present, and is consumed by `migration new`, `migration
+* plan`, and `migration emit` to keep strategy-specific branching in one
+* place.
+*/
+/**
+* Determine which authoring strategy a target uses, based on the shape of
+* its `TargetMigrationsCapability`. Callers that need strategy-specific
+* guarantees (e.g. that `resolveDescriptors` is present) should narrow on
+* the returned tag and trust the capability fields directly rather than
+* re-probing.
+*
+* Throws `errorTargetHasIncompleteMigrationCapabilities` (PN-MIG-2011) when
+* the capability registers neither flow. We diagnose this here rather than
+* deferring to the dispatch site so a misconfigured target gets an honest
+* "incomplete capability" error instead of being silently routed to one
+* flow and reported as missing the *other* flow's hook.
+*/
+function migrationStrategy(migrations, targetId) {
+	if (migrations.resolveDescriptors) return "descriptor";
+	if (migrations.emit) return "class-based";
+	throw errorTargetHasIncompleteMigrationCapabilities({ targetId });
+}
+
+//#endregion
+//#region src/lib/migration-emit.ts
+/**
+* Shared helper for emitting `ops.json` and attesting `migration.json` for a
+* migration package's `migration.ts`.
+*
+* Two flows are dispatched here:
+*  - Descriptor flow (Postgres): the framework evaluates `migration.ts`
+*    (which re-exports the planner's descriptor list), calls the target's
+*    `resolveDescriptors` to produce display-oriented operations, writes
+*    `ops.json`, and attests `migration.json`.
+*  - Class flow (Mongo): the target's `emit` capability dynamic-imports
+*    `migration.ts`, instantiates the default-exported `Migration` subclass
+*    (or invokes the default-exported factory function), reads `operations`,
+*    and writes `ops.json`. This helper then attests `migration.json` once
+*    the capability returns.
+*
+* In both cases attestation is owned by this helper so the on-disk artifacts
+* are guaranteed to be fully attested when emit returns.
+*
+* Note that this helper is the CLI-driven emit path. Class-flow `migration.ts`
+* files are also self-emitting via `Migration.run(...)` when run directly;
+* that path attests inside `Migration.run` and produces byte-identical
+* artifacts. This helper exists primarily to bridge descriptor-flow targets
+* and to give `migration plan` a single in-process emit dispatch.
+*
+* Used by `migration emit` (always) and `migration plan` (always, after
+* scaffolding `migration.ts`). Both flows run in-process so that structured
+* errors thrown during evaluation (notably `errorUnfilledPlaceholder` with
+* code `PN-MIG-2001`) propagate as real exceptions and the CLI's error
+* envelope renders them with full structured metadata.
+*/
+/**
+* Emit `ops.json` and attest `migrationId` for the migration package at `dir`.
+*
+* Dispatches to descriptor flow when the target implements `resolveDescriptors`,
+* otherwise to the target's `emit` capability. Throws a structured error if
+* `migration.ts` is missing or the target supports neither flow. Other
+* structured errors thrown during evaluation propagate unchanged.
+*/
+async function emitMigration(dir, ctx) {
+	if (!await hasMigrationTs(dir)) throw errorMigrationFileMissing(dir);
+	if (migrationStrategy(ctx.migrations, ctx.targetId) === "descriptor") return emitDescriptorFlow(dir, ctx.migrations, ctx);
+	if (!ctx.migrations.emit) throw errorTargetMigrationNotSupported({ why: `Target "${ctx.targetId}" does not implement the class-flow \`emit\` capability; cannot emit a migration package` });
+	return {
+		operations: await ctx.migrations.emit({
+			dir,
+			frameworkComponents: ctx.frameworkComponents
+		}),
+		migrationId: await attestMigration(dir)
+	};
+}
+/**
+* Descriptor flow: evaluate `migration.ts` to obtain a list of operation
+* descriptors, hand them to the target's `resolveDescriptors` along with the
+* manifest's contract bookends, then persist `ops.json` and attest the package.
+*/
+async function emitDescriptorFlow(dir, migrations, ctx) {
+	assert(migrations.resolveDescriptors, "emitDescriptorFlow requires resolveDescriptors; gated by caller");
+	const pkg = await readMigrationPackage(dir);
+	const descriptors = await evaluateMigrationTs(dir);
+	const operations = migrations.resolveDescriptors(descriptors, {
+		fromContract: pkg.manifest.fromContract,
+		toContract: pkg.manifest.toContract,
+		frameworkComponents: ctx.frameworkComponents
+	});
+	await writeMigrationOps(dir, operations);
+	return {
+		operations,
+		migrationId: await attestMigration(dir)
+	};
+}
+
+//#endregion
+export { migrationStrategy as n, emitMigration as t };
+//# sourceMappingURL=migration-emit-Du4DBMqz.mjs.map

package/dist/migration-emit-Du4DBMqz.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"migration-emit-Du4DBMqz.mjs","names":[],"sources":["../src/lib/migration-strategy.ts","../src/lib/migration-emit.ts"],"sourcesContent":["/**\n * Migration authoring strategy selector.\n *\n * Targets currently use one of two strategies to author `migration.ts`:\n *\n *  - **Descriptor flow** — the planner produces an `OperationDescriptor[]`\n *    and `migration.ts` is a `export default () => [...]` file that the CLI\n *    later replays through `resolveDescriptors` at emit time. Postgres uses\n *    this today.\n *  - **Class flow** — the planner produces a `MigrationPlanWithAuthoringSurface`\n *    that renders itself as a `class M extends Migration { ... }` file. The\n *    CLI dispatches to the target's `emit` capability at emit time. Mongo\n *    uses this today.\n *\n * The two are mutually exclusive at the target level: a migrations capability\n * either implements the descriptor-flow trio (`planWithDescriptors`,\n * `resolveDescriptors`, `renderDescriptorTypeScript`) or the class-flow\n * `emit` hook. `migrationStrategy` discriminates between them by observing\n * which hooks are present, and is consumed by `migration new`, `migration\n * plan`, and `migration emit` to keep strategy-specific branching in one\n * place.\n */\n\nimport { errorTargetHasIncompleteMigrationCapabilities } from '@prisma-next/errors/migration';\nimport type { TargetMigrationsCapability } from '@prisma-next/framework-components/control';\n\nexport type MigrationStrategy = 'descriptor' | 'class-based';\n\n/**\n * Determine which authoring strategy a target uses, based on the shape of\n * its `TargetMigrationsCapability`. Callers that need strategy-specific\n * guarantees (e.g. that `resolveDescriptors` is present) should narrow on\n * the returned tag and trust the capability fields directly rather than\n * re-probing.\n *\n * Throws `errorTargetHasIncompleteMigrationCapabilities` (PN-MIG-2011) when\n * the capability registers neither flow. We diagnose this here rather than\n * deferring to the dispatch site so a misconfigured target gets an honest\n * \"incomplete capability\" error instead of being silently routed to one\n * flow and reported as missing the *other* flow's hook.\n */\nexport function migrationStrategy(\n  migrations: TargetMigrationsCapability,\n  targetId: string,\n): MigrationStrategy {\n  if (migrations.resolveDescriptors) return 'descriptor';\n  if (migrations.emit) return 'class-based';\n  throw errorTargetHasIncompleteMigrationCapabilities({ targetId });\n}\n","/**\n * Shared helper for emitting `ops.json` and attesting `migration.json` for a\n * migration package's `migration.ts`.\n *\n * Two flows are dispatched here:\n *  - Descriptor flow (Postgres): the framework evaluates `migration.ts`\n *    (which re-exports the planner's descriptor list), calls the target's\n *    `resolveDescriptors` to produce display-oriented operations, writes\n *    `ops.json`, and attests `migration.json`.\n *  - Class flow (Mongo): the target's `emit` capability dynamic-imports\n *    `migration.ts`, instantiates the default-exported `Migration` subclass\n *    (or invokes the default-exported factory function), reads `operations`,\n *    and writes `ops.json`. This helper then attests `migration.json` once\n *    the capability returns.\n *\n * In both cases attestation is owned by this helper so the on-disk artifacts\n * are guaranteed to be fully attested when emit returns.\n *\n * Note that this helper is the CLI-driven emit path. Class-flow `migration.ts`\n * files are also self-emitting via `Migration.run(...)` when run directly;\n * that path attests inside `Migration.run` and produces byte-identical\n * artifacts. This helper exists primarily to bridge descriptor-flow targets\n * and to give `migration plan` a single in-process emit dispatch.\n *\n * Used by `migration emit` (always) and `migration plan` (always, after\n * scaffolding `migration.ts`). Both flows run in-process so that structured\n * errors thrown during evaluation (notably `errorUnfilledPlaceholder` with\n * code `PN-MIG-2001`) propagate as real exceptions and the CLI's error\n * envelope renders them with full structured metadata.\n */\n\nimport assert from 'node:assert/strict';\nimport type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';\nimport type {\n  MigrationPlanOperation,\n  OperationDescriptor,\n  TargetMigrationsCapability,\n} from '@prisma-next/framework-components/control';\nimport { attestMigration } from '@prisma-next/migration-tools/attestation';\nimport { readMigrationPackage, writeMigrationOps } from '@prisma-next/migration-tools/io';\nimport { evaluateMigrationTs, hasMigrationTs } from '@prisma-next/migration-tools/migration-ts';\nimport { errorMigrationFileMissing, errorTargetMigrationNotSupported } from '../utils/cli-errors';\nimport { migrationStrategy } from './migration-strategy';\n\n/**\n * Context passed to `emitMigration`. Captures everything the helper needs to\n * dispatch to the right flow without re-loading the config.\n */\nexport interface EmitMigrationContext {\n  readonly targetId: string;\n  readonly migrations: TargetMigrationsCapability;\n  readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<string, string>>;\n}\n\n/**\n * Result of a successful emit: the operations that were written to `ops.json`\n * (display-oriented shape) and the content-addressed migrationId persisted to\n * `migration.json`.\n */\nexport interface EmitMigrationResult {\n  readonly operations: readonly MigrationPlanOperation[];\n  readonly migrationId: string;\n}\n\n/**\n * Emit `ops.json` and attest `migrationId` for the migration package at `dir`.\n *\n * Dispatches to descriptor flow when the target implements `resolveDescriptors`,\n * otherwise to the target's `emit` capability. Throws a structured error if\n * `migration.ts` is missing or the target supports neither flow. Other\n * structured errors thrown during evaluation propagate unchanged.\n */\nexport async function emitMigration(\n  dir: string,\n  ctx: EmitMigrationContext,\n): Promise<EmitMigrationResult> {\n  if (!(await hasMigrationTs(dir))) {\n    throw errorMigrationFileMissing(dir);\n  }\n\n  const strategy = migrationStrategy(ctx.migrations, ctx.targetId);\n\n  if (strategy === 'descriptor') {\n    return emitDescriptorFlow(dir, ctx.migrations, ctx);\n  }\n\n  if (!ctx.migrations.emit) {\n    throw errorTargetMigrationNotSupported({\n      why: `Target \"${ctx.targetId}\" does not implement the class-flow \\`emit\\` capability; cannot emit a migration package`,\n    });\n  }\n\n  const operations = await ctx.migrations.emit({\n    dir,\n    frameworkComponents: ctx.frameworkComponents,\n  });\n  const migrationId = await attestMigration(dir);\n  return { operations, migrationId };\n}\n\n/**\n * Descriptor flow: evaluate `migration.ts` to obtain a list of operation\n * descriptors, hand them to the target's `resolveDescriptors` along with the\n * manifest's contract bookends, then persist `ops.json` and attest the package.\n */\nasync function emitDescriptorFlow(\n  dir: string,\n  migrations: TargetMigrationsCapability,\n  ctx: EmitMigrationContext,\n): Promise<EmitMigrationResult> {\n  assert(\n    migrations.resolveDescriptors,\n    'emitDescriptorFlow requires resolveDescriptors; gated by caller',\n  );\n  const pkg = await readMigrationPackage(dir);\n  const descriptors = await evaluateMigrationTs(dir);\n  const operations = migrations.resolveDescriptors(descriptors as OperationDescriptor[], {\n    fromContract: pkg.manifest.fromContract,\n    toContract: pkg.manifest.toContract,\n    frameworkComponents: ctx.frameworkComponents,\n  });\n  await writeMigrationOps(dir, operations);\n  const migrationId = await attestMigration(dir);\n  return { operations, migrationId };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,SAAgB,kBACd,YACA,UACmB;AACnB,KAAI,WAAW,mBAAoB,QAAO;AAC1C,KAAI,WAAW,KAAM,QAAO;AAC5B,OAAM,8CAA8C,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACyBnE,eAAsB,cACpB,KACA,KAC8B;AAC9B,KAAI,CAAE,MAAM,eAAe,IAAI,CAC7B,OAAM,0BAA0B,IAAI;AAKtC,KAFiB,kBAAkB,IAAI,YAAY,IAAI,SAAS,KAE/C,aACf,QAAO,mBAAmB,KAAK,IAAI,YAAY,IAAI;AAGrD,KAAI,CAAC,IAAI,WAAW,KAClB,OAAM,iCAAiC,EACrC,KAAK,WAAW,IAAI,SAAS,2FAC9B,CAAC;AAQJ,QAAO;EAAE,YALU,MAAM,IAAI,WAAW,KAAK;GAC3C;GACA,qBAAqB,IAAI;GAC1B,CAAC;EAEmB,aADD,MAAM,gBAAgB,IAAI;EACZ;;;;;;;AAQpC,eAAe,mBACb,KACA,YACA,KAC8B;AAC9B,QACE,WAAW,oBACX,kEACD;CACD,MAAM,MAAM,MAAM,qBAAqB,IAAI;CAC3C,MAAM,cAAc,MAAM,oBAAoB,IAAI;CAClD,MAAM,aAAa,WAAW,mBAAmB,aAAsC;EACrF,cAAc,IAAI,SAAS;EAC3B,YAAY,IAAI,SAAS;EACzB,qBAAqB,IAAI;EAC1B,CAAC;AACF,OAAM,kBAAkB,KAAK,WAAW;AAExC,QAAO;EAAE;EAAY,aADD,MAAM,gBAAgB,IAAI;EACZ"}

package/dist/{migration-status-BwKCQB_a.mjs → migration-status-CPamfEPj.mjs}

@@ -1,6 +1,6 @@
 import { t as loadConfig } from "./config-loader-C4VXKl8f.mjs";
 import { h as errorRuntime, v as errorUnexpected } from "./cli-errors-BUuJr6py.mjs";
-import { t as createControlClient } from "./client-DUs1DH-1.mjs";
+import { t as createControlClient } from "./client-CJxHfhze.mjs";
 import { _ as formatStyledHeader, a as maskConnectionUrl, c as resolveMigrationPaths, d as setCommandExamples, i as loadAllBundles, m as parseGlobalFlags, n as addGlobalOptions, o as readContractEnvelope, p as toPathDecisionResult, t as handleResult, u as setCommandDescriptions } from "./result-handler-AFK4hxyX.mjs";
 import { t as TerminalUI } from "./terminal-ui-C5k88MmW.mjs";
 import { Command } from "commander";
@@ -1580,4 +1580,4 @@ function summarizeRefDistance(graph, markerHash, refHash, refName) {
 
 //#endregion
 export { deriveEdgeStatuses as n, createMigrationStatusCommand as t };
-//# sourceMappingURL=migration-status-BwKCQB_a.mjs.map
+//# sourceMappingURL=migration-status-CPamfEPj.mjs.map