@prisma-next/sql-contract-ts 0.14.0-dev.80 → 0.14.0-dev.82

package/dist/contract-builder.mjs

@@ -1,10 +1,11 @@
-import { t as buildSqlContractFromDefinition } from "./build-contract-C07F2P2K.mjs";
+import { t as buildSqlContractFromDefinition } from "./build-contract-BzAyIu0y.mjs";
 import { blindCast } from "@prisma-next/utils/casts";
 import { ifDefined } from "@prisma-next/utils/defined";
 import { isColumnDefault } from "@prisma-next/contract/types";
 import { bindEnumType, createEntityHelpersFromNamespace, enumType, isEnumTypeHandle, member } from "@prisma-next/contract-authoring";
-import { assertNoCrossRegistryCollisions, instantiateAuthoringFieldPreset, instantiateAuthoringTypeConstructor, isAuthoringFieldPresetDescriptor, isAuthoringTypeConstructorDescriptor, mergeAuthoringNamespaces, validateAuthoringHelperArguments } from "@prisma-next/framework-components/authoring";
+import { assertNoCrossRegistryCollisions, instantiateAuthoringFieldPreset, instantiateAuthoringTypeConstructor, isAuthoringEntityTypeDescriptor, isAuthoringFieldPresetDescriptor, isAuthoringTypeConstructorDescriptor, mergeAuthoringNamespaces, validateAuthoringHelperArguments } from "@prisma-next/framework-components/authoring";
 import { toStorageTypeInstance } from "@prisma-next/sql-contract/types";
+import { providesEntityHandleLowering } from "@prisma-next/sql-contract/entity-handle-lowering-hook";
 //#region src/authoring-helper-runtime.ts
 function isNamedConstraintOptionsLike(value) {
 	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
@@ -1190,9 +1191,120 @@ function lowerModels(collection, extensionPacks) {
 	const storageTypeReverseLookup = buildStorageTypeReverseLookup(collection.storageTypes);
 	return Array.from(collection.modelSpecs.values()).map((spec) => resolveModelNode(spec, collection.modelSpecs, collection.storageTypes, storageTypeReverseLookup, extensionPacks));
 }
+/**
+* Kind-agnostic walk over the author-declared `entities` handle list:
+*
+* 1. Index the bound packs' `entityTypes` contributions by discriminator so
+*    each handle's `entityKind` maps to the pack that registered it; a
+*    handle whose kind no composed pack registers is an error naming the
+*    kind.
+* 2. Resolve each handle's declared model refs (`handle.refs`, actual
+*    model-handle objects) to storage table coordinates — identity against
+*    the contract's `models` record first, then the handle's declared model
+*    name against the build's model specs; never by re-deriving a table
+*    name. A cross-space (extensionModel) handle resolves to its own
+*    coordinate annotated with `spaceId`.
+* 3. Call each owning pack's batch lowering hook once with all of its
+*    claimed handles, and fold the returned rows into the namespace-scoped
+*    attachments (namespace → kind → key), rejecting two different entities
+*    in one slot. The result becomes `ContractDefinition.attachedEntities`.
+*
+* No entity kind is named anywhere in this walk.
+*/
+function lowerPackEntityHandles(definition, modelSpecs) {
+	const entities = definition.entities;
+	if (entities === void 0 || entities.length === 0) return void 0;
+	const components = [definition.target, ...Object.values(definition.extensionPacks ?? {})];
+	const owningComponent = /* @__PURE__ */ new Map();
+	const walkEntityTypes = (namespace, component) => {
+		for (const value of Object.values(namespace)) if (isAuthoringEntityTypeDescriptor(value)) owningComponent.set(value.discriminator, component);
+		else walkEntityTypes(value, component);
+	};
+	for (const component of components) {
+		const entityTypes = component.authoring?.entityTypes;
+		if (entityTypes !== void 0) walkEntityTypes(entityTypes, component);
+	}
+	const defaultNamespaceId = definition.target.defaultNamespaceId;
+	const modelNamesByIdentity = /* @__PURE__ */ new Map();
+	for (const [modelName, modelBuilder] of Object.entries(definition.models ?? {})) modelNamesByIdentity.set(modelBuilder, modelName);
+	const coordinateOf = (modelName) => {
+		const spec = modelSpecs.get(modelName);
+		if (spec === void 0) return void 0;
+		return {
+			kind: "resolved",
+			namespaceId: spec.namespace ?? defaultNamespaceId,
+			tableName: spec.tableName,
+			modelName
+		};
+	};
+	const declaredModelName = (value) => {
+		if (typeof value !== "object" || value === null || !("stageOne" in value)) return void 0;
+		const stageOne = value.stageOne;
+		if (typeof stageOne !== "object" || stageOne === null || !("modelName" in stageOne)) return;
+		return typeof stageOne.modelName === "string" ? stageOne.modelName : void 0;
+	};
+	const resolveRef = (value) => {
+		const modelName = declaredModelName(value);
+		if (isCrossSpaceHandle(value)) {
+			const tableName = value.tableName;
+			const namespaceId = value.stageOne.namespace;
+			if (tableName !== void 0 && namespaceId !== void 0) return {
+				kind: "cross-space",
+				spaceId: value.spaceId,
+				namespaceId,
+				tableName,
+				...ifDefined("modelName", modelName)
+			};
+			return {
+				kind: "unresolved",
+				...ifDefined("modelName", modelName)
+			};
+		}
+		const identityName = modelNamesByIdentity.get(value);
+		return (identityName !== void 0 ? coordinateOf(identityName) : void 0) ?? (modelName !== void 0 ? coordinateOf(modelName) : void 0) ?? {
+			kind: "unresolved",
+			...ifDefined("modelName", modelName)
+		};
+	};
+	const claimed = /* @__PURE__ */ new Map();
+	for (const handle of entities) {
+		const component = owningComponent.get(handle.entityKind);
+		if (component === void 0) throw new Error(`defineContract: entities contains a handle with entityKind "${handle.entityKind}", which no composed pack registers. Compose a pack whose entityTypes contribution claims "${handle.entityKind}", or remove the handle.`);
+		const refs = {};
+		for (const [refName, refValue] of Object.entries(handle.refs ?? {})) refs[refName] = resolveRef(refValue);
+		const forComponent = claimed.get(component) ?? [];
+		forComponent.push({
+			handle,
+			refs
+		});
+		claimed.set(component, forComponent);
+	}
+	const pack = {};
+	for (const [component, handles] of claimed) {
+		const authoring = component.authoring;
+		if (!providesEntityHandleLowering(authoring)) {
+			const kinds = [...new Set(handles.map((entry) => entry.handle.entityKind))].sort();
+			throw new Error(`defineContract: entityKind(s) ${kinds.map((kind) => `"${kind}"`).join(", ")} are registered by a pack that does not implement entity-handle lowering (no lowerEntityHandles on its authoring contributions).`);
+		}
+		for (const row of authoring.lowerEntityHandles({
+			handles,
+			defaultNamespaceId
+		})) {
+			const forNamespace = pack[row.namespaceId] ?? {};
+			pack[row.namespaceId] = forNamespace;
+			const forKind = forNamespace[row.entityKind] ?? {};
+			forNamespace[row.entityKind] = forKind;
+			const existing = forKind[row.key];
+			if (existing !== void 0 && existing !== row.entity) throw new Error(`defineContract: two different "${row.entityKind}" entities named "${row.key}" in namespace "${row.namespaceId}" — pack-entity names must be unique per namespace.`);
+			forKind[row.key] = row.entity;
+		}
+	}
+	return pack;
+}
 function buildContractDefinition(definition) {
 	const collection = collectRuntimeModelSpecs(definition);
 	const models = lowerModels(collection, definition.extensionPacks);
+	const attachedEntities = lowerPackEntityHandles(definition, collection.modelSpecs);
 	return {
 		target: definition.target,
 		...ifDefined("defaultControlPolicy", definition.defaultControlPolicy),
@@ -1203,7 +1315,7 @@ function buildContractDefinition(definition) {
 		...definition.namespaces ? { namespaces: definition.namespaces } : {},
 		createNamespace: definition.createNamespace,
 		...definition.enums && Object.keys(definition.enums).length > 0 ? { enums: definition.enums } : {},
-		...definition.packEntities && Object.keys(definition.packEntities).length > 0 ? { packEntities: definition.packEntities } : {},
+		...attachedEntities && Object.keys(attachedEntities).length > 0 ? { attachedEntities } : {},
 		models
 	};
 }
@@ -1291,29 +1403,6 @@ function buildContractFromDsl(definition) {
 	validatePerModelNamespaces(definition.target, definition.namespaces, definition.models ?? {});
 	return blindCast(buildSqlContractFromDefinition(buildContractDefinition(definition), definition.codecLookup));
 }
-function mergePackEntityNames(namespaceId, kind, a, b) {
-	if (a !== void 0 && b !== void 0) for (const [name, entity] of Object.entries(b)) {
-		const existing = a[name];
-		if (existing !== void 0 && existing !== entity) throw new Error(`defineContract: two different "${kind}" entities named "${name}" in namespace "${namespaceId}" — a factory-returned pack entity conflicts with a scaffold-declared one; pack-entity names must be unique per namespace.`);
-	}
-	return {
-		...a ?? {},
-		...b ?? {}
-	};
-}
-function mergePackEntityKinds(namespaceId, a, b) {
-	const kinds = /* @__PURE__ */ new Set([...Object.keys(a ?? {}), ...Object.keys(b ?? {})]);
-	const result = {};
-	for (const kind of kinds) result[kind] = mergePackEntityNames(namespaceId, kind, a?.[kind], b?.[kind]);
-	return result;
-}
-function mergePackEntities(a, b) {
-	if (a === void 0 && b === void 0) return void 0;
-	const namespaces = /* @__PURE__ */ new Set([...Object.keys(a ?? {}), ...Object.keys(b ?? {})]);
-	const result = {};
-	for (const namespaceId of namespaces) result[namespaceId] = mergePackEntityKinds(namespaceId, a?.[namespaceId], b?.[namespaceId]);
-	return result;
-}
 /** Implementation. */
 function buildBoundContract(family, target, definition, factory) {
 	const full = {
@@ -1331,13 +1420,13 @@ function buildBoundContract(family, target, definition, factory) {
 			...definition.enums ?? {},
 			...built.enums
 		};
-		const mergedPackEntities = mergePackEntities(definition.packEntities, built.packEntities);
+		const mergedEntities = [...definition.entities ?? [], ...built.entities ?? []];
 		return buildContractFromDsl({
 			...full,
 			...ifDefined("types", built.types),
 			...ifDefined("models", built.models),
 			...ifDefined("enums", Object.keys(mergedEnums).length > 0 ? mergedEnums : void 0),
-			...ifDefined("packEntities", mergedPackEntities)
+			...ifDefined("entities", mergedEntities.length > 0 ? mergedEntities : void 0)
 		});
 	}
 	return buildContractFromDsl(full);
@@ -1348,6 +1437,6 @@ function defineContract(definition, factory) {
 	return buildBoundContract(definition.family, definition.target, definition);
 }
 //#endregion
-export { bindEnumType, buildBoundContract, buildSqlContractFromDefinition, defineContract, enumType, extensionModel, field, member, model, rel };
+export { bindEnumType, buildBoundContract, buildContractDefinition, buildSqlContractFromDefinition, defineContract, enumType, extensionModel, field, member, model, rel };
 
 //# sourceMappingURL=contract-builder.mjs.map