@prisma/orm-family-sql 8.0.0-rc.19-dev.1 → 8.0.0-rc.19-dev.3

package/dist/{contract-builder-DT689tII.mjs → contract-builder-CNeGxqP_.mjs}

@@ -2,12 +2,12 @@ import { d as sqlColumnLength } from "./sql-data-type-D7M-YTTY-C9oWGZ3z.mjs";
 import { r as numeralText } from "./data-type-CUJMZOHo.mjs";
 import { t as providesEntityHandleLowering } from "./entity-handle-lowering-hook-B3atrRKX.mjs";
 import { a as isSqlExpression, c as requireSqlExpression, r as SqlExpression, s as readSqlExpression } from "./sql-expression-BJCuy-WI.mjs";
-import { t as CODEC_INSTANCE_KIND } from "./types-M_FeBD9w.mjs";
-import { n as checkSqlDefaultText, o as reservedSqlDefaultText } from "./validators-Cfy0jmZ2.mjs";
-import { n as buildSqlContractFromDefinition, o as toOneNullabilityContradictionMessage, r as contractError } from "./derived-checks-CXW9ytkb-B_zxX1-8.mjs";
+import { t as CODEC_INSTANCE_KIND } from "./types-C7610W2l.mjs";
+import { n as checkSqlDefaultText, o as reservedSqlDefaultText } from "./validators-xXKEHvnw.mjs";
+import { a as refuseTypesKey, n as buildSqlContractFromDefinition, r as contractError, s as toOneNullabilityContradictionMessage } from "./derived-checks-iXF3y0Ki-28vqz_8w.mjs";
 import { isStructuredError } from "@prisma/orm-framework/utils/structured-error";
 import { ifDefined } from "@prisma/orm-framework/utils/defined";
-import { assembleDataTypeSupport, assertNoCrossRegistryCollisions, describeAdmittedForms, instantiateAuthoringFieldPreset, instantiateAuthoringTypeConstructor, isAuthoringEntityTypeDescriptor, isAuthoringTypeConstructorDescriptor, readWrittenValueAs, validateAuthoringHelperArguments, validateAuthoringTypeParams } from "@prisma/orm-framework/components/authoring";
+import { assembleDataTypeSupport, assertNoCrossRegistryCollisions, assertTypeAliasesValid, describeAdmittedForms, instantiateAuthoringFieldPreset, instantiateAuthoringTypeAlias, instantiateAuthoringTypeConstructor, isAuthoringEntityTypeDescriptor, isAuthoringTypeAliasDescriptor, isAuthoringTypeConstructorDescriptor, readWrittenValueAs, validateAuthoringHelperArguments, validateAuthoringTypeParams } from "@prisma/orm-framework/components/authoring";
 import { dataTypeId } from "@prisma/orm-framework/components/codec";
 import { blindCast } from "@prisma/orm-framework/utils/casts";
 import { InternalError } from "@prisma/orm-framework/utils/internal-error";
@@ -81,6 +81,24 @@ function createTypeHelpersFromNamespace(namespace, lookups, path = []) {
 			};
 			continue;
 		}
+		if (isAuthoringTypeAliasDescriptor(value)) {
+			const helperPath = currentPath.join(".");
+			helpers[key] = (...args) => {
+				validateAuthoringHelperArguments(helperPath, [], args);
+				const { type, onCreate, onUpdate } = instantiateAuthoringTypeAlias(value);
+				const generatorCalls = {
+					...ifDefined("onCreate", onCreate),
+					...ifDefined("onUpdate", onUpdate)
+				};
+				return {
+					kind: CODEC_INSTANCE_KIND,
+					codecId: type.codecId,
+					typeParams: type.typeParams ?? {},
+					...Object.keys(generatorCalls).length === 0 ? {} : { generatorCalls }
+				};
+			};
+			continue;
+		}
 		helpers[key] = createTypeHelpersFromNamespace(value, lookups, currentPath);
 	}
 	return helpers;
@@ -113,7 +131,7 @@ function createFieldPresetHelper(options) {
 	};
 }
 function withGeneratorCall(state, phase, call) {
-	if (state.generatorCalls?.[phase] !== void 0 || state.executionDefaults?.[phase] !== void 0) throw contractError("CONTRACT.DEFAULT_INVALID", `.${phase}() is called on a field that already generates a value ${phase === "onCreate" ? "on create" : "on update"}. Set each phase once, and do not combine .${phase}() with a field preset that sets it.`, { meta: {
+	if (state.generatorCalls?.[phase] !== void 0 || state.executionDefaults?.[phase] !== void 0) throw contractError("CONTRACT.DEFAULT_INVALID", `.${phase}() is called on a field that already generates a value ${phase === "onCreate" ? "on create" : "on update"}. Set each phase once, and do not combine .${phase}() with a field preset, type alias or alias constant that sets it.`, { meta: {
 		reason: "generator-phase-set-twice",
 		phase
 	} });
@@ -125,6 +143,13 @@ function withGeneratorCall(state, phase, call) {
 		}
 	};
 }
+function withColumnDefault(state, columnDefault) {
+	if (state.default !== void 0) throw contractError("CONTRACT.DEFAULT_INVALID", ".default() is called on a field that already has a default. Set the default once, and do not combine .default() with a field preset or alias constant that sets one.", { meta: { reason: "default-set-twice" } });
+	return {
+		...state,
+		default: columnDefault
+	};
+}
 function toColumnDefault(value) {
 	const expression = readSqlExpression(value);
 	if (expression !== void 0) return sqlExpressionDefault(expression);
@@ -183,10 +208,7 @@ var ScalarFieldBuilder = class ScalarFieldBuilder {
 		}));
 	}
 	default(value) {
-		return blindCast(new ScalarFieldBuilder({
-			...this.state,
-			default: toColumnDefault(value)
-		}));
+		return blindCast(new ScalarFieldBuilder(withColumnDefault(this.state, toColumnDefault(value))));
 	}
 	/** Generates the field's value in the client when a row is created without one, with a call from `gen`, such as `gen.uuid()`. */
 	onCreate(call) {
@@ -200,13 +222,10 @@ var ScalarFieldBuilder = class ScalarFieldBuilder {
 	* @deprecated Write `.default(now())` or `.default(autoincrement())`, or `` .default(sql`...`) `` for any other SQL. Removed in 8.0.0.
 	*/
 	defaultSql(expression) {
-		return blindCast(new ScalarFieldBuilder({
-			...this.state,
-			default: {
-				kind: "function",
-				expression
-			}
-		}));
+		return blindCast(new ScalarFieldBuilder(withColumnDefault(this.state, {
+			kind: "function",
+			expression
+		})));
 	}
 	id(options) {
 		return new ScalarFieldBuilder(blindCast({
@@ -243,24 +262,34 @@ var EnumScalarFieldBuilder = class EnumScalarFieldBuilder extends ScalarFieldBui
 		this.#handle = handle;
 	}
 	default(value) {
-		return blindCast(new EnumScalarFieldBuilder({
-			...this.build(),
-			default: {
-				kind: "literal",
-				value
-			}
-		}, this.#handle));
+		return blindCast(new EnumScalarFieldBuilder(withColumnDefault(this.build(), {
+			kind: "literal",
+			value
+		}), this.#handle));
 	}
 	defaultSql(_expression) {
 		throw contractError("CONTRACT.DEFAULT_INVALID", "defaultSql is not available on an enum field; use .default(members.X) instead", { meta: { reason: "defaultSql-on-enum-field" } });
 	}
 };
-const columnField = (descriptor) => new ScalarFieldBuilder({
-	kind: "scalar",
-	descriptor,
-	nullable: false,
-	many: false
-});
+function isTypeAliasColumnType(descriptor) {
+	return "generatorCalls" in descriptor;
+}
+const columnField = (descriptor) => {
+	if (!isTypeAliasColumnType(descriptor)) return new ScalarFieldBuilder({
+		kind: "scalar",
+		descriptor,
+		nullable: false,
+		many: false
+	});
+	const { generatorCalls, ...columnType } = descriptor;
+	return new ScalarFieldBuilder({
+		kind: "scalar",
+		descriptor: blindCast(columnType),
+		nullable: false,
+		many: false,
+		...ifDefined("generatorCalls", generatorCalls)
+	});
+};
 function generatedField(spec) {
 	return new ScalarFieldBuilder({
 		kind: "scalar",
@@ -273,21 +302,12 @@ function generatedField(spec) {
 		executionDefaults: { onCreate: spec.generated }
 	});
 }
-function untypedNamedTypeField(typeRef) {
-	if (isEnumTypeHandle(typeRef)) return new EnumScalarFieldBuilder(blindCast({
-		kind: "scalar",
-		typeRef,
-		nullable: false,
-		many: false
-	}), typeRef);
-	return new ScalarFieldBuilder({
-		kind: "scalar",
-		typeRef,
-		nullable: false,
-		many: false
-	});
-}
-const namedTypeField = blindCast(untypedNamedTypeField);
+const namedTypeField = (handle) => new EnumScalarFieldBuilder(blindCast({
+	kind: "scalar",
+	enumHandle: handle,
+	nullable: false,
+	many: false
+}), handle);
 function buildFieldPreset(descriptor, args, namedConstraintOptions) {
 	const preset = instantiateAuthoringFieldPreset(descriptor, args);
 	return new ScalarFieldBuilder({
@@ -818,25 +838,12 @@ function flushWarnings(warnings) {
 		for (const message of warnings) process.emitWarning(message, { code: "PN_CONTRACT_TYPED_FALLBACK_AVAILABLE" });
 		return;
 	}
-	process.emitWarning(`${warnings.length} contract references use string fallbacks where typed alternatives are available. Use named model tokens and typed storage type refs for autocomplete and type safety.
+	process.emitWarning(`${warnings.length} contract references use string fallbacks where typed alternatives are available. Use named model tokens for autocomplete and type safety.
 ` + warnings.map((w) => `  - ${w}`).join("\n"), { code: "PN_CONTRACT_TYPED_FALLBACK_AVAILABLE" });
 }
 function formatFallbackWarning(location, current, suggested) {
 	return `Contract ${location} uses ${current}. Use ${suggested} when the named model token is available in the same contract to keep typed relation targets and model refs.`;
 }
-function emitTypedNamedTypeFallbackWarnings(models, storageTypes) {
-	const warnings = [];
-	const warnedFields = /* @__PURE__ */ new Set();
-	for (const [modelName, modelDefinition] of Object.entries(models)) for (const [fieldName, fieldBuilder] of Object.entries(modelDefinition.stageOne.fields)) {
-		const fieldState = fieldBuilder.build();
-		if (typeof fieldState.typeRef !== "string" || !(fieldState.typeRef in storageTypes)) continue;
-		const warningKey = `${modelName}.${fieldName}`;
-		if (warnedFields.has(warningKey)) continue;
-		warnedFields.add(warningKey);
-		warnings.push(`Contract field "${modelName}.${fieldName}" uses field.namedType('${fieldState.typeRef}'). Use field.namedType(types.${fieldState.typeRef}) when the storage type is declared in the same contract to keep autocomplete and typed local refs.`);
-	}
-	flushWarnings(warnings);
-}
 function emitTypedCrossModelFallbackWarnings(collection) {
 	const warnings = [];
 	const warnedKeys = /* @__PURE__ */ new Set();
@@ -874,32 +881,14 @@ function emitTypedCrossModelFallbackWarnings(collection) {
 	}
 	flushWarnings(warnings);
 }
-function buildStorageTypeReverseLookup(storageTypes) {
-	const lookup = /* @__PURE__ */ new Map();
-	for (const [key, instance] of Object.entries(storageTypes)) lookup.set(instance, key);
-	return lookup;
-}
-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 };
-		const typeRef = typeof fieldState.typeRef === "string" ? fieldState.typeRef : storageTypeReverseLookup.get(fieldState.typeRef);
-		if (!typeRef) throw contractError("CONTRACT.TYPE_UNKNOWN", `Field "${modelName}.${fieldName}" references a storage type instance that is not present in definition.types`, { meta: {
-			modelName,
-			fieldName,
-			reason: "instance-not-in-definition-types"
-		} });
-		const referencedType = storageTypes[typeRef];
-		if (!referencedType) throw contractError("CONTRACT.TYPE_UNKNOWN", `Field "${modelName}.${fieldName}" references unknown storage type "${typeRef}"`, { meta: {
-			modelName,
-			fieldName,
-			typeRef
-		} });
-		return {
-			codecId: referencedType.codecId,
-			typeRef
-		};
-	}
+/** A column stores no `typeParams` when it has none, as PSL writes it (ADR 246). */
+function withoutEmptyTypeParams(descriptor) {
+	const { typeParams, ...rest } = descriptor;
+	return typeParams === void 0 || Object.keys(typeParams).length > 0 ? descriptor : rest;
+}
+function resolveFieldDescriptor(modelName, fieldName, fieldState) {
+	if ("descriptor" in fieldState && fieldState.descriptor) return withoutEmptyTypeParams(fieldState.descriptor);
+	if ("enumHandle" in fieldState && isEnumTypeHandle(fieldState.enumHandle)) return { codecId: fieldState.enumHandle.codecId };
 	throw contractError("CONTRACT.TYPE_UNKNOWN", `Field "${modelName}.${fieldName}" does not resolve to a storage descriptor`, { meta: {
 		modelName,
 		fieldName,
@@ -1332,7 +1321,7 @@ function resolveGeneratorCalls(input) {
 	const { modelName, fieldName, fieldState, descriptor, generatorFunctions } = input;
 	const calls = fieldState.generatorCalls;
 	if (calls === void 0) return fieldState.executionDefaults;
-	const typeParams = descriptor.typeParams ?? (descriptor.typeRef === void 0 ? void 0 : input.storageTypes[descriptor.typeRef]?.typeParams);
+	const typeParams = descriptor.typeParams;
 	const column = {
 		codecId: descriptor.codecId,
 		typeParams,
@@ -1372,23 +1361,22 @@ function resolveGeneratorCalls(input) {
 	}
 	return phases;
 }
-function resolveModelNode(spec, allSpecs, storageTypes, storageTypeReverseLookup, generatorFunctions, columnLength, extensions) {
+function resolveModelNode(spec, allSpecs, generatorFunctions, columnLength, extensions) {
 	const fields = [];
 	/** Filled by the field loop below, read by a deferred index expression. */
 	const fieldCodecIds = {};
 	for (const [fieldName, fieldBuilder] of Object.entries(spec.fieldBuilders)) {
 		const fieldState = fieldBuilder.build();
-		const descriptor = resolveFieldDescriptor(spec.modelName, fieldName, fieldState, storageTypes, storageTypeReverseLookup);
+		const descriptor = resolveFieldDescriptor(spec.modelName, fieldName, fieldState);
 		const columnName = spec.fieldToColumn[fieldName];
 		if (!columnName) throw new InternalError(`Column name resolution failed for "${spec.modelName}.${fieldName}"`);
 		fieldCodecIds[fieldName] = descriptor.codecId;
-		const enumHandle = "typeRef" in fieldState && isEnumTypeHandle(fieldState.typeRef) ? fieldState.typeRef : void 0;
+		const enumHandle = "enumHandle" in fieldState && isEnumTypeHandle(fieldState.enumHandle) ? fieldState.enumHandle : void 0;
 		const executionDefaults = resolveGeneratorCalls({
 			modelName: spec.modelName,
 			fieldName,
 			fieldState,
 			descriptor,
-			storageTypes,
 			generatorFunctions,
 			columnLength
 		});
@@ -1463,9 +1451,8 @@ function columnLengthOf(definition) {
 	};
 }
 function collectRuntimeModelSpecs(definition) {
-	const storageTypes = { ...definition.types ?? {} };
+	const databaseTypes = { ...definition.databaseTypes };
 	const models = { ...definition.models ?? {} };
-	emitTypedNamedTypeFallbackWarnings(models, storageTypes);
 	const modelSpecs = /* @__PURE__ */ new Map();
 	const tableOwners = /* @__PURE__ */ new Map();
 	for (const [modelName, modelDefinition] of Object.entries(models)) {
@@ -1520,15 +1507,14 @@ function collectRuntimeModelSpecs(definition) {
 		});
 	}
 	return {
-		storageTypes,
+		databaseTypes,
 		models,
 		modelSpecs
 	};
 }
 function lowerModels(collection, generatorFunctions, columnLength, extensions) {
 	emitTypedCrossModelFallbackWarnings(collection);
-	const storageTypeReverseLookup = buildStorageTypeReverseLookup(collection.storageTypes);
-	return Array.from(collection.modelSpecs.values()).map((spec) => resolveModelNode(spec, collection.modelSpecs, collection.storageTypes, storageTypeReverseLookup, generatorFunctions, columnLength, extensions));
+	return Array.from(collection.modelSpecs.values()).map((spec) => resolveModelNode(spec, collection.modelSpecs, generatorFunctions, columnLength, extensions));
 }
 /**
 * Kind-agnostic walk over the author-declared `entities` handle list:
@@ -1648,12 +1634,21 @@ function lowerPackEntityHandles(definition, modelSpecs) {
 	return pack;
 }
 function buildContractDefinition(definition) {
+	refuseTypesKey(definition, "buildContractDefinition");
 	const collection = collectRuntimeModelSpecs(definition);
-	const models = lowerModels(collection, assembleGeneratorFunctions([
+	const packs = [
 		definition.family,
 		definition.target,
 		...Object.values(definition.extensions ?? {})
-	]), columnLengthOf(definition), definition.extensions);
+	];
+	const generatorFunctions = assembleGeneratorFunctions(packs);
+	const columnLength = columnLengthOf(definition);
+	assertTypeAliasesValid(composePackAuthoringNamespace(packs, "type"), {
+		generatorFunctions,
+		paramsSchemaOf: (codecId) => definition.codecLookup.descriptorFor(codecId)?.paramsSchema,
+		fieldLength: ({ codecId, typeParams }) => columnLength(codecId, typeParams)
+	});
+	const models = lowerModels(collection, generatorFunctions, columnLength, definition.extensions);
 	const attachedEntities = lowerPackEntityHandles(definition, collection.modelSpecs);
 	return {
 		target: definition.target,
@@ -1662,7 +1657,7 @@ function buildContractDefinition(definition) {
 		...ifDefined("capabilities", definition.adapter?.capabilities),
 		...definition.storageHash ? { storageHash: definition.storageHash } : {},
 		...definition.foreignKeyDefaults ? { foreignKeyDefaults: definition.foreignKeyDefaults } : {},
-		...Object.keys(collection.storageTypes).length > 0 ? { storageTypes: collection.storageTypes } : {},
+		...Object.keys(collection.databaseTypes).length > 0 ? { databaseTypes: collection.databaseTypes } : {},
 		...definition.namespaces ? { namespaces: definition.namespaces } : {},
 		warnings: void 0,
 		createNamespace: definition.createNamespace,
@@ -1805,6 +1800,7 @@ function buildContractFromDsl(definition) {
 }
 /** Implementation. */
 function buildBoundContract(family, target, definition, factory) {
+	refuseTypesKey(definition, "defineContract");
 	const full = {
 		...definition,
 		family,
@@ -1817,6 +1813,7 @@ function buildBoundContract(family, target, definition, factory) {
 			extensions: definition.extensions,
 			codecLookup: definition.codecLookup
 		}));
+		refuseTypesKey(built, "defineContract");
 		const mergedEnums = {
 			...definition.enums ?? {},
 			...built.enums
@@ -1824,7 +1821,7 @@ function buildBoundContract(family, target, definition, factory) {
 		const mergedEntities = [...definition.entities ?? [], ...built.entities ?? []];
 		return buildContractFromDsl({
 			...full,
-			...ifDefined("types", built.types),
+			...ifDefined("databaseTypes", built.databaseTypes),
 			...ifDefined("models", built.models),
 			...ifDefined("enums", Object.keys(mergedEnums).length > 0 ? mergedEnums : void 0),
 			...ifDefined("entities", mergedEntities.length > 0 ? mergedEntities : void 0)
@@ -1854,4 +1851,4 @@ function autoincrement() {
 //#endregion
 export { check as a, enumType as c, member as d, model as f, buildContractDefinition as i, extensionModel as l, rel as m, bindEnumType as n, createComposedAuthoringHelpers as o, now as p, buildBoundContract as r, defineContract as s, autoincrement as t, field as u };
 
-//# sourceMappingURL=contract-builder-DT689tII.mjs.map
+//# sourceMappingURL=contract-builder-CNeGxqP_.mjs.map