@prisma-next/psl-parser 0.14.0-dev.6 → 0.14.0-dev.60

package/dist/index.mjs

@@ -1,5 +1,7 @@
-import { O as printSyntax, c as NamespaceDeclarationAst, i as GenericBlockDeclarationAst, l as TypesBlockAst, m as ArrayLiteralAst, o as ModelDeclarationAst, t as CompositeTypeDeclarationAst } from "./declarations-D9h_ihD3.mjs";
+import { b as ObjectLiteralExprAst, c as NamespaceDeclarationAst, g as BooleanLiteralExprAst, i as GenericBlockDeclarationAst, k as printSyntax, l as TypesBlockAst, m as ArrayLiteralAst, o as ModelDeclarationAst, t as CompositeTypeDeclarationAst, v as NumberLiteralExprAst, w as IdentifierAst, x as StringLiteralExprAst } from "./declarations-DR6To8_k.mjs";
 import { UNSPECIFIED_PSL_NAMESPACE_ID, flatPslModels, makePslNamespace, makePslNamespaceEntries, namespacePslExtensionBlocks, validateExtensionBlock } from "@prisma-next/framework-components/psl-ast";
+import { notOk, ok } from "@prisma-next/utils/result";
+import { blindCast } from "@prisma-next/utils/casts";
 import { isAuthoringPslBlockDescriptor } from "@prisma-next/framework-components/authoring";
 //#region src/attribute-helpers.ts
 function getPositionalArgument(attribute, index = 0) {
@@ -11,63 +13,6 @@ function parseQuotedStringLiteral(value) {
 	return match[2] ?? "";
 }
 //#endregion
-//#region src/extension-block.ts
-function findBlockDescriptor(descriptors, keyword) {
-	if (descriptors === void 0) return void 0;
-	for (const value of Object.values(descriptors)) {
-		if (value === void 0) continue;
-		if (isAuthoringPslBlockDescriptor(value)) {
-			if (value.keyword === keyword) return value;
-			continue;
-		}
-		const nested = findBlockDescriptor(value, keyword);
-		if (nested !== void 0) return nested;
-	}
-}
-function validateExtensionBlockFromSymbol(input) {
-	const refCtx = buildRefResolutionContext(input.symbolTable, input.block);
-	return validateExtensionBlock(input.block.block, input.descriptor, input.sourceId, input.codecLookup, refCtx);
-}
-const ZERO_SPAN = {
-	start: {
-		offset: 0,
-		line: 1,
-		column: 1
-	},
-	end: {
-		offset: 0,
-		line: 1,
-		column: 1
-	}
-};
-function buildRefResolutionContext(symbolTable, block) {
-	const unspecifiedNamespace = makeNamespace(UNSPECIFIED_PSL_NAMESPACE_ID, Object.values(symbolTable.topLevel.models));
-	const allNamespaces = [unspecifiedNamespace, ...Object.values(symbolTable.topLevel.namespaces).map((namespace) => makeNamespace(namespace.name, Object.values(namespace.models)))];
-	const ownerNamespaceName = findOwnerNamespaceName(symbolTable, block);
-	return {
-		ownerNamespace: allNamespaces.find((namespace) => namespace.name === ownerNamespaceName) ?? unspecifiedNamespace,
-		allNamespaces
-	};
-}
-function makeNamespace(name, models) {
-	return makePslNamespace({
-		kind: "namespace",
-		name,
-		entries: makePslNamespaceEntries(models.map((model) => ({
-			kind: "model",
-			name: model.name,
-			fields: [],
-			attributes: [],
-			span: ZERO_SPAN
-		})), [], []),
-		span: ZERO_SPAN
-	});
-}
-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;
-}
-//#endregion
 //#region src/resolve.ts
 function readResolvedAttribute(attribute, sourceFile) {
 	return {
@@ -93,10 +38,12 @@ function readResolvedArgList(argList, sourceFile) {
 	const args = [];
 	for (const arg of argList.args()) {
 		const name = arg.name()?.name();
+		const expression = arg.value();
 		args.push({
 			kind: name !== void 0 ? "named" : "positional",
 			...name !== void 0 ? { name } : {},
-			value: renderExpression(arg.value()),
+			value: renderExpression(expression),
+			...expression !== void 0 ? { expression } : {},
 			span: nodePslSpan(arg.syntax, sourceFile)
 		});
 	}
@@ -141,6 +88,372 @@ function offsetToPslPosition(offset, sourceFile) {
 	};
 }
 //#endregion
+//#region src/attribute-spec/combinators/diagnostic.ts
+const ATTRIBUTE_DIAGNOSTIC_CODE = "PSL_INVALID_ATTRIBUTE_SYNTAX";
+function leafDiagnostic(ctx, node, message) {
+	return {
+		code: ATTRIBUTE_DIAGNOSTIC_CODE,
+		message,
+		sourceId: ctx.sourceId,
+		span: nodePslSpan(node.syntax, ctx.sourceFile)
+	};
+}
+//#endregion
+//#region src/attribute-spec/combinators/bool.ts
+function bool() {
+	return {
+		kind: "bool",
+		label: "boolean",
+		parse: (arg, ctx) => {
+			if (arg instanceof BooleanLiteralExprAst) {
+				const value = arg.value();
+				if (value !== void 0) return ok(value);
+			}
+			return notOk([leafDiagnostic(ctx, arg, "Expected a boolean literal")]);
+		}
+	};
+}
+//#endregion
+//#region src/attribute-spec/combinators/entity-ref.ts
+function entityRef() {
+	return {
+		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();
+			if (name === void 0) return notOk([leafDiagnostic(ctx, arg, "Expected a model name")]);
+			return ok(name);
+		}
+	};
+}
+//#endregion
+//#region src/attribute-spec/combinators/field-ref.ts
+function fieldRef(scope) {
+	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);
+		}
+	};
+}
+//#endregion
+//#region src/attribute-spec/combinators/identifier.ts
+function identifier(name) {
+	return {
+		kind: "identifier",
+		label: name,
+		parse: (arg, ctx) => {
+			if (arg instanceof IdentifierAst && arg.name() === name) return ok(name);
+			return notOk([leafDiagnostic(ctx, arg, `Expected ${name}`)]);
+		}
+	};
+}
+//#endregion
+//#region src/attribute-spec/combinators/int.ts
+function int() {
+	return {
+		kind: "int",
+		label: "integer",
+		parse: (arg, ctx) => {
+			if (arg instanceof NumberLiteralExprAst) {
+				const value = arg.value();
+				if (value !== void 0 && Number.isInteger(value)) return ok(value);
+			}
+			return notOk([leafDiagnostic(ctx, arg, "Expected an integer literal")]);
+		}
+	};
+}
+//#endregion
+//#region src/attribute-spec/combinators/list.ts
+function list(of, opts) {
+	return {
+		kind: "list",
+		label: `${of.label}[]`,
+		parse: (arg, ctx) => {
+			if (!(arg instanceof ArrayLiteralAst)) return notOk([leafDiagnostic(ctx, arg, `Expected a list of ${of.label}`)]);
+			const diagnostics = [];
+			const parsed = [];
+			let count = 0;
+			for (const element of arg.elements()) {
+				count += 1;
+				const result = of.parse(element, ctx);
+				if (result.ok) parsed.push({
+					node: element,
+					value: result.value
+				});
+				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) {
+				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);
+			}
+			if (diagnostics.length > 0) return notOk(diagnostics);
+			return ok(parsed.map((entry) => entry.value));
+		}
+	};
+}
+//#endregion
+//#region src/attribute-spec/combinators/one-of.ts
+function oneOf(...alts) {
+	const label = alts.map((alt) => alt.label).join(" | ");
+	return {
+		kind: "oneOf",
+		label,
+		parse: (arg, ctx) => {
+			for (const alt of alts) {
+				const result = alt.parse(arg, ctx);
+				if (result.ok) return ok(blindCast(result.value));
+			}
+			return notOk([leafDiagnostic(ctx, arg, `Expected one of: ${label}`)]);
+		}
+	};
+}
+//#endregion
+//#region src/attribute-spec/combinators/record.ts
+function record(of) {
+	return {
+		kind: "record",
+		label: `{ [key]: ${of.label} }`,
+		parse: (arg, ctx) => {
+			if (!(arg instanceof ObjectLiteralExprAst)) return notOk([leafDiagnostic(ctx, arg, "Expected an object literal")]);
+			const diagnostics = [];
+			const result = {};
+			for (const field of arg.fields()) {
+				const key = field.keyName();
+				if (key === void 0) {
+					diagnostics.push(leafDiagnostic(ctx, field, "Expected a key"));
+					continue;
+				}
+				const value = field.value();
+				if (value === void 0) {
+					diagnostics.push(leafDiagnostic(ctx, field, `Expected a value for key "${key}"`));
+					continue;
+				}
+				const parsed = of.parse(value, ctx);
+				if (!parsed.ok) {
+					diagnostics.push(...parsed.failure);
+					continue;
+				}
+				if (Object.hasOwn(result, key)) {
+					diagnostics.push(leafDiagnostic(ctx, field, `Duplicate key "${key}"`));
+					continue;
+				}
+				result[key] = parsed.value;
+			}
+			if (diagnostics.length > 0) return notOk(diagnostics);
+			return ok(result);
+		}
+	};
+}
+//#endregion
+//#region src/attribute-spec/combinators/str.ts
+function str() {
+	return {
+		kind: "str",
+		label: "string",
+		parse: (arg, ctx) => {
+			if (arg instanceof StringLiteralExprAst) {
+				const value = arg.value();
+				if (value !== void 0) return ok(value);
+			}
+			return notOk([leafDiagnostic(ctx, arg, "Expected a string literal")]);
+		}
+	};
+}
+//#endregion
+//#region src/attribute-spec/field-attribute.ts
+function fieldAttribute(name, config) {
+	return {
+		level: "field",
+		name,
+		positional: config.positional ?? [],
+		named: config.named ?? {},
+		...config.refine !== void 0 ? { refine: config.refine } : {}
+	};
+}
+//#endregion
+//#region src/attribute-spec/interpret.ts
+function interpretAttribute(attrNode, spec, ctx) {
+	const diagnostics = [];
+	const attributeSpan = nodePslSpan(attrNode.syntax, ctx.sourceFile);
+	const output = {};
+	const seen = /* @__PURE__ */ new Set();
+	let positionalSlot = 0;
+	let reportedExcess = false;
+	for (const arg of attrNode.argList()?.args() ?? []) {
+		const name = arg.name()?.name();
+		let key;
+		let param;
+		if (name === void 0) {
+			const posParam = spec.positional[positionalSlot];
+			if (posParam === void 0) {
+				if (!reportedExcess) {
+					diagnostics.push(diagnostic(`Attribute "${spec.name}" received too many positional arguments`, ctx, attributeSpan));
+					reportedExcess = true;
+				}
+				continue;
+			}
+			positionalSlot += 1;
+			key = posParam.key;
+			param = posParam.type;
+		} else {
+			const namedParam = Object.hasOwn(spec.named, name) ? spec.named[name] : void 0;
+			if (namedParam === void 0) {
+				diagnostics.push(diagnostic(`Attribute "${spec.name}" received unknown argument "${name}"`, ctx, nodePslSpan(arg.syntax, ctx.sourceFile)));
+				continue;
+			}
+			key = name;
+			param = namedParam;
+		}
+		if (seen.has(key)) {
+			diagnostics.push(diagnostic(`Attribute "${spec.name}" received duplicate argument "${key}"`, ctx, nodePslSpan(arg.syntax, ctx.sourceFile)));
+			continue;
+		}
+		seen.add(key);
+		const result = parseArgValue(arg, param, ctx, diagnostics);
+		if (result.ok) output[key] = result.value;
+	}
+	const finalized = /* @__PURE__ */ new Set();
+	const finalizeAbsentKey = (key, positionalParam, namedParam) => {
+		if (finalized.has(key) || seen.has(key)) return;
+		finalized.add(key);
+		const effective = namedParam ?? positionalParam;
+		if (effective === void 0) return;
+		if (isOptionalArgType(effective)) {
+			if (effective.hasDefault) output[key] = effective.defaultValue;
+			return;
+		}
+		diagnostics.push(diagnostic(`Attribute "${spec.name}" is missing required argument "${key}"`, ctx, attributeSpan));
+	};
+	for (const param of spec.positional) {
+		const namedParam = Object.hasOwn(spec.named, param.key) ? spec.named[param.key] : void 0;
+		finalizeAbsentKey(param.key, param.type, namedParam);
+	}
+	for (const key of Object.keys(spec.named)) finalizeAbsentKey(key, void 0, spec.named[key]);
+	if (diagnostics.length > 0) return notOk(diagnostics);
+	const value = blindCast(output);
+	if (spec.refine !== void 0) {
+		const refineDiagnostics = spec.refine(value, ctx);
+		if (refineDiagnostics.length > 0) return notOk(refineDiagnostics);
+	}
+	return ok(value);
+}
+function parseArgValue(arg, argType, ctx, diagnostics) {
+	const value = arg.value();
+	if (value === void 0) {
+		const missing = diagnostic("Attribute argument is missing a value", ctx, nodePslSpan(arg.syntax, ctx.sourceFile));
+		diagnostics.push(missing);
+		return notOk([missing]);
+	}
+	const result = argType.parse(value, ctx);
+	if (!result.ok) for (const failure of result.failure) diagnostics.push(failure);
+	return result;
+}
+function isOptionalArgType(param) {
+	return "optional" in param && param.optional === true;
+}
+function diagnostic(message, ctx, span) {
+	return {
+		code: ATTRIBUTE_DIAGNOSTIC_CODE,
+		message,
+		sourceId: ctx.sourceId,
+		span
+	};
+}
+//#endregion
+//#region src/attribute-spec/model-attribute.ts
+function modelAttribute(name, config) {
+	return {
+		level: "model",
+		name,
+		positional: config.positional ?? [],
+		named: config.named ?? {},
+		...config.refine !== void 0 ? { refine: config.refine } : {}
+	};
+}
+//#endregion
+//#region src/attribute-spec/optional.ts
+function optional(type, ...rest) {
+	if (rest.length === 0) return {
+		...type,
+		optional: true,
+		hasDefault: false
+	};
+	return {
+		...type,
+		optional: true,
+		hasDefault: true,
+		defaultValue: rest[0]
+	};
+}
+//#endregion
+//#region src/extension-block.ts
+function findBlockDescriptor(descriptors, keyword) {
+	if (descriptors === void 0) return void 0;
+	for (const value of Object.values(descriptors)) {
+		if (value === void 0) continue;
+		if (isAuthoringPslBlockDescriptor(value)) {
+			if (value.keyword === keyword) return value;
+			continue;
+		}
+		const nested = findBlockDescriptor(value, keyword);
+		if (nested !== void 0) return nested;
+	}
+}
+function validateExtensionBlockFromSymbol(input) {
+	const refCtx = buildRefResolutionContext(input.symbolTable, input.block);
+	return validateExtensionBlock(input.block.block, input.descriptor, input.sourceId, input.codecLookup, refCtx);
+}
+const ZERO_SPAN = {
+	start: {
+		offset: 0,
+		line: 1,
+		column: 1
+	},
+	end: {
+		offset: 0,
+		line: 1,
+		column: 1
+	}
+};
+function buildRefResolutionContext(symbolTable, block) {
+	const unspecifiedNamespace = makeNamespace(UNSPECIFIED_PSL_NAMESPACE_ID, Object.values(symbolTable.topLevel.models));
+	const allNamespaces = [unspecifiedNamespace, ...Object.values(symbolTable.topLevel.namespaces).map((namespace) => makeNamespace(namespace.name, Object.values(namespace.models)))];
+	const ownerNamespaceName = findOwnerNamespaceName(symbolTable, block);
+	return {
+		ownerNamespace: allNamespaces.find((namespace) => namespace.name === ownerNamespaceName) ?? unspecifiedNamespace,
+		allNamespaces
+	};
+}
+function makeNamespace(name, models) {
+	return makePslNamespace({
+		kind: "namespace",
+		name,
+		entries: makePslNamespaceEntries(models.map((model) => ({
+			kind: "model",
+			name: model.name,
+			fields: [],
+			attributes: [],
+			span: ZERO_SPAN
+		})), [], []),
+		span: ZERO_SPAN
+	});
+}
+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;
+}
+//#endregion
 //#region src/block-reconstruction.ts
 /**
 * Descriptor-free and unknown parameters become `value` stubs so validation can
@@ -479,6 +792,6 @@ function nodeRange(node, sourceFile) {
 	};
 }
 //#endregion
-export { buildSymbolTable, findBlockDescriptor, flatPslModels, getPositionalArgument, keywordPslSpan, namespacePslExtensionBlocks, nodePslSpan, parseQuotedStringLiteral, rangeToPslSpan, readResolvedAttribute, readResolvedAttributes, readResolvedConstructorCall, validateExtensionBlockFromSymbol };
+export { bool, buildSymbolTable, entityRef, fieldAttribute, fieldRef, findBlockDescriptor, flatPslModels, getPositionalArgument, identifier, int, interpretAttribute, keywordPslSpan, leafDiagnostic, list, modelAttribute, namespacePslExtensionBlocks, nodePslSpan, oneOf, optional, parseQuotedStringLiteral, rangeToPslSpan, readResolvedAttribute, readResolvedAttributes, readResolvedConstructorCall, record, str, validateExtensionBlockFromSymbol };
 
 //# sourceMappingURL=index.mjs.map