@prisma-next/sql-contract-psl 0.13.0-dev.28 → 0.13.0-dev.29

package/dist/index.d.mts

@@ -1,6 +1,5 @@
 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";
@@ -8,6 +7,7 @@ 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 = {

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;;;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"}
+{"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-BT6dEGeD.mjs";
+import { t as interpretPslDocumentToSqlContract } from "./interpreter-B0BsCLKT.mjs";
 export { interpretPslDocumentToSqlContract };

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

@@ -1,7 +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";
 import { ifDefined } from "@prisma-next/utils/defined";
@@ -1309,7 +1308,7 @@ function resolveColumnDescriptor(field, enumTypeDescriptors, namedTypeDescriptor
 }
 //#endregion
 //#region src/psl-field-resolution.ts
-function lowerEnum2DefaultForField(input) {
+function lowerEnumDefaultForField(input) {
 	const expressionEntry = getPositionalArgumentEntry(input.defaultAttribute);
 	if (!expressionEntry) return {};
 	const raw = expressionEntry.value.trim();
@@ -1317,8 +1316,8 @@ function lowerEnum2DefaultForField(input) {
 	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.`,
+			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
 		});
@@ -1328,7 +1327,7 @@ function lowerEnum2DefaultForField(input) {
 	if (!match) {
 		const validNames = input.enumHandle.enumMembers.map((m) => m.name).join(", ");
 		input.diagnostics.push({
-			code: "PSL_ENUM2_UNKNOWN_DEFAULT_MEMBER",
+			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
@@ -1413,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, enum2Handles } = 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);
@@ -1506,12 +1505,12 @@ function collectResolvedFields(input) {
 			});
 			continue;
 		}
-		const enum2Handle = enum2Handles?.get(field.typeName);
-		const loweredDefault = defaultAttribute ? enum2Handle ? lowerEnum2DefaultForField({
+		const enumHandle = enumHandles?.get(field.typeName);
+		const loweredDefault = defaultAttribute ? enumHandle ? lowerEnumDefaultForField({
 			modelName: model.name,
 			fieldName: field.name,
 			defaultAttribute,
-			enumHandle: enum2Handle,
+			enumHandle,
 			sourceId,
 			diagnostics
 		}) : lowerDefaultForField({
@@ -1984,73 +1983,17 @@ function validateNamespaceBlocksForSqlTarget(input) {
 	}
 }
 function processEnumDeclarations(input) {
-	const storageTypes = {};
-	const enumTypeDescriptors = /* @__PURE__ */ new Map();
-	if (input.enums.length === 0) return {
-		storageTypes,
-		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`,
-			sourceId: input.sourceId,
-			span: enumDeclaration.span
-		});
-		return {
-			storageTypes,
-			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;
-	}
-	return {
-		storageTypes,
-		enumTypeDescriptors
-	};
-}
-function processEnum2Declarations(input) {
 	const enumHandles = {};
 	const enumTypeDescriptors = /* @__PURE__ */ new Map();
-	if (input.enum2Blocks.length === 0) return {
+	if (input.enumBlocks.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`,
+	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: decl.span
 		});
@@ -2059,8 +2002,8 @@ function processEnum2Declarations(input) {
 			enumTypeDescriptors
 		};
 	}
-	for (const decl of input.enum2Blocks) {
-		const handle = instantiateAuthoringEntityType("enum2", enum2EntityDescriptor, [decl], input.entityContext);
+	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;
@@ -2246,7 +2189,7 @@ function buildModelNodeFromPsl(input) {
 		diagnostics,
 		sourceId,
 		scalarTypeDescriptors: input.scalarTypeDescriptors,
-		...ifDefined("enum2Handles", input.enum2Handles)
+		...ifDefined("enumHandles", input.enumHandles)
 	});
 	const inlineIdFields = resolvedFields.filter((field) => field.isId);
 	if (inlineIdFields.length > 1) diagnostics.push({
@@ -2788,7 +2731,7 @@ function buildModelNodeFromPsl(input) {
 			modelName: model.name,
 			tableName,
 			fields: resolvedFields.map((resolvedField) => {
-				const enumHandle = input.enum2Handles?.get(resolvedField.field.typeName);
+				const enumHandle = input.enumHandles?.get(resolvedField.field.typeName);
 				return {
 					fieldName: resolvedField.field.name,
 					columnName: resolvedField.columnName,
@@ -3270,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));
@@ -3291,47 +3222,20 @@ 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 enumResult = processEnumDeclarations({
-		enums: topLevelEnums,
-		sourceId,
-		enumEntityDescriptor,
-		entityContext: enumEntityContext,
-		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 topLevelEnum2s = input.document.ast.namespaces.filter((ns) => ns.name === UNSPECIFIED_PSL_NAMESPACE_NAME).flatMap((ns) => namespacePslExtensionBlocks(ns).filter((b) => b.kind === "enum2"));
+	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 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`,
+		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 enum2Result = processEnum2Declarations({
-		enum2Blocks: topLevelEnum2s,
+	const enumResult = processEnumDeclarations({
+		enumBlocks: topLevelEnums,
 		sourceId,
 		authoringContributions: input.authoringContributions,
 		entityContext: {
@@ -3345,20 +3249,9 @@ function interpretPslDocumentToSqlContract(input) {
 		},
 		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 allEnumTypeDescriptors = new Map(enumResult.enumTypeDescriptors);
+	const validEnumHandles = { ...enumResult.enumHandles };
+	const enumHandlesByName = new Map(Object.entries(validEnumHandles));
 	const namedTypeResult = resolveNamedTypeDeclarations({
 		declarations: input.document.ast.types?.declarations ?? [],
 		sourceId,
@@ -3370,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);
@@ -3406,7 +3296,7 @@ function interpretPslDocumentToSqlContract(input) {
 			sourceId,
 			diagnostics,
 			modelNamespaceIds,
-			...enum2HandlesByName.size > 0 ? { enum2Handles: enum2HandlesByName } : {}
+			...enumHandlesByName.size > 0 ? { enumHandles: enumHandlesByName } : {}
 		});
 		modelNodes.push(namespaceId !== void 0 ? {
 			...result.modelNode,
@@ -3458,8 +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(validEnum2Handles).length > 0 ? { enums: validEnum2Handles } : {},
+		...Object.keys(validEnumHandles).length > 0 ? { enums: validEnumHandles } : {},
 		...ifDefined("createNamespace", input.createNamespace),
 		models: stiColumnModelNodes.map((model) => ({
 			...model,
@@ -3495,4 +3384,4 @@ function interpretPslDocumentToSqlContract(input) {
 //#endregion
 export { interpretPslDocumentToSqlContract as t };
 
-//# sourceMappingURL=interpreter-BT6dEGeD.mjs.map
+//# sourceMappingURL=interpreter-B0BsCLKT.mjs.map