@prisma-next/sql-contract-psl 0.13.0-dev.16 → 0.13.0-dev.18

package/dist/index.d.mts

@@ -5,6 +5,7 @@ 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";
 
@@ -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;;;UCwDb,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;ED/DzB;;;AAAmB;;;;ACwD9B;;EDxDW,SCyEA,0BAAA,EAA4B,WAAA,SAAoB,QAAA;EAhBtC;;;;;;;;;EAAA,SA0BV,eAAA,IAAmB,KAAA,EAAO,uBAAA,KAA4B,SAAA;EAAA,SACtD,WAAA,GAAc,WAAA;AAAA;AAAA,iBAywDT,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-CQdQo427.mjs";
 export { interpretPslDocumentToSqlContract };

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

@@ -1,5 +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 { namespacePslExtensionBlocks } from "@prisma-next/framework-components/psl-ast";
 import { isPostgresEnumStorageEntry } from "@prisma-next/sql-contract/types";
 import { buildSqlContractFromDefinition } from "@prisma-next/sql-contract-ts/contract-builder";
 import { blindCast } from "@prisma-next/utils/casts";
@@ -1308,6 +1309,37 @@ function resolveColumnDescriptor(field, enumTypeDescriptors, namedTypeDescriptor
 }
 //#endregion
 //#region src/psl-field-resolution.ts
+function lowerEnum2DefaultForField(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_ENUM2_DEFAULT_MUST_BE_MEMBER_NAME",
+			message: `Field "${input.modelName}.${input.fieldName}" @default on an enum2 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_ENUM2_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 +1413,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, enum2Handles } = input;
 	const resolvedFields = [];
 	for (const field of model.fields) {
 		const isModelField = modelNames.has(field.typeName);
@@ -1474,7 +1506,15 @@ function collectResolvedFields(input) {
 			});
 			continue;
 		}
-		const loweredDefault = defaultAttribute ? lowerDefaultForField({
+		const enum2Handle = enum2Handles?.get(field.typeName);
+		const loweredDefault = defaultAttribute ? enum2Handle ? lowerEnum2DefaultForField({
+			modelName: model.name,
+			fieldName: field.name,
+			defaultAttribute,
+			enumHandle: enum2Handle,
+			sourceId,
+			diagnostics
+		}) : lowerDefaultForField({
 			modelName: model.name,
 			fieldName: field.name,
 			defaultAttribute,
@@ -1998,6 +2038,41 @@ function processEnumDeclarations(input) {
 		enumTypeDescriptors
 	};
 }
+function processEnum2Declarations(input) {
+	const enumHandles = {};
+	const enumTypeDescriptors = /* @__PURE__ */ new Map();
+	if (input.enum2Blocks.length === 0) return {
+		enumHandles,
+		enumTypeDescriptors
+	};
+	const enum2EntityDescriptor = getAuthoringEntity(input.authoringContributions, ["enum2"]);
+	if (!enum2EntityDescriptor) {
+		for (const decl of input.enum2Blocks) input.diagnostics.push({
+			code: "PSL_ENUM2_MISSING_FACTORY",
+			message: `enum2 "${decl.name}" requires an "enum2" entityType factory in the active authoring contributions`,
+			sourceId: input.sourceId,
+			span: decl.span
+		});
+		return {
+			enumHandles,
+			enumTypeDescriptors
+		};
+	}
+	for (const decl of input.enum2Blocks) {
+		const handle = instantiateAuthoringEntityType("enum2", enum2EntityDescriptor, [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 {
+		enumHandles,
+		enumTypeDescriptors
+	};
+}
 function validateNamedTypeAttributes(input) {
 	const [dbNativeTypeAttribute, ...extraDbNativeTypeAttributes] = input.allowDbNativeType ? input.declaration.attributes.filter((attribute) => attribute.name.startsWith("db.")) : [];
 	let hasUnsupportedNamedTypeAttribute = false;
@@ -2169,7 +2244,8 @@ function buildModelNodeFromPsl(input) {
 		generatorDescriptorById: input.generatorDescriptorById,
 		diagnostics,
 		sourceId,
-		scalarTypeDescriptors: input.scalarTypeDescriptors
+		scalarTypeDescriptors: input.scalarTypeDescriptors,
+		...ifDefined("enum2Handles", input.enum2Handles)
 	});
 	const inlineIdFields = resolvedFields.filter((field) => field.isId);
 	if (inlineIdFields.length > 1) diagnostics.push({
@@ -2710,14 +2786,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.enum2Handles?.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 } : {},
@@ -3237,6 +3317,47 @@ function interpretPslDocumentToSqlContract(input) {
 		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 topLevelEnum2s = input.document.ast.namespaces.filter((ns) => ns.name === UNSPECIFIED_PSL_NAMESPACE_NAME).flatMap((ns) => namespacePslExtensionBlocks(ns).filter((b) => b.kind === "enum2"));
+	for (const ns of input.document.ast.namespaces) {
+		if (ns.name === UNSPECIFIED_PSL_NAMESPACE_NAME) continue;
+		const nsEnum2s = namespacePslExtensionBlocks(ns).filter((b) => b.kind === "enum2");
+		if (nsEnum2s.length === 0) continue;
+		for (const decl of nsEnum2s) diagnostics.push({
+			code: "PSL_ENUM2_NAMESPACE_NOT_SUPPORTED",
+			message: `enum2 "${decl.name}" inside namespace "${ns.name}" is not supported; declare enum2 at the top level`,
+			sourceId,
+			span: decl.span
+		});
+	}
+	const enum2Result = processEnum2Declarations({
+		enum2Blocks: topLevelEnum2s,
+		sourceId,
+		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 collidingEnum2Names = /* @__PURE__ */ new Set();
+	for (const [name, descriptor] of enum2Result.enumTypeDescriptors) if (allEnumTypeDescriptors.has(name)) {
+		collidingEnum2Names.add(name);
+		const collision = topLevelEnum2s.find((e) => e.name === name);
+		diagnostics.push({
+			code: "PSL_ENUM2_DUPLICATE_TYPE_NAME",
+			message: `enum2 "${name}" collides with an existing type name; each type name must be unique`,
+			sourceId,
+			...ifDefined("span", collision?.span)
+		});
+	} else allEnumTypeDescriptors.set(name, descriptor);
+	const validEnum2Handles = {};
+	for (const [name, handle] of Object.entries(enum2Result.enumHandles)) if (!collidingEnum2Names.has(name)) validEnum2Handles[name] = handle;
+	const enum2HandlesByName = new Map(Object.entries(validEnum2Handles));
 	const namedTypeResult = resolveNamedTypeDeclarations({
 		declarations: input.document.ast.types?.declarations ?? [],
 		sourceId,
@@ -3283,7 +3404,8 @@ function interpretPslDocumentToSqlContract(input) {
 			scalarTypeDescriptors: input.scalarTypeDescriptors,
 			sourceId,
 			diagnostics,
-			modelNamespaceIds
+			modelNamespaceIds,
+			...enum2HandlesByName.size > 0 ? { enum2Handles: enum2HandlesByName } : {}
 		});
 		modelNodes.push(namespaceId !== void 0 ? {
 			...result.modelNode,
@@ -3336,6 +3458,7 @@ function interpretPslDocumentToSqlContract(input) {
 		...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(validEnum2Handles).length > 0 ? { enums: validEnum2Handles } : {},
 		...ifDefined("createNamespace", input.createNamespace),
 		models: stiColumnModelNodes.map((model) => ({
 			...model,
@@ -3362,6 +3485,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 +3494,4 @@ function interpretPslDocumentToSqlContract(input) {
 //#endregion
 export { interpretPslDocumentToSqlContract as t };
 
-//# sourceMappingURL=interpreter-B_KtZusL.mjs.map
+//# sourceMappingURL=interpreter-CQdQo427.mjs.map