@prisma-next/sql-contract-psl 0.5.0-dev.80 → 0.5.0-dev.82

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":";;;;;;;;;KAuCY,gBAAA;EAAA,SACD,OAAA;EAAA,SACA,UAAA;EAAA,SACA,OAAA;EAAA,SACA,UAAA,GAAa,MAAA;AAAA;;;UCoCP,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;AAAA;AAAA,iBAqlCpB,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":";;;;;;;;;KAuCY,gBAAA;EAAA,SACD,OAAA;EAAA,SACA,UAAA;EAAA,SACA,OAAA;EAAA,SACA,UAAA,GAAa,MAAA;AAAA;;;UCsCP,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;AAAA;AAAA,iBA+nCpB,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-C9MPo8FK.mjs";
+import { t as interpretPslDocumentToSqlContract } from "./interpreter-ijCjxhaU.mjs";
 export { interpretPslDocumentToSqlContract };

package/dist/{interpreter-C9MPo8FK.mjs → interpreter-ijCjxhaU.mjs}

@@ -76,6 +76,109 @@ function parseConstraintMapArgument(input) {
 function getPositionalArguments(attribute) {
 	return attribute.args.filter((arg) => arg.kind === "positional").map((arg) => arg.kind === "positional" ? arg.value : "");
 }
+/**
+* Parses a PSL object-literal attribute argument value of the form
+* `{ key1: "value1", key2: "value2" }` into a `Record<string, string>`.
+*
+* V1 admits string literals only as leaf values. Boolean and number
+* literals are rejected. Trailing commas are allowed.
+*
+* Returns the parsed record, or pushes a diagnostic and returns undefined
+* on malformed input or non-string leaves.
+*/
+function parseObjectLiteralStringMap(input) {
+	const trimmed = input.raw.trim();
+	if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) return pushInvalidAttributeArgument({
+		diagnostics: input.diagnostics,
+		sourceId: input.sourceId,
+		span: input.span,
+		message: `${input.entityLabel} expected an object literal value of the form { key: "value", ... }`
+	});
+	const body = trimmed.slice(1, -1).trim();
+	if (body.length === 0) return {};
+	const result = {};
+	for (const part of splitObjectLiteralEntries(body)) {
+		const colonAt = findTopLevelColon(part);
+		if (colonAt === -1) return pushInvalidAttributeArgument({
+			diagnostics: input.diagnostics,
+			sourceId: input.sourceId,
+			span: input.span,
+			message: `${input.entityLabel} object-literal entry "${part}" is missing a "key: value" colon`
+		});
+		const key = part.slice(0, colonAt).trim();
+		const rawValue = part.slice(colonAt + 1).trim();
+		if (key.length === 0 || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) return pushInvalidAttributeArgument({
+			diagnostics: input.diagnostics,
+			sourceId: input.sourceId,
+			span: input.span,
+			message: `${input.entityLabel} object-literal key "${key}" must be a bare identifier`
+		});
+		const parsedString = parseQuotedStringLiteral(rawValue);
+		if (parsedString === void 0) return pushInvalidAttributeArgument({
+			diagnostics: input.diagnostics,
+			sourceId: input.sourceId,
+			span: input.span,
+			message: `${input.entityLabel} object-literal value for "${key}" must be a quoted string literal (V1 PSL @@index options support string leaves only; use the TS authoring surface for non-string options)`
+		});
+		if (Object.hasOwn(result, key)) return pushInvalidAttributeArgument({
+			diagnostics: input.diagnostics,
+			sourceId: input.sourceId,
+			span: input.span,
+			message: `${input.entityLabel} object-literal key "${key}" appears more than once`
+		});
+		result[key] = parsedString;
+	}
+	return result;
+}
+function splitObjectLiteralEntries(body) {
+	const parts = [];
+	let depthBrace = 0;
+	let depthBracket = 0;
+	let depthParen = 0;
+	let quote = null;
+	let start = 0;
+	for (let index = 0; index < body.length; index += 1) {
+		const ch = body[index] ?? "";
+		if (quote) {
+			if (ch === quote && body[index - 1] !== "\\") quote = null;
+			continue;
+		}
+		if (ch === "\"" || ch === "'") {
+			quote = ch;
+			continue;
+		}
+		if (ch === "{") depthBrace += 1;
+		else if (ch === "}") depthBrace = Math.max(0, depthBrace - 1);
+		else if (ch === "[") depthBracket += 1;
+		else if (ch === "]") depthBracket = Math.max(0, depthBracket - 1);
+		else if (ch === "(") depthParen += 1;
+		else if (ch === ")") depthParen = Math.max(0, depthParen - 1);
+		else if (ch === "," && depthBrace === 0 && depthBracket === 0 && depthParen === 0) {
+			const segment = body.slice(start, index).trim();
+			if (segment.length > 0) parts.push(segment);
+			start = index + 1;
+		}
+	}
+	const tail = body.slice(start).trim();
+	if (tail.length > 0) parts.push(tail);
+	return parts;
+}
+function findTopLevelColon(entry) {
+	let quote = null;
+	for (let index = 0; index < entry.length; index += 1) {
+		const ch = entry[index] ?? "";
+		if (quote) {
+			if (ch === quote && entry[index - 1] !== "\\") quote = null;
+			continue;
+		}
+		if (ch === "\"" || ch === "'") {
+			quote = ch;
+			continue;
+		}
+		if (ch === ":") return index;
+	}
+	return -1;
+}
 function pushInvalidAttributeArgument(input) {
 	input.diagnostics.push({
 		code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
@@ -2072,10 +2175,52 @@ function buildModelNodeFromPsl(input) {
 				columns: columnNames,
 				...ifDefined("name", constraintName)
 			});
-			else indexNodes.push({
-				columns: columnNames,
-				...ifDefined("name", constraintName)
-			});
+			else {
+				const indexEntityLabel = `Model "${model.name}" @@index`;
+				const rawTypeArg = getNamedArgument(modelAttribute, "type");
+				let indexType;
+				if (rawTypeArg !== void 0) {
+					const parsed = parseQuotedStringLiteral(rawTypeArg);
+					if (parsed === void 0) {
+						diagnostics.push({
+							code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+							message: `${indexEntityLabel} type argument must be a quoted string literal`,
+							sourceId,
+							span: modelAttribute.span
+						});
+						continue;
+					}
+					indexType = parsed;
+				}
+				const rawOptionsArg = getNamedArgument(modelAttribute, "options");
+				let indexOptions;
+				if (rawOptionsArg !== void 0) {
+					if (indexType === void 0) {
+						diagnostics.push({
+							code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+							message: `${indexEntityLabel} options argument requires a type argument`,
+							sourceId,
+							span: modelAttribute.span
+						});
+						continue;
+					}
+					const parsed = parseObjectLiteralStringMap({
+						raw: rawOptionsArg,
+						diagnostics,
+						sourceId,
+						span: modelAttribute.span,
+						entityLabel: indexEntityLabel
+					});
+					if (parsed === void 0) continue;
+					indexOptions = parsed;
+				}
+				indexNodes.push({
+					columns: columnNames,
+					...ifDefined("name", constraintName),
+					...ifDefined("type", indexType),
+					...ifDefined("options", indexOptions)
+				});
+			}
 			continue;
 		}
 		const uncomposedNamespace = checkUncomposedNamespace(modelAttribute.name, input.composedExtensions, {
@@ -2622,4 +2767,4 @@ function interpretPslDocumentToSqlContract(input) {
 //#endregion
 export { interpretPslDocumentToSqlContract as t };
 
-//# sourceMappingURL=interpreter-C9MPo8FK.mjs.map
+//# sourceMappingURL=interpreter-ijCjxhaU.mjs.map