@prisma-next/sql-contract-ts 0.12.0-dev.57 → 0.12.0-dev.59

package/dist/contract-builder.mjs

@@ -1,4 +1,4 @@
-import { t as buildSqlContractFromDefinition } from "./build-contract-B1odoaHR.mjs";
+import { t as buildSqlContractFromDefinition } from "./build-contract-C9dZNMRg.mjs";
 import { blindCast } from "@prisma-next/utils/casts";
 import { ifDefined } from "@prisma-next/utils/defined";
 import { isColumnDefault } from "@prisma-next/contract/types";
@@ -79,6 +79,61 @@ function createFieldHelpersFromNamespace(namespace, createLeafHelper, path = [])
 	return helpers;
 }
 //#endregion
+//#region src/enum-type.ts
+function member(name, value) {
+	return {
+		name,
+		value: blindCast(value ?? name)
+	};
+}
+/**
+* Internal brand that identifies an EnumTypeHandle in the lowering pipeline.
+* Not exported — callers only interact with `EnumTypeHandle`.
+*/
+const ENUM_TYPE_HANDLE_BRAND = Symbol("EnumTypeHandle");
+function enumType(name, codec, ...members) {
+	if (members.length === 0) throw new Error(`enumType("${name}"): must have at least one member.`);
+	const seenNames = /* @__PURE__ */ new Set();
+	const seenValues = /* @__PURE__ */ new Set();
+	for (const m of members) {
+		if (seenNames.has(m.name)) throw new Error(`enumType("${name}"): duplicate member name "${m.name}". Member names must be unique.`);
+		seenNames.add(m.name);
+		if (seenValues.has(m.value)) throw new Error(`enumType("${name}"): duplicate member value "${m.value}". Member values must be unique.`);
+		seenValues.add(m.value);
+	}
+	const values = Object.freeze(members.map((m) => m.value));
+	const names = Object.freeze(members.map((m) => m.name));
+	const enumMembers = Object.freeze(members.map((m) => ({
+		name: m.name,
+		value: m.value
+	})));
+	const membersAccessor = Object.freeze(Object.fromEntries(members.map((m) => [m.name, m.value])));
+	const valueSet = new Set(values);
+	const valueToName = new Map(members.map((m) => [m.value, m.name]));
+	const valueToOrdinal = new Map(values.map((v, i) => [v, i]));
+	return {
+		[ENUM_TYPE_HANDLE_BRAND]: true,
+		enumName: name,
+		codecId: codec.codecId,
+		nativeType: codec.nativeType,
+		enumMembers,
+		values,
+		names,
+		members: membersAccessor,
+		has: (v) => valueSet.has(v),
+		nameOf: (v) => valueToName.get(v),
+		ordinalOf: (v) => valueToOrdinal.get(v) ?? -1
+	};
+}
+/**
+* Returns true when the value is an `EnumTypeHandle` produced by
+* `enumType()`. Used in the lowering pipeline to detect enum handles
+* in field state without importing the BRAND symbol at every call site.
+*/
+function isEnumTypeHandle(value) {
+	return typeof value === "object" && value !== null && Reflect.get(value, ENUM_TYPE_HANDLE_BRAND) === true;
+}
+//#endregion
 //#region src/contract-dsl.ts
 function toColumnDefault(value) {
 	if (isColumnDefault(value)) return value;
@@ -166,6 +221,11 @@ function generatedField(spec) {
 	});
 }
 function namedTypeField(typeRef) {
+	if (isEnumTypeHandle(typeRef)) return new ScalarFieldBuilder({
+		kind: "scalar",
+		typeRef,
+		nullable: false
+	});
 	return new ScalarFieldBuilder({
 		kind: "scalar",
 		typeRef,
@@ -677,6 +737,10 @@ function buildStorageTypeReverseLookup(storageTypes) {
 function resolveFieldDescriptor(modelName, fieldName, fieldState, storageTypes, storageTypeReverseLookup) {
 	if ("descriptor" in fieldState && fieldState.descriptor) return fieldState.descriptor;
 	if ("typeRef" in fieldState && fieldState.typeRef) {
+		if (isEnumTypeHandle(fieldState.typeRef)) return {
+			codecId: fieldState.typeRef.codecId,
+			nativeType: fieldState.typeRef.nativeType
+		};
 		const typeRef = typeof fieldState.typeRef === "string" ? fieldState.typeRef : storageTypeReverseLookup.get(fieldState.typeRef);
 		if (!typeRef) throw new Error(`Field "${modelName}.${fieldName}" references a storage type instance that is not present in definition.types`);
 		const referencedType = storageTypes[typeRef];
@@ -906,13 +970,15 @@ function resolveModelNode(spec, allSpecs, storageTypes, storageTypeReverseLookup
 		const descriptor = resolveFieldDescriptor(spec.modelName, fieldName, fieldState, storageTypes, storageTypeReverseLookup);
 		const columnName = spec.fieldToColumn[fieldName];
 		if (!columnName) throw new Error(`Column name resolution failed for "${spec.modelName}.${fieldName}"`);
+		const enumHandle = "typeRef" in fieldState && isEnumTypeHandle(fieldState.typeRef) ? fieldState.typeRef : void 0;
 		fields.push({
 			fieldName,
 			columnName,
 			descriptor,
 			nullable: fieldState.nullable,
 			...fieldState.default ? { default: fieldState.default } : {},
-			...fieldState.executionDefaults ? { executionDefaults: fieldState.executionDefaults } : {}
+			...fieldState.executionDefaults ? { executionDefaults: fieldState.executionDefaults } : {},
+			...enumHandle !== void 0 ? { enumTypeHandle: enumHandle } : {}
 		});
 	}
 	const { idConstraint } = spec;
@@ -1009,6 +1075,7 @@ function buildContractDefinition(definition) {
 		...Object.keys(collection.storageTypes).length > 0 ? { storageTypes: collection.storageTypes } : {},
 		...definition.namespaces ? { namespaces: definition.namespaces } : {},
 		...definition.createNamespace ? { createNamespace: definition.createNamespace } : {},
+		...definition.enums && Object.keys(definition.enums).length > 0 ? { enums: definition.enums } : {},
 		models
 	};
 }
@@ -1123,6 +1190,6 @@ function defineContract(definition, factory) {
 	return buildBoundContract(definition.family, definition.target, definition);
 }
 //#endregion
-export { buildBoundContract, buildSqlContractFromDefinition, defineContract, field, model, rel };
+export { buildBoundContract, buildSqlContractFromDefinition, defineContract, enumType, field, member, model, rel };
 
 //# sourceMappingURL=contract-builder.mjs.map