@prisma-next/sql-contract-ts 0.11.0-dev.63 → 0.11.0-dev.65

package/dist/contract-builder.mjs

@@ -1,371 +1,10 @@
+import { t as buildSqlContractFromDefinition } from "./build-contract-BEkCxdji.mjs";
 import { blindCast } from "@prisma-next/utils/casts";
-import { computeExecutionHash, computeProfileHash, computeStorageHash } from "@prisma-next/contract/hashing";
-import { asNamespaceId, coreHash, crossRef, isColumnDefault } from "@prisma-next/contract/types";
-import { createEntityHelpersFromNamespace, mergeCapabilityMatrices } from "@prisma-next/contract-authoring";
-import { UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
-import { sqlContractCanonicalizationHooks } from "@prisma-next/sql-contract/canonicalization-hooks";
-import { validateIndexTypes } from "@prisma-next/sql-contract/index-type-validation";
-import { createIndexTypeRegistry } from "@prisma-next/sql-contract/index-types";
-import { SqlStorage, StorageTable, applyFkDefaults, buildSqlNamespace, isPostgresEnumStorageEntry, toStorageTypeInstance } from "@prisma-next/sql-contract/types";
-import { validateStorageSemantics } from "@prisma-next/sql-contract/validators";
+import { isColumnDefault } from "@prisma-next/contract/types";
+import { createEntityHelpersFromNamespace } from "@prisma-next/contract-authoring";
+import { isPostgresEnumStorageEntry, toStorageTypeInstance } from "@prisma-next/sql-contract/types";
 import { ifDefined } from "@prisma-next/utils/defined";
 import { assertNoCrossRegistryCollisions, instantiateAuthoringFieldPreset, instantiateAuthoringTypeConstructor, isAuthoringEntityTypeDescriptor, isAuthoringFieldPresetDescriptor, isAuthoringTypeConstructorDescriptor, mergeAuthoringNamespaces, validateAuthoringHelperArguments } from "@prisma-next/framework-components/authoring";
-//#region src/build-contract.ts
-function encodeDefaultLiteralValue(value, codecId, codecLookup) {
-	const codec = codecLookup?.get(codecId);
-	if (codec) return codec.encodeJson(value);
-	return value;
-}
-function encodeColumnDefault(defaultInput, codecId, codecLookup) {
-	if (defaultInput.kind === "function") return {
-		kind: "function",
-		expression: defaultInput.expression
-	};
-	return {
-		kind: "literal",
-		value: encodeDefaultLiteralValue(defaultInput.value, codecId, codecLookup)
-	};
-}
-function assertStorageSemantics(definition, contract) {
-	const semanticErrors = validateStorageSemantics(contract.storage);
-	if (semanticErrors.length > 0) throw new Error(`Contract semantic validation failed: ${semanticErrors.join("; ")}`);
-	const indexTypeRegistry = createIndexTypeRegistry();
-	const packsToRegister = [definition.target, ...Object.values(definition.extensionPacks ?? {})];
-	for (const pack of packsToRegister) {
-		const registration = pack.indexTypes;
-		if (registration === void 0) continue;
-		if (typeof registration !== "object" || registration === null || !Array.isArray(registration.entries)) throw new Error(`Pack "${pack.id ?? "<unknown>"}" declares "indexTypes" but its value is not an IndexTypeRegistration (expected an object with an "entries" array; got ${typeof registration}).`);
-		for (const entry of registration.entries) indexTypeRegistry.register(entry);
-	}
-	validateIndexTypes(contract, indexTypeRegistry);
-}
-function assertKnownTargetModel(modelsByName, sourceModelName, targetModelName, context) {
-	const targetModel = modelsByName.get(targetModelName);
-	if (!targetModel) throw new Error(`${context} on model "${sourceModelName}" references unknown model "${targetModelName}"`);
-	return targetModel;
-}
-function assertTargetTableMatches(sourceModelName, targetModel, referencedTableName, context) {
-	if (targetModel.tableName !== referencedTableName) throw new Error(`${context} on model "${sourceModelName}" references table "${referencedTableName}" but model "${targetModel.modelName}" maps to "${targetModel.tableName}"`);
-}
-function isValueObjectField(field) {
-	return "valueObjectName" in field;
-}
-const JSONB_CODEC_ID = "pg/jsonb@1";
-const JSONB_NATIVE_TYPE = "jsonb";
-function resolveModelNamespaceId(model, modelNameToNamespaceId) {
-	if (model.namespaceId !== void 0 && model.namespaceId.length > 0) return model.namespaceId;
-	return modelNameToNamespaceId.get(model.modelName) ?? UNBOUND_NAMESPACE_ID;
-}
-function buildStorageColumn(field, codecLookup) {
-	if (isValueObjectField(field)) {
-		const encodedDefault = field.default !== void 0 ? encodeColumnDefault(field.default, JSONB_CODEC_ID, codecLookup) : void 0;
-		return {
-			nativeType: JSONB_NATIVE_TYPE,
-			codecId: JSONB_CODEC_ID,
-			nullable: field.nullable,
-			...ifDefined("default", encodedDefault)
-		};
-	}
-	if (field.many) return {
-		nativeType: JSONB_NATIVE_TYPE,
-		codecId: JSONB_CODEC_ID,
-		nullable: field.nullable
-	};
-	const codecId = field.descriptor.codecId;
-	const encodedDefault = field.default !== void 0 ? encodeColumnDefault(field.default, codecId, codecLookup) : void 0;
-	return {
-		nativeType: field.descriptor.nativeType,
-		codecId,
-		nullable: field.nullable,
-		...ifDefined("typeParams", field.descriptor.typeParams),
-		...ifDefined("default", encodedDefault),
-		...ifDefined("typeRef", field.descriptor.typeRef)
-	};
-}
-function buildDomainField(field, column) {
-	if (isValueObjectField(field)) return {
-		type: {
-			kind: "valueObject",
-			name: field.valueObjectName
-		},
-		nullable: field.nullable,
-		...field.many ? { many: true } : {}
-	};
-	return {
-		type: {
-			kind: "scalar",
-			codecId: column.codecId,
-			...ifDefined("typeParams", column.typeParams)
-		},
-		nullable: column.nullable,
-		...field.many ? { many: true } : {}
-	};
-}
-function collectStorageNamespaceCoordinateIds(definition) {
-	const ids = /* @__PURE__ */ new Set();
-	ids.add(UNBOUND_NAMESPACE_ID);
-	for (const id of definition.namespaces ?? []) if (id.length > 0) ids.add(id);
-	for (const model of definition.models) if (model.namespaceId !== void 0 && model.namespaceId.length > 0) ids.add(model.namespaceId);
-	return ids;
-}
-const POSTGRES_ENUM_NAMESPACE_ID = "public";
-function partitionStorageTypesForTarget(targetId, types, namespaceTypes) {
-	const documentTypes = {};
-	const namespaceEnumTypesById = {};
-	for (const [name, entry] of Object.entries(types)) {
-		if (isPostgresEnumStorageEntry(entry)) {
-			if (targetId !== "postgres") throw new Error(`buildSqlContractFromDefinition: postgres enum "${name}" is only valid when target is "postgres" (got "${targetId}").`);
-			let slot = namespaceEnumTypesById[POSTGRES_ENUM_NAMESPACE_ID];
-			if (slot === void 0) {
-				slot = {};
-				namespaceEnumTypesById[POSTGRES_ENUM_NAMESPACE_ID] = slot;
-			}
-			slot[name] = entry;
-			continue;
-		}
-		documentTypes[name] = entry;
-	}
-	if (namespaceTypes !== void 0) for (const [nsId, enumsInNs] of Object.entries(namespaceTypes)) for (const [name, entry] of Object.entries(enumsInNs)) {
-		if (targetId !== "postgres") throw new Error(`buildSqlContractFromDefinition: postgres enum "${name}" is only valid when target is "postgres" (got "${targetId}").`);
-		let slot = namespaceEnumTypesById[nsId];
-		if (slot === void 0) {
-			slot = {};
-			namespaceEnumTypesById[nsId] = slot;
-		}
-		slot[name] = entry;
-	}
-	return {
-		documentTypes,
-		namespaceEnumTypesById
-	};
-}
-function buildSqlContractFromDefinition(definition, codecLookup) {
-	const target = definition.target.targetId;
-	const targetFamily = "sql";
-	const modelsByName = new Map(definition.models.map((m) => [m.modelName, m]));
-	const tablesByNamespace = {};
-	const tableNameToNamespaceId = /* @__PURE__ */ new Map();
-	const modelNameToNamespaceId = /* @__PURE__ */ new Map();
-	const executionDefaults = [];
-	const models = {};
-	const roots = {};
-	for (const semanticModel of definition.models) {
-		const tableName = semanticModel.tableName;
-		const namespaceId = semanticModel.namespaceId !== void 0 && semanticModel.namespaceId.length > 0 ? semanticModel.namespaceId : UNBOUND_NAMESPACE_ID;
-		modelNameToNamespaceId.set(semanticModel.modelName, namespaceId);
-		roots[tableName] = crossRef(semanticModel.modelName, namespaceId);
-		const columns = {};
-		const fieldToColumn = {};
-		const domainFields = {};
-		const domainFieldRefs = {};
-		for (const field of semanticModel.fields) {
-			const executionDefaultPhases = field.executionDefaults?.onCreate || field.executionDefaults?.onUpdate ? field.executionDefaults : void 0;
-			if (executionDefaultPhases) {
-				if (field.default !== void 0) throw new Error(`Field "${semanticModel.modelName}.${field.fieldName}" cannot define both default and executionDefaults.`);
-				if (field.nullable) throw new Error(`Field "${semanticModel.modelName}.${field.fieldName}" cannot be nullable when executionDefaults are present.`);
-			}
-			const column = buildStorageColumn(field, codecLookup);
-			columns[field.columnName] = column;
-			fieldToColumn[field.fieldName] = field.columnName;
-			domainFields[field.fieldName] = buildDomainField(field, column);
-			if (isValueObjectField(field)) domainFieldRefs[field.fieldName] = {
-				kind: "valueObject",
-				name: field.valueObjectName,
-				...field.many ? { many: true } : {}
-			};
-			else if (field.many) domainFieldRefs[field.fieldName] = {
-				kind: "scalar",
-				many: true
-			};
-			if (executionDefaultPhases) executionDefaults.push({
-				ref: {
-					table: tableName,
-					column: field.columnName
-				},
-				...ifDefined("onCreate", executionDefaultPhases.onCreate),
-				...ifDefined("onUpdate", executionDefaultPhases.onUpdate)
-			});
-		}
-		const foreignKeys = (semanticModel.foreignKeys ?? []).map((fk) => {
-			const targetModel = assertKnownTargetModel(modelsByName, semanticModel.modelName, fk.references.model, "Foreign key");
-			assertTargetTableMatches(semanticModel.modelName, targetModel, fk.references.table, "Foreign key");
-			const targetNamespaceId = fk.references.namespaceId ?? (targetModel.namespaceId !== void 0 && targetModel.namespaceId.length > 0 ? targetModel.namespaceId : UNBOUND_NAMESPACE_ID);
-			return {
-				source: {
-					namespaceId: asNamespaceId(namespaceId),
-					tableName,
-					columns: fk.columns
-				},
-				target: {
-					namespaceId: asNamespaceId(targetNamespaceId),
-					tableName: fk.references.table,
-					columns: fk.references.columns
-				},
-				...applyFkDefaults({
-					...ifDefined("constraint", fk.constraint),
-					...ifDefined("index", fk.index)
-				}, definition.foreignKeyDefaults),
-				...ifDefined("name", fk.name),
-				...ifDefined("onDelete", fk.onDelete),
-				...ifDefined("onUpdate", fk.onUpdate)
-			};
-		});
-		const existingNs = tableNameToNamespaceId.get(tableName);
-		if (existingNs !== void 0 && existingNs !== namespaceId) throw new Error(`buildSqlContractFromDefinition: table "${tableName}" is mapped in namespace "${namespaceId}" but already exists in namespace "${existingNs}".`);
-		tableNameToNamespaceId.set(tableName, namespaceId);
-		const tableInput = {
-			columns,
-			uniques: (semanticModel.uniques ?? []).map((u) => ({
-				columns: u.columns,
-				...ifDefined("name", u.name)
-			})),
-			indexes: (semanticModel.indexes ?? []).map((i) => ({
-				columns: i.columns,
-				...ifDefined("name", i.name),
-				...ifDefined("type", i.type),
-				...ifDefined("options", i.options)
-			})),
-			foreignKeys,
-			...semanticModel.id ? { primaryKey: {
-				columns: semanticModel.id.columns,
-				...ifDefined("name", semanticModel.id.name)
-			} } : {}
-		};
-		let nsTables = tablesByNamespace[namespaceId];
-		if (nsTables === void 0) {
-			nsTables = {};
-			tablesByNamespace[namespaceId] = nsTables;
-		}
-		if (nsTables[tableName] !== void 0) throw new Error(`buildSqlContractFromDefinition: duplicate table "${tableName}" in namespace "${namespaceId}".`);
-		nsTables[tableName] = new StorageTable(tableInput);
-		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]));
-		const modelRelations = {};
-		for (const relation of semanticModel.relations ?? []) {
-			const targetModel = assertKnownTargetModel(modelsByName, semanticModel.modelName, relation.toModel, "Relation");
-			assertTargetTableMatches(semanticModel.modelName, targetModel, relation.toTable, "Relation");
-			if (relation.cardinality === "N:M" && !relation.through) throw new Error(`Relation "${semanticModel.modelName}.${relation.fieldName}" with cardinality "N:M" requires through metadata`);
-			const targetColumnToField = new Map(targetModel.fields.map((f) => [f.columnName, f.fieldName]));
-			modelRelations[relation.fieldName] = {
-				to: crossRef(relation.toModel, resolveModelNamespaceId(targetModel, modelNameToNamespaceId)),
-				cardinality: relation.cardinality,
-				on: {
-					localFields: relation.on.parentColumns.map((col) => columnToField.get(col) ?? col),
-					targetFields: relation.on.childColumns.map((col) => targetColumnToField.get(col) ?? col)
-				},
-				...relation.through ? { through: {
-					table: relation.through.table,
-					parentCols: relation.through.parentColumns,
-					childCols: relation.through.childColumns
-				} } : void 0
-			};
-		}
-		models[semanticModel.modelName] = {
-			storage: {
-				table: tableName,
-				fields: storageFields
-			},
-			fields: domainFields,
-			relations: modelRelations
-		};
-	}
-	const rawStorageTypes = definition.storageTypes ?? {};
-	const { documentTypes, namespaceEnumTypesById } = partitionStorageTypesForTarget(target, Object.fromEntries(Object.entries(rawStorageTypes).map(([name, entry]) => {
-		if (isPostgresEnumStorageEntry(entry)) return [name, entry];
-		if (entry.kind === "codec-instance") return [name, entry];
-		return [name, toStorageTypeInstance({
-			codecId: entry.codecId,
-			nativeType: entry.nativeType,
-			typeParams: entry.typeParams ?? {}
-		})];
-	})), definition.namespaceTypes);
-	const namespaceCoordinateIds = collectStorageNamespaceCoordinateIds(definition);
-	for (const id of Object.keys(namespaceEnumTypesById)) namespaceCoordinateIds.add(id);
-	const { createNamespace } = definition;
-	const namespaces = blindCast(Object.fromEntries([...namespaceCoordinateIds].sort().map((id) => {
-		const enumTypes = namespaceEnumTypesById[id];
-		const nsInput = {
-			id,
-			tables: tablesByNamespace[id] ?? {},
-			...ifDefined("enum", enumTypes)
-		};
-		return [id, createNamespace ? createNamespace(nsInput) : buildSqlNamespace(nsInput)];
-	})));
-	const domainUnboundTypes = Object.keys(documentTypes).length > 0 ? { types: documentTypes } : void 0;
-	const domain = domainUnboundTypes !== void 0 ? { [UNBOUND_NAMESPACE_ID]: domainUnboundTypes } : void 0;
-	const storageWithoutHash = {
-		...Object.keys(documentTypes).length > 0 ? { types: documentTypes } : {},
-		namespaces
-	};
-	const storageHash = definition.storageHash ? coreHash(definition.storageHash) : computeStorageHash({
-		target,
-		targetFamily,
-		storage: storageWithoutHash,
-		...sqlContractCanonicalizationHooks
-	});
-	const storage = new SqlStorage({
-		...storageWithoutHash,
-		storageHash
-	});
-	const executionSection = executionDefaults.length > 0 ? { mutations: { defaults: executionDefaults.sort((a, b) => {
-		const tableCompare = a.ref.table.localeCompare(b.ref.table);
-		if (tableCompare !== 0) return tableCompare;
-		return a.ref.column.localeCompare(b.ref.column);
-	}) } } : void 0;
-	const extensionNamespaces = definition.extensionPacks ? Object.values(definition.extensionPacks).map((pack) => pack.id) : void 0;
-	const extensionPacks = { ...definition.extensionPacks || {} };
-	if (extensionNamespaces) {
-		for (const namespace of extensionNamespaces) if (!Object.hasOwn(extensionPacks, namespace)) extensionPacks[namespace] = {};
-	}
-	const extensionPackCapabilitySources = definition.extensionPacks ? Object.values(definition.extensionPacks).map((pack) => pack.capabilities) : [];
-	const capabilities = mergeCapabilityMatrices(definition.target.capabilities, ...extensionPackCapabilitySources);
-	const profileHash = computeProfileHash({
-		target,
-		targetFamily,
-		capabilities: {}
-	});
-	const executionWithHash = executionSection ? {
-		...executionSection,
-		executionHash: computeExecutionHash({
-			target,
-			targetFamily,
-			execution: executionSection
-		})
-	} : void 0;
-	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, isValueObjectField(f) ? {
-		type: {
-			kind: "valueObject",
-			name: f.valueObjectName
-		},
-		nullable: f.nullable,
-		...f.many ? { many: true } : {}
-	} : {
-		type: {
-			kind: "scalar",
-			codecId: f.descriptor.codecId,
-			...ifDefined("typeParams", f.descriptor.typeParams)
-		},
-		nullable: f.nullable
-	}])) }])) : void 0;
-	const contract = {
-		target,
-		targetFamily,
-		models,
-		roots,
-		storage,
-		...domain !== void 0 ? { domain } : {},
-		...executionWithHash ? { execution: executionWithHash } : {},
-		...ifDefined("valueObjects", valueObjects),
-		extensionPacks,
-		capabilities,
-		profileHash,
-		meta: {}
-	};
-	assertStorageSemantics(definition, contract);
-	return contract;
-}
-//#endregion
 //#region src/authoring-helper-runtime.ts
 function isNamedConstraintOptionsLike(value) {
 	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;