@prisma-next/sql-contract-psl 0.14.0-dev.8 → 0.14.0-dev.9

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/psl-column-resolution.ts","../src/interpreter.ts"],"mappings":";;;;;;;;;;;;;KA2CY,gBAAA;EAAA,SACD,OAAA;EAAA,SACA,UAAA;EAAA,SACA,OAAA;EAAA,SACA,UAAA,GAAa,MAAM;AAAA;;;UCuDb,sCAAA;EAAA,SACN,WAAA,EAAa,WAAA;EAAA,SACb,UAAA,EAAY,UAAA;EAAA,SACZ,QAAA;EAAA,SACA,MAAA,EAAQ,aAAA;EAAA,SACR,qBAAA,EAAuB,WAAA,SAAoB,gBAAA;EAAA,SAC3C,sBAAA;EAAA,SACA,yBAAA,YAAqC,gBAAA;EAAA,SACrC,uBAAA,GAA0B,yBAAA;EAAA,SAC1B,sBAAA,GAAyB,sBAAA;EDhEN;AAAA;;;;ACuD9B;;;;EDvD8B,SC0EnB,0BAAA,EAA4B,WAAA,SAAoB,QAAA;EAfxC;;;;;;;;;EAAA,SAyBR,eAAA,IAAmB,KAAA,EAAO,uBAAA,KAA4B,SAAA;EAAA,SACtD,WAAA,GAAc,WAAA;EAAA,SACd,eAAA,YAA2B,wBAAA;AAAA;AAAA,iBAo9CtB,iCAAA,CACd,KAAA,EAAO,sCAAA,GACN,MAAA,CAAO,QAAA,EAAU,yBAAA"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/psl-column-resolution.ts","../src/interpreter.ts"],"mappings":";;;;;;;;;;;;;KA2CY,gBAAA;EAAA,SACD,OAAA;EAAA,SACA,UAAA;EAAA,SACA,OAAA;EAAA,SACA,UAAA,GAAa,MAAM;AAAA;;;UCuDb,sCAAA;EAAA,SACN,WAAA,EAAa,WAAA;EAAA,SACb,UAAA,EAAY,UAAA;EAAA,SACZ,QAAA;EAAA,SACA,MAAA,EAAQ,aAAA;EAAA,SACR,qBAAA,EAAuB,WAAA,SAAoB,gBAAA;EAAA,SAC3C,sBAAA;EAAA,SACA,yBAAA,YAAqC,gBAAA;EAAA,SACrC,uBAAA,GAA0B,yBAAA;EAAA,SAC1B,sBAAA,GAAyB,sBAAA;EDhEN;AAAA;;;;ACuD9B;;;;EDvD8B,SC0EnB,0BAAA,EAA4B,WAAA,SAAoB,QAAA;EAfxC;;;;;;;;;EAAA,SAyBR,eAAA,IAAmB,KAAA,EAAO,uBAAA,KAA4B,SAAA;EAAA,SACtD,WAAA,GAAc,WAAA;EAAA,SACd,eAAA,YAA2B,wBAAA;AAAA;AAAA,iBAq9CtB,iCAAA,CACd,KAAA,EAAO,sCAAA,GACN,MAAA,CAAO,QAAA,EAAU,yBAAA"}

package/dist/index.mjs

@@ -1,2 +1,2 @@
-import { t as interpretPslDocumentToSqlContract } from "./interpreter-kDkm5opL.mjs";
+import { t as interpretPslDocumentToSqlContract } from "./interpreter-CygvamTk.mjs";
 export { interpretPslDocumentToSqlContract };

package/dist/{interpreter-kDkm5opL.mjs → interpreter-CygvamTk.mjs}

@@ -1934,7 +1934,11 @@ function parseRelationAttribute(input) {
 function indexFkRelations(input) {
 	const modelRelations = /* @__PURE__ */ new Map();
 	const fkRelationsByPair = /* @__PURE__ */ new Map();
+	const fkRelationsByDeclaringModel = /* @__PURE__ */ new Map();
 	for (const relation of input.fkRelationMetadata) {
+		const declaringFkRelations = fkRelationsByDeclaringModel.get(relation.declaringModelName);
+		if (declaringFkRelations) declaringFkRelations.push(relation);
+		else fkRelationsByDeclaringModel.set(relation.declaringModelName, [relation]);
 		const existing = modelRelations.get(relation.declaringModelName);
 		const current = existing ?? [];
 		if (!existing) modelRelations.set(relation.declaringModelName, current);
@@ -1961,15 +1965,177 @@ function indexFkRelations(input) {
 	}
 	return {
 		modelRelations,
-		fkRelationsByPair
+		fkRelationsByPair,
+		fkRelationsByDeclaringModel
 	};
 }
+function idColumnsAreExactlyFkPair(idColumns, parentColumns, childColumns) {
+	if (idColumns.length !== parentColumns.length + childColumns.length) return false;
+	const fkColumns = new Set([...parentColumns, ...childColumns]);
+	if (fkColumns.size !== parentColumns.length + childColumns.length) return false;
+	return idColumns.every((column) => fkColumns.has(column));
+}
+/**
+* Reorders the child FK's junction columns into the target model's id-column
+* order. Returns undefined unless the FK references exactly the target's full
+* id, because downstream consumers pair `through.childColumns` positionally
+* against the target id columns — an FK referencing anything else (a non-id
+* unique, a partial id) would produce a silently wrong join.
+*/
+function childColumnsInTargetIdOrder(childFk, targetIdColumns) {
+	if (childFk.referencedColumns.length !== targetIdColumns.length) return;
+	const localByReferenced = /* @__PURE__ */ new Map();
+	for (const [index, referencedColumn] of childFk.referencedColumns.entries()) {
+		const localColumn = childFk.localColumns[index];
+		if (localColumn === void 0) return;
+		localByReferenced.set(referencedColumn, localColumn);
+	}
+	if (localByReferenced.size !== targetIdColumns.length) return;
+	const ordered = [];
+	for (const idColumn of targetIdColumns) {
+		const localColumn = localByReferenced.get(idColumn);
+		if (localColumn === void 0) return;
+		ordered.push(localColumn);
+	}
+	return ordered;
+}
+/**
+* Finds explicit junction models that connect a bare backrelation list field
+* to its target model: a model whose composite id columns are exactly the FK
+* columns of one relation back to the candidate's model (the parent side) and
+* one relation to the candidate's target model (the child side). The child
+* FK must reference exactly the target model's id columns; its junction
+* columns are carried in target-id order on the pair. A relation name on the
+* list field pins the parent-side FK relation, which is how self-referential
+* many-to-many sides are disambiguated.
+*
+* Alongside the recognised pairs, returns junction-shaped near-misses (models
+* that link both sides but were declined) so the caller can emit a
+* junction-specific diagnostic instead of the generic orphaned-list message.
+*/
+function findJunctionFkPairs(input) {
+	const targetIdColumns = input.modelIdColumns.get(input.candidate.targetModelName);
+	if (!targetIdColumns || targetIdColumns.length === 0) return {
+		pairs: [],
+		nearMisses: []
+	};
+	const pairs = [];
+	const nearMisses = [];
+	for (const [junctionModelName, junctionFks] of input.fkRelationsByDeclaringModel) {
+		const idColumns = input.modelIdColumns.get(junctionModelName);
+		for (const parentFk of junctionFks) {
+			if (parentFk.targetModelName !== input.candidate.modelName) continue;
+			if (input.candidate.relationName !== void 0 && parentFk.relationName !== input.candidate.relationName) continue;
+			for (const childFk of junctionFks) {
+				if (childFk === parentFk || childFk.targetModelName !== input.candidate.targetModelName) continue;
+				if (!idColumns || !idColumnsAreExactlyFkPair(idColumns, parentFk.localColumns, childFk.localColumns)) {
+					nearMisses.push({
+						junctionModelName,
+						reason: "id-not-fk-covering"
+					});
+					continue;
+				}
+				const orderedChildColumns = childColumnsInTargetIdOrder(childFk, targetIdColumns);
+				if (!orderedChildColumns) {
+					nearMisses.push({
+						junctionModelName,
+						reason: "target-fk-not-id"
+					});
+					continue;
+				}
+				pairs.push({
+					parentFk,
+					childFk,
+					childColumnsInTargetIdOrder: orderedChildColumns
+				});
+			}
+		}
+	}
+	return {
+		pairs,
+		nearMisses
+	};
+}
+function junctionNearMissDiagnostic(candidate, nearMiss, sourceId) {
+	const listField = `${candidate.modelName}.${candidate.field.name}`;
+	const data = {
+		listField,
+		junctionModel: nearMiss.junctionModelName,
+		targetModel: candidate.targetModelName
+	};
+	if (nearMiss.reason === "target-fk-not-id") return {
+		code: "PSL_JUNCTION_TARGET_FK_NOT_ID",
+		message: `Backrelation list field "${listField}" found junction model "${nearMiss.junctionModelName}", but its foreign key to "${candidate.targetModelName}" does not reference "${candidate.targetModelName}"'s @id. The junction's target-side foreign key must reference "${candidate.targetModelName}"'s full @id columns for many-to-many recognition.`,
+		sourceId,
+		span: candidate.field.span,
+		data
+	};
+	return {
+		code: "PSL_JUNCTION_ID_NOT_FK_COVERING",
+		message: `Backrelation list field "${listField}" found junction-shaped model "${nearMiss.junctionModelName}" linking "${candidate.modelName}" and "${candidate.targetModelName}", but its id does not cover exactly its foreign-key columns. Declare @@id([...]) on "${nearMiss.junctionModelName}" listing exactly the two foreign-key columns for many-to-many recognition.`,
+		sourceId,
+		span: candidate.field.span,
+		data
+	};
+}
+function manyToManyRelationNode(candidate, pair) {
+	return {
+		fieldName: candidate.field.name,
+		toModel: pair.childFk.targetModelName,
+		toTable: pair.childFk.targetTableName,
+		...ifDefined("toNamespaceId", pair.childFk.targetNamespaceId),
+		cardinality: "N:M",
+		on: {
+			parentTable: candidate.tableName,
+			parentColumns: pair.parentFk.referencedColumns,
+			childTable: pair.parentFk.declaringTableName,
+			childColumns: pair.parentFk.localColumns
+		},
+		through: {
+			table: pair.parentFk.declaringTableName,
+			...ifDefined("namespaceId", pair.parentFk.declaringNamespaceId),
+			parentColumns: pair.parentFk.localColumns,
+			childColumns: pair.childColumnsInTargetIdOrder
+		}
+	};
+}
+function relationsForModel(modelRelations, modelName) {
+	const existing = modelRelations.get(modelName);
+	if (existing) return existing;
+	const created = [];
+	modelRelations.set(modelName, created);
+	return created;
+}
 function applyBackrelationCandidates(input) {
 	for (const candidate of input.backrelationCandidates) {
 		const pairKey = fkRelationPairKey(candidate.targetModelName, candidate.modelName);
 		const pairMatches = input.fkRelationsByPair.get(pairKey) ?? [];
 		const matches = candidate.relationName ? pairMatches.filter((relation) => relation.relationName === candidate.relationName) : [...pairMatches];
 		if (matches.length === 0) {
+			const { pairs: junctionPairs, nearMisses } = findJunctionFkPairs({
+				candidate,
+				fkRelationsByDeclaringModel: input.fkRelationsByDeclaringModel,
+				modelIdColumns: input.modelIdColumns
+			});
+			const junctionPair = junctionPairs[0];
+			if (junctionPairs.length === 1 && junctionPair) {
+				relationsForModel(input.modelRelations, candidate.modelName).push(manyToManyRelationNode(candidate, junctionPair));
+				continue;
+			}
+			if (junctionPairs.length > 1) {
+				input.diagnostics.push({
+					code: "PSL_AMBIGUOUS_BACKRELATION_LIST",
+					message: `Backrelation list field "${candidate.modelName}.${candidate.field.name}" matches multiple junction FK pairs for a many-to-many relation. Add @relation(name: "...") (or @relation("...")) to the list field and the junction FK-side relation pointing back at "${candidate.modelName}" to disambiguate.`,
+					sourceId: input.sourceId,
+					span: candidate.field.span
+				});
+				continue;
+			}
+			const nearMiss = nearMisses[0];
+			if (nearMiss) {
+				input.diagnostics.push(junctionNearMissDiagnostic(candidate, nearMiss, input.sourceId));
+				continue;
+			}
 			input.diagnostics.push({
 				code: "PSL_ORPHANED_BACKRELATION_LIST",
 				message: `Backrelation list field "${candidate.modelName}.${candidate.field.name}" has no matching FK-side relation on model "${candidate.targetModelName}". Add @relation(fields: [...], references: [...]) on the FK-side relation or use an explicit join model for many-to-many.`,
@@ -1990,13 +2156,11 @@ function applyBackrelationCandidates(input) {
 		invariant(matches.length === 1, "Backrelation matching requires exactly one match");
 		const matched = matches[0];
 		assertDefined(matched, "Backrelation matching requires a defined relation match");
-		const existing = input.modelRelations.get(candidate.modelName);
-		const current = existing ?? [];
-		if (!existing) input.modelRelations.set(candidate.modelName, current);
-		current.push({
+		relationsForModel(input.modelRelations, candidate.modelName).push({
 			fieldName: candidate.field.name,
 			toModel: matched.declaringModelName,
 			toTable: matched.declaringTableName,
+			...ifDefined("toNamespaceId", matched.declaringNamespaceId),
 			cardinality: "1:N",
 			on: {
 				parentTable: candidate.tableName,
@@ -2728,6 +2892,7 @@ function buildModelNodeFromPsl(input) {
 			declaringModelName: model.name,
 			declaringFieldName: relationAttribute.field.name,
 			declaringTableName: tableName,
+			...ifDefined("declaringNamespaceId", input.modelNamespaceIds.get(model.name)),
 			targetModelName: targetMapping.model.name,
 			targetTableName: targetMapping.tableName,
 			...ifDefined("targetNamespaceId", targetNamespaceId),
@@ -3344,10 +3509,14 @@ function interpretPslDocumentToSqlContract(input) {
 			crossSpaceRelationsByModel.set(model.name, [...existing, ...result.crossSpaceRelations]);
 		}
 	}
-	const { modelRelations, fkRelationsByPair } = indexFkRelations({ fkRelationMetadata });
+	const { modelRelations, fkRelationsByPair, fkRelationsByDeclaringModel } = indexFkRelations({ fkRelationMetadata });
+	const modelIdColumns = /* @__PURE__ */ new Map();
+	for (const modelNode of modelNodes) if (modelNode.id) modelIdColumns.set(modelNode.modelName, modelNode.id.columns);
 	applyBackrelationCandidates({
 		backrelationCandidates,
 		fkRelationsByPair,
+		fkRelationsByDeclaringModel,
+		modelIdColumns,
 		modelRelations,
 		diagnostics,
 		sourceId
@@ -3418,4 +3587,4 @@ function interpretPslDocumentToSqlContract(input) {
 //#endregion
 export { interpretPslDocumentToSqlContract as t };
 
-//# sourceMappingURL=interpreter-kDkm5opL.mjs.map
+//# sourceMappingURL=interpreter-CygvamTk.mjs.map