@prisma-next/cli 0.3.0-pr.99.6 → 0.3.0

package/dist/chunk-VG2R7DGF.js

@@ -1,735 +0,0 @@
-// src/utils/cli-errors.ts
-import {
-  CliStructuredError,
-  errorConfigFileNotFound,
-  errorConfigValidation,
-  errorContractConfigMissing,
-  errorContractMissingExtensionPacks,
-  errorContractValidationFailed,
-  errorDatabaseConnectionRequired,
-  errorDriverRequired,
-  errorFamilyReadMarkerSqlRequired,
-  errorFileNotFound,
-  errorHashMismatch,
-  errorJsonFormatNotSupported,
-  errorMarkerMissing,
-  errorMigrationPlanningFailed,
-  errorQueryRunnerFactoryRequired,
-  errorRuntime,
-  errorTargetMigrationNotSupported,
-  errorTargetMismatch,
-  errorUnexpected
-} from "@prisma-next/core-control-plane/errors";
-
-// src/control-api/client.ts
-import { createControlPlaneStack } from "@prisma-next/core-control-plane/stack";
-import { notOk as notOk2, ok as ok2 } from "@prisma-next/utils/result";
-
-// src/utils/framework-components.ts
-import {
-  checkContractComponentRequirements
-} from "@prisma-next/contract/framework-components";
-function assertFrameworkComponentsCompatible(expectedFamilyId, expectedTargetId, frameworkComponents) {
-  for (let i = 0; i < frameworkComponents.length; i++) {
-    const component = frameworkComponents[i];
-    if (typeof component !== "object" || component === null) {
-      throw errorConfigValidation("frameworkComponents[]", {
-        why: `Framework component at index ${i} must be an object`
-      });
-    }
-    const record = component;
-    if (!Object.hasOwn(record, "kind")) {
-      throw errorConfigValidation("frameworkComponents[].kind", {
-        why: `Framework component at index ${i} must have 'kind' property`
-      });
-    }
-    const kind = record["kind"];
-    if (kind !== "target" && kind !== "adapter" && kind !== "extension" && kind !== "driver") {
-      throw errorConfigValidation("frameworkComponents[].kind", {
-        why: `Framework component at index ${i} has invalid kind '${String(kind)}' (must be 'target', 'adapter', 'extension', or 'driver')`
-      });
-    }
-    if (!Object.hasOwn(record, "familyId")) {
-      throw errorConfigValidation("frameworkComponents[].familyId", {
-        why: `Framework component at index ${i} (kind: ${String(kind)}) must have 'familyId' property`
-      });
-    }
-    const familyId = record["familyId"];
-    if (familyId !== expectedFamilyId) {
-      throw errorConfigValidation("frameworkComponents[].familyId", {
-        why: `Framework component at index ${i} (kind: ${String(kind)}) has familyId '${String(familyId)}' but expected '${expectedFamilyId}'`
-      });
-    }
-    if (!Object.hasOwn(record, "targetId")) {
-      throw errorConfigValidation("frameworkComponents[].targetId", {
-        why: `Framework component at index ${i} (kind: ${String(kind)}) must have 'targetId' property`
-      });
-    }
-    const targetId = record["targetId"];
-    if (targetId !== expectedTargetId) {
-      throw errorConfigValidation("frameworkComponents[].targetId", {
-        why: `Framework component at index ${i} (kind: ${String(kind)}) has targetId '${String(targetId)}' but expected '${expectedTargetId}'`
-      });
-    }
-  }
-  return frameworkComponents;
-}
-
-// src/control-api/operations/db-init.ts
-import { notOk, ok } from "@prisma-next/utils/result";
-async function executeDbInit(options) {
-  const { driver, familyInstance, contractIR, mode, migrations, frameworkComponents, onProgress } = options;
-  const planner = migrations.createPlanner(familyInstance);
-  const runner = migrations.createRunner(familyInstance);
-  const introspectSpanId = "introspect";
-  onProgress?.({
-    action: "dbInit",
-    kind: "spanStart",
-    spanId: introspectSpanId,
-    label: "Introspecting database schema"
-  });
-  const schemaIR = await familyInstance.introspect({ driver });
-  onProgress?.({
-    action: "dbInit",
-    kind: "spanEnd",
-    spanId: introspectSpanId,
-    outcome: "ok"
-  });
-  const policy = { allowedOperationClasses: ["additive"] };
-  const planSpanId = "plan";
-  onProgress?.({
-    action: "dbInit",
-    kind: "spanStart",
-    spanId: planSpanId,
-    label: "Planning migration"
-  });
-  const plannerResult = await planner.plan({
-    contract: contractIR,
-    schema: schemaIR,
-    policy,
-    frameworkComponents
-  });
-  if (plannerResult.kind === "failure") {
-    onProgress?.({
-      action: "dbInit",
-      kind: "spanEnd",
-      spanId: planSpanId,
-      outcome: "error"
-    });
-    return notOk({
-      code: "PLANNING_FAILED",
-      summary: "Migration planning failed due to conflicts",
-      conflicts: plannerResult.conflicts,
-      why: void 0,
-      meta: void 0
-    });
-  }
-  const migrationPlan = plannerResult.plan;
-  onProgress?.({
-    action: "dbInit",
-    kind: "spanEnd",
-    spanId: planSpanId,
-    outcome: "ok"
-  });
-  const checkMarkerSpanId = "checkMarker";
-  onProgress?.({
-    action: "dbInit",
-    kind: "spanStart",
-    spanId: checkMarkerSpanId,
-    label: "Checking contract marker"
-  });
-  const existingMarker = await familyInstance.readMarker({ driver });
-  if (existingMarker) {
-    const markerMatchesDestination = existingMarker.coreHash === migrationPlan.destination.coreHash && (!migrationPlan.destination.profileHash || existingMarker.profileHash === migrationPlan.destination.profileHash);
-    if (markerMatchesDestination) {
-      onProgress?.({
-        action: "dbInit",
-        kind: "spanEnd",
-        spanId: checkMarkerSpanId,
-        outcome: "skipped"
-      });
-      const result2 = {
-        mode,
-        plan: { operations: [] },
-        ...mode === "apply" ? {
-          execution: { operationsPlanned: 0, operationsExecuted: 0 },
-          marker: {
-            coreHash: existingMarker.coreHash,
-            profileHash: existingMarker.profileHash
-          }
-        } : {},
-        summary: "Database already at target contract state"
-      };
-      return ok(result2);
-    }
-    onProgress?.({
-      action: "dbInit",
-      kind: "spanEnd",
-      spanId: checkMarkerSpanId,
-      outcome: "error"
-    });
-    return notOk({
-      code: "MARKER_ORIGIN_MISMATCH",
-      summary: "Existing contract marker does not match plan destination",
-      marker: {
-        coreHash: existingMarker.coreHash,
-        profileHash: existingMarker.profileHash
-      },
-      destination: {
-        coreHash: migrationPlan.destination.coreHash,
-        profileHash: migrationPlan.destination.profileHash
-      },
-      why: void 0,
-      conflicts: void 0,
-      meta: void 0
-    });
-  }
-  onProgress?.({
-    action: "dbInit",
-    kind: "spanEnd",
-    spanId: checkMarkerSpanId,
-    outcome: "ok"
-  });
-  if (mode === "plan") {
-    const result2 = {
-      mode: "plan",
-      plan: { operations: migrationPlan.operations },
-      summary: `Planned ${migrationPlan.operations.length} operation(s)`
-    };
-    return ok(result2);
-  }
-  const applySpanId = "apply";
-  onProgress?.({
-    action: "dbInit",
-    kind: "spanStart",
-    spanId: applySpanId,
-    label: "Applying migration plan"
-  });
-  const callbacks = onProgress ? {
-    onOperationStart: (op) => {
-      onProgress({
-        action: "dbInit",
-        kind: "spanStart",
-        spanId: `operation:${op.id}`,
-        parentSpanId: applySpanId,
-        label: op.label
-      });
-    },
-    onOperationComplete: (op) => {
-      onProgress({
-        action: "dbInit",
-        kind: "spanEnd",
-        spanId: `operation:${op.id}`,
-        outcome: "ok"
-      });
-    }
-  } : void 0;
-  const runnerResult = await runner.execute({
-    plan: migrationPlan,
-    driver,
-    destinationContract: contractIR,
-    policy,
-    ...callbacks ? { callbacks } : {},
-    // db init plans and applies back-to-back from a fresh introspection, so per-operation
-    // pre/postchecks and the idempotency probe are usually redundant overhead. We still
-    // enforce marker/origin compatibility and a full schema verification after apply.
-    executionChecks: {
-      prechecks: false,
-      postchecks: false,
-      idempotencyChecks: false
-    },
-    frameworkComponents
-  });
-  if (!runnerResult.ok) {
-    onProgress?.({
-      action: "dbInit",
-      kind: "spanEnd",
-      spanId: applySpanId,
-      outcome: "error"
-    });
-    return notOk({
-      code: "RUNNER_FAILED",
-      summary: runnerResult.failure.summary,
-      why: runnerResult.failure.why,
-      meta: runnerResult.failure.meta,
-      conflicts: void 0
-    });
-  }
-  const execution = runnerResult.value;
-  onProgress?.({
-    action: "dbInit",
-    kind: "spanEnd",
-    spanId: applySpanId,
-    outcome: "ok"
-  });
-  const result = {
-    mode: "apply",
-    plan: { operations: migrationPlan.operations },
-    execution: {
-      operationsPlanned: execution.operationsPlanned,
-      operationsExecuted: execution.operationsExecuted
-    },
-    marker: migrationPlan.destination.profileHash ? {
-      coreHash: migrationPlan.destination.coreHash,
-      profileHash: migrationPlan.destination.profileHash
-    } : { coreHash: migrationPlan.destination.coreHash },
-    summary: `Applied ${execution.operationsExecuted} operation(s), marker written`
-  };
-  return ok(result);
-}
-
-// src/control-api/client.ts
-function createControlClient(options) {
-  return new ControlClientImpl(options);
-}
-var ControlClientImpl = class {
-  options;
-  stack = null;
-  driver = null;
-  familyInstance = null;
-  frameworkComponents = null;
-  initialized = false;
-  defaultConnection;
-  constructor(options) {
-    this.options = options;
-    this.defaultConnection = options.connection;
-  }
-  init() {
-    if (this.initialized) {
-      return;
-    }
-    this.stack = createControlPlaneStack({
-      target: this.options.target,
-      adapter: this.options.adapter,
-      driver: this.options.driver,
-      extensionPacks: this.options.extensionPacks
-    });
-    this.familyInstance = this.options.family.create(this.stack);
-    const rawComponents = [
-      this.options.target,
-      this.options.adapter,
-      ...this.options.extensionPacks ?? []
-    ];
-    this.frameworkComponents = assertFrameworkComponentsCompatible(
-      this.options.family.familyId,
-      this.options.target.targetId,
-      rawComponents
-    );
-    this.initialized = true;
-  }
-  async connect(connection) {
-    this.init();
-    if (this.driver) {
-      throw new Error("Already connected. Call close() before reconnecting.");
-    }
-    const resolvedConnection = connection ?? this.defaultConnection;
-    if (resolvedConnection === void 0) {
-      throw new Error(
-        "No connection provided. Pass a connection to connect() or provide a default connection when creating the client."
-      );
-    }
-    if (!this.stack?.driver) {
-      throw new Error(
-        "Driver is not configured. Pass a driver descriptor when creating the control client to enable database operations."
-      );
-    }
-    this.driver = await this.stack?.driver.create(resolvedConnection);
-  }
-  async close() {
-    if (this.driver) {
-      await this.driver.close();
-      this.driver = null;
-    }
-  }
-  async ensureConnected() {
-    this.init();
-    if (!this.driver && this.defaultConnection !== void 0) {
-      await this.connect(this.defaultConnection);
-    }
-    if (!this.driver || !this.familyInstance || !this.frameworkComponents) {
-      throw new Error("Not connected. Call connect(connection) first.");
-    }
-    return {
-      driver: this.driver,
-      familyInstance: this.familyInstance,
-      frameworkComponents: this.frameworkComponents
-    };
-  }
-  async verify(options) {
-    const { onProgress } = options;
-    if (options.connection !== void 0) {
-      onProgress?.({
-        action: "verify",
-        kind: "spanStart",
-        spanId: "connect",
-        label: "Connecting to database..."
-      });
-      try {
-        await this.connect(options.connection);
-        onProgress?.({
-          action: "verify",
-          kind: "spanEnd",
-          spanId: "connect",
-          outcome: "ok"
-        });
-      } catch (error) {
-        onProgress?.({
-          action: "verify",
-          kind: "spanEnd",
-          spanId: "connect",
-          outcome: "error"
-        });
-        throw error;
-      }
-    }
-    const { driver, familyInstance } = await this.ensureConnected();
-    const contractIR = familyInstance.validateContractIR(options.contractIR);
-    onProgress?.({
-      action: "verify",
-      kind: "spanStart",
-      spanId: "verify",
-      label: "Verifying contract marker..."
-    });
-    try {
-      const result = await familyInstance.verify({
-        driver,
-        contractIR,
-        expectedTargetId: this.options.target.targetId,
-        contractPath: ""
-      });
-      onProgress?.({
-        action: "verify",
-        kind: "spanEnd",
-        spanId: "verify",
-        outcome: result.ok ? "ok" : "error"
-      });
-      return result;
-    } catch (error) {
-      onProgress?.({
-        action: "verify",
-        kind: "spanEnd",
-        spanId: "verify",
-        outcome: "error"
-      });
-      throw error;
-    }
-  }
-  async schemaVerify(options) {
-    const { onProgress } = options;
-    if (options.connection !== void 0) {
-      onProgress?.({
-        action: "schemaVerify",
-        kind: "spanStart",
-        spanId: "connect",
-        label: "Connecting to database..."
-      });
-      try {
-        await this.connect(options.connection);
-        onProgress?.({
-          action: "schemaVerify",
-          kind: "spanEnd",
-          spanId: "connect",
-          outcome: "ok"
-        });
-      } catch (error) {
-        onProgress?.({
-          action: "schemaVerify",
-          kind: "spanEnd",
-          spanId: "connect",
-          outcome: "error"
-        });
-        throw error;
-      }
-    }
-    const { driver, familyInstance, frameworkComponents } = await this.ensureConnected();
-    const contractIR = familyInstance.validateContractIR(options.contractIR);
-    onProgress?.({
-      action: "schemaVerify",
-      kind: "spanStart",
-      spanId: "schemaVerify",
-      label: "Verifying database schema..."
-    });
-    try {
-      const result = await familyInstance.schemaVerify({
-        driver,
-        contractIR,
-        strict: options.strict ?? false,
-        contractPath: "",
-        frameworkComponents
-      });
-      onProgress?.({
-        action: "schemaVerify",
-        kind: "spanEnd",
-        spanId: "schemaVerify",
-        outcome: result.ok ? "ok" : "error"
-      });
-      return result;
-    } catch (error) {
-      onProgress?.({
-        action: "schemaVerify",
-        kind: "spanEnd",
-        spanId: "schemaVerify",
-        outcome: "error"
-      });
-      throw error;
-    }
-  }
-  async sign(options) {
-    const { onProgress } = options;
-    if (options.connection !== void 0) {
-      onProgress?.({
-        action: "sign",
-        kind: "spanStart",
-        spanId: "connect",
-        label: "Connecting to database..."
-      });
-      try {
-        await this.connect(options.connection);
-        onProgress?.({
-          action: "sign",
-          kind: "spanEnd",
-          spanId: "connect",
-          outcome: "ok"
-        });
-      } catch (error) {
-        onProgress?.({
-          action: "sign",
-          kind: "spanEnd",
-          spanId: "connect",
-          outcome: "error"
-        });
-        throw error;
-      }
-    }
-    const { driver, familyInstance } = await this.ensureConnected();
-    const contractIR = familyInstance.validateContractIR(options.contractIR);
-    onProgress?.({
-      action: "sign",
-      kind: "spanStart",
-      spanId: "sign",
-      label: "Signing database..."
-    });
-    try {
-      const result = await familyInstance.sign({
-        driver,
-        contractIR,
-        contractPath: options.contractPath ?? "",
-        ...options.configPath ? { configPath: options.configPath } : {}
-      });
-      onProgress?.({
-        action: "sign",
-        kind: "spanEnd",
-        spanId: "sign",
-        outcome: "ok"
-      });
-      return result;
-    } catch (error) {
-      onProgress?.({
-        action: "sign",
-        kind: "spanEnd",
-        spanId: "sign",
-        outcome: "error"
-      });
-      throw error;
-    }
-  }
-  async dbInit(options) {
-    const { onProgress } = options;
-    if (options.connection !== void 0) {
-      onProgress?.({
-        action: "dbInit",
-        kind: "spanStart",
-        spanId: "connect",
-        label: "Connecting to database..."
-      });
-      try {
-        await this.connect(options.connection);
-        onProgress?.({
-          action: "dbInit",
-          kind: "spanEnd",
-          spanId: "connect",
-          outcome: "ok"
-        });
-      } catch (error) {
-        onProgress?.({
-          action: "dbInit",
-          kind: "spanEnd",
-          spanId: "connect",
-          outcome: "error"
-        });
-        throw error;
-      }
-    }
-    const { driver, familyInstance, frameworkComponents } = await this.ensureConnected();
-    if (!this.options.target.migrations) {
-      throw new Error(`Target "${this.options.target.targetId}" does not support migrations`);
-    }
-    const contractIR = familyInstance.validateContractIR(options.contractIR);
-    return executeDbInit({
-      driver,
-      familyInstance,
-      contractIR,
-      mode: options.mode,
-      migrations: this.options.target.migrations,
-      frameworkComponents,
-      ...onProgress ? { onProgress } : {}
-    });
-  }
-  async introspect(options) {
-    const onProgress = options?.onProgress;
-    if (options?.connection !== void 0) {
-      onProgress?.({
-        action: "introspect",
-        kind: "spanStart",
-        spanId: "connect",
-        label: "Connecting to database..."
-      });
-      try {
-        await this.connect(options.connection);
-        onProgress?.({
-          action: "introspect",
-          kind: "spanEnd",
-          spanId: "connect",
-          outcome: "ok"
-        });
-      } catch (error) {
-        onProgress?.({
-          action: "introspect",
-          kind: "spanEnd",
-          spanId: "connect",
-          outcome: "error"
-        });
-        throw error;
-      }
-    }
-    const { driver, familyInstance } = await this.ensureConnected();
-    const _schema = options?.schema;
-    void _schema;
-    onProgress?.({
-      action: "introspect",
-      kind: "spanStart",
-      spanId: "introspect",
-      label: "Introspecting database schema..."
-    });
-    try {
-      const result = await familyInstance.introspect({ driver });
-      onProgress?.({
-        action: "introspect",
-        kind: "spanEnd",
-        spanId: "introspect",
-        outcome: "ok"
-      });
-      return result;
-    } catch (error) {
-      onProgress?.({
-        action: "introspect",
-        kind: "spanEnd",
-        spanId: "introspect",
-        outcome: "error"
-      });
-      throw error;
-    }
-  }
-  toSchemaView(schemaIR) {
-    this.init();
-    if (this.familyInstance?.toSchemaView) {
-      return this.familyInstance.toSchemaView(schemaIR);
-    }
-    return void 0;
-  }
-  async emit(options) {
-    const { onProgress, contractConfig } = options;
-    this.init();
-    if (!this.familyInstance) {
-      throw new Error("Family instance was not initialized. This is a bug.");
-    }
-    let contractRaw;
-    onProgress?.({
-      action: "emit",
-      kind: "spanStart",
-      spanId: "resolveSource",
-      label: "Resolving contract source..."
-    });
-    try {
-      switch (contractConfig.source.kind) {
-        case "loader":
-          contractRaw = await contractConfig.source.load();
-          break;
-        case "value":
-          contractRaw = contractConfig.source.value;
-          break;
-      }
-      onProgress?.({
-        action: "emit",
-        kind: "spanEnd",
-        spanId: "resolveSource",
-        outcome: "ok"
-      });
-    } catch (error) {
-      onProgress?.({
-        action: "emit",
-        kind: "spanEnd",
-        spanId: "resolveSource",
-        outcome: "error"
-      });
-      return notOk2({
-        code: "CONTRACT_SOURCE_INVALID",
-        summary: "Failed to resolve contract source",
-        why: error instanceof Error ? error.message : String(error),
-        meta: void 0
-      });
-    }
-    onProgress?.({
-      action: "emit",
-      kind: "spanStart",
-      spanId: "emit",
-      label: "Emitting contract..."
-    });
-    try {
-      const emitResult = await this.familyInstance.emitContract({ contractIR: contractRaw });
-      onProgress?.({
-        action: "emit",
-        kind: "spanEnd",
-        spanId: "emit",
-        outcome: "ok"
-      });
-      return ok2({
-        coreHash: emitResult.coreHash,
-        profileHash: emitResult.profileHash,
-        contractJson: emitResult.contractJson,
-        contractDts: emitResult.contractDts
-      });
-    } catch (error) {
-      onProgress?.({
-        action: "emit",
-        kind: "spanEnd",
-        spanId: "emit",
-        outcome: "error"
-      });
-      return notOk2({
-        code: "EMIT_FAILED",
-        summary: "Failed to emit contract",
-        why: error instanceof Error ? error.message : String(error),
-        meta: void 0
-      });
-    }
-  }
-};
-
-export {
-  CliStructuredError,
-  errorContractValidationFailed,
-  errorDatabaseConnectionRequired,
-  errorDriverRequired,
-  errorFileNotFound,
-  errorHashMismatch,
-  errorJsonFormatNotSupported,
-  errorMarkerMissing,
-  errorMigrationPlanningFailed,
-  errorRuntime,
-  errorTargetMigrationNotSupported,
-  errorTargetMismatch,
-  errorUnexpected,
-  createControlClient
-};
-//# sourceMappingURL=chunk-VG2R7DGF.js.map