@prisma-next/cli 0.3.0-pr.94.3 → 0.3.0-pr.95.2

package/dist/client-CoxxGz_7.mjs

@@ -1,692 +0,0 @@
-import { CliStructuredError, errorConfigValidation, errorContractValidationFailed, errorDatabaseConnectionRequired, errorDriverRequired, errorFileNotFound, errorHashMismatch, errorJsonFormatNotSupported, errorMarkerMissing, errorMigrationPlanningFailed, errorRuntime, errorTargetMigrationNotSupported, errorTargetMismatch, errorUnexpected as errorUnexpected$1 } from "@prisma-next/core-control-plane/errors";
-import { notOk, ok } from "@prisma-next/utils/result";
-import { createControlPlaneStack } from "@prisma-next/core-control-plane/stack";
-import "@prisma-next/contract/framework-components";
-
-//#region src/utils/framework-components.ts
-/**
-* Asserts that all framework components are compatible with the expected family and target.
-*
-* This function validates that each component in the framework components array:
-* - Has kind 'target', 'adapter', 'extension', or 'driver'
-* - Has familyId matching expectedFamilyId
-* - Has targetId matching expectedTargetId
-*
-* This validation happens at the CLI composition boundary, before passing components
-* to typed planner/runner instances. It fills the gap between runtime validation
-* (via `validateConfig()`) and compile-time type enforcement.
-*
-* @param expectedFamilyId - The expected family ID (e.g., 'sql')
-* @param expectedTargetId - The expected target ID (e.g., 'postgres')
-* @param frameworkComponents - Array of framework components to validate
-* @returns The same array typed as TargetBoundComponentDescriptor
-* @throws CliStructuredError if any component is incompatible
-*
-* @example
-* ```ts
-* const config = await loadConfig();
-* const frameworkComponents = [config.target, config.adapter, ...(config.extensionPacks ?? [])];
-*
-* // Validate and type-narrow components before passing to planner
-* const typedComponents = assertFrameworkComponentsCompatible(
-*   config.family.familyId,
-*   config.target.targetId,
-*   frameworkComponents
-* );
-*
-* const planner = target.migrations.createPlanner(familyInstance);
-* planner.plan({ contract, schema, policy, frameworkComponents: typedComponents });
-* ```
-*/
-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;
-}
-
-//#endregion
-//#region src/control-api/operations/db-init.ts
-/**
-* Executes the dbInit operation.
-*
-* This is the core logic extracted from the CLI command, without any file I/O,
-* process.exit(), or console output. It uses the Result pattern to return
-* success or failure details.
-*
-* @param options - The options for executing dbInit
-* @returns Result with DbInitSuccess on success, DbInitFailure on failure
-*/
-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) {
-		if (existingMarker.coreHash === migrationPlan.destination.coreHash && (!migrationPlan.destination.profileHash || existingMarker.profileHash === migrationPlan.destination.profileHash)) {
-			onProgress?.({
-				action: "dbInit",
-				kind: "spanEnd",
-				spanId: checkMarkerSpanId,
-				outcome: "skipped"
-			});
-			return ok({
-				mode,
-				plan: { operations: [] },
-				...mode === "apply" ? {
-					execution: {
-						operationsPlanned: 0,
-						operationsExecuted: 0
-					},
-					marker: {
-						coreHash: existingMarker.coreHash,
-						profileHash: existingMarker.profileHash
-					}
-				} : {},
-				summary: "Database already at target contract state"
-			});
-		}
-		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") return ok({
-		mode: "plan",
-		plan: { operations: migrationPlan.operations },
-		summary: `Planned ${migrationPlan.operations.length} operation(s)`
-	});
-	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 } : {},
-		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"
-	});
-	return ok({
-		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`
-	});
-}
-
-//#endregion
-//#region src/control-api/client.ts
-/**
-* Creates a programmatic control client for Prisma Next operations.
-*
-* The client accepts framework component descriptors at creation time,
-* manages driver lifecycle via connect()/close(), and exposes domain
-* operations that delegate to the existing family instance methods.
-*
-* @see {@link ControlClient} for the client interface
-* @see README.md "Programmatic Control API" section for usage examples
-*/
-function createControlClient(options) {
-	return new ControlClientImpl(options);
-}
-/**
-* Implementation of ControlClient.
-* Manages initialization and connection state, delegates operations to family instance.
-*/
-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`);
-		return executeDbInit({
-			driver,
-			familyInstance,
-			contractIR: familyInstance.validateContractIR(options.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();
-		options?.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);
-	}
-	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 notOk({
-				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 ok({
-				coreHash: emitResult.coreHash,
-				profileHash: emitResult.profileHash,
-				contractJson: emitResult.contractJson,
-				contractDts: emitResult.contractDts
-			});
-		} catch (error) {
-			onProgress?.({
-				action: "emit",
-				kind: "spanEnd",
-				spanId: "emit",
-				outcome: "error"
-			});
-			return notOk({
-				code: "EMIT_FAILED",
-				summary: "Failed to emit contract",
-				why: error instanceof Error ? error.message : String(error),
-				meta: void 0
-			});
-		}
-	}
-};
-
-//#endregion
-export { errorDriverRequired as a, errorJsonFormatNotSupported as c, errorRuntime as d, errorTargetMigrationNotSupported as f, errorDatabaseConnectionRequired as i, errorMarkerMissing as l, errorUnexpected$1 as m, CliStructuredError as n, errorFileNotFound as o, errorTargetMismatch as p, errorContractValidationFailed as r, errorHashMismatch as s, createControlClient as t, errorMigrationPlanningFailed as u };
-//# sourceMappingURL=client-CoxxGz_7.mjs.map