@prisma-next/sql-contract-ts 0.12.0-dev.59 → 0.12.0-dev.60

package/dist/contract-builder.mjs

@@ -1,4 +1,4 @@
-import { t as buildSqlContractFromDefinition } from "./build-contract-C9dZNMRg.mjs";
+import { t as buildSqlContractFromDefinition } from "./build-contract-6Rvs461H.mjs";
 import { blindCast } from "@prisma-next/utils/casts";
 import { ifDefined } from "@prisma-next/utils/defined";
 import { isColumnDefault } from "@prisma-next/contract/types";
@@ -147,6 +147,15 @@ var ScalarFieldBuilder = class ScalarFieldBuilder {
 	constructor(state) {
 		this.state = state;
 	}
+	/**
+	* Returns the physical column name when `.column(name)` was called, or
+	* `undefined` when the field uses the default (logical field name) mapping.
+	* Used by cross-space FK lowering to stamp the physical column name onto
+	* `TargetFieldRef.columnName` so FK target columns are resolved correctly.
+	*/
+	get physicalColumnName() {
+		return this.state.columnName;
+	}
 	optional() {
 		return new ScalarFieldBuilder({
 			...this.state,
@@ -268,10 +277,16 @@ function normalizeTargetFieldRefInput(input) {
 	const [first] = refs;
 	if (!first) throw new Error("Expected at least one target ref");
 	if (refs.some((ref) => ref.modelName !== first.modelName)) throw new Error("All target refs in a foreign key must point to the same model");
+	if (refs.some((ref) => ref.spaceId !== first.spaceId)) throw new Error(`All target refs in a compound foreign key must share the same spaceId (found mismatch: "${first.spaceId ?? "<local>"}" vs "${refs.find((r) => r.spaceId !== first.spaceId)?.spaceId ?? "<local>"}")`);
+	if (refs.some((ref) => ref.namespaceId !== first.namespaceId)) throw new Error("All target refs in a compound foreign key must share the same namespaceId (found mismatch)");
+	if (refs.some((ref) => ref.tableName !== first.tableName)) throw new Error("All target refs in a compound foreign key must share the same tableName (found mismatch)");
 	return {
 		modelName: first.modelName,
-		fieldNames: refs.map((ref) => ref.fieldName),
-		source: refs.some((ref) => ref.source === "string") ? "string" : "token"
+		fieldNames: refs.map((ref) => ref.columnName ?? ref.fieldName),
+		source: refs.some((ref) => ref.source === "string") ? "string" : "token",
+		spaceId: first.spaceId,
+		namespaceId: first.namespaceId,
+		tableName: first.tableName
 	};
 }
 function createConstraintsDsl() {
@@ -314,6 +329,9 @@ function createConstraintsDsl() {
 			targetModel: normalizedTarget.modelName,
 			targetFields: normalizedTarget.fieldNames,
 			targetSource: normalizedTarget.source,
+			...normalizedTarget.spaceId !== void 0 ? { targetSpaceId: normalizedTarget.spaceId } : {},
+			...normalizedTarget.namespaceId !== void 0 ? { targetNamespaceId: normalizedTarget.namespaceId } : {},
+			...normalizedTarget.tableName !== void 0 ? { targetTableName: normalizedTarget.tableName } : {},
 			...options?.name ? { name: options.name } : {},
 			...options?.onDelete ? { onDelete: options.onDelete } : {},
 			...options?.onUpdate ? { onUpdate: options.onUpdate } : {},
@@ -337,14 +355,23 @@ function createFieldRefs(fields) {
 	};
 	return refs;
 }
-function createModelTokenRefs(modelName, fields) {
+function createModelTokenRefs(modelName, fields, crossSpaceCoordinate) {
 	const refs = {};
-	for (const fieldName of Object.keys(fields)) refs[fieldName] = {
-		kind: "targetFieldRef",
-		source: "token",
-		modelName,
-		fieldName
-	};
+	for (const [fieldName, fieldBuilder] of Object.entries(fields)) {
+		const physicalColumn = crossSpaceCoordinate !== void 0 ? fieldBuilder.physicalColumnName : void 0;
+		refs[fieldName] = {
+			kind: "targetFieldRef",
+			source: "token",
+			modelName,
+			fieldName,
+			...crossSpaceCoordinate !== void 0 ? {
+				spaceId: crossSpaceCoordinate.spaceId,
+				...crossSpaceCoordinate.namespaceId !== void 0 ? { namespaceId: crossSpaceCoordinate.namespaceId } : {},
+				...crossSpaceCoordinate.tableName !== void 0 ? { tableName: crossSpaceCoordinate.tableName } : {},
+				...physicalColumn !== void 0 ? { columnName: physicalColumn } : {}
+			} : {}
+		};
+	}
 	return refs;
 }
 function buildStageSpec(stageInput, context) {
@@ -376,12 +403,21 @@ var ContractModelBuilder = class ContractModelBuilder {
 	stageOne;
 	attributesFactory;
 	sqlFactory;
+	spaceId;
+	tableName;
 	refs;
-	constructor(stageOne, attributesFactory, sqlFactory) {
+	constructor(stageOne, attributesFactory, sqlFactory, spaceId, tableName) {
 		this.stageOne = stageOne;
 		this.attributesFactory = attributesFactory;
 		this.sqlFactory = sqlFactory;
-		this.refs = stageOne.modelName ? createModelTokenRefs(stageOne.modelName, stageOne.fields) : void 0;
+		this.spaceId = spaceId;
+		this.tableName = tableName;
+		const crossSpaceCoordinate = spaceId !== void 0 ? {
+			spaceId,
+			...stageOne.namespace !== void 0 ? { namespaceId: stageOne.namespace } : {},
+			...tableName !== void 0 ? { tableName } : {}
+		} : void 0;
+		this.refs = blindCast(stageOne.modelName ? createModelTokenRefs(stageOne.modelName, stageOne.fields, crossSpaceCoordinate) : void 0);
 	}
 	ref(fieldName) {
 		const modelName = this.stageOne.modelName;
@@ -402,13 +438,14 @@ var ContractModelBuilder = class ContractModelBuilder {
 				...this.stageOne.relations,
 				...relations
 			}
-		}, this.attributesFactory, this.sqlFactory);
+		}, this.attributesFactory, this.sqlFactory, this.spaceId, this.tableName);
 	}
 	attributes(specOrFactory) {
-		return new ContractModelBuilder(this.stageOne, specOrFactory, this.sqlFactory);
+		return new ContractModelBuilder(this.stageOne, specOrFactory, this.sqlFactory, this.spaceId, this.tableName);
 	}
 	sql(specOrFactory) {
-		return new ContractModelBuilder(this.stageOne, this.attributesFactory, specOrFactory);
+		const nextTableName = typeof specOrFactory !== "function" ? specOrFactory.table : this.tableName;
+		return blindCast(new ContractModelBuilder(this.stageOne, this.attributesFactory, specOrFactory, this.spaceId, nextTableName));
 	}
 	buildAttributesSpec() {
 		if (!this.attributesFactory) return;
@@ -460,12 +497,47 @@ function model(modelNameOrInput, maybeInput) {
 		relations: input.relations ?? {}
 	});
 }
+/**
+* Factory for building a standalone branded extension model handle.
+*
+* Use this instead of `new ContractModelBuilder(…)` when constructing handles
+* for models that live in a foreign contract space (e.g. a Supabase extension
+* model referenced by a user's contract). The `spaceId` brands the returned
+* handle so `refs.<field>.spaceId` carries the foreign space identifier.
+*
+* @param name - The domain model name as declared in the foreign contract
+*   (e.g. `'AuthUser'`, not a bare table alias like `'User'`).
+* @param input.namespace - The namespace within the foreign space (e.g. `'auth'`).
+* @param input.fields - Field definitions (use `field.column(…)`).
+* @param input.table - The physical table name in the foreign schema.
+* @param spaceId - The extension space identifier (e.g. `'supabase'`).
+*/
+function extensionModel(name, input, spaceId) {
+	return new ContractModelBuilder({
+		modelName: name,
+		namespace: input.namespace,
+		fields: input.fields,
+		relations: {}
+	}, void 0, void 0, spaceId, input.table);
+}
+function isCrossSpaceHandle(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const rec = blindCast(value);
+	return typeof rec["spaceId"] === "string" && typeof rec["stageOne"] === "object" && rec["stageOne"] !== null;
+}
 function belongsTo(toModel, options) {
+	const resolvedModel = typeof toModel === "function" ? toModel() : toModel;
+	const crossSpaceCoordinate = isCrossSpaceHandle(resolvedModel) ? {
+		spaceId: resolvedModel.spaceId,
+		...resolvedModel.tableName !== void 0 ? { tableName: resolvedModel.tableName } : {},
+		...resolvedModel.stageOne.namespace !== void 0 ? { namespaceId: resolvedModel.stageOne.namespace } : {}
+	} : void 0;
 	return new RelationBuilder({
 		kind: "belongsTo",
 		toModel: normalizeRelationModelSource(toModel),
 		from: options.from,
-		to: options.to
+		to: options.to,
+		...crossSpaceCoordinate !== void 0 ? crossSpaceCoordinate : {}
 	});
 }
 function hasMany(toModel, options) {
@@ -815,6 +887,33 @@ function resolveRelationForeignKeys(spec, allSpecs) {
 		const relation = relationBuilder.build();
 		if (relation.kind !== "belongsTo" || !relation.sql?.fk) continue;
 		const targetModelName = resolveRelationModelName(relation.toModel);
+		if (relation.spaceId !== void 0) {
+			const fields = normalizeRelationFieldNames(relation.from);
+			const targetFields = normalizeRelationFieldNames(relation.to);
+			assertRelationFieldArity({
+				modelName: spec.modelName,
+				relationName,
+				leftLabel: "source",
+				leftFields: fields,
+				rightLabel: "target",
+				rightFields: targetFields
+			});
+			foreignKeys.push({
+				kind: "fk",
+				fields,
+				targetModel: targetModelName,
+				targetFields,
+				targetSpaceId: relation.spaceId,
+				...relation.namespaceId !== void 0 ? { targetNamespaceId: relation.namespaceId } : {},
+				...relation.tableName !== void 0 ? { targetTableName: relation.tableName } : {},
+				...relation.sql.fk.name ? { name: relation.sql.fk.name } : {},
+				...relation.sql.fk.onDelete ? { onDelete: relation.sql.fk.onDelete } : {},
+				...relation.sql.fk.onUpdate ? { onUpdate: relation.sql.fk.onUpdate } : {},
+				...relation.sql.fk.constraint !== void 0 ? { constraint: relation.sql.fk.constraint } : {},
+				...relation.sql.fk.index !== void 0 ? { index: relation.sql.fk.index } : {}
+			});
+			continue;
+		}
 		if (!allSpecs.has(targetModelName)) throw new Error(`Relation "${spec.modelName}.${relationName}" references unknown model "${targetModelName}"`);
 		const fields = normalizeRelationFieldNames(relation.from);
 		const targetFields = normalizeRelationFieldNames(relation.to);
@@ -846,10 +945,8 @@ function resolveRelationAnchorFields(spec) {
 	if ("id" in spec.fieldToColumn) return ["id"];
 	throw new Error(`Model "${spec.modelName}" needs an explicit id or an "id" field to anchor non-owning relations`);
 }
-function lowerBelongsToRelation(relationName, relation, currentSpec, allSpecs) {
+function lowerBelongsToRelation(relationName, relation, currentSpec, allSpecs, extensionPacks) {
 	const targetModelName = resolveRelationModelName(relation.toModel);
-	const targetSpec = allSpecs.get(targetModelName);
-	if (!targetSpec) throw new Error(`Relation "${currentSpec.modelName}.${relationName}" references unknown model "${targetModelName}"`);
 	const fromFields = normalizeRelationFieldNames(relation.from);
 	const toFields = normalizeRelationFieldNames(relation.to);
 	assertRelationFieldArity({
@@ -860,6 +957,27 @@ function lowerBelongsToRelation(relationName, relation, currentSpec, allSpecs) {
 		rightLabel: "target",
 		rightFields: toFields
 	});
+	if (relation.spaceId !== void 0) {
+		assertKnownExtensionPack(extensionPacks, relation.spaceId, `Relation "${currentSpec.modelName}.${relationName}"`);
+		const targetTable = relation.tableName ?? targetModelName.toLowerCase();
+		const parentColumns = mapFieldNamesToColumnNames(currentSpec.modelName, fromFields, currentSpec.fieldToColumn);
+		return {
+			fieldName: relationName,
+			toModel: targetModelName,
+			toTable: targetTable,
+			cardinality: "N:1",
+			spaceId: relation.spaceId,
+			...relation.namespaceId !== void 0 ? { namespaceId: relation.namespaceId } : {},
+			on: {
+				parentTable: currentSpec.tableName,
+				parentColumns,
+				childTable: targetTable,
+				childColumns: toFields
+			}
+		};
+	}
+	const targetSpec = allSpecs.get(targetModelName);
+	if (!targetSpec) throw new Error(`Relation "${currentSpec.modelName}.${relationName}" references unknown model "${targetModelName}"`);
 	return {
 		fieldName: relationName,
 		toModel: targetModelName,
@@ -930,12 +1048,12 @@ function lowerManyToManyRelation(relationName, relation, currentSpec, allSpecs)
 		}
 	};
 }
-function resolveRelationNode(relationName, relation, currentSpec, allSpecs) {
-	if (relation.kind === "belongsTo") return lowerBelongsToRelation(relationName, relation, currentSpec, allSpecs);
+function resolveRelationNode(relationName, relation, currentSpec, allSpecs, extensionPacks) {
+	if (relation.kind === "belongsTo") return lowerBelongsToRelation(relationName, relation, currentSpec, allSpecs, extensionPacks);
 	if (relation.kind === "hasMany" || relation.kind === "hasOne") return lowerHasOwnershipRelation(relationName, relation, currentSpec, allSpecs);
 	return lowerManyToManyRelation(relationName, relation, currentSpec, allSpecs);
 }
-function lowerForeignKeyNode(spec, targetSpec, foreignKey) {
+function lowerLocalForeignKeyNode(spec, targetSpec, foreignKey) {
 	return {
 		columns: mapFieldNamesToColumnNames(spec.modelName, foreignKey.fields, spec.fieldToColumn),
 		references: {
@@ -950,20 +1068,55 @@ function lowerForeignKeyNode(spec, targetSpec, foreignKey) {
 		...foreignKey.index !== void 0 ? { index: foreignKey.index } : {}
 	};
 }
-function resolveForeignKeyNodes(spec, allSpecs) {
+function lowerCrossSpaceForeignKeyNode(spec, foreignKey) {
+	return {
+		columns: mapFieldNamesToColumnNames(spec.modelName, foreignKey.fields, spec.fieldToColumn),
+		references: {
+			model: foreignKey.targetModel,
+			table: foreignKey.targetTableName ?? foreignKey.targetModel.toLowerCase(),
+			columns: foreignKey.targetFields,
+			...foreignKey.targetNamespaceId !== void 0 ? { namespaceId: foreignKey.targetNamespaceId } : {},
+			spaceId: foreignKey.targetSpaceId
+		},
+		...foreignKey.name ? { name: foreignKey.name } : {},
+		...foreignKey.onDelete ? { onDelete: foreignKey.onDelete } : {},
+		...foreignKey.onUpdate ? { onUpdate: foreignKey.onUpdate } : {},
+		...foreignKey.constraint !== void 0 ? { constraint: foreignKey.constraint } : {},
+		...foreignKey.index !== void 0 ? { index: foreignKey.index } : {}
+	};
+}
+function assertKnownExtensionPack(extensionPacks, spaceId, context) {
+	if (extensionPacks !== void 0 && Object.hasOwn(extensionPacks, spaceId)) return;
+	throw new Error(`${context} references contract space "${spaceId}" but "${spaceId}" is not declared in extensionPacks. Add the pack to extensionPacks.`);
+}
+function resolveForeignKeyNodes(spec, allSpecs, extensionPacks) {
 	const relationForeignKeys = resolveRelationForeignKeys(spec, allSpecs).map((foreignKey) => {
+		if (foreignKey.targetSpaceId !== void 0) {
+			assertKnownExtensionPack(extensionPacks, foreignKey.targetSpaceId, `Relation-derived foreign key on "${spec.modelName}"`);
+			return lowerCrossSpaceForeignKeyNode(spec, {
+				...foreignKey,
+				targetSpaceId: foreignKey.targetSpaceId
+			});
+		}
 		const targetSpec = allSpecs.get(foreignKey.targetModel);
 		if (!targetSpec) throw new Error(`Foreign key on "${spec.modelName}" references unknown model "${foreignKey.targetModel}"`);
-		return lowerForeignKeyNode(spec, targetSpec, foreignKey);
+		return lowerLocalForeignKeyNode(spec, targetSpec, foreignKey);
 	});
 	const sqlForeignKeys = (spec.sqlSpec?.foreignKeys ?? []).map((foreignKey) => {
+		if (foreignKey.targetSpaceId !== void 0) {
+			assertKnownExtensionPack(extensionPacks, foreignKey.targetSpaceId, `Foreign key on "${spec.modelName}"`);
+			return lowerCrossSpaceForeignKeyNode(spec, {
+				...foreignKey,
+				targetSpaceId: foreignKey.targetSpaceId
+			});
+		}
 		const targetSpec = allSpecs.get(foreignKey.targetModel);
 		if (!targetSpec) throw new Error(`Foreign key on "${spec.modelName}" references unknown model "${foreignKey.targetModel}"`);
-		return lowerForeignKeyNode(spec, targetSpec, foreignKey);
+		return lowerLocalForeignKeyNode(spec, targetSpec, foreignKey);
 	});
 	return [...relationForeignKeys, ...sqlForeignKeys];
 }
-function resolveModelNode(spec, allSpecs, storageTypes, storageTypeReverseLookup) {
+function resolveModelNode(spec, allSpecs, storageTypes, storageTypeReverseLookup, extensionPacks) {
 	const fields = [];
 	for (const [fieldName, fieldBuilder] of Object.entries(spec.fieldBuilders)) {
 		const fieldState = fieldBuilder.build();
@@ -992,8 +1145,8 @@ function resolveModelNode(spec, allSpecs, storageTypes, storageTypeReverseLookup
 		...ifDefined("type", index.type),
 		...ifDefined("options", index.options)
 	}));
-	const foreignKeys = resolveForeignKeyNodes(spec, allSpecs);
-	const relations = Object.entries(spec.relations).map(([relationName, relationBuilder]) => resolveRelationNode(relationName, relationBuilder.build(), spec, allSpecs));
+	const foreignKeys = resolveForeignKeyNodes(spec, allSpecs, extensionPacks);
+	const relations = Object.entries(spec.relations).map(([relationName, relationBuilder]) => resolveRelationNode(relationName, relationBuilder.build(), spec, allSpecs, extensionPacks));
 	return {
 		modelName: spec.modelName,
 		tableName: spec.tableName,
@@ -1058,14 +1211,14 @@ function collectRuntimeModelSpecs(definition) {
 		modelSpecs
 	};
 }
-function lowerModels(collection) {
+function lowerModels(collection, extensionPacks) {
 	emitTypedCrossModelFallbackWarnings(collection);
 	const storageTypeReverseLookup = buildStorageTypeReverseLookup(collection.storageTypes);
-	return Array.from(collection.modelSpecs.values()).map((spec) => resolveModelNode(spec, collection.modelSpecs, collection.storageTypes, storageTypeReverseLookup));
+	return Array.from(collection.modelSpecs.values()).map((spec) => resolveModelNode(spec, collection.modelSpecs, collection.storageTypes, storageTypeReverseLookup, extensionPacks));
 }
 function buildContractDefinition(definition) {
 	const collection = collectRuntimeModelSpecs(definition);
-	const models = lowerModels(collection);
+	const models = lowerModels(collection, definition.extensionPacks);
 	return {
 		target: definition.target,
 		...ifDefined("defaultControlPolicy", definition.defaultControlPolicy),
@@ -1190,6 +1343,6 @@ function defineContract(definition, factory) {
 	return buildBoundContract(definition.family, definition.target, definition);
 }
 //#endregion
-export { buildBoundContract, buildSqlContractFromDefinition, defineContract, enumType, field, member, model, rel };
+export { buildBoundContract, buildSqlContractFromDefinition, defineContract, enumType, extensionModel, field, member, model, rel };
 
 //# sourceMappingURL=contract-builder.mjs.map