@prisma/orm-family-sql 8.0.0-rc.21-dev.5 → 8.0.0-rc.21-dev.7

package/dist/{derived-checks-D5HVRvqN-BJx1gwPA.mjs → derived-checks-D__agoFB-Boa1MHcA.mjs}

@@ -1,32 +1,33 @@
 import { i as indexTypeRegistryOf } from "./index-types-pC_5vADQ-BOOBi14R.mjs";
-import { i as computeCheckContentHash, r as composeCheckWirePrefix, s as derivedCheckPrefixes } from "./naming-bM5qm5PY-jOg3JFMb.mjs";
-import { r as lowerAuthoredIndex } from "./index-naming-BOcJT1B3-mG8Fd6KN.mjs";
-import { t as lowerAuthoredCheck } from "./authored-check-naming-BHGJhjqn.mjs";
+import { a as computeCheckContentHash, c as derivedCheckPrefixes, i as composeCheckWirePrefix, t as CHECK_KINDS } from "./naming-DEpT6Zad-C9PFkWt6.mjs";
+import { r as lowerAuthoredIndex } from "./index-naming-BOcJT1B3-D-49owHA.mjs";
+import { t as lowerAuthoredCheck } from "./authored-check-naming-DTKcH2_d.mjs";
 import { t as sqlContractCanonicalizationHooks } from "./canonicalization-hooks-Ce1v_TDl.mjs";
-import { p as sqlDataTypeOfCodec, y as validateSqlTypeParams } from "./sql-data-type-D7M-YTTY-D2vRqDxn.mjs";
-import { c as StorageTable, i as Index, t as CheckConstraint } from "./storage-table-DDvN83mw-DkbBFmK9.mjs";
-import { n as checkConstraintInputFromSerialized } from "./serialized-index-DjCCnXB1-DMA7BtO2.mjs";
-import { m as valueSetEntityKind, p as tableEntityKind } from "./entity-kinds-JR5SAm5h-DOH6VUtL.mjs";
-import { a as materializeForeignKeysAndIndexes } from "./foreign-key-materialization-BM59w_Xg.mjs";
+import { n as resolveColumnValueObject, t as discriminatorValueSet } from "./check-expressions-BDsLvzqN.mjs";
+import { p as sqlDataTypeOfCodec, y as validateSqlTypeParams } from "./sql-data-type-LVBldu1a-Bq203xWX.mjs";
+import { i as Index, s as StorageTable, t as CheckConstraint } from "./storage-table-B_MrLtQX-eWx6BgGT.mjs";
+import { n as checkConstraintInputFromSerialized } from "./serialized-index-BefvjuZ0-Bbsja7If.mjs";
+import { h as valueSetEntityKind, p as tableEntityKind } from "./entity-kinds-CgEwK0hH-D1NKoKE5.mjs";
+import { a as materializeForeignKeysAndIndexes } from "./foreign-key-materialization-CCHAR789.mjs";
 import { t as validateIndexTypes } from "./index-type-validation-DJEMmmw0.mjs";
-import { c as isMaterializedSqlNamespace, d as nonEmptyTypeParams, f as toStorageTypeInstance, o as SqlStorage, s as applyFkDefaults } from "./types-CTdSkl0s.mjs";
-import { h as validateStorageSemantics } from "./validators-BwA7ttZM.mjs";
+import { c as isMaterializedSqlNamespace, d as nonEmptyTypeParams, f as toStorageTypeInstance, o as SqlStorage, s as applyFkDefaults } from "./types-CISwoRED.mjs";
+import { h as validateStorageSemantics } from "./validators-qcQteqs2.mjs";
 import { t as deriveValueSetFromEntity } from "./value-set-derivation-hook-HVaxhALD.mjs";
 import { isStructuredError, structuredError } from "@prisma/orm-framework/utils/structured-error";
 import { ifDefined } from "@prisma/orm-framework/utils/defined";
 import { flushAuthoringWarnings, isAuthoringEntityTypeDescriptor } from "@prisma/orm-framework/components/authoring";
 import { compareCodeUnits } from "@prisma/orm-framework/contract/hashing-utils";
 import { UNBOUND_NAMESPACE_ID } from "@prisma/orm-framework/components/ir";
+import { asNamespaceId, coreHash, crossRef, effectiveControlPolicy } from "@prisma/orm-framework/contract/types";
+import { invariant } from "@prisma/orm-framework/utils/assertions";
 import { codecForRef, dataTypeParams } from "@prisma/orm-framework/components/codec";
 import { blindCast } from "@prisma/orm-framework/utils/casts";
 import { InternalError } from "@prisma/orm-framework/utils/internal-error";
-import { asNamespaceId, coreHash, crossRef, effectiveControlPolicy } from "@prisma/orm-framework/contract/types";
 import { mergeCapabilityMatrices } from "@prisma/orm-framework/components/components";
 import { encodeEnumTypeMembers, resolveToOneRelationNullable } from "@prisma/orm-framework/contract-authoring";
 import { buildExecutionSection, computeProfileHash, computeStorageHash } from "@prisma/orm-framework/contract/hashing";
-import { invariant } from "@prisma/orm-framework/utils/assertions";
 import { applySpecifierDefaultControlPolicy } from "@prisma/orm-framework/contract/apply-specifier-default-control-policy";
-//#region ../../../2-sql-family/2-authoring/contract-ts/dist/derived-checks-D5HVRvqN.mjs
+//#region ../../../2-sql-family/2-authoring/contract-ts/dist/derived-checks-D__agoFB.mjs
 function contractError(code, message, options) {
 	return structuredError(code, message, options);
 }
@@ -49,6 +50,7 @@ function describeColumn(column, site) {
 		many: column.many === true ? { elementNullable: column.elementNullable === true } : false,
 		default: column.default,
 		enumTypeHandle: column.enumTypeHandle,
+		valueObject: void 0,
 		site
 	};
 }
@@ -90,14 +92,24 @@ function enumValueSetRefs(enumHandle, defaultNamespaceId) {
 		}
 	};
 }
-function buildDomainField(field, defaultNamespaceId) {
+/** The storage coordinate of a value object. Value objects are all in the default namespace. */
+function valueObjectReference(valueObjectName, defaultNamespaceId) {
+	return {
+		plane: "storage",
+		namespaceId: defaultNamespaceId,
+		entityKind: "valueObject",
+		entityName: valueObjectName
+	};
+}
+function fieldWithoutValueSet(field, defaultNamespaceId) {
+	const many = field.many ? { elementNullable: field.elementNullable === true } : false;
 	if (isValueObjectMember(field)) return {
 		type: {
 			kind: "valueObject",
-			name: field.valueObjectName
+			...valueObjectReference(field.valueObjectName, defaultNamespaceId)
 		},
 		nullable: field.nullable,
-		many: field.many ? { elementNullable: field.elementNullable === true } : false
+		many
 	};
 	return {
 		type: {
@@ -106,8 +118,24 @@ function buildDomainField(field, defaultNamespaceId) {
 			...ifDefined("typeParams", nonEmptyTypeParams(field.descriptor.typeParams))
 		},
 		nullable: field.nullable,
-		many: field.many ? { elementNullable: field.elementNullable === true } : false,
-		...ifDefined("valueSet", enumValueSetRefs(field.enumTypeHandle, defaultNamespaceId)?.domain)
+		many
+	};
+}
+function enumRefsOf(field, defaultNamespaceId) {
+	return isValueObjectMember(field) ? void 0 : enumValueSetRefs(field.enumTypeHandle, defaultNamespaceId);
+}
+/** A model field in the domain plane. A value object is referred to by its storage coordinate, an enum by the domain enum. */
+function buildDomainField(field, defaultNamespaceId) {
+	return {
+		...fieldWithoutValueSet(field, defaultNamespaceId),
+		...ifDefined("valueSet", enumRefsOf(field, defaultNamespaceId)?.domain)
+	};
+}
+/** A member of a storage value object. Storage never refers to the domain plane, so an enum member refers to the storage value set. */
+function buildValueObjectMember(field, defaultNamespaceId) {
+	return {
+		...fieldWithoutValueSet(field, defaultNamespaceId),
+		...ifDefined("valueSet", enumRefsOf(field, defaultNamespaceId)?.storage)
 	};
 }
 /** How an error message names the column: `Field "Model.field"` or `Column "table.column"`. */
@@ -391,6 +419,9 @@ function hasColumnTypeQualifier(authoring) {
 function hasCheckExpressionRenderer(authoring) {
 	return "renderCheckExpressions" in authoring && typeof authoring.renderCheckExpressions === "function";
 }
+/**
+* The target's check renderer, contributed through `target.authoring.renderCheckExpressions`. The target owns the SQL of each check and the family names it, so the family never depends on a property of text it cannot read. `memberValues` is supplied only for a domain enum authored through an `enumType()` handle and for a discriminator column, so a target cannot write a membership check for a column whose native type already enforces its member set. Targets without the hook write no checks.
+*/
 function resolveCheckExpressionRenderer(target) {
 	const authoring = target.authoring;
 	if (authoring === void 0) return void 0;
@@ -457,7 +488,7 @@ function describeModel(model, context) {
 			kind: "model",
 			modelName: model.modelName
 		}
-	}, context)));
+	}, context)), context.defaultNamespaceId);
 	const storageFields = {};
 	for (const [fieldName, columnName] of Object.entries(fieldToColumn)) storageFields[fieldName] = { column: columnName };
 	const columnToField = new Map(Object.entries(fieldToColumn).map(([field, col]) => [col, field]));
@@ -473,7 +504,10 @@ function describeModel(model, context) {
 					fields: storageFields
 				},
 				fields: domainFields,
-				relations: lowerRelations(model, columnToField, context)
+				relations: lowerRelations(model, columnToField, context),
+				...ifDefined("discriminator", model.discriminator),
+				...ifDefined("variants", model.variants),
+				...ifDefined("base", model.base)
 			},
 			executionDefaults
 		}
@@ -482,9 +516,9 @@ function describeModel(model, context) {
 /**
 * Single-table-inheritance variants share their base model's table: the variant's columns must already be on that table, and it has no table of its own. That leaves an authored check nowhere to attach, so it is refused here as a backstop; the PSL surface refuses it earlier, at interpretation, with a diagnostic that names the base model.
 */
-function describeModelStorage(model, namespaceId, foreignKeys) {
+function describeModelStorage(model, namespaceId, foreignKeys, defaultNamespaceId) {
 	const { tableName } = model;
-	const columns = model.fields.map((field) => describeFieldColumn(model.modelName, field));
+	const columns = model.fields.map((field) => describeFieldColumn(model.modelName, field, defaultNamespaceId));
 	if (model.sharesBaseTable) {
 		if (model.checks && model.checks.length > 0) throw contractError("CONTRACT.CHECK_ON_STI_VARIANT", `Model "${model.modelName}" declares a check constraint but shares its base model's storage table (single-table inheritance) and has no table of its own to declare it on. Declare the check on the base model instead.`, { meta: {
 			tableName,
@@ -514,18 +548,24 @@ function describeModelStorage(model, namespaceId, foreignKeys) {
 		}
 	};
 }
-function describeFieldColumn(modelName, field) {
+function describeFieldColumn(modelName, field, defaultNamespaceId) {
 	const site = {
 		kind: "field",
 		modelName,
 		fieldName: field.fieldName
 	};
-	if (isValueObjectMember(field)) return describeColumn({
-		columnName: field.columnName,
-		descriptor: field.descriptor,
-		nullable: field.nullable,
-		...ifDefined("default", field.default)
-	}, site);
+	if (isValueObjectMember(field)) return {
+		...describeColumn({
+			columnName: field.columnName,
+			descriptor: field.descriptor,
+			nullable: field.nullable,
+			...ifDefined("default", field.default)
+		}, site),
+		valueObject: {
+			reference: valueObjectReference(field.valueObjectName, defaultNamespaceId),
+			many: field.many === true ? { elementNullable: field.elementNullable === true } : false
+		}
+	};
 	return describeColumn(field, site);
 }
 function executionDefaultOf(field) {
@@ -886,16 +926,19 @@ function lowerColumn(description, placement, context) {
 	const candidates = render({
 		tableName: placement.tableName,
 		columnName: description.columnName,
-		many: many !== false,
-		elementNullable,
-		memberValues: enumTypeHandle !== void 0 ? checkMemberValues(enumTypeHandle, codecLookup) : void 0
+		many,
+		memberValues: enumTypeHandle !== void 0 ? checkMemberValues(enumTypeHandle, codecLookup) : void 0,
+		valueObject: description.valueObject !== void 0 ? resolveColumnValueObject(context.storage, {
+			reference: description.valueObject.reference,
+			nullable: description.nullable,
+			many: description.valueObject.many
+		}, codecLookup) : void 0
 	});
 	return {
 		column,
 		derivedChecks: lowerRenderedChecks(placement.tableName, candidates)
 	};
 }
-const DERIVABLE_CHECK_KINDS = ["membership", "elementNotNull"];
 /**
 * Which of `columnNames` could have produced `prefix` for some
 * {@link CheckKind} — the reverse of {@link derivedCheckPrefixes}, used only
@@ -904,7 +947,7 @@ const DERIVABLE_CHECK_KINDS = ["membership", "elementNotNull"];
 * columnNames)`, so the result is never empty.
 */
 function columnsProducingCheckPrefix(tableName, columnNames, prefix) {
-	return columnNames.filter((columnName) => DERIVABLE_CHECK_KINDS.some((kind) => composeCheckWirePrefix(tableName, columnName, kind) === prefix));
+	return columnNames.filter((columnName) => CHECK_KINDS.some((kind) => composeCheckWirePrefix(tableName, columnName, kind) === prefix));
 }
 /**
 * Lowers one table: each of its columns, then its indexes, checks, primary key, uniques and foreign keys, with the backing indexes its foreign keys need.
@@ -1185,6 +1228,77 @@ function enabledCapabilities(matrix) {
 	}
 	return enabled;
 }
+/** The value objects of a definition as storage entities, all in the default namespace; `undefined` when it has none. */
+function valueObjectsFromDefinition(definition, defaultNamespaceId) {
+	if (definition.valueObjects === void 0 || definition.valueObjects.length === 0) return;
+	return Object.fromEntries(definition.valueObjects.map((valueObject) => [valueObject.name, { fields: Object.fromEntries(valueObject.fields.map((field) => [field.fieldName, buildValueObjectMember(field, defaultNamespaceId)])) }]));
+}
+/** The value objects and value sets storage will hold, in the shape storage readers take. */
+function storageOf(defaultNamespaceId, valueObjects, storageValueSetsByNs) {
+	const namespaceIds = /* @__PURE__ */ new Set([defaultNamespaceId, ...Object.keys(storageValueSetsByNs)]);
+	return { namespaces: Object.fromEntries([...namespaceIds].map((id) => [id, {
+		id,
+		entries: {
+			valueSet: storageValueSetsByNs[id] ?? {},
+			...id === defaultNamespaceId ? { valueObject: valueObjects ?? {} } : {}
+		}
+	}])) };
+}
+/**
+* Writes the value set of each discriminator, keyed `<Base>.<field>` in the base table's namespace and holding the variants' values as the column stores them, sorted, and points the discriminator column at it (ADR 309). A column an enum types keeps the enum's value set. An enum with the same name in the same namespace is refused, since the two value sets would share one entry.
+*/
+function writeDiscriminatorValueSets(definition, tablesByNamespace, storageValueSetsByNs, checkRendererFor) {
+	const defaultNamespaceId = definition.target.defaultNamespaceId;
+	for (const model of definition.models) {
+		const { discriminator, variants } = model;
+		if (discriminator === void 0 || variants === void 0) continue;
+		const namespaceId = modelNamespaceId(model, defaultNamespaceId);
+		const table = tablesByNamespace[namespaceId]?.[model.tableName];
+		const columnName = model.fields.find((field) => field.fieldName === discriminator.field)?.columnName;
+		const column = columnName === void 0 ? void 0 : table?.columns[columnName];
+		if (table === void 0 || columnName === void 0 || column === void 0) continue;
+		if (column.valueSet !== void 0) continue;
+		const { name: valueSetName, values } = discriminatorValueSet(model.modelName, discriminator.field, Object.keys(variants));
+		const namespaceValueSets = storageValueSetsByNs[namespaceId] ?? {};
+		if (Object.hasOwn(namespaceValueSets, valueSetName)) throw contractError("CONTRACT.ENUM_INVALID", `enumType("${valueSetName}"): has the name of the value set that the discriminator field "${discriminator.field}" of model "${model.modelName}" writes. Rename the enum.`, { meta: {
+			enumName: valueSetName,
+			model: model.modelName,
+			field: discriminator.field,
+			reason: "discriminator-value-set-name"
+		} });
+		namespaceValueSets[valueSetName] = {
+			kind: "valueSet",
+			values
+		};
+		storageValueSetsByNs[namespaceId] = namespaceValueSets;
+		const render = checkRendererFor(table);
+		const derivedChecks = render === void 0 ? [] : lowerRenderedChecks(model.tableName, render({
+			tableName: model.tableName,
+			columnName,
+			many: false,
+			memberValues: values,
+			valueObject: void 0
+		}));
+		const namespaceTables = tablesByNamespace[namespaceId] ?? {};
+		namespaceTables[model.tableName] = {
+			...table,
+			...derivedChecks.length > 0 ? { checks: inCanonicalOrder([...(table.checks ?? []).map((check) => CheckConstraint.from(check)), ...derivedChecks]) } : {},
+			columns: {
+				...table.columns,
+				[columnName]: {
+					...column,
+					valueSet: {
+						plane: "storage",
+						entityKind: "valueSet",
+						namespaceId,
+						entityName: valueSetName
+					}
+				}
+			}
+		};
+		tablesByNamespace[namespaceId] = namespaceTables;
+	}
+}
 function buildSqlContractFromDefinition(definition, codecLookup, dataTypeLookup) {
 	refuseTypesKey(definition, "buildSqlContractFromDefinition");
 	const lookups = {
@@ -1236,11 +1350,14 @@ function buildSqlContractFromDefinition(definition, codecLookup, dataTypeLookup)
 	const tableNodes = (definition.tables ?? []).map((table) => describeTableNode(table, modelDescriptionContext));
 	const authoringWarnings = [...definition.warnings ?? []];
 	const collectedColumnEntities = {};
+	const valueObjects = valueObjectsFromDefinition(definition, defaultNamespaceId);
+	const renderCheckExpressions = resolveCheckExpressionRenderer(definition.target);
 	const tableLoweringContext = {
 		lookups,
 		defaultNamespaceId,
 		qualifyColumnType,
-		renderCheckExpressions: resolveCheckExpressionRenderer(definition.target),
+		renderCheckExpressions,
+		storage: storageOf(defaultNamespaceId, valueObjects, storageValueSetsByNs),
 		collectedColumnEntities,
 		defaultControlPolicy: definition.defaultControlPolicy,
 		indexTypeRegistry,
@@ -1255,6 +1372,7 @@ function buildSqlContractFromDefinition(definition, codecLookup, dataTypeLookup)
 		namespaceTables[table.tableName] = lowerTable(table, tableLoweringContext);
 		tablesByNamespace[table.namespaceId] = namespaceTables;
 	}
+	writeDiscriminatorValueSets(definition, tablesByNamespace, storageValueSetsByNs, (table) => renderCheckExpressions !== void 0 && effectiveControlPolicy(table.control, definition.defaultControlPolicy) === "managed" ? renderCheckExpressions : void 0);
 	const executionDefaults = components.flatMap((c) => c.domain.executionDefaults);
 	const modelsByNamespace = {};
 	for (const { domain } of components) {
@@ -1282,7 +1400,8 @@ function buildSqlContractFromDefinition(definition, codecLookup, dataTypeLookup)
 			entries: {
 				table: tablesByNamespace[id] ?? {},
 				...entitiesForNs,
-				...valueSetEntries !== void 0 && Object.keys(valueSetEntries).length > 0 ? { valueSet: valueSetEntries } : {}
+				...valueSetEntries !== void 0 && Object.keys(valueSetEntries).length > 0 ? { valueSet: valueSetEntries } : {},
+				...id === defaultNamespaceId && valueObjects !== void 0 ? { valueObject: valueObjects } : {}
 			}
 		};
 		return [id, createNamespace(nsInput)];
@@ -1321,17 +1440,14 @@ function buildSqlContractFromDefinition(definition, codecLookup, dataTypeLookup)
 		targetFamily,
 		defaults: executionDefaults
 	});
-	const valueObjects = definition.valueObjects && definition.valueObjects.length > 0 ? Object.fromEntries(definition.valueObjects.map((vo) => [vo.name, { fields: Object.fromEntries(vo.fields.map((f) => [f.fieldName, buildDomainField(f, defaultNamespaceId)])) }])) : void 0;
 	const domainNamespaceIds = new Set(Object.keys(modelsByNamespace));
 	if (domainNamespaceIds.size === 0) domainNamespaceIds.add(defaultNamespaceId);
-	if (valueObjects !== void 0) domainNamespaceIds.add(defaultNamespaceId);
 	for (const nsId of Object.keys(domainEnumsByNs)) domainNamespaceIds.add(nsId);
 	const domainNamespaces = Object.fromEntries([...domainNamespaceIds].sort().map((namespaceId) => {
 		const modelsInNs = modelsByNamespace[namespaceId] ?? {};
 		const enumsInNs = domainEnumsByNs[namespaceId];
 		return [namespaceId, {
 			models: modelsInNs,
-			...namespaceId === defaultNamespaceId && valueObjects !== void 0 ? { valueObjects } : {},
 			...enumsInNs !== void 0 && Object.keys(enumsInNs).length > 0 ? { enum: enumsInNs } : {}
 		}];
 	}));
@@ -1505,4 +1621,4 @@ function withoutDerivedChecks(tableName, table, contractDefault) {
 //#endregion
 export { refuseTypesKey as a, isValueObjectMember as i, buildSqlContractFromDefinition as n, storedAsListColumn as o, contractError as r, toOneNullabilityContradictionMessage as s, applySqlSpecifierControlPolicy as t };
 
-//# sourceMappingURL=derived-checks-D5HVRvqN-BJx1gwPA.mjs.map
+//# sourceMappingURL=derived-checks-D__agoFB-Boa1MHcA.mjs.map