@prisma-next/sql-contract-psl 0.3.0-dev.55 → 0.3.0-dev.64

package/src/provider.ts

@@ -1,10 +1,11 @@
 import { readFile } from 'node:fs/promises';
+import type { ContractConfig } from '@prisma-next/config/config-types';
 import type { TargetPackRef } from '@prisma-next/contract/framework-components';
-import type { ContractConfig } from '@prisma-next/core-control-plane/config-types';
 import { parsePslDocument } from '@prisma-next/psl-parser';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { notOk } from '@prisma-next/utils/result';
 import { resolve } from 'pathe';
+import { createBuiltinDefaultFunctionRegistry } from './default-function-registry';
 import { interpretPslDocumentToSqlContractIR } from './interpreter';
 
 export interface PrismaContractOptions {
@@ -56,6 +57,7 @@ export function prismaContract(
         document,
         ...ifDefined('target', options?.target),
         ...ifDefined('composedExtensionPacks', options?.composedExtensionPacks),
+        defaultFunctionRegistry: createBuiltinDefaultFunctionRegistry(),
       });
     },
     ...ifDefined('output', options?.output),

package/dist/interpreter-_6-Xk1_m.mjs

@@ -1,661 +0,0 @@
-import { defineContract } from "@prisma-next/sql-contract-ts/contract-builder";
-import { notOk, ok } from "@prisma-next/utils/result";
-
-//#region src/interpreter.ts
-const DEFAULT_POSTGRES_TARGET = {
-	kind: "target",
-	familyId: "sql",
-	targetId: "postgres",
-	id: "postgres",
-	version: "0.0.1",
-	capabilities: {}
-};
-const SCALAR_COLUMN_MAP = {
-	String: {
-		codecId: "pg/text@1",
-		nativeType: "text"
-	},
-	Boolean: {
-		codecId: "pg/bool@1",
-		nativeType: "bool"
-	},
-	Int: {
-		codecId: "pg/int4@1",
-		nativeType: "int4"
-	},
-	BigInt: {
-		codecId: "pg/int8@1",
-		nativeType: "int8"
-	},
-	Float: {
-		codecId: "pg/float8@1",
-		nativeType: "float8"
-	},
-	Decimal: {
-		codecId: "pg/numeric@1",
-		nativeType: "numeric"
-	},
-	DateTime: {
-		codecId: "pg/timestamptz@1",
-		nativeType: "timestamptz"
-	},
-	Json: {
-		codecId: "pg/jsonb@1",
-		nativeType: "jsonb"
-	},
-	Bytes: {
-		codecId: "pg/bytea@1",
-		nativeType: "bytea"
-	}
-};
-const REFERENTIAL_ACTION_MAP = {
-	NoAction: "noAction",
-	Restrict: "restrict",
-	Cascade: "cascade",
-	SetNull: "setNull",
-	SetDefault: "setDefault",
-	noAction: "noAction",
-	restrict: "restrict",
-	cascade: "cascade",
-	setNull: "setNull",
-	setDefault: "setDefault"
-};
-function lowerFirst(value) {
-	if (value.length === 0) return value;
-	return value[0]?.toLowerCase() + value.slice(1);
-}
-function getAttribute(attributes, name) {
-	return attributes.find((attribute) => attribute.name === name);
-}
-function getNamedArgument(attribute, name) {
-	const entry = attribute.args.find((arg) => arg.kind === "named" && arg.name === name);
-	if (!entry || entry.kind !== "named") return;
-	return entry.value;
-}
-function getPositionalArgument(attribute, index = 0) {
-	const entry = attribute.args.filter((arg) => arg.kind === "positional")[index];
-	if (!entry || entry.kind !== "positional") return;
-	return entry.value;
-}
-function unquoteStringLiteral(value) {
-	const trimmed = value.trim();
-	const match = trimmed.match(/^(['"])(.*)\1$/);
-	if (!match) return trimmed;
-	return match[2] ?? "";
-}
-function parseQuotedStringLiteral(value) {
-	const match = value.trim().match(/^(['"])(.*)\1$/);
-	if (!match) return;
-	return match[2] ?? "";
-}
-function parseFieldList(value) {
-	const trimmed = value.trim();
-	if (!trimmed.startsWith("[") || !trimmed.endsWith("]")) return;
-	return trimmed.slice(1, -1).split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
-}
-function parseDefaultValueExpression(expression) {
-	const trimmed = expression.trim();
-	if (trimmed === "autoincrement()") return {
-		kind: "function",
-		expression: "autoincrement()"
-	};
-	if (trimmed === "now()") return {
-		kind: "function",
-		expression: "now()"
-	};
-	if (trimmed === "true" || trimmed === "false") return {
-		kind: "literal",
-		value: trimmed === "true"
-	};
-	const numericValue = Number(trimmed);
-	if (!Number.isNaN(numericValue) && trimmed.length > 0 && !/^(['"]).*\1$/.test(trimmed)) return {
-		kind: "literal",
-		value: numericValue
-	};
-	if (/^(['"]).*\1$/.test(trimmed)) return {
-		kind: "literal",
-		value: unquoteStringLiteral(trimmed)
-	};
-}
-function parseMapName(input) {
-	if (!input.attribute) return input.defaultValue;
-	const value = getPositionalArgument(input.attribute);
-	if (!value) {
-		input.diagnostics.push({
-			code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
-			message: `${input.entityLabel} @map requires a positional quoted string literal argument`,
-			sourceId: input.sourceId,
-			span: input.attribute.span
-		});
-		return input.defaultValue;
-	}
-	const parsed = parseQuotedStringLiteral(value);
-	if (parsed === void 0) {
-		input.diagnostics.push({
-			code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
-			message: `${input.entityLabel} @map requires a positional quoted string literal argument`,
-			sourceId: input.sourceId,
-			span: input.attribute.span
-		});
-		return input.defaultValue;
-	}
-	return parsed;
-}
-function parsePgvectorLength(input) {
-	const namedLength = getNamedArgument(input.attribute, "length");
-	const namedDim = getNamedArgument(input.attribute, "dim");
-	const positional = getPositionalArgument(input.attribute);
-	const raw = namedLength ?? namedDim ?? positional;
-	if (!raw) {
-		input.diagnostics.push({
-			code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
-			message: "@pgvector.column requires length/dim argument",
-			sourceId: input.sourceId,
-			span: input.attribute.span
-		});
-		return;
-	}
-	const parsed = Number(unquoteStringLiteral(raw));
-	if (!Number.isInteger(parsed) || parsed < 1) {
-		input.diagnostics.push({
-			code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
-			message: "@pgvector.column length/dim must be a positive integer",
-			sourceId: input.sourceId,
-			span: input.attribute.span
-		});
-		return;
-	}
-	return parsed;
-}
-function resolveColumnDescriptor(field, enumTypeDescriptors, namedTypeDescriptors) {
-	if (field.typeRef && namedTypeDescriptors.has(field.typeRef)) return namedTypeDescriptors.get(field.typeRef);
-	if (namedTypeDescriptors.has(field.typeName)) return namedTypeDescriptors.get(field.typeName);
-	if (enumTypeDescriptors.has(field.typeName)) return enumTypeDescriptors.get(field.typeName);
-	return SCALAR_COLUMN_MAP[field.typeName];
-}
-function collectResolvedFields(model, mapping, enumTypeDescriptors, namedTypeDescriptors, namedTypeBaseTypes, modelNames, composedExtensions, diagnostics, sourceId) {
-	const resolvedFields = [];
-	for (const field of model.fields) {
-		if (field.list) {
-			diagnostics.push({
-				code: "PSL_UNSUPPORTED_FIELD_LIST",
-				message: `Field "${model.name}.${field.name}" uses list types, which are not supported in SQL PSL provider v1`,
-				sourceId,
-				span: field.span
-			});
-			continue;
-		}
-		for (const attribute of field.attributes) {
-			if (attribute.name === "id" || attribute.name === "unique" || attribute.name === "default" || attribute.name === "relation" || attribute.name === "map" || attribute.name === "pgvector.column") continue;
-			if (attribute.name.startsWith("pgvector.") && !composedExtensions.has("pgvector")) {
-				diagnostics.push({
-					code: "PSL_EXTENSION_NAMESPACE_NOT_COMPOSED",
-					message: `Attribute "@${attribute.name}" uses unrecognized namespace "pgvector". Add extension pack "pgvector" to extensionPacks in prisma-next.config.ts.`,
-					sourceId,
-					span: attribute.span
-				});
-				continue;
-			}
-			diagnostics.push({
-				code: "PSL_UNSUPPORTED_FIELD_ATTRIBUTE",
-				message: `Field "${model.name}.${field.name}" uses unsupported attribute "@${attribute.name}"`,
-				sourceId,
-				span: attribute.span
-			});
-		}
-		if (getAttribute(field.attributes, "relation") && modelNames.has(field.typeName)) continue;
-		let descriptor = resolveColumnDescriptor(field, enumTypeDescriptors, namedTypeDescriptors);
-		const pgvectorColumnAttribute = getAttribute(field.attributes, "pgvector.column");
-		if (pgvectorColumnAttribute) if (!composedExtensions.has("pgvector")) diagnostics.push({
-			code: "PSL_EXTENSION_NAMESPACE_NOT_COMPOSED",
-			message: "Attribute \"@pgvector.column\" uses unrecognized namespace \"pgvector\". Add extension pack \"pgvector\" to extensionPacks in prisma-next.config.ts.",
-			sourceId,
-			span: pgvectorColumnAttribute.span
-		});
-		else if (!(field.typeName === "Bytes" || namedTypeBaseTypes.get(field.typeRef ?? field.typeName) === "Bytes")) diagnostics.push({
-			code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
-			message: `Field "${model.name}.${field.name}" uses @pgvector.column on unsupported base type "${field.typeName}"`,
-			sourceId,
-			span: pgvectorColumnAttribute.span
-		});
-		else {
-			const length = parsePgvectorLength({
-				attribute: pgvectorColumnAttribute,
-				diagnostics,
-				sourceId
-			});
-			if (length !== void 0) descriptor = {
-				codecId: "pg/vector@1",
-				nativeType: `vector(${length})`,
-				typeParams: { length }
-			};
-		}
-		if (!descriptor) {
-			diagnostics.push({
-				code: "PSL_UNSUPPORTED_FIELD_TYPE",
-				message: `Field "${model.name}.${field.name}" type "${field.typeName}" is not supported in SQL PSL provider v1`,
-				sourceId,
-				span: field.span
-			});
-			continue;
-		}
-		const defaultAttribute = getAttribute(field.attributes, "default");
-		const defaultValueRaw = defaultAttribute ? getPositionalArgument(defaultAttribute) : void 0;
-		const defaultValue = defaultValueRaw ? parseDefaultValueExpression(defaultValueRaw) : void 0;
-		if (defaultAttribute && defaultValueRaw && !defaultValue) diagnostics.push({
-			code: "PSL_INVALID_DEFAULT_VALUE",
-			message: `Unsupported default value "${defaultValueRaw}"`,
-			sourceId,
-			span: defaultAttribute.span
-		});
-		const mappedColumnName = mapping.fieldColumns.get(field.name) ?? field.name;
-		resolvedFields.push({
-			field,
-			columnName: mappedColumnName,
-			descriptor,
-			...defaultValue ? { defaultValue } : {},
-			isId: Boolean(getAttribute(field.attributes, "id")),
-			isUnique: Boolean(getAttribute(field.attributes, "unique"))
-		});
-	}
-	return resolvedFields;
-}
-function hasSameSpan(a, b) {
-	return a.start.offset === b.start.offset && a.end.offset === b.end.offset && a.start.line === b.start.line && a.end.line === b.end.line;
-}
-function mapParserDiagnostics(document) {
-	return document.diagnostics.map((diagnostic) => ({
-		code: diagnostic.code,
-		message: diagnostic.message,
-		sourceId: diagnostic.sourceId,
-		span: diagnostic.span
-	}));
-}
-function normalizeReferentialAction(input) {
-	const normalized = REFERENTIAL_ACTION_MAP[input.actionToken];
-	if (normalized) return normalized;
-	input.diagnostics.push({
-		code: "PSL_UNSUPPORTED_REFERENTIAL_ACTION",
-		message: `Relation field "${input.modelName}.${input.fieldName}" has unsupported ${input.actionName} action "${input.actionToken}"`,
-		sourceId: input.sourceId,
-		span: input.span
-	});
-}
-function parseAttributeFieldList(input) {
-	const raw = getNamedArgument(input.attribute, "fields") ?? getPositionalArgument(input.attribute);
-	if (!raw) {
-		input.diagnostics.push({
-			code: input.code,
-			message: `${input.messagePrefix} requires fields list argument`,
-			sourceId: input.sourceId,
-			span: input.attribute.span
-		});
-		return;
-	}
-	const fields = parseFieldList(raw);
-	if (!fields || fields.length === 0) {
-		input.diagnostics.push({
-			code: input.code,
-			message: `${input.messagePrefix} requires bracketed field list argument`,
-			sourceId: input.sourceId,
-			span: input.attribute.span
-		});
-		return;
-	}
-	return fields;
-}
-function mapFieldNamesToColumns(input) {
-	const columns = [];
-	for (const fieldName of input.fieldNames) {
-		const columnName = input.mapping.fieldColumns.get(fieldName);
-		if (!columnName) {
-			input.diagnostics.push({
-				code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
-				message: `${input.contextLabel} references unknown field "${input.modelName}.${fieldName}"`,
-				sourceId: input.sourceId,
-				span: input.span
-			});
-			return;
-		}
-		columns.push(columnName);
-	}
-	return columns;
-}
-function buildModelMappings(models, diagnostics, sourceId) {
-	const result = /* @__PURE__ */ new Map();
-	for (const model of models) {
-		const tableName = parseMapName({
-			attribute: getAttribute(model.attributes, "map"),
-			defaultValue: lowerFirst(model.name),
-			sourceId,
-			diagnostics,
-			entityLabel: `Model "${model.name}"`,
-			span: model.span
-		});
-		const fieldColumns = /* @__PURE__ */ new Map();
-		for (const field of model.fields) {
-			const columnName = parseMapName({
-				attribute: getAttribute(field.attributes, "map"),
-				defaultValue: field.name,
-				sourceId,
-				diagnostics,
-				entityLabel: `Field "${model.name}.${field.name}"`,
-				span: field.span
-			});
-			fieldColumns.set(field.name, columnName);
-		}
-		result.set(model.name, {
-			model,
-			tableName,
-			fieldColumns
-		});
-	}
-	return result;
-}
-function parseRelationAttribute(input) {
-	for (const arg of input.attribute.args) {
-		if (arg.kind === "positional") {
-			input.diagnostics.push({
-				code: "PSL_INVALID_RELATION_ATTRIBUTE",
-				message: `Relation field "${input.modelName}.${input.fieldName}" must use named arguments`,
-				sourceId: input.sourceId,
-				span: arg.span
-			});
-			return;
-		}
-		if (arg.name !== "fields" && arg.name !== "references" && arg.name !== "onDelete" && arg.name !== "onUpdate") {
-			input.diagnostics.push({
-				code: "PSL_INVALID_RELATION_ATTRIBUTE",
-				message: `Relation field "${input.modelName}.${input.fieldName}" has unsupported argument "${arg.name}"`,
-				sourceId: input.sourceId,
-				span: arg.span
-			});
-			return;
-		}
-	}
-	const fieldsRaw = getNamedArgument(input.attribute, "fields");
-	const referencesRaw = getNamedArgument(input.attribute, "references");
-	if (!fieldsRaw || !referencesRaw) {
-		input.diagnostics.push({
-			code: "PSL_INVALID_RELATION_ATTRIBUTE",
-			message: `Relation field "${input.modelName}.${input.fieldName}" requires fields and references arguments`,
-			sourceId: input.sourceId,
-			span: input.attribute.span
-		});
-		return;
-	}
-	const fields = parseFieldList(fieldsRaw);
-	const references = parseFieldList(referencesRaw);
-	if (!fields || !references || fields.length === 0 || references.length === 0) {
-		input.diagnostics.push({
-			code: "PSL_INVALID_RELATION_ATTRIBUTE",
-			message: `Relation field "${input.modelName}.${input.fieldName}" requires bracketed fields and references lists`,
-			sourceId: input.sourceId,
-			span: input.attribute.span
-		});
-		return;
-	}
-	return {
-		fields,
-		references,
-		...getNamedArgument(input.attribute, "onDelete") ? { onDelete: unquoteStringLiteral(getNamedArgument(input.attribute, "onDelete") ?? "") } : {},
-		...getNamedArgument(input.attribute, "onUpdate") ? { onUpdate: unquoteStringLiteral(getNamedArgument(input.attribute, "onUpdate") ?? "") } : {}
-	};
-}
-function interpretPslDocumentToSqlContractIR(input) {
-	const diagnostics = mapParserDiagnostics(input.document);
-	const modelNames = new Set(input.document.ast.models.map((model) => model.name));
-	const sourceId = input.document.ast.sourceId;
-	const composedExtensions = new Set(input.composedExtensionPacks ?? []);
-	let builder = defineContract().target(input.target ?? DEFAULT_POSTGRES_TARGET);
-	const enumTypeDescriptors = /* @__PURE__ */ new Map();
-	const namedTypeDescriptors = /* @__PURE__ */ new Map();
-	const namedTypeBaseTypes = /* @__PURE__ */ new Map();
-	for (const enumDeclaration of input.document.ast.enums) {
-		const nativeType = enumDeclaration.name.toLowerCase();
-		const descriptor = {
-			codecId: "pg/enum@1",
-			nativeType,
-			typeRef: enumDeclaration.name
-		};
-		enumTypeDescriptors.set(enumDeclaration.name, descriptor);
-		builder = builder.storageType(enumDeclaration.name, {
-			codecId: "pg/enum@1",
-			nativeType,
-			typeParams: { values: enumDeclaration.values.map((value) => value.name) }
-		});
-	}
-	for (const declaration of input.document.ast.types?.declarations ?? []) {
-		const baseDescriptor = enumTypeDescriptors.get(declaration.baseType) ?? SCALAR_COLUMN_MAP[declaration.baseType];
-		if (!baseDescriptor) {
-			diagnostics.push({
-				code: "PSL_UNSUPPORTED_NAMED_TYPE_BASE",
-				message: `Named type "${declaration.name}" references unsupported base type "${declaration.baseType}"`,
-				sourceId,
-				span: declaration.span
-			});
-			continue;
-		}
-		namedTypeBaseTypes.set(declaration.name, declaration.baseType);
-		const pgvectorAttribute = getAttribute(declaration.attributes, "pgvector.column");
-		const unsupportedNamedTypeAttribute = declaration.attributes.find((attribute) => attribute.name !== "pgvector.column");
-		if (unsupportedNamedTypeAttribute) {
-			diagnostics.push({
-				code: "PSL_UNSUPPORTED_NAMED_TYPE_ATTRIBUTE",
-				message: `Named type "${declaration.name}" uses unsupported attribute "${unsupportedNamedTypeAttribute.name}"`,
-				sourceId,
-				span: unsupportedNamedTypeAttribute.span
-			});
-			continue;
-		}
-		if (pgvectorAttribute) {
-			if (!composedExtensions.has("pgvector")) {
-				diagnostics.push({
-					code: "PSL_EXTENSION_NAMESPACE_NOT_COMPOSED",
-					message: "Attribute \"@pgvector.column\" uses unrecognized namespace \"pgvector\". Add extension pack \"pgvector\" to extensionPacks in prisma-next.config.ts.",
-					sourceId,
-					span: pgvectorAttribute.span
-				});
-				continue;
-			}
-			if (declaration.baseType !== "Bytes") {
-				diagnostics.push({
-					code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
-					message: `Named type "${declaration.name}" uses @pgvector.column on unsupported base type "${declaration.baseType}"`,
-					sourceId,
-					span: pgvectorAttribute.span
-				});
-				continue;
-			}
-			const length = parsePgvectorLength({
-				attribute: pgvectorAttribute,
-				diagnostics,
-				sourceId
-			});
-			if (length === void 0) continue;
-			namedTypeDescriptors.set(declaration.name, {
-				codecId: "pg/vector@1",
-				nativeType: `vector(${length})`,
-				typeRef: declaration.name
-			});
-			builder = builder.storageType(declaration.name, {
-				codecId: "pg/vector@1",
-				nativeType: `vector(${length})`,
-				typeParams: { length }
-			});
-			continue;
-		}
-		const descriptor = {
-			codecId: baseDescriptor.codecId,
-			nativeType: baseDescriptor.nativeType,
-			typeRef: declaration.name
-		};
-		namedTypeDescriptors.set(declaration.name, descriptor);
-		builder = builder.storageType(declaration.name, {
-			codecId: baseDescriptor.codecId,
-			nativeType: baseDescriptor.nativeType,
-			typeParams: {}
-		});
-	}
-	const modelMappings = buildModelMappings(input.document.ast.models, diagnostics, sourceId);
-	for (const model of input.document.ast.models) {
-		const mapping = modelMappings.get(model.name);
-		if (!mapping) continue;
-		const tableName = mapping.tableName;
-		const resolvedFields = collectResolvedFields(model, mapping, enumTypeDescriptors, namedTypeDescriptors, namedTypeBaseTypes, modelNames, composedExtensions, diagnostics, sourceId);
-		const primaryKeyColumns = resolvedFields.filter((field) => field.isId).map((field) => field.columnName);
-		if (primaryKeyColumns.length === 0) diagnostics.push({
-			code: "PSL_MISSING_PRIMARY_KEY",
-			message: `Model "${model.name}" must declare at least one @id field for SQL provider`,
-			sourceId,
-			span: model.span
-		});
-		const relationAttributes = model.fields.map((field) => ({
-			field,
-			relation: getAttribute(field.attributes, "relation")
-		})).filter((entry) => Boolean(entry.relation));
-		builder = builder.table(tableName, (tableBuilder) => {
-			let table = tableBuilder;
-			for (const resolvedField of resolvedFields) {
-				const options = {
-					type: resolvedField.descriptor,
-					...resolvedField.field.optional ? { nullable: true } : {},
-					...resolvedField.defaultValue ? { default: resolvedField.defaultValue } : {}
-				};
-				table = table.column(resolvedField.columnName, options);
-				if (resolvedField.isUnique) table = table.unique([resolvedField.columnName]);
-			}
-			if (primaryKeyColumns.length > 0) table = table.primaryKey(primaryKeyColumns);
-			for (const modelAttribute of model.attributes) {
-				if (modelAttribute.name === "map") continue;
-				if (modelAttribute.name === "unique" || modelAttribute.name === "index") {
-					const fieldNames = parseAttributeFieldList({
-						attribute: modelAttribute,
-						sourceId,
-						diagnostics,
-						code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
-						messagePrefix: `Model "${model.name}" @@${modelAttribute.name}`
-					});
-					if (!fieldNames) continue;
-					const columnNames = mapFieldNamesToColumns({
-						modelName: model.name,
-						fieldNames,
-						mapping,
-						sourceId,
-						diagnostics,
-						span: modelAttribute.span,
-						contextLabel: `Model "${model.name}" @@${modelAttribute.name}`
-					});
-					if (!columnNames) continue;
-					if (modelAttribute.name === "unique") table = table.unique(columnNames);
-					else table = table.index(columnNames);
-					continue;
-				}
-				if (modelAttribute.name.startsWith("pgvector.") && !composedExtensions.has("pgvector")) {
-					diagnostics.push({
-						code: "PSL_EXTENSION_NAMESPACE_NOT_COMPOSED",
-						message: `Attribute "@@${modelAttribute.name}" uses unrecognized namespace "pgvector". Add extension pack "pgvector" to extensionPacks in prisma-next.config.ts.`,
-						sourceId,
-						span: modelAttribute.span
-					});
-					continue;
-				}
-				diagnostics.push({
-					code: "PSL_UNSUPPORTED_MODEL_ATTRIBUTE",
-					message: `Model "${model.name}" uses unsupported attribute "@@${modelAttribute.name}"`,
-					sourceId,
-					span: modelAttribute.span
-				});
-			}
-			for (const relationAttribute of relationAttributes) {
-				if (!modelNames.has(relationAttribute.field.typeName)) {
-					diagnostics.push({
-						code: "PSL_INVALID_RELATION_TARGET",
-						message: `Relation field "${model.name}.${relationAttribute.field.name}" references unknown model "${relationAttribute.field.typeName}"`,
-						sourceId,
-						span: relationAttribute.field.span
-					});
-					continue;
-				}
-				const parsedRelation = parseRelationAttribute({
-					attribute: relationAttribute.relation,
-					modelName: model.name,
-					fieldName: relationAttribute.field.name,
-					sourceId,
-					diagnostics
-				});
-				if (!parsedRelation) continue;
-				const targetMapping = modelMappings.get(relationAttribute.field.typeName);
-				if (!targetMapping) {
-					diagnostics.push({
-						code: "PSL_INVALID_RELATION_TARGET",
-						message: `Relation field "${model.name}.${relationAttribute.field.name}" references unknown model "${relationAttribute.field.typeName}"`,
-						sourceId,
-						span: relationAttribute.field.span
-					});
-					continue;
-				}
-				const localColumns = mapFieldNamesToColumns({
-					modelName: model.name,
-					fieldNames: parsedRelation.fields,
-					mapping,
-					sourceId,
-					diagnostics,
-					span: relationAttribute.relation.span,
-					contextLabel: `Relation field "${model.name}.${relationAttribute.field.name}"`
-				});
-				if (!localColumns) continue;
-				const referencedColumns = mapFieldNamesToColumns({
-					modelName: targetMapping.model.name,
-					fieldNames: parsedRelation.references,
-					mapping: targetMapping,
-					sourceId,
-					diagnostics,
-					span: relationAttribute.relation.span,
-					contextLabel: `Relation field "${model.name}.${relationAttribute.field.name}"`
-				});
-				if (!referencedColumns) continue;
-				const onDelete = parsedRelation.onDelete ? normalizeReferentialAction({
-					modelName: model.name,
-					fieldName: relationAttribute.field.name,
-					actionName: "onDelete",
-					actionToken: parsedRelation.onDelete,
-					sourceId,
-					span: relationAttribute.field.span,
-					diagnostics
-				}) : void 0;
-				const onUpdate = parsedRelation.onUpdate ? normalizeReferentialAction({
-					modelName: model.name,
-					fieldName: relationAttribute.field.name,
-					actionName: "onUpdate",
-					actionToken: parsedRelation.onUpdate,
-					sourceId,
-					span: relationAttribute.field.span,
-					diagnostics
-				}) : void 0;
-				table = table.foreignKey(localColumns, {
-					table: targetMapping.tableName,
-					columns: referencedColumns
-				}, {
-					...onDelete ? { onDelete } : {},
-					...onUpdate ? { onUpdate } : {}
-				});
-			}
-			return table;
-		});
-		builder = builder.model(model.name, tableName, (modelBuilder) => {
-			let next = modelBuilder;
-			for (const resolvedField of resolvedFields) next = next.field(resolvedField.field.name, resolvedField.columnName);
-			return next;
-		});
-	}
-	if (diagnostics.length > 0) return notOk({
-		summary: "PSL to SQL Contract IR normalization failed",
-		diagnostics: diagnostics.filter((diagnostic, index, allDiagnostics) => allDiagnostics.findIndex((candidate) => candidate.code === diagnostic.code && candidate.message === diagnostic.message && candidate.sourceId === diagnostic.sourceId && (candidate.span && diagnostic.span && hasSameSpan(candidate.span, diagnostic.span) || !candidate.span && !diagnostic.span)) === index)
-	});
-	return ok(builder.build());
-}
-
-//#endregion
-export { interpretPslDocumentToSqlContractIR as t };
-//# sourceMappingURL=interpreter-_6-Xk1_m.mjs.map