@prisma-next/cli 0.4.0-dev.9 → 0.5.0-dev.1

package/src/commands/migration-emit.ts

@@ -1,134 +0,0 @@
-import { MigrationToolsError } from '@prisma-next/migration-tools/types';
-import { notOk, ok, type Result } from '@prisma-next/utils/result';
-import { Command } from 'commander';
-import { loadConfig } from '../config-loader';
-import { emitMigration } from '../lib/migration-emit';
-import {
-  CliStructuredError,
-  errorRuntime,
-  errorTargetMigrationNotSupported,
-  errorUnexpected,
-} from '../utils/cli-errors';
-import {
-  addGlobalOptions,
-  getTargetMigrations,
-  setCommandDescriptions,
-  setCommandExamples,
-} from '../utils/command-helpers';
-import { formatMigrationEmitCommandOutput } from '../utils/formatters/migrations';
-import { formatStyledHeader } from '../utils/formatters/styled';
-import { assertFrameworkComponentsCompatible } from '../utils/framework-components';
-import type { CommonCommandOptions } from '../utils/global-flags';
-import { type GlobalFlags, parseGlobalFlags } from '../utils/global-flags';
-import { handleResult } from '../utils/result-handler';
-import { TerminalUI } from '../utils/terminal-ui';
-
-export interface MigrationEmitOptions extends CommonCommandOptions {
-  readonly dir: string;
-  readonly config?: string;
-}
-
-export interface MigrationEmitResult {
-  readonly ok: boolean;
-  readonly dir: string;
-  readonly migrationId: string;
-  readonly summary: string;
-}
-
-async function executeMigrationEmitCommand(
-  options: MigrationEmitOptions,
-  flags: GlobalFlags,
-  ui: TerminalUI,
-): Promise<Result<MigrationEmitResult, CliStructuredError>> {
-  const dir = options.dir;
-
-  if (!flags.json && !flags.quiet) {
-    const header = formatStyledHeader({
-      command: 'migration emit',
-      description: 'Emit ops.json from migration.ts and compute migrationId',
-      details: [{ label: 'dir', value: dir }],
-      flags,
-    });
-    ui.stderr(header);
-  }
-
-  try {
-    const config = await loadConfig(options.config);
-    const migrations = getTargetMigrations(config.target);
-    if (!migrations) {
-      throw errorTargetMigrationNotSupported({
-        why: `Target "${config.target.id}" does not support migrations`,
-      });
-    }
-    const frameworkComponents = assertFrameworkComponentsCompatible(
-      config.family.familyId,
-      config.target.targetId,
-      [config.target, config.adapter, ...(config.extensionPacks ?? [])],
-    );
-
-    const { migrationId } = await emitMigration(dir, {
-      targetId: config.target.targetId,
-      migrations,
-      frameworkComponents,
-    });
-
-    return ok({
-      ok: true,
-      dir,
-      migrationId,
-      summary: `Emitted ops.json and attested migrationId: ${migrationId}`,
-    });
-  } catch (error) {
-    if (CliStructuredError.is(error)) {
-      return notOk(error);
-    }
-    if (MigrationToolsError.is(error)) {
-      return notOk(
-        errorRuntime(error.message, {
-          why: error.why,
-          fix: error.fix,
-          meta: { code: error.code, ...(error.details ?? {}) },
-        }),
-      );
-    }
-    return notOk(
-      errorUnexpected(error instanceof Error ? error.message : String(error), {
-        why: `Failed to emit migration: ${error instanceof Error ? error.message : String(error)}`,
-      }),
-    );
-  }
-}
-
-export function createMigrationEmitCommand(): Command {
-  const command = new Command('emit');
-  setCommandDescriptions(
-    command,
-    'Emit ops.json from migration.ts and compute migrationId',
-    'Evaluates migration.ts in the package directory, resolves it to ops.json,\n' +
-      'then computes and persists the content-addressed migrationId in migration.json.\n' +
-      'If the file contains unfilled placeholder() slots, emit fails with PN-MIG-2001\n' +
-      'and reports the slot to fill in.',
-  );
-  setCommandExamples(command, ['prisma-next migration emit --dir migrations/20250101-add-users']);
-  addGlobalOptions(command)
-    .requiredOption('--dir <path>', 'Path to the migration package directory')
-    .option('--config <path>', 'Path to prisma-next.config.ts')
-    .action(async (options: MigrationEmitOptions) => {
-      const flags = parseGlobalFlags(options);
-      const ui = new TerminalUI({ color: flags.color, interactive: flags.interactive });
-
-      const result = await executeMigrationEmitCommand(options, flags, ui);
-
-      const exitCode = handleResult(result, flags, ui, (emitResult) => {
-        if (flags.json) {
-          ui.output(JSON.stringify(emitResult, null, 2));
-        } else if (!flags.quiet) {
-          ui.log(formatMigrationEmitCommandOutput(emitResult, flags));
-        }
-      });
-
-      process.exit(exitCode);
-    });
-
-  return command;
-}

package/src/lib/migration-emit.ts

@@ -1,125 +0,0 @@
-/**
- * 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.
- */
-
-import assert from 'node:assert/strict';
-import type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';
-import type {
-  MigrationPlanOperation,
-  OperationDescriptor,
-  TargetMigrationsCapability,
-} from '@prisma-next/framework-components/control';
-import { attestMigration } from '@prisma-next/migration-tools/attestation';
-import { readMigrationPackage, writeMigrationOps } from '@prisma-next/migration-tools/io';
-import { evaluateMigrationTs, hasMigrationTs } from '@prisma-next/migration-tools/migration-ts';
-import { errorMigrationFileMissing, errorTargetMigrationNotSupported } from '../utils/cli-errors';
-import { migrationStrategy } from './migration-strategy';
-
-/**
- * Context passed to `emitMigration`. Captures everything the helper needs to
- * dispatch to the right flow without re-loading the config.
- */
-export interface EmitMigrationContext {
-  readonly targetId: string;
-  readonly migrations: TargetMigrationsCapability;
-  readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<string, string>>;
-}
-
-/**
- * Result of a successful emit: the operations that were written to `ops.json`
- * (display-oriented shape) and the content-addressed migrationId persisted to
- * `migration.json`.
- */
-export interface EmitMigrationResult {
-  readonly operations: readonly MigrationPlanOperation[];
-  readonly migrationId: string;
-}
-
-/**
- * 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.
- */
-export async function emitMigration(
-  dir: string,
-  ctx: EmitMigrationContext,
-): Promise<EmitMigrationResult> {
-  if (!(await hasMigrationTs(dir))) {
-    throw errorMigrationFileMissing(dir);
-  }
-
-  const strategy = migrationStrategy(ctx.migrations, ctx.targetId);
-
-  if (strategy === '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`,
-    });
-  }
-
-  const operations = await ctx.migrations.emit({
-    dir,
-    frameworkComponents: ctx.frameworkComponents,
-  });
-  const migrationId = await attestMigration(dir);
-  return { operations, migrationId };
-}
-
-/**
- * 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: string,
-  migrations: TargetMigrationsCapability,
-  ctx: EmitMigrationContext,
-): Promise<EmitMigrationResult> {
-  assert(
-    migrations.resolveDescriptors,
-    'emitDescriptorFlow requires resolveDescriptors; gated by caller',
-  );
-  const pkg = await readMigrationPackage(dir);
-  const descriptors = await evaluateMigrationTs(dir);
-  const operations = migrations.resolveDescriptors(descriptors as OperationDescriptor[], {
-    fromContract: pkg.manifest.fromContract,
-    toContract: pkg.manifest.toContract,
-    frameworkComponents: ctx.frameworkComponents,
-  });
-  await writeMigrationOps(dir, operations);
-  const migrationId = await attestMigration(dir);
-  return { operations, migrationId };
-}

package/src/lib/migration-strategy.ts

@@ -1,49 +0,0 @@
-/**
- * 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.
- */
-
-import { errorTargetHasIncompleteMigrationCapabilities } from '@prisma-next/errors/migration';
-import type { TargetMigrationsCapability } from '@prisma-next/framework-components/control';
-
-export type MigrationStrategy = 'descriptor' | 'class-based';
-
-/**
- * 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.
- */
-export function migrationStrategy(
-  migrations: TargetMigrationsCapability,
-  targetId: string,
-): MigrationStrategy {
-  if (migrations.resolveDescriptors) return 'descriptor';
-  if (migrations.emit) return 'class-based';
-  throw errorTargetHasIncompleteMigrationCapabilities({ targetId });
-}