@prisma-next/sql-contract-psl 0.12.0-dev.46 → 0.12.0-dev.48

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":";;;;;;;;;;;KA0CY,gBAAA;EAAA,SACD,OAAA;EAAA,SACA,UAAA;EAAA,SACA,OAAA;EAAA,SACA,UAAA,GAAa,MAAM;AAAA;;;UC8Cb,sCAAA;EAAA,SACN,QAAA,EAAU,sBAAA;EAAA,SACV,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;EDrDzB;;;AAAmB;;;;AC8C9B;;ED9CW,SC+DA,eAAA,IAAmB,KAAA,EAAO,uBAAA,KAA4B,SAAA;AAAA;AAAA,iBA4zCjD,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":";;;;;;;;;;;KA0CY,gBAAA;EAAA,SACD,OAAA;EAAA,SACA,UAAA;EAAA,SACA,OAAA;EAAA,SACA,UAAA,GAAa,MAAM;AAAA;;;UCiDb,sCAAA;EAAA,SACN,QAAA,EAAU,sBAAA;EAAA,SACV,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;EDxDzB;;;AAAmB;;;;ACiD9B;;EDjDW,SCkEA,eAAA,IAAmB,KAAA,EAAO,uBAAA,KAA4B,SAAA;AAAA;AAAA,iBAwgDjD,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-BTfcjVFM.mjs";
+import { t as interpretPslDocumentToSqlContract } from "./interpreter-Rn_Vzvt-.mjs";
 export { interpretPslDocumentToSqlContract };

package/dist/{interpreter-BTfcjVFM.mjs → interpreter-Rn_Vzvt-.mjs}

@@ -2,10 +2,10 @@ import { crossRef } from "@prisma-next/contract/types";
 import { hasRegisteredFieldNamespace, instantiateAuthoringEntityType, instantiateAuthoringFieldPreset, instantiateAuthoringTypeConstructor, isAuthoringEntityTypeDescriptor, isAuthoringFieldPresetDescriptor, isAuthoringTypeConstructorDescriptor, validateAuthoringHelperArguments } from "@prisma-next/framework-components/authoring";
 import { isPostgresEnumStorageEntry } from "@prisma-next/sql-contract/types";
 import { buildSqlContractFromDefinition } from "@prisma-next/sql-contract-ts/contract-builder";
+import { blindCast } from "@prisma-next/utils/casts";
 import { ifDefined } from "@prisma-next/utils/defined";
 import { notOk, ok } from "@prisma-next/utils/result";
 import { getPositionalArgument, parseQuotedStringLiteral } from "@prisma-next/psl-parser";
-import { blindCast } from "@prisma-next/utils/casts";
 import { assertDefined, invariant } from "@prisma-next/utils/assertions";
 //#region src/psl-attribute-parsing.ts
 function lowerFirst(value) {
@@ -2757,8 +2757,16 @@ function collectPolymorphismDeclarations(models, sourceId, diagnostics) {
 		baseDeclarations
 	};
 }
-function resolvePolymorphism(models, discriminatorDeclarations, baseDeclarations, modelNames, modelMappings, modelNamespaceIds, defaultNamespaceId, sourceId, diagnostics) {
+function resolvePolymorphism(models, discriminatorDeclarations, baseDeclarations, modelNames, modelMappings, modelNamespaceIds, defaultNamespaceId, syntheticPkFieldsByVariant, stiBaseFieldsByBase, sourceId, diagnostics) {
 	let patched = models;
+	for (const [baseName, fieldNames] of stiBaseFieldsByBase) {
+		const baseModel = patched[baseName];
+		if (!baseModel || fieldNames.length === 0) continue;
+		patched = {
+			...patched,
+			[baseName]: stripStorageOnlyDomainFields(baseModel, fieldNames)
+		};
+	}
 	for (const [modelName, decl] of discriminatorDeclarations) {
 		if (baseDeclarations.has(modelName)) {
 			diagnostics.push({
@@ -2840,20 +2848,168 @@ function resolvePolymorphism(models, discriminatorDeclarations, baseDeclarations
 		const baseMapping = modelMappings.get(baseDecl.baseName);
 		const variantMapping = modelMappings.get(variantName);
 		const resolvedTable = variantMapping?.model.attributes.some((attr) => attr.name === "map") ?? false ? variantMapping?.tableName : baseMapping?.tableName;
+		const patchedVariant = {
+			...variantModel,
+			base: crossRef(baseDecl.baseName, modelNamespaceIds.get(baseDecl.baseName) ?? defaultNamespaceId),
+			...resolvedTable ? { storage: {
+				...variantModel.storage,
+				table: resolvedTable
+			} } : {}
+		};
 		patched = {
 			...patched,
-			[variantName]: {
-				...variantModel,
-				base: crossRef(baseDecl.baseName, modelNamespaceIds.get(baseDecl.baseName) ?? defaultNamespaceId),
-				...resolvedTable ? { storage: {
-					...variantModel.storage,
-					table: resolvedTable
-				} } : {}
-			}
+			[variantName]: stripStorageOnlyDomainFields(patchedVariant, syntheticPkFieldsByVariant.get(variantName) ?? [])
 		};
 	}
 	return patched;
 }
+/**
+* Multi-table-inheritance variants (`@@base` + their own `@@map`) live in a
+* separate table from their base. The ORM joins that table to the base on the
+* shared primary key (`base.id = variant.id`), so the variant storage table
+* must carry the base PK column even though the variant domain model declares
+* only its own fields. This enriches each MTI variant's `ModelNode` with that
+* link column, a primary key on it, and a FK back to the base table.
+*
+* The link column is reported back per variant in `syntheticPkFieldsByVariant`
+* so the domain-model patch can drop it again — keeping the variant's domain
+* surface thin (its create/read inputs don't gain a redundant `id`) while the
+* storage table stays joinable. Single-table-inheritance variants (no own
+* table) are left untouched.
+*/
+function materializeMtiVariantStorageLinks(modelNodes, baseDeclarations, stiVariantNames) {
+	const nodeByModel = new Map(modelNodes.map((node) => [node.modelName, node]));
+	const syntheticPkFieldsByVariant = /* @__PURE__ */ new Map();
+	return {
+		modelNodes: modelNodes.map((node) => {
+			const baseDecl = baseDeclarations.get(node.modelName);
+			if (!baseDecl) return node;
+			const baseNode = nodeByModel.get(baseDecl.baseName);
+			if (!baseNode) return node;
+			if (stiVariantNames.has(node.modelName)) return node;
+			const basePrimaryKey = baseNode.id;
+			if (!basePrimaryKey || basePrimaryKey.columns.length === 0) return node;
+			const existingColumns = new Set(node.fields.map((field) => field.columnName));
+			const linkFields = [];
+			for (const pkColumn of basePrimaryKey.columns) {
+				if (existingColumns.has(pkColumn)) continue;
+				const baseField = baseNode.fields.find((field) => "descriptor" in field && field.columnName === pkColumn);
+				if (!baseField) continue;
+				linkFields.push({
+					fieldName: baseField.fieldName,
+					columnName: pkColumn,
+					descriptor: baseField.descriptor,
+					nullable: false
+				});
+			}
+			if (linkFields.length === 0) return node;
+			syntheticPkFieldsByVariant.set(node.modelName, linkFields.map((field) => field.fieldName));
+			const foreignKey = {
+				columns: basePrimaryKey.columns,
+				references: {
+					model: baseNode.modelName,
+					table: baseNode.tableName,
+					columns: basePrimaryKey.columns,
+					...ifDefined("namespaceId", baseNode.namespaceId)
+				},
+				constraint: true,
+				index: false,
+				onDelete: "cascade"
+			};
+			return {
+				...node,
+				fields: [...linkFields, ...node.fields],
+				id: { columns: basePrimaryKey.columns },
+				foreignKeys: [...node.foreignKeys ?? [], foreignKey]
+			};
+		}),
+		syntheticPkFieldsByVariant
+	};
+}
+/**
+* Single-table-inheritance variants (`@@base` with no own `@@map`) share the
+* base table: `resolvePolymorphism` points the variant's `storage.table` at the
+* base, and the ORM reads variant-declared fields straight off the base table.
+* For that to validate and round-trip, the base storage table must physically
+* carry every STI variant's declared columns. This enriches the base
+* `ModelNode` with those columns.
+*
+* The materialised columns are always nullable in storage: the base table hosts
+* every variant's rows, so a column a variant declares as required is still
+* NULL on sibling-variant rows. The variant's domain field keeps its declared
+* nullability — required-in-domain / nullable-in-storage is the intended STI
+* shape.
+*
+* Collisions (two variants declaring the same column, or a variant column name
+* clashing with a base column) are resolved skip-if-exists here, mirroring the
+* MTI link guard; surfacing them as diagnostics is tracked separately
+* (TML-2827).
+*/
+function materializeStiVariantStorageColumns(modelNodes, baseDeclarations, stiVariantNames) {
+	if (stiVariantNames.size === 0) return {
+		modelNodes: [...modelNodes],
+		stiBaseFieldsByBase: /* @__PURE__ */ new Map()
+	};
+	const nodeByModel = new Map(modelNodes.map((node) => [node.modelName, node]));
+	const stiColumnsByBase = /* @__PURE__ */ new Map();
+	for (const variantName of stiVariantNames) {
+		const variantNode = nodeByModel.get(variantName);
+		const baseDecl = baseDeclarations.get(variantName);
+		if (!variantNode || !baseDecl) continue;
+		const baseNode = nodeByModel.get(baseDecl.baseName);
+		if (!baseNode) continue;
+		const baseColumns = new Set(baseNode.fields.map((field) => field.columnName));
+		const claimed = stiColumnsByBase.get(baseDecl.baseName) ?? [];
+		const claimedColumns = new Set(claimed.map((field) => field.columnName));
+		for (const field of variantNode.fields) {
+			if (baseColumns.has(field.columnName) || claimedColumns.has(field.columnName)) continue;
+			claimedColumns.add(field.columnName);
+			claimed.push({
+				...field,
+				nullable: true
+			});
+		}
+		stiColumnsByBase.set(baseDecl.baseName, claimed);
+	}
+	const stiBaseFieldsByBase = /* @__PURE__ */ new Map();
+	for (const [baseName, columns] of stiColumnsByBase) stiBaseFieldsByBase.set(baseName, columns.map((field) => field.fieldName));
+	return {
+		modelNodes: modelNodes.map((node) => {
+			if (stiVariantNames.has(node.modelName)) return {
+				...node,
+				sharesBaseTable: true
+			};
+			const stiColumns = stiColumnsByBase.get(node.modelName);
+			if (!stiColumns || stiColumns.length === 0) return node;
+			return {
+				...node,
+				fields: [...node.fields, ...stiColumns]
+			};
+		}),
+		stiBaseFieldsByBase
+	};
+}
+/**
+* Drop the storage-only link fields (added by
+* {@link materializeMtiVariantStorageLinks}) from a variant's domain model, so
+* the domain surface stays thin while the storage table keeps the link column.
+*/
+function stripStorageOnlyDomainFields(model, fieldNames) {
+	if (fieldNames.length === 0) return model;
+	const fields = { ...model.fields };
+	for (const name of fieldNames) delete fields[name];
+	const storage = blindCast(model.storage);
+	const storageFields = { ...storage.fields };
+	for (const name of fieldNames) delete storageFields[name];
+	return {
+		...model,
+		fields,
+		storage: {
+			...storage,
+			fields: storageFields
+		}
+	};
+}
 function interpretPslDocumentToSqlContract(input) {
 	const sourceId = input.document.ast.sourceId;
 	if (!input.target) return notOk({
@@ -2998,6 +3154,10 @@ function interpretPslDocumentToSqlContract(input) {
 		sourceId
 	});
 	const { discriminatorDeclarations, baseDeclarations } = collectPolymorphismDeclarations(models, sourceId, diagnostics);
+	const stiVariantNames = /* @__PURE__ */ new Set();
+	for (const variantName of baseDeclarations.keys()) if (!(modelMappings.get(variantName)?.model.attributes.some((attr) => attr.name === "map") ?? false)) stiVariantNames.add(variantName);
+	const { modelNodes: mtiLinkedModelNodes, syntheticPkFieldsByVariant } = materializeMtiVariantStorageLinks(modelNodes, baseDeclarations, stiVariantNames);
+	const { modelNodes: stiColumnModelNodes, stiBaseFieldsByBase } = materializeStiVariantStorageColumns(mtiLinkedModelNodes, baseDeclarations, stiVariantNames);
 	const valueObjects = buildValueObjects({
 		compositeTypes,
 		enumTypeDescriptors: allEnumTypeDescriptors,
@@ -3020,7 +3180,7 @@ function interpretPslDocumentToSqlContract(input) {
 		...Object.keys(storageTypes).length > 0 ? { storageTypes } : {},
 		...Object.keys(namespaceEnumStorageTypes).length > 0 ? { namespaceTypes: namespaceEnumStorageTypes } : {},
 		...ifDefined("createNamespace", input.createNamespace),
-		models: modelNodes.map((model) => ({
+		models: stiColumnModelNodes.map((model) => ({
 			...model,
 			...modelRelations.has(model.modelName) ? { relations: [...modelRelations.get(model.modelName) ?? []].sort((left, right) => compareStrings(left.fieldName, right.fieldName)) } : {}
 		}))
@@ -3032,7 +3192,7 @@ function interpretPslDocumentToSqlContract(input) {
 	}
 	let patchedModels = patchModelDomainFields(modelsForPatch, modelResolvedFields);
 	const polyDiagnostics = [];
-	patchedModels = resolvePolymorphism(patchedModels, discriminatorDeclarations, baseDeclarations, modelNames, modelMappings, modelNamespaceIds, input.target.defaultNamespaceId, sourceId, polyDiagnostics);
+	patchedModels = resolvePolymorphism(patchedModels, discriminatorDeclarations, baseDeclarations, modelNames, modelMappings, modelNamespaceIds, input.target.defaultNamespaceId, syntheticPkFieldsByVariant, stiBaseFieldsByBase, sourceId, polyDiagnostics);
 	if (polyDiagnostics.length > 0) return notOk({
 		summary: "PSL to SQL contract interpretation failed",
 		diagnostics: polyDiagnostics
@@ -3052,4 +3212,4 @@ function interpretPslDocumentToSqlContract(input) {
 //#endregion
 export { interpretPslDocumentToSqlContract as t };
 
-//# sourceMappingURL=interpreter-BTfcjVFM.mjs.map
+//# sourceMappingURL=interpreter-Rn_Vzvt-.mjs.map