@prisma/orm-framework 8.0.0-rc.1-dev.46 → 8.0.0-rc.10-dev.1

package/dist/psl-parser.mjs

@@ -1,6 +1,7 @@
 import { t as blindCast } from "./casts-DpaahrlC-Bd5n2coI.mjs";
-import { n as ok, t as notOk } from "./result-CBZ8X9mU.mjs";
-import { h as isAuthoringPslBlockDescriptor } from "./framework-authoring-CDEvlouU-DKklu-fL.mjs";
+import { t as InternalError } from "./internal-error-ChGYPVpq-DhUD05u0.mjs";
+import { n as ok, t as notOk } from "./result-C0NUq1Ok.mjs";
+import { h as isAuthoringPslBlockDescriptor, m as isAuthoringModelAttributeDescriptor } from "./framework-authoring-BvxZnsPY-DlD1nwU5.mjs";
 import { a as makePslNamespace, c as validateExtensionBlock, i as flatPslModels, n as UNSPECIFIED_PSL_NAMESPACE_ID, o as makePslNamespaceEntries, s as namespacePslExtensionBlocks } from "./psl-ast-DUCvVXbB.mjs";
 import { E as TypesBlockAst, N as printSyntax, _ as NumberLiteralExprAst, a as CompositeTypeDeclarationAst, d as IdentifierAst, g as NamespaceDeclarationAst, i as BooleanLiteralExprAst, l as FunctionCallAst, m as ModelDeclarationAst, t as ArrayLiteralAst, u as GenericBlockDeclarationAst, x as StringLiteralExprAst, y as ObjectLiteralExprAst } from "./declarations-DR6To8_k-BFwkCGeP.mjs";
 //#region ../../../1-framework/2-authoring/psl-parser/dist/index.mjs
@@ -12,6 +13,37 @@ function parseQuotedStringLiteral(value) {
 	if (!match) return void 0;
 	return match[2] ?? "";
 }
+function* modelAttributeDescriptors(namespace) {
+	for (const value of Object.values(namespace)) {
+		if (isAuthoringModelAttributeDescriptor(value)) {
+			yield value;
+			continue;
+		}
+		yield* modelAttributeDescriptors(value);
+	}
+}
+function assembleAttributeSpecs(contributions) {
+	const entries = Object.entries(contributions.attributeSpecs.model);
+	const claimed = new Set(entries.map(([attribute]) => attribute));
+	for (const descriptor of modelAttributeDescriptors(contributions.modelAttributes)) {
+		if (claimed.has(descriptor.attribute)) throw new InternalError(`Duplicate attribute spec registration for "${descriptor.attribute}". Each model attribute name may be registered once across family built-ins and model-attribute descriptors.`);
+		claimed.add(descriptor.attribute);
+		entries.push([descriptor.attribute, descriptor.spec]);
+	}
+	return Object.freeze(blindCast({
+		model: Object.freeze(Object.fromEntries(entries)),
+		field: Object.freeze({ ...contributions.attributeSpecs.field })
+	}));
+}
+function blockAttribute(name, config) {
+	return {
+		level: "block",
+		name,
+		positional: config.positional ?? [],
+		named: config.named ?? {},
+		...config.refine !== void 0 ? { refine: config.refine } : {}
+	};
+}
 function readResolvedAttribute(attribute, sourceFile) {
 	return {
 		name: attributeName(attribute.name()),
@@ -99,8 +131,9 @@ function bool() {
 		kind: "bool",
 		label: "boolean",
 		parse: (arg, ctx) => {
-			if (arg instanceof BooleanLiteralExprAst) {
-				const value = arg.value();
+			const literal = BooleanLiteralExprAst.cast(arg.syntax);
+			if (literal !== void 0) {
+				const value = literal.value();
 				if (value !== void 0) return ok(value);
 			}
 			return notOk([leafDiagnostic(ctx, arg, "Expected a boolean literal")]);
@@ -112,26 +145,34 @@ function entityRef() {
 		kind: "entityRef",
 		label: "model name",
 		parse: (arg, ctx) => {
-			if (!(arg instanceof IdentifierAst)) return notOk([leafDiagnostic(ctx, arg, "Expected a model name")]);
-			const name = arg.name();
+			const identifier = IdentifierAst.cast(arg.syntax);
+			if (identifier === void 0) return notOk([leafDiagnostic(ctx, arg, "Expected a model name")]);
+			const name = identifier.name();
 			if (name === void 0) return notOk([leafDiagnostic(ctx, arg, "Expected a model name")]);
 			return ok(name);
 		}
 	};
 }
-function fieldRef(scope) {
+function parseFieldName(arg, ctx, model) {
+	const identifier = IdentifierAst.cast(arg.syntax);
+	if (identifier === void 0) return notOk([leafDiagnostic(ctx, arg, "Expected a field name")]);
+	const name = identifier.name();
+	if (name === void 0) return notOk([leafDiagnostic(ctx, arg, "Expected a field name")]);
+	if (model !== void 0 && !Object.hasOwn(model.fields, name)) return notOk([leafDiagnostic(ctx, arg, `Field "${name}" does not exist on model "${model.name}"`)]);
+	return ok(name);
+}
+function fieldRef() {
 	return {
 		kind: "fieldRef",
 		label: "field name",
-		scope,
-		parse: (arg, ctx) => {
-			if (!(arg instanceof IdentifierAst)) return notOk([leafDiagnostic(ctx, arg, "Expected a field name")]);
-			const name = arg.name();
-			if (name === void 0) return notOk([leafDiagnostic(ctx, arg, "Expected a field name")]);
-			const model = scope === "self" ? ctx.selfModel : ctx.resolveReferencedModel();
-			if (model !== void 0 && !Object.hasOwn(model.fields, name)) return notOk([leafDiagnostic(ctx, arg, `Field "${name}" does not exist on model "${model.name}"`)]);
-			return ok(name);
-		}
+		parse: (arg, ctx) => parseFieldName(arg, ctx, ctx.selfModel)
+	};
+}
+function referencedFieldRef() {
+	return {
+		kind: "referencedFieldRef",
+		label: "field name",
+		parse: (arg, ctx) => parseFieldName(arg, ctx, ctx.resolveReferencedModel())
 	};
 }
 function interpretArgs(args, spec, ctx, span) {
@@ -229,7 +270,9 @@ function diagnostic(message, ctx, span) {
 function funcCall(name, sig) {
 	return {
 		kind: "funcCall",
-		label: "function call",
+		label: `${name}()`,
+		name,
+		signature: sig,
 		parse: (arg, ctx) => {
 			const guard = matchCallee(arg, name, ctx);
 			if (!guard.ok) return guard;
@@ -249,20 +292,23 @@ function funcCall(name, sig) {
 	};
 }
 function matchCallee(arg, name, ctx) {
-	if (!(arg instanceof FunctionCallAst)) return notOk([leafDiagnostic(ctx, arg, "Expected a function call")]);
-	const qname = arg.name();
+	const call = FunctionCallAst.cast(arg.syntax);
+	if (call === void 0) return notOk([leafDiagnostic(ctx, arg, "Expected a function call")]);
+	const qname = call.name();
 	if (qname === void 0 || qname.dot() !== void 0 || qname.colon() !== void 0) return notOk([leafDiagnostic(ctx, arg, "Expected a function call")]);
 	const calleeName = qname.identifier()?.token()?.text;
 	if (calleeName === void 0) return notOk([leafDiagnostic(ctx, arg, "Expected a function call")]);
 	if (calleeName !== name) return notOk([leafDiagnostic(ctx, arg, `Expected ${name}()`)]);
-	return ok(arg);
+	return ok(call);
 }
 function identifier(name) {
 	return {
 		kind: "identifier",
 		label: name,
+		name,
 		parse: (arg, ctx) => {
-			if (arg instanceof IdentifierAst && arg.name() === name) return ok(name);
+			const identifier = IdentifierAst.cast(arg.syntax);
+			if (identifier !== void 0 && identifier.name() === name) return ok(name);
 			return notOk([leafDiagnostic(ctx, arg, `Expected ${name}`)]);
 		}
 	};
@@ -273,9 +319,12 @@ function int(opts) {
 	return {
 		kind: "int",
 		label: "integer",
+		...min === void 0 ? {} : { min },
+		...max === void 0 ? {} : { max },
 		parse: (arg, ctx) => {
-			if (arg instanceof NumberLiteralExprAst) {
-				const value = arg.value();
+			const literal = NumberLiteralExprAst.cast(arg.syntax);
+			if (literal !== void 0) {
+				const value = literal.value();
 				if (value !== void 0 && Number.isInteger(value)) {
 					if ((min === void 0 || value >= min) && (max === void 0 || value <= max)) return ok(value);
 					return notOk([leafDiagnostic(ctx, arg, rangeMessage(min, max))]);
@@ -290,16 +339,43 @@ function rangeMessage(min, max) {
 	if (min !== void 0) return `Expected an integer greater than or equal to ${min}`;
 	return `Expected an integer less than or equal to ${max}`;
 }
+/**
+* Reads an opaque JSON object from a quoted JSON string — the ADR's one text-encoded surface
+* exception (e.g. an index `filter` / `weights` argument). The string is decoded by the parser,
+* then JSON-parsed; a non-object (array/scalar) or invalid JSON is a diagnostic.
+*/
+function json() {
+	return {
+		kind: "json",
+		label: "JSON object",
+		parse: (arg, ctx) => {
+			const literal = StringLiteralExprAst.cast(arg.syntax);
+			if (literal === void 0) return notOk([leafDiagnostic(ctx, arg, "Expected a JSON object string")]);
+			const raw = literal.value();
+			if (raw !== void 0) try {
+				const parsed = JSON.parse(raw);
+				if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) return ok(blindCast(parsed));
+			} catch {}
+			return notOk([leafDiagnostic(ctx, arg, "Expected a valid JSON object")]);
+		}
+	};
+}
 function list(of, opts) {
+	const allowEmpty = opts?.allowEmpty ?? true;
+	const unique = opts?.unique ?? false;
 	return {
 		kind: "list",
 		label: `${of.label}[]`,
+		of,
+		allowEmpty,
+		unique,
 		parse: (arg, ctx) => {
-			if (!(arg instanceof ArrayLiteralAst)) return notOk([leafDiagnostic(ctx, arg, `Expected a list of ${of.label}`)]);
+			const literal = ArrayLiteralAst.cast(arg.syntax);
+			if (literal === void 0) return notOk([leafDiagnostic(ctx, arg, `Expected a list of ${of.label}`)]);
 			const diagnostics = [];
 			const parsed = [];
 			let count = 0;
-			for (const element of arg.elements()) {
+			for (const element of literal.elements()) {
 				count += 1;
 				const result = of.parse(element, ctx);
 				if (result.ok) parsed.push({
@@ -308,8 +384,8 @@ function list(of, opts) {
 				});
 				else diagnostics.push(...result.failure);
 			}
-			if (opts?.nonEmpty === true && count === 0) diagnostics.push(leafDiagnostic(ctx, arg, "Expected a non-empty list"));
-			if (opts?.unique === true) {
+			if (!allowEmpty && count === 0) diagnostics.push(leafDiagnostic(ctx, arg, "Expected a non-empty list"));
+			if (unique) {
 				const seen = /* @__PURE__ */ new Set();
 				for (const { node, value } of parsed) if (seen.has(value)) diagnostics.push(leafDiagnostic(ctx, node, "Duplicate list entry"));
 				else seen.add(value);
@@ -320,15 +396,29 @@ function list(of, opts) {
 	};
 }
 function num(value) {
+	if (value === void 0) return {
+		kind: "num",
+		label: "number",
+		value: void 0,
+		parse: (arg, ctx) => {
+			const literal = NumberLiteralExprAst.cast(arg.syntax);
+			if (literal !== void 0) {
+				const parsed = literal.value();
+				if (parsed !== void 0) return ok(parsed);
+			}
+			return notOk([leafDiagnostic(ctx, arg, "Expected a number literal")]);
+		}
+	};
 	return {
 		kind: "num",
-		label: value === void 0 ? "number" : String(value),
+		label: String(value),
+		value,
 		parse: (arg, ctx) => {
-			if (arg instanceof NumberLiteralExprAst) {
-				const parsed = arg.value();
-				if (parsed !== void 0 && (value === void 0 || parsed === value)) return ok(parsed);
+			const literal = NumberLiteralExprAst.cast(arg.syntax);
+			if (literal !== void 0) {
+				if (literal.value() === value) return ok(value);
 			}
-			return notOk([leafDiagnostic(ctx, arg, value === void 0 ? "Expected a number literal" : `Expected ${value}`)]);
+			return notOk([leafDiagnostic(ctx, arg, `Expected ${value}`)]);
 		}
 	};
 }
@@ -337,9 +427,10 @@ function oneOf(...alts) {
 	return {
 		kind: "oneOf",
 		label,
+		alternatives: alts,
 		parse: (arg, ctx) => {
 			for (const alt of alts) {
-				const result = alt.parse(arg, ctx);
+				const result = blindCast(alt.parse)(arg, ctx);
 				if (result.ok) return ok(blindCast(result.value));
 			}
 			return notOk([leafDiagnostic(ctx, arg, `Expected one of: ${label}`)]);
@@ -350,11 +441,14 @@ function record(of) {
 	return {
 		kind: "record",
 		label: `{ [key]: ${of.label} }`,
+		of,
 		parse: (arg, ctx) => {
-			if (!(arg instanceof ObjectLiteralExprAst)) return notOk([leafDiagnostic(ctx, arg, "Expected an object literal")]);
+			const literal = ObjectLiteralExprAst.cast(arg.syntax);
+			if (literal === void 0) return notOk([leafDiagnostic(ctx, arg, "Expected an object literal")]);
 			const diagnostics = [];
-			const result = {};
-			for (const field of arg.fields()) {
+			const entries = [];
+			const keys = /* @__PURE__ */ new Set();
+			for (const field of Array.from(literal.fields())) {
 				const key = field.keyName();
 				if (key === void 0) {
 					diagnostics.push(leafDiagnostic(ctx, field, "Expected a key"));
@@ -370,29 +464,44 @@ function record(of) {
 					diagnostics.push(...parsed.failure);
 					continue;
 				}
-				if (Object.hasOwn(result, key)) {
+				if (keys.has(key)) {
 					diagnostics.push(leafDiagnostic(ctx, field, `Duplicate key "${key}"`));
 					continue;
 				}
-				result[key] = parsed.value;
+				keys.add(key);
+				entries.push([key, parsed.value]);
 			}
 			if (diagnostics.length > 0) return notOk(diagnostics);
-			return ok(result);
+			return ok(Object.fromEntries(entries));
 		}
 	};
 }
-function str() {
-	return {
+function str(value) {
+	if (value === void 0) return {
 		kind: "str",
 		label: "string",
+		value: void 0,
 		parse: (arg, ctx) => {
-			if (arg instanceof StringLiteralExprAst) {
-				const value = arg.value();
-				if (value !== void 0) return ok(value);
+			const literal = StringLiteralExprAst.cast(arg.syntax);
+			if (literal !== void 0) {
+				const parsed = literal.value();
+				if (parsed !== void 0) return ok(parsed);
 			}
 			return notOk([leafDiagnostic(ctx, arg, "Expected a string literal")]);
 		}
 	};
+	return {
+		kind: "str",
+		label: JSON.stringify(value),
+		value,
+		parse: (arg, ctx) => {
+			const literal = StringLiteralExprAst.cast(arg.syntax);
+			if (literal !== void 0) {
+				if (literal.value() === value) return ok(value);
+			}
+			return notOk([leafDiagnostic(ctx, arg, `Expected ${JSON.stringify(value)}`)]);
+		}
+	};
 }
 function fieldAttribute(name, config) {
 	return {
@@ -480,6 +589,7 @@ function findOwnerNamespaceName(symbolTable, block) {
 	for (const namespace of Object.values(symbolTable.topLevel.namespaces)) if (Object.values(namespace.blocks).some((candidate) => candidate === block)) return namespace.name;
 	return UNSPECIFIED_PSL_NAMESPACE_ID;
 }
+const BLOCK_ATTRIBUTE_SOURCE_ID = "unknown";
 /**
 * Descriptor-free and unknown parameters become `value` stubs so validation can
 * report them via key-set comparison. Duplicate member names are first-wins.
@@ -488,6 +598,8 @@ function reconstructExtensionBlock(node, descriptor, sourceFile, diagnostics) {
 	const keyword = node.keyword()?.text ?? "";
 	const blockName = node.name()?.name() ?? "";
 	const blockAttributes = [];
+	const attributes = {};
+	const seenAttributeNames = /* @__PURE__ */ new Set();
 	for (const attribute of node.attributes()) {
 		const name = attribute.name()?.path().join(".") ?? "";
 		const args = Array.from(attribute.argList()?.args() ?? [], (arg) => {
@@ -498,11 +610,16 @@ function reconstructExtensionBlock(node, descriptor, sourceFile, diagnostics) {
 				span: nodePslSpan(arg.syntax, sourceFile)
 			};
 		});
+		const span = nodePslSpan(attribute.syntax, sourceFile);
 		blockAttributes.push({
 			name,
 			args,
-			span: nodePslSpan(attribute.syntax, sourceFile)
+			span
 		});
+		if (descriptor === void 0) continue;
+		const parsed = parseBlockAttribute(attribute, name, span, descriptor, seenAttributeNames, keyword, blockName, sourceFile);
+		if (parsed.ok) attributes[name] = parsed.value;
+		else diagnostics.push(...parsed.diagnostics);
 	}
 	const parameters = {};
 	for (const entry of node.entries()) {
@@ -528,9 +645,59 @@ function reconstructExtensionBlock(node, descriptor, sourceFile, diagnostics) {
 		name: blockName,
 		parameters,
 		blockAttributes,
+		attributes,
 		span: nodePslSpan(node.syntax, sourceFile)
 	};
 }
+function parseBlockAttribute(attribute, name, span, descriptor, seenNames, keyword, blockName, sourceFile) {
+	const range = pslSpanToRange(span, sourceFile);
+	const declared = descriptor.attributes ?? {};
+	if (!Object.hasOwn(declared, name)) return {
+		ok: false,
+		diagnostics: [{
+			code: "PSL_EXTENSION_UNKNOWN_BLOCK_ATTRIBUTE",
+			message: `Unknown attribute "@@${name}" in "${keyword}" block "${blockName}"`,
+			range
+		}]
+	};
+	if (seenNames.has(name)) return {
+		ok: false,
+		diagnostics: [{
+			code: "PSL_INVALID_EXTENSION_BLOCK_ATTRIBUTE",
+			message: `Duplicate attribute "@@${name}" in "${keyword}" block "${blockName}"; first occurrence wins`,
+			range
+		}]
+	};
+	seenNames.add(name);
+	const result = interpretAttribute(attribute, blindCast(declared[name])(), {
+		sourceId: BLOCK_ATTRIBUTE_SOURCE_ID,
+		sourceFile
+	});
+	if (!result.ok) return {
+		ok: false,
+		diagnostics: result.failure.map((diagnostic) => toParseDiagnostic(diagnostic, sourceFile))
+	};
+	return {
+		ok: true,
+		value: {
+			args: result.value,
+			span
+		}
+	};
+}
+function toParseDiagnostic(diagnostic, sourceFile) {
+	return {
+		code: diagnostic.code,
+		message: diagnostic.message,
+		range: pslSpanToRange(diagnostic.span, sourceFile)
+	};
+}
+function pslSpanToRange(span, sourceFile) {
+	return {
+		start: sourceFile.positionAt(span.start.offset),
+		end: sourceFile.positionAt(span.end.offset)
+	};
+}
 function reconstructParamValue(entry, param, span, sourceFile, diagnostics) {
 	const value = entry.value();
 	if (value === void 0) return {
@@ -799,6 +966,6 @@ function nodeRange(node, sourceFile) {
 	};
 }
 //#endregion
-export { bool, buildSymbolTable, entityRef, fieldAttribute, fieldRef, findBlockDescriptor, flatPslModels, funcCall, getPositionalArgument, identifier, int, interpretArgs, interpretAttribute, keywordPslSpan, leafDiagnostic, list, modelAttribute, namespacePslExtensionBlocks, nodePslSpan, num, oneOf, optional, parseQuotedStringLiteral, rangeToPslSpan, readResolvedAttribute, readResolvedAttributes, readResolvedConstructorCall, record, str, validateExtensionBlockFromSymbol };
+export { assembleAttributeSpecs, blockAttribute, bool, buildSymbolTable, entityRef, fieldAttribute, fieldRef, findBlockDescriptor, flatPslModels, funcCall, getPositionalArgument, identifier, int, interpretArgs, interpretAttribute, json, keywordPslSpan, leafDiagnostic, list, modelAttribute, namespacePslExtensionBlocks, nodePslSpan, num, oneOf, optional, parseQuotedStringLiteral, rangeToPslSpan, readResolvedAttribute, readResolvedAttributes, readResolvedConstructorCall, record, referencedFieldRef, str, validateExtensionBlockFromSymbol };
 
 //# sourceMappingURL=psl-parser.mjs.map