@prisma-next/sql-contract-psl 0.13.0 → 0.14.0-dev.2

package/dist/index.d.mts

@@ -1,12 +1,13 @@
 import { Contract } from "@prisma-next/contract/types";
 import { AuthoringContributions } from "@prisma-next/framework-components/authoring";
-import { SqlNamespaceTablesInput } from "@prisma-next/sql-contract/types";
 import { Result } from "@prisma-next/utils/result";
 import { ParsePslDocumentResult } from "@prisma-next/psl-parser";
 import { ControlMutationDefaults, ControlMutationDefaults as ControlMutationDefaults$1, DefaultFunctionLoweringContext, DefaultFunctionLoweringHandler, DefaultFunctionRegistry, DefaultFunctionRegistryEntry, MutationDefaultGeneratorDescriptor } from "@prisma-next/framework-components/control";
 import { ContractSourceDiagnostics } from "@prisma-next/config/config-types";
+import { CodecLookup } from "@prisma-next/framework-components/codec";
 import { ExtensionPackRef, TargetPackRef } from "@prisma-next/framework-components/components";
 import { Namespace } from "@prisma-next/framework-components/ir";
+import { SqlNamespaceTablesInput } from "@prisma-next/sql-contract/types";
 
 //#region src/psl-column-resolution.d.ts
 type ColumnDescriptor = {
@@ -45,6 +46,7 @@ interface InterpretPslDocumentToSqlContractInput {
    * `SqlUnboundNamespace` singleton.
    */
   readonly createNamespace?: (input: SqlNamespaceTablesInput) => Namespace;
+  readonly codecLookup?: CodecLookup;
 }
 declare function interpretPslDocumentToSqlContract(input: InterpretPslDocumentToSqlContractInput): Result<Contract, ContractSourceDiagnostics>;
 //#endregion

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/psl-column-resolution.ts","../src/interpreter.ts"],"mappings":";;;;;;;;;;;KA0CY,gBAAA;EAAA,SACD,OAAA;EAAA,SACA,UAAA;EAAA,SACA,OAAA;EAAA,SACA,UAAA,GAAa,MAAM;AAAA;;;UCoDb,sCAAA;EAAA,SACN,QAAA,EAAU,sBAAA;EAAA,SACV,MAAA,EAAQ,aAAA;EAAA,SACR,qBAAA,EAAuB,WAAA,SAAoB,gBAAA;EAAA,SAC3C,sBAAA;EAAA,SACA,yBAAA,YAAqC,gBAAA;EAAA,SACrC,uBAAA,GAA0B,yBAAA;EAAA,SAC1B,sBAAA,GAAyB,sBAAA;ED3DzB;;;AAAmB;;;;ACoD9B;;EDpDW,SCqEA,0BAAA,EAA4B,WAAA,SAAoB,QAAA;EAhBtC;;;;;;;;;EAAA,SA0BV,eAAA,IAAmB,KAAA,EAAO,uBAAA,KAA4B,SAAA;AAAA;AAAA,iBA8sDjD,iCAAA,CACd,KAAA,EAAO,sCAAA,GACN,MAAA,CAAO,QAAA,EAAU,yBAAA"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/psl-column-resolution.ts","../src/interpreter.ts"],"mappings":";;;;;;;;;;;;KA0CY,gBAAA;EAAA,SACD,OAAA;EAAA,SACA,UAAA;EAAA,SACA,OAAA;EAAA,SACA,UAAA,GAAa,MAAM;AAAA;;;UCmDb,sCAAA;EAAA,SACN,QAAA,EAAU,sBAAA;EAAA,SACV,MAAA,EAAQ,aAAA;EAAA,SACR,qBAAA,EAAuB,WAAA,SAAoB,gBAAA;EAAA,SAC3C,sBAAA;EAAA,SACA,yBAAA,YAAqC,gBAAA;EAAA,SACrC,uBAAA,GAA0B,yBAAA;EAAA,SAC1B,sBAAA,GAAyB,sBAAA;ED1DzB;;;AAAmB;;;;ACmD9B;;EDnDW,SCoEA,0BAAA,EAA4B,WAAA,SAAoB,QAAA;EAhBtC;;;;;;;;;EAAA,SA0BV,eAAA,IAAmB,KAAA,EAAO,uBAAA,KAA4B,SAAA;EAAA,SACtD,WAAA,GAAc,WAAA;AAAA;AAAA,iBA+rDT,iCAAA,CACd,KAAA,EAAO,sCAAA,GACN,MAAA,CAAO,QAAA,EAAU,yBAAA"}

package/dist/index.mjs

@@ -1,2 +1,2 @@
-import { t as interpretPslDocumentToSqlContract } from "./interpreter-B_KtZusL.mjs";
+import { t as interpretPslDocumentToSqlContract } from "./interpreter-B0BsCLKT.mjs";
 export { interpretPslDocumentToSqlContract };

package/dist/{interpreter-B_KtZusL.mjs → interpreter-B0BsCLKT.mjs}

@@ -1,6 +1,6 @@
 import { crossRef } from "@prisma-next/contract/types";
 import { hasRegisteredFieldNamespace, instantiateAuthoringEntityType, instantiateAuthoringFieldPreset, instantiateAuthoringTypeConstructor, isAuthoringEntityTypeDescriptor, isAuthoringFieldPresetDescriptor, isAuthoringTypeConstructorDescriptor, validateAuthoringHelperArguments } from "@prisma-next/framework-components/authoring";
-import { isPostgresEnumStorageEntry } from "@prisma-next/sql-contract/types";
+import { namespacePslExtensionBlocks } from "@prisma-next/framework-components/psl-ast";
 import { buildSqlContractFromDefinition } from "@prisma-next/sql-contract-ts/contract-builder";
 import { blindCast } from "@prisma-next/utils/casts";
 import { ifDefined } from "@prisma-next/utils/defined";
@@ -1071,7 +1071,7 @@ const NATIVE_TYPE_SPECS = {
 	"db.Uuid": {
 		args: "noArgs",
 		baseType: "String",
-		codecId: null,
+		codecId: "pg/uuid@1",
 		nativeType: "uuid"
 	},
 	"db.SmallInt": {
@@ -1308,6 +1308,37 @@ function resolveColumnDescriptor(field, enumTypeDescriptors, namedTypeDescriptor
 }
 //#endregion
 //#region src/psl-field-resolution.ts
+function lowerEnumDefaultForField(input) {
+	const expressionEntry = getPositionalArgumentEntry(input.defaultAttribute);
+	if (!expressionEntry) return {};
+	const raw = expressionEntry.value.trim();
+	const isQuotedString = /^(['"]).*\1$/.test(raw);
+	const isFunctionCall = raw.includes("(") && raw.endsWith(")");
+	if (isQuotedString || isFunctionCall) {
+		input.diagnostics.push({
+			code: "PSL_ENUM_DEFAULT_MUST_BE_MEMBER_NAME",
+			message: `Field "${input.modelName}.${input.fieldName}" @default on an enum field must name a member (e.g. @default(Low)), not a raw value or function.`,
+			sourceId: input.sourceId,
+			span: input.defaultAttribute.span
+		});
+		return {};
+	}
+	const match = input.enumHandle.enumMembers.find((m) => m.name === raw);
+	if (!match) {
+		const validNames = input.enumHandle.enumMembers.map((m) => m.name).join(", ");
+		input.diagnostics.push({
+			code: "PSL_ENUM_UNKNOWN_DEFAULT_MEMBER",
+			message: `Field "${input.modelName}.${input.fieldName}" @default(${raw}) does not name a member of ${input.enumHandle.enumName}. Valid members: ${validNames}.`,
+			sourceId: input.sourceId,
+			span: input.defaultAttribute.span
+		});
+		return {};
+	}
+	return { defaultValue: {
+		kind: "literal",
+		value: blindCast(match.value)
+	} };
+}
 const MODEL_COORDINATE_SEPARATOR = "\0";
 function modelCoordinateKey(namespaceId, modelName) {
 	return `${namespaceId}${MODEL_COORDINATE_SEPARATOR}${modelName}`;
@@ -1381,7 +1412,7 @@ function extractFieldConstraintNames(input) {
 	};
 }
 function collectResolvedFields(input) {
-	const { model, mapping, enumTypeDescriptors, namedTypeDescriptors, modelNames, compositeTypeNames, composedExtensions, authoringContributions, familyId, targetId, defaultFunctionRegistry, generatorDescriptorById, diagnostics, sourceId, scalarTypeDescriptors } = input;
+	const { model, mapping, enumTypeDescriptors, namedTypeDescriptors, modelNames, compositeTypeNames, composedExtensions, authoringContributions, familyId, targetId, defaultFunctionRegistry, generatorDescriptorById, diagnostics, sourceId, scalarTypeDescriptors, enumHandles } = input;
 	const resolvedFields = [];
 	for (const field of model.fields) {
 		const isModelField = modelNames.has(field.typeName);
@@ -1474,7 +1505,15 @@ function collectResolvedFields(input) {
 			});
 			continue;
 		}
-		const loweredDefault = defaultAttribute ? lowerDefaultForField({
+		const enumHandle = enumHandles?.get(field.typeName);
+		const loweredDefault = defaultAttribute ? enumHandle ? lowerEnumDefaultForField({
+			modelName: model.name,
+			fieldName: field.name,
+			defaultAttribute,
+			enumHandle,
+			sourceId,
+			diagnostics
+		}) : lowerDefaultForField({
 			modelName: model.name,
 			fieldName: field.name,
 			defaultAttribute,
@@ -1495,7 +1534,8 @@ function collectResolvedFields(input) {
 			});
 			continue;
 		}
-		if (loweredOnCreate) {
+		const fieldUsesNamedType = field.typeRef !== void 0 || namedTypeDescriptors.has(field.typeName);
+		if (loweredOnCreate && !fieldUsesNamedType) {
 			const generatedDescriptor = generatorDescriptorById.get(loweredOnCreate.id)?.resolveGeneratedColumnDescriptor?.({ generated: loweredOnCreate });
 			if (generatedDescriptor) descriptor = generatedDescriptor;
 		}
@@ -1943,58 +1983,37 @@ function validateNamespaceBlocksForSqlTarget(input) {
 	}
 }
 function processEnumDeclarations(input) {
-	const storageTypes = {};
+	const enumHandles = {};
 	const enumTypeDescriptors = /* @__PURE__ */ new Map();
-	if (input.enums.length === 0) return {
-		storageTypes,
+	if (input.enumBlocks.length === 0) return {
+		enumHandles,
 		enumTypeDescriptors
 	};
-	if (!input.enumEntityDescriptor) {
-		for (const enumDeclaration of input.enums) input.diagnostics.push({
-			code: "PSL_UNSUPPORTED_NAMED_TYPE_BASE",
-			message: `Enum "${enumDeclaration.name}" requires the active target pack to contribute an enum entity-type helper`,
+	const enumDescriptor = getAuthoringEntity(input.authoringContributions, ["enum"]);
+	if (!enumDescriptor) {
+		for (const decl of input.enumBlocks) input.diagnostics.push({
+			code: "PSL_ENUM_MISSING_FACTORY",
+			message: `enum "${decl.name}" requires an "enum" entityType factory in the active authoring contributions`,
 			sourceId: input.sourceId,
-			span: enumDeclaration.span
+			span: decl.span
 		});
 		return {
-			storageTypes,
+			enumHandles,
 			enumTypeDescriptors
 		};
 	}
-	for (const enumDeclaration of input.enums) {
-		const nativeType = parseMapName({
-			attribute: getAttribute(enumDeclaration.attributes, "map"),
-			defaultValue: enumDeclaration.name,
-			sourceId: input.sourceId,
-			diagnostics: input.diagnostics,
-			entityLabel: `Enum "${enumDeclaration.name}"`,
-			span: enumDeclaration.span
-		});
-		const values = enumDeclaration.values.map((value) => value.name);
-		const constructed = instantiateAuthoringEntityType("enum", input.enumEntityDescriptor, [{
-			name: enumDeclaration.name,
-			nativeType,
-			values
-		}], input.entityContext);
-		if (!isPostgresEnumStorageEntry(constructed)) {
-			input.diagnostics.push({
-				code: "PSL_UNSUPPORTED_NAMED_TYPE_BASE",
-				message: `Enum "${enumDeclaration.name}": enum entity-type factory must return a PostgresEnumStorageEntry-shaped value (kind: 'postgres-enum')`,
-				sourceId: input.sourceId,
-				span: enumDeclaration.span
-			});
-			continue;
-		}
-		const descriptor = {
-			codecId: constructed.codecId,
-			nativeType: constructed.nativeType,
-			typeRef: enumDeclaration.name
-		};
-		enumTypeDescriptors.set(enumDeclaration.name, descriptor);
-		storageTypes[enumDeclaration.name] = constructed;
+	for (const decl of input.enumBlocks) {
+		const handle = instantiateAuthoringEntityType("enum", enumDescriptor, [decl], input.entityContext);
+		if (handle === void 0 || handle === null) continue;
+		const enumHandle = blindCast(handle);
+		enumHandles[decl.name] = enumHandle;
+		enumTypeDescriptors.set(decl.name, {
+			codecId: enumHandle.codecId,
+			nativeType: enumHandle.nativeType
+		});
 	}
 	return {
-		storageTypes,
+		enumHandles,
 		enumTypeDescriptors
 	};
 }
@@ -2169,7 +2188,8 @@ function buildModelNodeFromPsl(input) {
 		generatorDescriptorById: input.generatorDescriptorById,
 		diagnostics,
 		sourceId,
-		scalarTypeDescriptors: input.scalarTypeDescriptors
+		scalarTypeDescriptors: input.scalarTypeDescriptors,
+		...ifDefined("enumHandles", input.enumHandles)
 	});
 	const inlineIdFields = resolvedFields.filter((field) => field.isId);
 	if (inlineIdFields.length > 1) diagnostics.push({
@@ -2710,14 +2730,18 @@ function buildModelNodeFromPsl(input) {
 		modelNode: {
 			modelName: model.name,
 			tableName,
-			fields: resolvedFields.map((resolvedField) => ({
-				fieldName: resolvedField.field.name,
-				columnName: resolvedField.columnName,
-				descriptor: resolvedField.descriptor,
-				nullable: resolvedField.field.optional,
-				...ifDefined("default", resolvedField.defaultValue),
-				...ifDefined("executionDefaults", resolvedField.executionDefaults)
-			})),
+			fields: resolvedFields.map((resolvedField) => {
+				const enumHandle = input.enumHandles?.get(resolvedField.field.typeName);
+				return {
+					fieldName: resolvedField.field.name,
+					columnName: resolvedField.columnName,
+					descriptor: resolvedField.descriptor,
+					nullable: resolvedField.field.optional,
+					...ifDefined("default", resolvedField.defaultValue),
+					...ifDefined("executionDefaults", resolvedField.executionDefaults),
+					...ifDefined("enumTypeHandle", enumHandle)
+				};
+			}),
 			...ifDefined("id", primaryKey),
 			...uniqueConstraints.length > 0 ? { uniques: uniqueConstraints } : {},
 			...indexNodes.length > 0 ? { indexes: indexNodes } : {},
@@ -3189,18 +3213,6 @@ function interpretPslDocumentToSqlContract(input) {
 		}
 	}
 	const defaultNamespaceId = input.target.defaultNamespaceId;
-	const topLevelEnums = input.document.ast.namespaces.filter((ns) => ns.name === UNSPECIFIED_PSL_NAMESPACE_NAME).flatMap((ns) => ns.enums);
-	const namedNamespaceEnumsByNsId = /* @__PURE__ */ new Map();
-	for (const ns of input.document.ast.namespaces) {
-		if (ns.name === UNSPECIFIED_PSL_NAMESPACE_NAME || ns.enums.length === 0) continue;
-		const resolvedId = resolveNamespaceIdForSqlTarget({
-			bucketName: ns.name,
-			targetId: input.target.targetId
-		});
-		if (resolvedId === void 0) continue;
-		const existing = namedNamespaceEnumsByNsId.get(resolvedId) ?? [];
-		namedNamespaceEnumsByNsId.set(resolvedId, [...existing, ...ns.enums]);
-	}
 	const compositeTypes = input.document.ast.namespaces.flatMap((ns) => ns.compositeTypes);
 	const modelNames = new Set(models.map((model) => model.name));
 	const compositeTypeNames = new Set(compositeTypes.map((ct) => ct.name));
@@ -3210,33 +3222,36 @@ function interpretPslDocumentToSqlContract(input) {
 	const generatorDescriptors = input.controlMutationDefaults?.generatorDescriptors ?? [];
 	const generatorDescriptorById = /* @__PURE__ */ new Map();
 	for (const descriptor of generatorDescriptors) generatorDescriptorById.set(descriptor.id, descriptor);
-	const enumEntityDescriptor = getAuthoringEntity(input.authoringContributions, ["enum"]);
-	const enumEntityContext = {
-		family: input.target.familyId,
-		target: input.target.targetId
-	};
+	const topLevelEnums = input.document.ast.namespaces.filter((ns) => ns.name === UNSPECIFIED_PSL_NAMESPACE_NAME).flatMap((ns) => namespacePslExtensionBlocks(ns).filter((b) => b.kind === "enum"));
+	for (const ns of input.document.ast.namespaces) {
+		if (ns.name === UNSPECIFIED_PSL_NAMESPACE_NAME) continue;
+		const nsEnums = namespacePslExtensionBlocks(ns).filter((b) => b.kind === "enum");
+		if (nsEnums.length === 0) continue;
+		for (const decl of nsEnums) diagnostics.push({
+			code: "PSL_ENUM_NAMESPACE_NOT_SUPPORTED",
+			message: `enum "${decl.name}" inside namespace "${ns.name}" is not supported; declare enum at the top level`,
+			sourceId,
+			span: decl.span
+		});
+	}
 	const enumResult = processEnumDeclarations({
-		enums: topLevelEnums,
+		enumBlocks: topLevelEnums,
 		sourceId,
-		enumEntityDescriptor,
-		entityContext: enumEntityContext,
+		authoringContributions: input.authoringContributions,
+		entityContext: {
+			family: input.target.familyId,
+			target: input.target.targetId,
+			...ifDefined("codecLookup", input.codecLookup),
+			sourceId,
+			diagnostics: { push: (d) => {
+				diagnostics.push(blindCast(d));
+			} }
+		},
 		diagnostics
 	});
 	const allEnumTypeDescriptors = new Map(enumResult.enumTypeDescriptors);
-	const namespaceEnumStorageTypes = {};
-	for (const [nsId, nsEnums] of namedNamespaceEnumsByNsId) {
-		const nsEnumResult = processEnumDeclarations({
-			enums: nsEnums,
-			sourceId,
-			enumEntityDescriptor,
-			entityContext: enumEntityContext,
-			diagnostics
-		});
-		for (const [name, descriptor] of nsEnumResult.enumTypeDescriptors) allEnumTypeDescriptors.set(name, descriptor);
-		const nsEntries = {};
-		for (const [name, entry] of Object.entries(nsEnumResult.storageTypes)) if (isPostgresEnumStorageEntry(entry)) nsEntries[name] = entry;
-		if (Object.keys(nsEntries).length > 0) namespaceEnumStorageTypes[nsId] = nsEntries;
-	}
+	const validEnumHandles = { ...enumResult.enumHandles };
+	const enumHandlesByName = new Map(Object.entries(validEnumHandles));
 	const namedTypeResult = resolveNamedTypeDeclarations({
 		declarations: input.document.ast.types?.declarations ?? [],
 		sourceId,
@@ -3248,10 +3263,7 @@ function interpretPslDocumentToSqlContract(input) {
 		authoringContributions: input.authoringContributions,
 		diagnostics
 	});
-	const storageTypes = {
-		...enumResult.storageTypes,
-		...namedTypeResult.storageTypes
-	};
+	const storageTypes = { ...namedTypeResult.storageTypes };
 	const modelMappingsByCoordinate = buildModelMappings(modelEntries, defaultNamespaceId, diagnostics, sourceId);
 	const modelMappings = /* @__PURE__ */ new Map();
 	for (const mapping of modelMappingsByCoordinate.values()) modelMappings.set(mapping.model.name, mapping);
@@ -3283,7 +3295,8 @@ function interpretPslDocumentToSqlContract(input) {
 			scalarTypeDescriptors: input.scalarTypeDescriptors,
 			sourceId,
 			diagnostics,
-			modelNamespaceIds
+			modelNamespaceIds,
+			...enumHandlesByName.size > 0 ? { enumHandles: enumHandlesByName } : {}
 		});
 		modelNodes.push(namespaceId !== void 0 ? {
 			...result.modelNode,
@@ -3335,7 +3348,7 @@ function interpretPslDocumentToSqlContract(input) {
 		target: input.target,
 		...ifDefined("extensionPacks", buildComposedExtensionPackRefs(input.target, [...composedExtensions].sort(compareStrings), input.composedExtensionPackRefs)),
 		...Object.keys(storageTypes).length > 0 ? { storageTypes } : {},
-		...Object.keys(namespaceEnumStorageTypes).length > 0 ? { namespaceTypes: namespaceEnumStorageTypes } : {},
+		...Object.keys(validEnumHandles).length > 0 ? { enums: validEnumHandles } : {},
 		...ifDefined("createNamespace", input.createNamespace),
 		models: stiColumnModelNodes.map((model) => ({
 			...model,
@@ -3362,6 +3375,7 @@ function interpretPslDocumentToSqlContract(input) {
 		roots: filteredRoots,
 		domain: { namespaces: Object.fromEntries(Object.entries(contract.domain.namespaces).map(([namespaceId, namespaceSlice]) => [namespaceId, {
 			models: Object.fromEntries(Object.entries(namespaceSlice.models).map(([modelName, model]) => [modelName, patchedModels[modelCoordinateKey(namespaceId, modelName)] ?? model])),
+			...namespaceSlice.enum !== void 0 ? { enum: namespaceSlice.enum } : {},
 			...namespaceSlice.valueObjects !== void 0 ? { valueObjects: namespaceSlice.valueObjects } : {},
 			...namespaceId === input.target.defaultNamespaceId && Object.keys(valueObjects).length > 0 ? { valueObjects } : {}
 		}])) }
@@ -3370,4 +3384,4 @@ function interpretPslDocumentToSqlContract(input) {
 //#endregion
 export { interpretPslDocumentToSqlContract as t };
 
-//# sourceMappingURL=interpreter-B_KtZusL.mjs.map
+//# sourceMappingURL=interpreter-B0BsCLKT.mjs.map