@prisma-next/family-sql 0.12.0-dev.4 → 0.12.0-dev.40

package/dist/control.mjs

@@ -1,18 +1,18 @@
 import { n as sqlFamilyAuthoringFieldPresets, t as sqlFamilyAuthoringTypes } from "./authoring-type-constructors-F4JpCJl7.mjs";
 import { t as SqlContractSerializer } from "./sql-contract-serializer-8axtK4lg.mjs";
-import { a as extractCodecControlHooks, t as verifySqlSchema } from "./verify-sql-schema-CYLsGCFO.mjs";
+import { a as extractCodecControlHooks, t as verifySqlSchema } from "./verify-sql-schema-fljAiO-C.mjs";
 import { t as collectSupportedCodecTypeIds } from "./verify-Crewz6hG.mjs";
 import { n as temporalAuthoringPresets, r as timestampNowControlDescriptor } from "./timestamp-now-generator-BkjCQIde.mjs";
 import { sqlEmission } from "@prisma-next/sql-contract-emitter";
 import { APP_SPACE_ID, SchemaTreeNode, VERIFY_CODE_HASH_MISMATCH, VERIFY_CODE_MARKER_MISSING, VERIFY_CODE_TARGET_MISMATCH, assembleAuthoringContributions } from "@prisma-next/framework-components/control";
 import { assertDescriptorSelfConsistency } from "@prisma-next/migration-tools/spaces";
 import { sqlContractCanonicalizationHooks } from "@prisma-next/sql-contract/canonicalization-hooks";
-import { ensureSchemaStatement, ensureTableStatement, writeContractMarker } from "@prisma-next/sql-runtime";
 import { defaultIndexName } from "@prisma-next/sql-schema-ir/naming";
 import { ifDefined } from "@prisma-next/utils/defined";
 import { UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
 import { StorageTable, isPostgresEnumStorageEntry, isStorageTypeInstance, toStorageTypeInstance } from "@prisma-next/sql-contract/types";
 import { UNSPECIFIED_PSL_NAMESPACE_ID } from "@prisma-next/framework-components/psl-ast";
+import { effectiveControlPolicy } from "@prisma-next/contract/types";
 import { notOk, ok } from "@prisma-next/utils/result";
 //#region src/core/operation-preview.ts
 function isDdlStatement(sqlStatement) {
@@ -1057,9 +1057,6 @@ function createVerifyResult(options) {
 	if (options.codecCoverageSkipped) result.codecCoverageSkipped = options.codecCoverageSkipped;
 	return result;
 }
-function isSqlControlAdapter(value) {
-	return typeof value === "object" && value !== null && "introspect" in value && typeof value.introspect === "function" && "readMarker" in value && typeof value.readMarker === "function" && "readAllMarkers" in value && typeof value.readAllMarkers === "function" && "lower" in value && typeof value.lower === "function";
-}
 function buildSqlTypeMetadataRegistry(options) {
 	const { target, adapter, extensionPacks: extensions } = options;
 	const registry = /* @__PURE__ */ new Map();
@@ -1103,11 +1100,7 @@ function createSqlFamilyInstance(stack) {
 		adapter,
 		extensionPacks: extensions
 	});
-	const getControlAdapter = () => {
-		const controlAdapter = adapter.create(stack);
-		if (!isSqlControlAdapter(controlAdapter)) throw new Error("Adapter does not implement SqlControlAdapter (missing introspect, readMarker, or readAllMarkers)");
-		return controlAdapter;
-	};
+	const getControlAdapter = () => adapter.create(stack);
 	const targetSerializer = target.contractSerializer;
 	const deserializeWithTargetSerializer = (contractJson) => {
 		return (targetSerializer ?? new SqlContractSerializer()).deserializeContract(contractJson);
@@ -1223,6 +1216,7 @@ function createSqlFamilyInstance(stack) {
 				frameworkComponents: options.frameworkComponents,
 				...ifDefined("normalizeDefault", controlAdapter.normalizeDefault),
 				...ifDefined("normalizeNativeType", controlAdapter.normalizeNativeType),
+				...ifDefined("columnsCompatible", controlAdapter.columnsCompatible),
 				...ifDefined("resolveExistingEnumValues", resolveExistingEnumValues)
 			});
 		},
@@ -1233,21 +1227,21 @@ function createSqlFamilyInstance(stack) {
 			const contractStorageHash = contract.storage.storageHash;
 			const contractProfileHash = "profileHash" in contract && typeof contract.profileHash === "string" ? contract.profileHash : contractStorageHash;
 			const contractTarget = contract.target;
-			await driver.query(ensureSchemaStatement.sql, ensureSchemaStatement.params);
-			await driver.query(ensureTableStatement.sql, ensureTableStatement.params);
-			const existingMarker = await getControlAdapter().readMarker(driver, APP_SPACE_ID);
+			const controlAdapter = getControlAdapter();
+			const lowererContext = { contract };
+			for (const query of controlAdapter.bootstrapSignMarkerQueries()) {
+				const lowered = controlAdapter.lower(query, lowererContext);
+				await driver.query(lowered.sql, lowered.params);
+			}
+			const existingMarker = await controlAdapter.readMarker(driver, APP_SPACE_ID);
 			let markerCreated = false;
 			let markerUpdated = false;
 			let previousHashes;
 			if (!existingMarker) {
-				const write = writeContractMarker({
-					space: APP_SPACE_ID,
+				await controlAdapter.insertMarker(driver, APP_SPACE_ID, {
 					storageHash: contractStorageHash,
-					profileHash: contractProfileHash,
-					contractJson: contractInput,
-					canonicalVersion: 1
+					profileHash: contractProfileHash
 				});
-				await driver.query(write.insert.sql, write.insert.params);
 				markerCreated = true;
 			} else {
 				const existingStorageHash = existingMarker.storageHash;
@@ -1257,14 +1251,10 @@ function createSqlFamilyInstance(stack) {
 						storageHash: existingStorageHash,
 						profileHash: existingProfileHash
 					};
-					const write = writeContractMarker({
-						space: APP_SPACE_ID,
+					if (!await controlAdapter.updateMarker(driver, APP_SPACE_ID, existingStorageHash, {
 						storageHash: contractStorageHash,
-						profileHash: contractProfileHash,
-						contractJson: contractInput,
-						canonicalVersion: existingMarker.canonicalVersion ?? 1
-					});
-					await driver.query(write.update.sql, write.update.params);
+						profileHash: contractProfileHash
+					})) throw new Error("CAS conflict: marker was modified by another process during sign");
 					markerUpdated = true;
 				}
 			}
@@ -1302,6 +1292,18 @@ function createSqlFamilyInstance(stack) {
 		async readAllMarkers(options) {
 			return getControlAdapter().readAllMarkers(options.driver);
 		},
+		async readLedger(options) {
+			return getControlAdapter().readLedger(options.driver, options.space);
+		},
+		async initMarker(options) {
+			return getControlAdapter().initMarker(options.driver, options.space, options.destination);
+		},
+		async updateMarker(options) {
+			return getControlAdapter().updateMarker(options.driver, options.space, options.expectedFrom, options.destination);
+		},
+		async writeLedgerEntry(options) {
+			return getControlAdapter().writeLedgerEntry(options.driver, options.space, options.entry);
+		},
 		async introspect(options) {
 			return getControlAdapter().introspect(options.driver, options.contract);
 		},
@@ -1311,6 +1313,12 @@ function createSqlFamilyInstance(stack) {
 		lowerAst(ast, context) {
 			return getControlAdapter().lower(ast, context);
 		},
+		bootstrapControlTableQueries() {
+			return getControlAdapter().bootstrapControlTableQueries();
+		},
+		bootstrapSignMarkerQueries() {
+			return getControlAdapter().bootstrapSignMarkerQueries();
+		},
 		toOperationPreview(operations) {
 			return sqlOperationsToPreview(operations);
 		},
@@ -1616,6 +1624,176 @@ function deriveAnnotations(storage, annotationNamespace, resolveEnumStorageKey)
 	return { [annotationNamespace]: { storageTypes } };
 }
 //#endregion
+//#region src/core/migrations/control-policy.ts
+/**
+* The control policy that governs a single call. The `external` default is an
+* un-overridable namespace floor: when the contract default is `external`, no
+* per-object `managed` override can escalate DDL above the floor, so the
+* policy is forced to `external` regardless of the node's own declaration.
+* Every other default defers to the node's effective control policy.
+*/
+function controlPolicyForCall(subject, defaultControlPolicy) {
+	if (defaultControlPolicy === "external") return "external";
+	return effectiveControlPolicy(subject?.explicitNodeControlPolicy, defaultControlPolicy);
+}
+/**
+* Whether a call is allowed to emit under a given control policy.
+*
+* - `managed` — full lifecycle, every op allowed.
+* - `tolerated` — create-if-absent only: allowed iff the call creates a whole
+*   new top-level object (and its subject was positively resolved). Anything
+*   that modifies an existing object, and anything whose subject could not be
+*   resolved, is suppressed.
+* - `external` / `observed` — no DDL at all.
+*/
+function callAllowedUnderControlPolicy(policy, subject) {
+	switch (policy) {
+		case "managed": return true;
+		case "tolerated": return subject?.createsNewObject === true;
+		case "external":
+		case "observed": return false;
+	}
+}
+function defaultSubjectLabel(factoryName, subject) {
+	if (subject?.table) return `${factoryName}(${subject.table})`;
+	if (subject?.typeName) return `${factoryName}(${subject.typeName})`;
+	return factoryName;
+}
+function suppressionSummary(subjectLabel, subject, effectivePolicy) {
+	const namespace = subject?.namespaceId ?? "unknown";
+	const declared = subject?.explicitNodeControlPolicy;
+	if (effectivePolicy === "external" && declared === "managed") return `control policy suppressed: ${subjectLabel} — namespace '${namespace}' has effective control 'external' but table declared 'managed'`;
+	return `control policy suppressed: ${subjectLabel} — namespace '${namespace}' has effective control '${effectivePolicy}'${declared ? ` but table declared '${declared}'` : ""}`;
+}
+function buildSubjectSuppressionWarning(subject, effectivePolicy, factoryName, formatSubjectLabel) {
+	return {
+		kind: "controlPolicySuppressedCall",
+		summary: suppressionSummary(formatSubjectLabel(factoryName, subject), subject, effectivePolicy),
+		location: {
+			...ifDefined("namespace", subject?.namespaceId),
+			...ifDefined("table", subject?.table),
+			...ifDefined("column", subject?.column),
+			...ifDefined("type", subject?.typeName)
+		},
+		meta: {
+			controlPolicy: effectivePolicy,
+			factoryName,
+			...ifDefined("declaredControlPolicy", subject?.explicitNodeControlPolicy)
+		}
+	};
+}
+function defaultModificationFactoryNameForSubject(subject) {
+	if (subject.table) return "alterTable";
+	if (subject.typeName) return "alterType";
+	return "alterSchema";
+}
+/**
+* Partition the calls produced for a single set of subjects into those the
+* effective control policy permits (`kept`) and a list of
+* {@link SqlPlannerConflict} warnings describing the suppressed calls.
+*
+* **Prefer {@link partitionIssuesByControlPolicy}** for the schema-issue
+* pipeline: it filters subjects out of the planner's *input* so the planner
+* never has to reason about un-modeled state on `external`/`observed`
+* subjects. This call-level helper remains for paths that bypass the issue
+* pipeline — currently the codec-emitted field-event ops, which originate
+* from declared contract fields rather than from introspected schema state
+* and therefore cannot trip the diff engine.
+*/
+function partitionCallsByControlPolicy(options) {
+	const defaultControlPolicy = options.contract.defaultControlPolicy;
+	const formatSubjectLabel = options.formatSubjectLabel ?? defaultSubjectLabel;
+	const kept = [];
+	const warnings = [];
+	for (const call of options.calls) {
+		const subject = options.resolveControlPolicySubject(call);
+		const policy = controlPolicyForCall(subject, defaultControlPolicy);
+		if (callAllowedUnderControlPolicy(policy, subject)) kept.push(call);
+		else {
+			const factoryName = options.resolveFactoryName(call);
+			warnings.push(buildSubjectSuppressionWarning(subject, policy, factoryName, formatSubjectLabel));
+		}
+	}
+	return Object.freeze({
+		kept: Object.freeze(kept),
+		warnings: Object.freeze(warnings)
+	});
+}
+/**
+* Partition a list of schema-issue-shaped inputs by the effective control
+* policy of each issue's subject *before* the planner is invoked.
+*
+* `plannable` is the list of issues whose subject's effective policy permits
+* the planner to act on them (`managed`, or `tolerated` for whole-object
+* creation issues only). Issues for `external`/`observed` subjects, and
+* non-creation issues for `tolerated` subjects, are dropped from the planner's
+* input entirely — they never enter introspection-driven planning, never feed
+* the diff engine, and never produce DDL calls that would have to be
+* post-filtered. This sidesteps a class of failure where the diff engine
+* cannot reason about the live shape of a subject the user marked as
+* out-of-scope (`external`).
+*
+* `warnings` is one {@link SqlPlannerConflict} per suppressed subject (not per
+* suppressed issue). `factoryName` is inferred from the subject's issue mix:
+* if any of the subject's issues is whole-object creation, the warning takes
+* the corresponding creation factoryName (e.g. `createTable`,
+* `createEnumType`, `createSchema`); otherwise it falls back to
+* `defaultModificationFactoryName(subject)` — a synthetic label that names
+* the *kind* of mutation that would have run, since no concrete DDL call was
+* generated.
+*
+* Unresolved-subject issues (`resolveControlPolicySubject` returns
+* `undefined`) emit one warning each; they cannot be deduplicated because
+* they carry no subject coordinate.
+*/
+function partitionIssuesByControlPolicy(options) {
+	const defaultControlPolicy = options.contract.defaultControlPolicy;
+	const formatSubjectLabel = options.formatSubjectLabel ?? defaultSubjectLabel;
+	const inferModificationFactoryName = options.defaultModificationFactoryName ?? defaultModificationFactoryNameForSubject;
+	const plannable = [];
+	const suppressedSubjects = /* @__PURE__ */ new Map();
+	const unresolvedSuppressions = [];
+	for (const issue of options.issues) {
+		const subject = options.resolveControlPolicySubject(issue);
+		const policy = controlPolicyForCall(subject, defaultControlPolicy);
+		const creationFactoryName = options.resolveCreationFactoryName(issue);
+		if (policy === "managed") {
+			plannable.push(issue);
+			continue;
+		}
+		if (policy === "tolerated" && subject !== void 0 && creationFactoryName !== void 0 && subject.createsNewObject) {
+			plannable.push(issue);
+			continue;
+		}
+		if (subject === void 0) {
+			const factoryName = creationFactoryName ?? "unknown";
+			unresolvedSuppressions.push(buildSubjectSuppressionWarning(void 0, policy, factoryName, formatSubjectLabel));
+			continue;
+		}
+		const key = subjectKey(subject);
+		const existing = suppressedSubjects.get(key);
+		if (existing) {
+			if (existing.creationFactoryName === void 0 && creationFactoryName !== void 0) existing.creationFactoryName = creationFactoryName;
+		} else suppressedSubjects.set(key, {
+			subject,
+			policy,
+			...ifDefined("creationFactoryName", creationFactoryName)
+		});
+	}
+	const warnings = [...unresolvedSuppressions];
+	for (const entry of suppressedSubjects.values()) {
+		const factoryName = entry.creationFactoryName ?? inferModificationFactoryName(entry.subject);
+		warnings.push(buildSubjectSuppressionWarning(entry.subject, entry.policy, factoryName, formatSubjectLabel));
+	}
+	return Object.freeze({
+		plannable: Object.freeze(plannable),
+		warnings: Object.freeze(warnings)
+	});
+}
+function subjectKey(subject) {
+	return `${subject.namespaceId}\u0000${subject.table ?? ""}\u0000${subject.typeName ?? ""}`;
+}
+//#endregion
 //#region src/core/migrations/field-event-planner.ts
 function planFieldEventOperations(options) {
 	const priorContract = options.priorContract;
@@ -1796,10 +1974,17 @@ function createMigrationPlan(options) {
 		...options.meta ? { meta: cloneRecord(options.meta) } : {}
 	});
 }
-function plannerSuccess(plan) {
+function plannerSuccess(plan, warnings) {
 	return Object.freeze({
 		kind: "success",
-		plan
+		plan,
+		...warnings && warnings.length > 0 ? { warnings: Object.freeze(warnings.map((conflict) => Object.freeze({
+			kind: conflict.kind,
+			summary: conflict.summary,
+			...conflict.why ? { why: conflict.why } : {},
+			...conflict.location ? { location: Object.freeze({ ...conflict.location }) } : {},
+			...conflict.meta ? { meta: cloneRecord(conflict.meta) } : {}
+		}))) } : {}
 	});
 }
 function plannerFailure(conflicts) {
@@ -1844,6 +2029,6 @@ const INIT_ADDITIVE_POLICY = Object.freeze({ allowedOperationClasses: Object.fre
 //#region src/exports/control.ts
 var control_default = new SqlFamilyDescriptor();
 //#endregion
-export { INIT_ADDITIVE_POLICY, assembleAuthoringContributions, contractToSchemaIR, createMigrationPlan, control_default as default, detectDestructiveChanges, extractCodecControlHooks, planFieldEventOperations, plannerFailure, plannerSuccess, runnerFailure, runnerSuccess, temporalAuthoringPresets, timestampNowControlDescriptor };
+export { INIT_ADDITIVE_POLICY, assembleAuthoringContributions, contractToSchemaIR, controlPolicyForCall, createMigrationPlan, control_default as default, detectDestructiveChanges, extractCodecControlHooks, partitionCallsByControlPolicy, partitionIssuesByControlPolicy, planFieldEventOperations, plannerFailure, plannerSuccess, runnerFailure, runnerSuccess, temporalAuthoringPresets, timestampNowControlDescriptor };
 
 //# sourceMappingURL=control.mjs.map