@prisma/orm-family-sql 8.0.0-rc.13-dev.1 → 8.0.0-rc.13-dev.2

package/dist/{interpreter-BrW0_y8Q-ChkFlzaN.mjs → interpreter-BMMGMTBa-CT5iKl13.mjs}

@@ -1,7 +1,8 @@
 import { n as isAuthoredIndexInput } from "./index-naming-Cj1Anq-T-w1JL7-EM.mjs";
+import { n as providesPslEntityPlacement } from "./entity-handle-lowering-hook-B3atrRKX.mjs";
 import { t as deriveValueSetFromEntity } from "./value-set-derivation-hook-Di9JZ0X7.mjs";
 import { n as buildSqlContractFromDefinition } from "./derived-checks-Bsrdb2Wk-D4UfM06W.mjs";
-import { a as findModelAttributeNode, c as lowerDefaultFunctionWithRegistry, i as findFieldAttributeNode, l as modelAttributeSpecsFrom, n as createSqlBinder, o as interpretFieldAttribute, r as fieldSpecContext, s as interpretModelAttribute, t as PSL_CHECK_ON_STI_VARIANT, u as sqlAttributeSpecs } from "./sql-attribute-specs-DH3Yxb21-CZV-L28L.mjs";
+import { a as findModelAttributeNode, c as lowerDefaultFunctionWithRegistry, i as findFieldAttributeNode, l as modelAttributeSpecsFrom, n as createSqlBinder, o as interpretFieldAttribute, r as fieldSpecContext, s as interpretModelAttribute, t as PSL_CHECK_ON_STI_VARIANT, u as sqlAttributeSpecs } from "./sql-attribute-specs-4YqT9Gt_-DkPyYEaE.mjs";
 import { t as defaultTableName } from "./default-table-name-BfFY8qYR-lHNcVmY5.mjs";
 import { isStructuredError, structuredError } from "@prisma/orm-framework/utils/structured-error";
 import { checkUncomposedNamespace, getAuthoringFieldPreset, hasRegisteredFieldNamespace, instantiateAuthoringEntityType, instantiateAuthoringTypeConstructor, isAuthoringEntityTypeDescriptor, isAuthoringModelAttributeDescriptor, isAuthoringTypeConstructorDescriptor, isDataTypeLoweringEntry, loweringEntryKey, validateAuthoringHelperArguments } from "@prisma/orm-framework/components/authoring";
@@ -15,10 +16,10 @@ import { materializeCodec } from "@prisma/orm-framework/components/codec";
 import { assertDefined, invariant } from "@prisma/orm-framework/utils/assertions";
 import { describeTaggedLiteralFailure } from "@prisma/orm-framework/components/control";
 import { notOk, ok } from "@prisma/orm-framework/utils/result";
-import { createPslDiagnosticCollector, diagnosticSource, findBlockDescriptor, nodePslSpan } from "@prisma/orm-framework/psl-parser";
+import { createPslDiagnosticCollector, diagnosticSource, findBlockDescriptor, interpretExtensionBlocks, nodePslSpan } from "@prisma/orm-framework/psl-parser";
 import { UNBOUND_PSL_NAMESPACE_NAME, UNSPECIFIED_PSL_NAMESPACE_ID } from "@prisma/orm-framework/components/psl-ast";
 import { claimedBlockKeywords, consumeInvalidFkPairing, enumMemberAttributeDiagnostics, fkRelationPairKey, instantiatePslFieldPreset, mapPslHelperArgs, reportUncomposedNamespace, reportUnknownFieldPreset, requiredOneToOneBackrelationDiagnostic, uncomposedNamespaceDiagnostic, unsupportedBlockDiagnostic } from "@prisma/orm-framework/psl-parser/interpret";
-//#region ../../../2-sql/2-authoring/contract-psl/dist/interpreter-BrW0_y8Q.mjs
+//#region ../../../2-sql/2-authoring/contract-psl/dist/interpreter-BMMGMTBa.mjs
 function contractError(code, message, options) {
 	return structuredError(code, message, options);
 }
@@ -1871,29 +1872,23 @@ function duplicateModelAttributeDiagnostic(input) {
 		...input.source.at(input.span)
 	};
 }
-/**
-* Enforces `AuthoringPslBlockDescriptor.requiresModelAttribute` over one
-* scope (the top level or one namespace): every block whose descriptor
-* declares the requirement must name a model that carries the required
-* bare `@@` attribute. Runs on the parsed symbol table, so it is
-* independent of block/model declaration order and of lowering order. A
-* missing parameter or an unresolvable model is skipped — the
-* missing-required-parameter and unresolved-ref diagnostics own those
-* failure modes.
-*/
+function isResolvedModelReference(value) {
+	if (typeof value !== "object" || value === null || !("declaration" in value)) return false;
+	const declaration = value.declaration;
+	return typeof declaration === "object" && declaration !== null && "kind" in declaration && declaration.kind === "model";
+}
 function validateBlockModelAttributeRequirements(input) {
-	for (const scope of input.scopes) for (const blockSymbol of Object.values(scope.blocks)) {
+	for (const [blockSymbol, envelope] of input.parsedBlocks) {
 		const requirement = findBlockDescriptor(input.pslBlockDescriptors, blockSymbol.keyword)?.requiresModelAttribute;
 		if (requirement === void 0) continue;
-		const captured = blockSymbol.block.parameters[requirement.parameter];
-		if (captured?.kind !== "ref") continue;
-		const model = scope.models[captured.identifier];
-		if (model === void 0) continue;
+		const target = envelope.values[requirement.parameter];
+		if (!isResolvedModelReference(target)) continue;
+		const model = target.declaration;
 		if (model.attributes.some((attribute) => attribute.name === requirement.attribute)) continue;
 		input.diagnostics.push({
 			code: "PSL_EXTENSION_TARGET_MODEL_MISSING_ATTRIBUTE",
-			message: `\`${blockSymbol.keyword}\` block "${blockSymbol.block.name}" targets model "${captured.identifier}", which does not declare \`@@${requirement.attribute}\`. Add \`@@${requirement.attribute}\` to model "${captured.identifier}".`,
-			...diagnosticSource(input.source.sources, blockSymbol.node.syntax).at(captured.span)
+			message: `\`${blockSymbol.keyword}\` block "${envelope.name}" targets model "${model.name}", which does not declare \`@@${requirement.attribute}\`. Add \`@@${requirement.attribute}\` to model "${model.name}".`,
+			...diagnosticSource(input.sources, blockSymbol.node.syntax).at(envelope.parameterSpans[requirement.parameter] ?? envelope.span)
 		});
 	}
 }
@@ -1915,77 +1910,29 @@ function buildModelAttributesByName(contributions) {
 	return result;
 }
 /**
-* For a single lexical scope (a named PSL namespace, or the document top
-* level), lowers all extension blocks into IR entities via the registered
-* factory for each block's discriminator. Groups results by discriminator
-* (the entries key — one-string rule: discriminator === entries key).
-*
 * This pass is intentionally generic: no discriminator value is named here.
 * The factory (registered by the target pack) owns all block-specific logic.
-* A descriptor's factory output may also opt into value-set derivation via
-* the SQL family's `SqlValueSetDerivingEntityTypeOutput.deriveValueSet` hook
-* (probed by {@link deriveValueSetFromEntity}) — when present, the derived
-* value-set is folded into the namespace's `valueSet` slot (keyed by block
-* name), so a value-set-carrying pack entity (e.g. Postgres `native_enum`)
-* contributes the value-set that drives value-set → codec typing without
-* this pass inspecting a target-specific shape.
-*
-* The `namespaceId` is attached to the block before the factory call so the
-* factory can record the namespace coordinate without the interpreter
-* containing any target-specific knowledge about how namespace ids are used.
-*
-* Ref conversion is this pass's job, over typed data: each block-descriptor
-* parameter declared `{ kind: 'ref', refKind: 'model' }` (same-namespace
-* scope) is resolved to the referenced model's storage table name and
-* attached to the block as `resolvedModelRefs` ({@link ResolvedPslModelRefs})
-* before the factory runs — the factory consumes a resolved coordinate and
-* never looks a model up itself. A required model ref that is missing or
-* does not resolve is this pass's diagnostic; the factory is skipped.
 */
-function lowerExtensionBlocksForNamespace(blocks, nsId, entityTypesByDiscriminator, entityContext, pslBlockDescriptors, resolveModelTable, sources, diagnostics) {
-	const blockSymbols = Object.values(blocks);
-	if (blockSymbols.length === 0) return {};
-	const result = {};
-	for (const blockSymbol of blockSymbols) {
-		const block = blockSymbol.block;
-		const descriptor = entityTypesByDiscriminator.get(block.kind);
+function lowerExtensionBlocksForNamespace(blocks, ownerNamespaceId, entityTypesByDiscriminator, entityContext, parsedBlocks, modelCoordinateOf, sources) {
+	const rows = [];
+	for (const blockSymbol of Object.values(blocks)) {
+		const envelope = parsedBlocks.get(blockSymbol);
+		if (envelope === void 0) continue;
+		const descriptor = entityTypesByDiscriminator.get(envelope.kind);
 		if (descriptor === void 0) continue;
-		const blockDescriptor = findBlockDescriptor(pslBlockDescriptors, block.keyword);
-		let unresolvedRef = false;
 		let resolvedModelRefs;
-		for (const [paramName, paramDecl] of Object.entries(blockDescriptor?.parameters ?? {})) {
-			if (paramDecl.kind !== "ref" || paramDecl.refKind !== "model" || paramDecl.scope !== "same-namespace") continue;
-			const captured = block.parameters[paramName];
-			if (captured?.kind !== "ref") {
-				if (paramDecl.required === true) {
-					diagnostics.push({
-						code: "PSL_EXTENSION_MODEL_REF_UNRESOLVED",
-						message: `\`${block.keyword}\` block "${block.name}" is missing the required \`${paramName}\` model reference.`,
-						...diagnosticSource(sources, blockSymbol.node.syntax).at(block.span)
-					});
-					unresolvedRef = true;
-				}
-				continue;
-			}
-			const tableName = resolveModelTable(captured.identifier);
-			if (tableName === void 0) {
-				diagnostics.push({
-					code: "PSL_EXTENSION_MODEL_REF_UNRESOLVED",
-					message: `\`${block.keyword}\` block "${block.name}" references model "${captured.identifier}" in \`${paramName}\`, which is not declared in the same namespace. Declare the model or fix the reference.`,
-					...diagnosticSource(sources, blockSymbol.node.syntax).at(captured.span)
-				});
-				unresolvedRef = true;
-				continue;
-			}
+		for (const [paramName, value] of Object.entries(envelope.values)) {
+			if (!isResolvedModelReference(value)) continue;
+			const coordinate = modelCoordinateOf(value.declaration);
+			invariant(coordinate !== void 0, `model mappings cover every collected model; \`${envelope.keyword}\` block "${envelope.name}" selected model "${value.declaration.name}" in \`${paramName}\` without a storage coordinate`);
 			resolvedModelRefs = {
 				...resolvedModelRefs ?? {},
-				[paramName]: { tableName }
+				[paramName]: coordinate
 			};
 		}
-		if (unresolvedRef) continue;
 		const annotatedBlock = {
-			...block,
-			namespaceId: nsId,
+			...envelope,
+			namespaceId: ownerNamespaceId,
 			...resolvedModelRefs !== void 0 ? { resolvedModelRefs } : {}
 		};
 		const entity = instantiateAuthoringEntityType(descriptor.discriminator, descriptor, [annotatedBlock], {
@@ -1993,18 +1940,22 @@ function lowerExtensionBlocksForNamespace(blocks, nsId, entityTypesByDiscriminat
 			sourceId: sources.sourceFileFor(blockSymbol.node.syntax).filename
 		});
 		if (entity === void 0) continue;
-		const entriesKey = descriptor.discriminator;
-		const slot = result[entriesKey] ?? {};
-		result[entriesKey] = slot;
-		slot[block.name] = entity;
+		const namespaceId = providesPslEntityPlacement(descriptor.output) ? descriptor.output.pslPlacement(entity).namespaceId : ownerNamespaceId;
+		rows.push({
+			namespaceId,
+			entityKind: descriptor.discriminator,
+			key: envelope.name,
+			entity
+		});
 		const derivedValueSet = deriveValueSetFromEntity(descriptor.output, entity);
-		if (derivedValueSet !== void 0) {
-			const valueSetSlot = result["valueSet"] ?? {};
-			result["valueSet"] = valueSetSlot;
-			valueSetSlot[block.name] = derivedValueSet;
-		}
+		if (derivedValueSet !== void 0) rows.push({
+			namespaceId,
+			entityKind: "valueSet",
+			key: envelope.name,
+			entity: derivedValueSet
+		});
 	}
-	return result;
+	return rows;
 }
 function processEnumDeclarations(input) {
 	const enumHandles = {};
@@ -2015,29 +1966,27 @@ function processEnumDeclarations(input) {
 	};
 	const enumDescriptor = getAuthoringEntity(input.authoringContributions, ["enum"]);
 	if (!enumDescriptor) {
-		for (const symbol of input.enumBlocks) {
-			const decl = symbol.block;
-			input.diagnostics.push({
-				code: "PSL_ENUM_MISSING_FACTORY",
-				message: `enum "${decl.name}" requires an "enum" entityType factory in the active authoring contributions`,
-				...diagnosticSource(input.source.sources, symbol.node.syntax).at(decl.span)
-			});
-		}
+		for (const symbol of input.enumBlocks) input.diagnostics.push({
+			code: "PSL_ENUM_MISSING_FACTORY",
+			message: `enum "${symbol.name}" requires an "enum" entityType factory in the active authoring contributions`,
+			...diagnosticSource(input.source.sources, symbol.node.syntax).at(symbol.span)
+		});
 		return {
 			enumHandles,
 			enumTypeDescriptors
 		};
 	}
 	for (const symbol of input.enumBlocks) {
-		const decl = symbol.block;
+		const envelope = input.parsedBlocks.get(symbol);
 		input.diagnostics.push(...enumMemberAttributeDiagnostics(symbol, input.source.sources));
-		const handle = instantiateAuthoringEntityType("enum", enumDescriptor, [decl], {
+		if (envelope === void 0) continue;
+		const handle = instantiateAuthoringEntityType("enum", enumDescriptor, [envelope], {
 			...input.entityContext,
 			sourceId: input.source.sources.sourceFileFor(symbol.node.syntax).filename
 		});
 		if (handle === void 0 || handle === null) continue;
-		enumHandles[decl.name] = handle;
-		enumTypeDescriptors.set(decl.name, {
+		enumHandles[envelope.name] = handle;
+		enumTypeDescriptors.set(envelope.name, {
 			codecId: handle.codecId,
 			nativeType: handle.nativeType
 		});
@@ -3109,9 +3058,11 @@ function interpretPslDocumentToSqlContract(input) {
 	const composedExtensionNames = new Set(input.composedExtensions ?? []);
 	const modelAttributesByName = buildModelAttributesByName(input.authoringContributions);
 	const contributedModelSpecs = modelAttributeSpecsFrom(modelAttributesByName);
+	const composedPslBlockDescriptors = input.authoringContributions?.pslBlockDescriptors ?? {};
 	const { binder, diagnostics: binderDiagnostics } = createSqlBinder({
 		symbolTable: input.symbolTable,
 		sources: input.sources,
+		pslBlockDescriptors: composedPslBlockDescriptors,
 		authoringContributions: input.authoringContributions,
 		controlMutationDefaults: {
 			defaultFunctionRegistry: input.controlMutationDefaults?.defaultFunctionRegistry ?? /* @__PURE__ */ new Map(),
@@ -3142,10 +3093,17 @@ function interpretPslDocumentToSqlContract(input) {
 		binder,
 		diagnostics
 	});
+	const { parsedBlocks, diagnostics: blockDiagnostics } = interpretExtensionBlocks({
+		symbolTable: input.symbolTable,
+		sources: input.sources,
+		pslBlockDescriptors: composedPslBlockDescriptors,
+		binder
+	});
+	diagnostics.push(...blockDiagnostics);
 	validateBlockModelAttributeRequirements({
-		scopes: [topLevel, ...namespaceSymbols],
-		pslBlockDescriptors: input.authoringContributions?.pslBlockDescriptors ?? {},
-		source,
+		parsedBlocks,
+		pslBlockDescriptors: composedPslBlockDescriptors,
+		sources: input.sources,
 		diagnostics
 	});
 	const models = [];
@@ -3210,6 +3168,7 @@ function interpretPslDocumentToSqlContract(input) {
 	}
 	const enumResult = processEnumDeclarations({
 		enumBlocks: topLevelEnums,
+		parsedBlocks,
 		source,
 		authoringContributions: input.authoringContributions,
 		entityContext: {
@@ -3241,35 +3200,38 @@ function interpretPslDocumentToSqlContract(input) {
 		warnings: authoringWarnings
 	};
 	const earlyModelMappingsByCoordinate = buildModelMappings(input.symbolTable, modelEntries, defaultNamespaceId, createPslDiagnosticCollector(input.sources), input.sources, binder);
-	const composedPslBlockDescriptors = input.authoringContributions?.pslBlockDescriptors ?? {};
+	const modelCoordinates = /* @__PURE__ */ new Map();
+	for (const entry of modelEntries) {
+		const nsId = entry.namespaceId ?? defaultNamespaceId;
+		const mapping = earlyModelMappingsByCoordinate.get(modelCoordinateKey(nsId, entry.model.name));
+		if (mapping !== void 0) modelCoordinates.set(entry.model, {
+			namespaceId: nsId,
+			tableName: mapping.tableName
+		});
+	}
+	const modelCoordinateOf = (model) => modelCoordinates.get(model);
 	const namespaceExtensionEntities = /* @__PURE__ */ new Map();
-	const mergeNamespaceExtensionEntities = (nsId, entities, blocks) => {
-		if (Object.keys(entities).length === 0) return;
-		const existing = namespaceExtensionEntities.get(nsId);
-		if (existing === void 0) {
-			namespaceExtensionEntities.set(nsId, entities);
-			return;
-		}
-		const merged = { ...existing };
-		for (const [entriesKey, slot] of Object.entries(entities)) {
-			const existingSlot = existing[entriesKey];
-			if (existingSlot !== void 0) {
-				for (const name of Object.keys(slot)) if (Object.hasOwn(existingSlot, name)) {
-					const block = Object.values(blocks).find((block) => block.name === name);
-					invariant(block !== void 0, "Lowered entity has an owning block");
-					diagnostics.pushUnlocated({
-						code: "PSL_DUPLICATE_EXTENSION_ENTITY",
-						message: `entries slot "${entriesKey}" in namespace "${nsId}": entity "${name}" is declared more than once in the same namespace.`,
-						...diagnosticSource(input.sources, block.node.syntax).at()
-					});
-				}
+	const fileExtensionEntityRows = (rows, blocks) => {
+		for (const row of rows) {
+			let entities = namespaceExtensionEntities.get(row.namespaceId);
+			if (entities === void 0) {
+				entities = {};
+				namespaceExtensionEntities.set(row.namespaceId, entities);
 			}
-			merged[entriesKey] = {
-				...existingSlot,
-				...slot
-			};
+			const slot = entities[row.entityKind] ?? {};
+			entities[row.entityKind] = slot;
+			if (Object.hasOwn(slot, row.key)) {
+				const block = Object.values(blocks).find((candidate) => candidate.name === row.key);
+				invariant(block !== void 0, "Lowered entity has an owning block");
+				diagnostics.pushUnlocated({
+					code: "PSL_DUPLICATE_EXTENSION_ENTITY",
+					message: `entries slot "${row.entityKind}" in namespace "${row.namespaceId}": entity "${row.key}" is declared more than once in the same namespace.`,
+					...diagnosticSource(input.sources, block.node.syntax).at()
+				});
+				continue;
+			}
+			slot[row.key] = row.entity;
 		}
-		namespaceExtensionEntities.set(nsId, merged);
 	};
 	for (const ns of namespaceSymbols) {
 		if (ns.name === UNSPECIFIED_PSL_NAMESPACE_ID) continue;
@@ -3278,15 +3240,12 @@ function interpretPslDocumentToSqlContract(input) {
 			targetId: input.target.targetId
 		});
 		if (nsId === void 0) continue;
-		mergeNamespaceExtensionEntities(nsId, lowerExtensionBlocksForNamespace(ns.blocks, nsId, entityTypesByDiscriminator, extensionEntityContext, composedPslBlockDescriptors, (modelName) => earlyModelMappingsByCoordinate.get(modelCoordinateKey(nsId, modelName))?.tableName, input.sources, diagnostics), ns.blocks);
-	}
-	if (Object.keys(topLevelExtensionBlocks).length > 0) {
-		const topLevelNsId = resolveNamespaceIdForSqlTarget({
-			bucketName: UNSPECIFIED_PSL_NAMESPACE_ID,
-			targetId: input.target.targetId
-		}) ?? defaultNamespaceId;
-		mergeNamespaceExtensionEntities(topLevelNsId, lowerExtensionBlocksForNamespace(topLevelExtensionBlocks, topLevelNsId, entityTypesByDiscriminator, extensionEntityContext, composedPslBlockDescriptors, (modelName) => earlyModelMappingsByCoordinate.get(modelCoordinateKey(topLevelNsId, modelName))?.tableName, input.sources, diagnostics), topLevelExtensionBlocks);
+		fileExtensionEntityRows(lowerExtensionBlocksForNamespace(ns.blocks, nsId, entityTypesByDiscriminator, extensionEntityContext, parsedBlocks, modelCoordinateOf, input.sources), ns.blocks);
 	}
+	if (Object.keys(topLevelExtensionBlocks).length > 0) fileExtensionEntityRows(lowerExtensionBlocksForNamespace(topLevelExtensionBlocks, resolveNamespaceIdForSqlTarget({
+		bucketName: UNSPECIFIED_PSL_NAMESPACE_ID,
+		targetId: input.target.targetId
+	}) ?? defaultNamespaceId, entityTypesByDiscriminator, extensionEntityContext, parsedBlocks, modelCoordinateOf, input.sources), topLevelExtensionBlocks);
 	const defaultNsExtensionValueSets = namespaceExtensionEntities.get(defaultNamespaceId)?.["valueSet"];
 	if (defaultNsExtensionValueSets !== void 0) {
 		for (const name of Object.keys(defaultNsExtensionValueSets)) if (Object.hasOwn(validEnumHandles, name)) {
@@ -3356,7 +3315,8 @@ function interpretPslDocumentToSqlContract(input) {
 			...ifDefined("codecLookup", input.codecLookup),
 			modelAttributesByName,
 			contributedModelAttributeSpecs: contributedModelSpecs,
-			defaultNamespaceId
+			defaultNamespaceId,
+			parsedBlocks
 		});
 		modelNodes.push(namespaceId !== void 0 ? {
 			...result.modelNode,
@@ -3518,4 +3478,4 @@ function interpretPslDocumentToSqlContract(input) {
 //#endregion
 export { interpretPslDocumentToSqlContract as a, resolveFieldTypeDescriptor as c, indexFkRelations as i, buildEntityTypesByDiscriminator as n, normalizeReferentialAction as o, entryForTag as r, readDataTypeDefault as s, applyBackrelationCandidates as t };
 
-//# sourceMappingURL=interpreter-BrW0_y8Q-ChkFlzaN.mjs.map
+//# sourceMappingURL=interpreter-BMMGMTBa-CT5iKl13.mjs.map