@prisma/orm-framework 8.0.0-rc.15-dev.2 → 8.0.0-rc.15-dev.3

package/dist/psl-parser.mjs

@@ -1,12 +1,14 @@
 import { t as blindCast } from "./casts-DpaahrlC-Bd5n2coI.mjs";
 import { t as InternalError } from "./internal-error-ChGYPVpq-DhUD05u0.mjs";
 import { a as or, i as okVoid, n as notOk, r as ok, t as and } from "./result-8OXF26MN.mjs";
-import { S as isAuthoringPslBlockDescriptor, x as isAuthoringModelAttributeDescriptor } from "./temporal-presets-DIo9uYtS-Odk6WBk8.mjs";
+import { r as createDataTypeLookup } from "./data-type-4xQlxYB5-DD158cOq.mjs";
+import { S as isAuthoringPslBlockDescriptor, f as describeTaggedLiteralFailure, x as isAuthoringModelAttributeDescriptor } from "./temporal-presets-DUCEijgt-CODhqGVy.mjs";
+import { _ as tagForm, a as describeExpected, g as readWrittenValue, i as describeAdmittedForms, n as admittedTags, o as describeRefusal, r as castTypedValue, t as admittedForms, u as exactRewrite } from "./authoring-DcJL9g8s.mjs";
 import { a as flatPslModels, c as namespacePslExtensionBlocks } from "./psl-ast-CyvE6CR-.mjs";
 import { n as isPslIdentifier } from "./tokenizer-BMz7z2KR-J0yZ4im3.mjs";
-import { C as TaggedLiteralExprAst, S as StringLiteralExprAst, T as TypesBlockAst, _ as NumberLiteralExprAst, a as CompositeTypeDeclarationAst, b as PathExprAst, d as IdentifierAst, g as NamespaceDeclarationAst, i as BooleanLiteralExprAst, l as FunctionCallAst, m as ModelDeclarationAst, t as ArrayLiteralAst, u as GenericBlockDeclarationAst, y as ObjectLiteralExprAst } from "./declarations-DDT0hm5r-BZoOKiu1.mjs";
+import { C as TaggedLiteralExprAst, S as StringLiteralExprAst, T as TypesBlockAst, _ as NumberLiteralExprAst, a as CompositeTypeDeclarationAst, b as PathExprAst, d as IdentifierAst, g as NamespaceDeclarationAst, i as BooleanLiteralExprAst, l as FunctionCallAst, m as ModelDeclarationAst, t as ArrayLiteralAst, u as GenericBlockDeclarationAst, y as ObjectLiteralExprAst } from "./declarations-5xLxC310-R3-Z4vcK.mjs";
 import { a as mapPslDiagnostics, c as readResolvedAttributes, i as keywordPslSpan, l as readResolvedConstructorCall, n as diagnosticFromSpan, o as nodePslSpan, r as diagnosticSource, s as readResolvedAttribute, t as createPslDiagnosticCollector } from "./resolve-C8PUf8zv-QAvnPhCt.mjs";
-//#region ../../../1-framework/2-authoring/psl-parser/dist/symbol-table-C1ATzvmU.mjs
+//#region ../../../1-framework/2-authoring/psl-parser/dist/symbol-table-BtWXPbMr.mjs
 function* modelAttributeDescriptors(namespace) {
 	for (const value of Object.values(namespace)) {
 		if (isAuthoringModelAttributeDescriptor(value)) {
@@ -37,6 +39,72 @@ function resolveDescribeUnresolvedType(pslDiagnostics) {
 	if (pslDiagnostics?.describeUnresolvedType === void 0) return;
 	return blindCast(pslDiagnostics.describeUnresolvedType);
 }
+const AN_EXPRESSION = {
+	ok: false,
+	reason: "not-a-literal",
+	found: "an expression"
+};
+function written(value) {
+	return {
+		ok: true,
+		written: value
+	};
+}
+/** Reads a PSL literal expression as a `WrittenScalar`, for a position that takes a value of a data type. ADR 254. */
+function readWrittenScalar(expression) {
+	const syntax = expression.syntax;
+	const string = StringLiteralExprAst.cast(syntax)?.value();
+	if (string !== void 0) return written({
+		kind: "string",
+		text: string
+	});
+	const number = NumberLiteralExprAst.cast(syntax);
+	if (number !== void 0) {
+		const text = number.token()?.text;
+		return text === void 0 ? AN_EXPRESSION : written({
+			kind: "number",
+			text
+		});
+	}
+	const boolean = BooleanLiteralExprAst.cast(syntax)?.value();
+	if (boolean !== void 0) return written({
+		kind: "boolean",
+		value: boolean
+	});
+	const tagged = TaggedLiteralExprAst.cast(syntax);
+	if (tagged !== void 0) {
+		const canonicalization = tagged.canonicalization();
+		return canonicalization.ok ? written({
+			kind: "tag",
+			tag: tagged.tagName(),
+			text: canonicalization.text
+		}) : {
+			ok: false,
+			reason: canonicalization.reason
+		};
+	}
+	if (IdentifierAst.cast(syntax) !== void 0) return {
+		ok: false,
+		reason: "not-a-literal",
+		found: "an identifier"
+	};
+	if (FunctionCallAst.cast(syntax) !== void 0) return {
+		ok: false,
+		reason: "not-a-literal",
+		found: "a function call"
+	};
+	if (ArrayLiteralAst.cast(syntax) !== void 0) return {
+		ok: false,
+		reason: "not-a-literal",
+		found: "a list"
+	};
+	if (ObjectLiteralExprAst.cast(syntax) !== void 0) return {
+		ok: false,
+		reason: "not-a-literal",
+		found: "an object"
+	};
+	return AN_EXPRESSION;
+}
 function writtenEntityReference(node) {
 	const name = IdentifierAst.cast(node)?.name();
 	if (name !== void 0) return {
@@ -371,16 +439,14 @@ function createBinder(input) {
 		contributedTypes: mergeContributedTypes(contributions.field, contributions.type),
 		attributeSpecs: assembleAttributeSpecs(contributions),
 		pslBlockDescriptors: contributions.pslBlockDescriptors,
-		controlMutationDefaults: {
-			defaultFunctionRegistry: context.controlMutationDefaults.defaultFunctionRegistry,
-			dataTypeEntries: contributions.dataTypes
-		},
+		controlMutationDefaults: { defaultFunctionRegistry: context.controlMutationDefaults.defaultFunctionRegistry },
+		dataTypes: context.dataTypes,
 		...describeUnsupportedAttributeFactory !== void 0 ? { describeUnsupportedAttribute: describeUnsupportedAttributeFactory(sources) } : {},
 		...describeUnresolvedTypeFactory !== void 0 ? { describeUnresolvedType: describeUnresolvedTypeFactory(contributions) } : {}
 	});
 }
 function bind(options) {
-	const { sources, symbolTable, contributedTypes, attributeSpecs, controlMutationDefaults, describeUnsupportedAttribute, describeUnresolvedType } = options;
+	const { sources, symbolTable, contributedTypes, attributeSpecs, controlMutationDefaults, dataTypes, describeUnsupportedAttribute, describeUnresolvedType } = options;
 	const pslBlockDescriptors = options.pslBlockDescriptors ?? {};
 	const contributed = contributedScope(contributedTypeScope(contributedTypes));
 	const document = documentScope(symbolTable.topLevel, contributed);
@@ -478,7 +544,8 @@ function bind(options) {
 		const specContext = entity.kind === "model" ? {
 			symbols: symbolTable,
 			model: entity,
-			controlMutationDefaults
+			controlMutationDefaults,
+			dataTypes
 		} : void 0;
 		bindAttributes(entity, entity.attributes, attributeSpecs.model, (factory) => specContext === void 0 ? void 0 : factory(specContext), {
 			...context,
@@ -778,6 +845,14 @@ function tryBindExpression(rule, expression, ctx, modelContext) {
 			references,
 			diagnostics
 		};
+		case "dataTypeValue": {
+			const literal = readWrittenScalar(expression);
+			return {
+				matched: literal.ok || literal.reason !== "not-a-literal",
+				references,
+				diagnostics
+			};
+		}
 		case "rejecting": return {
 			matched: false,
 			references,
@@ -1257,6 +1332,55 @@ function bool() {
 		}
 	};
 }
+const TAGGED_LITERAL_FAILURE_CODES = {
+	nul: "PSL_TAGGED_LITERAL_NUL",
+	"too-large": "PSL_TAGGED_LITERAL_TOO_LARGE"
+};
+/** An argument typed by a data type: any literal, admitted by the ADR 254 cast rule. Used as a parameter of an attribute or a `funcCall`. ADR 231, ADR 254. */
+function dataTypeValue(dataType, support) {
+	const tags = admittedTags(support, dataType);
+	const [firstTag] = tags;
+	const forms = admittedForms(support, [dataType]);
+	return {
+		kind: "dataTypeValue",
+		label: firstTag === void 0 ? describeAdmittedForms(support, dataType) : tagForm(firstTag).phrase,
+		dataType,
+		tags,
+		documentation: support.entries[dataType]?.documentation ?? "",
+		parse: (arg, ctx) => parseDataTypeValue(arg, ctx, dataType, support, forms)
+	};
+}
+function parseDataTypeValue(arg, ctx, dataType, support, forms) {
+	if (!support.lookup.has(dataType)) throw new InternalError(`An argument receives data type "${dataType}", which this stack does not register.`);
+	if (forms.length === 0) throw new InternalError(`An argument receives data type "${dataType}", which nothing in this stack writes.`);
+	const refuse = ({ code, message }) => notOk([leafDiagnostic(ctx, arg, message, code)]);
+	const literal = readWrittenScalar(arg);
+	if (!literal.ok) return literal.reason === "not-a-literal" ? refuse({
+		code: "PSL_INVALID_ATTRIBUTE_SYNTAX",
+		message: `${describeExpected(forms)}; got ${literal.found}`
+	}) : refuse({
+		code: TAGGED_LITERAL_FAILURE_CODES[literal.reason],
+		message: describeTaggedLiteralFailure(literal.reason)
+	});
+	const read = readWrittenValue(support, literal.written);
+	if (!read.ok) return refuse(describeRefusal(read.failure, support, {
+		forms,
+		rewrite: void 0
+	}));
+	const cast = castTypedValue(support, dataType, read.value);
+	if (!cast.ok) {
+		const rewrite = exactRewrite(support, dataType, literal.written);
+		return refuse(describeRefusal(cast.failure, support, {
+			forms,
+			rewrite
+		}));
+	}
+	return ok({
+		type: dataType,
+		value: cast.value.value,
+		span: nodePslSpan(arg.syntax, ctx.sources)
+	});
+}
 function entityRef(expected) {
 	const label = `${expected.kind === "block" ? expected.keyword : expected.kind} reference`;
 	return {
@@ -1392,6 +1516,7 @@ function funcCall(name, sig) {
 		label: `${name}()`,
 		name,
 		signature: sig,
+		claims: (arg) => plainCallee(arg)?.name === name,
 		parse: (arg, ctx) => {
 			const guard = matchCallee(arg, name, ctx);
 			if (!guard.ok) return guard;
@@ -1410,15 +1535,22 @@ function funcCall(name, sig) {
 		}
 	};
 }
-function matchCallee(arg, name, ctx) {
+function plainCallee(arg) {
 	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(call);
+	const qname = call?.name();
+	if (call === void 0 || qname === void 0) return void 0;
+	if (qname.dot() !== void 0 || qname.colon() !== void 0) return void 0;
+	const name = qname.identifier()?.token()?.text;
+	return name === void 0 ? void 0 : {
+		call,
+		name
+	};
+}
+function matchCallee(arg, name, ctx) {
+	const callee = plainCallee(arg);
+	if (callee === void 0) return notOk([leafDiagnostic(ctx, arg, "Expected a function call")]);
+	if (callee.name !== name) return notOk([leafDiagnostic(ctx, arg, `Expected ${name}()`)]);
+	return ok(callee.call);
 }
 function identifier(name, options) {
 	const label = name ?? "identifier";
@@ -1516,6 +1648,9 @@ function list(of, opts) {
 		}
 	};
 }
+/**
+* The first alternative that accepts the argument. When exactly one alternative claims the argument's shape, its result, success or failure, so its diagnostics about the argument are kept.
+*/
 function oneOf(...alts) {
 	const label = alts.map((alt) => alt.label).join(" | ");
 	return {
@@ -1524,6 +1659,9 @@ function oneOf(...alts) {
 		alternatives: alts,
 		parse: (arg, ctx) => {
 			const [head, ...tail] = blindCast(alts);
+			const claiming = [head, ...tail].filter((alt) => alt.claims?.(arg) === true);
+			const [only] = claiming;
+			if (only !== void 0 && claiming.length === 1) return only.parse(arg, ctx);
 			let rejection = head.parse(arg, ctx);
 			if (rejection.ok) return rejection;
 			for (const alt of tail) {
@@ -1730,6 +1868,11 @@ function optional(type, ...rest) {
 		defaultValue: rest[0]
 	};
 }
+/** The data types of a stack that registers none. */
+const EMPTY_DATA_TYPES = {
+	entries: {},
+	lookup: createDataTypeLookup([])
+};
 function structBlock(config) {
 	return {
 		mode: "struct",
@@ -1975,6 +2118,6 @@ function renameLegacyDirective(text) {
 	return text.replace(DIRECTIVE, (whole, lead, name, trail) => name === LEGACY_NAME ? `${lead}prisma-8${trail}` : whole);
 }
 //#endregion
-export { NAME_THE_PSL_SOURCE_LOSES, PSL_UNRESOLVED_REFERENCE, assembleAttributeSpecs, blockAttribute, blockSpecFactoryOf, bool, buildSymbolTable, contributedTypeOf, createBinder, createPslDiagnosticCollector, diagnosticFromSpan, diagnosticSource, entityRef, entityReference, fieldAttribute, fieldRef, findBlockDescriptor, flatPslModels, funcCall, getPositionalArgument, identifier, int, interpretArgs, interpretAttribute, interpretExtensionBlock, interpretExtensionBlockAttributes, interpretExtensionBlocks, isNamespaceLike, isPrismaNextSchema, isPslIdentifier, json, jsonValue, keywordPslSpan, leafDiagnostic, list, mapBlock, mapPslDiagnostics, matchesSelector, memberEntries, modelAttribute, namespacePslExtensionBlocks, nodePslSpan, num, numLiteral, oneOf, optional, parseQuotedStringLiteral, readResolvedAttribute, readResolvedAttributes, readResolvedConstructorCall, record, referencedFieldRef, renameLegacyDirective, str, structBlock, taggedLiteral, typeReferenceNode };
+export { EMPTY_DATA_TYPES, NAME_THE_PSL_SOURCE_LOSES, PSL_UNRESOLVED_REFERENCE, assembleAttributeSpecs, blockAttribute, blockSpecFactoryOf, bool, buildSymbolTable, contributedTypeOf, createBinder, createPslDiagnosticCollector, dataTypeValue, diagnosticFromSpan, diagnosticSource, entityRef, entityReference, fieldAttribute, fieldRef, findBlockDescriptor, flatPslModels, funcCall, getPositionalArgument, identifier, int, interpretArgs, interpretAttribute, interpretExtensionBlock, interpretExtensionBlockAttributes, interpretExtensionBlocks, isNamespaceLike, isPrismaNextSchema, isPslIdentifier, json, jsonValue, keywordPslSpan, leafDiagnostic, list, mapBlock, mapPslDiagnostics, matchesSelector, memberEntries, modelAttribute, namespacePslExtensionBlocks, nodePslSpan, num, numLiteral, oneOf, optional, parseQuotedStringLiteral, readResolvedAttribute, readResolvedAttributes, readResolvedConstructorCall, readWrittenScalar, record, referencedFieldRef, renameLegacyDirective, str, structBlock, taggedLiteral, typeReferenceNode };
 
 //# sourceMappingURL=psl-parser.mjs.map