@prisma/orm-toolchain 8.0.0-rc.11-dev.26 → 8.0.0-rc.11-dev.27

package/dist/cli.mjs

@@ -5144,7 +5144,7 @@ const lspCommand = defineServerCommand({
 	} },
 	handler: async (args, io) => {
 		const exitCode = await withoutClientProcessIdInArgv(async () => {
-			const { startServer } = await import("./exports-Bg8ce6Ih.mjs");
+			const { startServer } = await import("./exports-DMDyYe3P.mjs");
 			return startServer({
 				stdin: io.stdin,
 				stdout: io.stdout,

package/dist/{exports-Bg8ce6Ih.mjs → exports-DMDyYe3P.mjs}

@@ -10,7 +10,7 @@ import { format } from "@prisma/orm-framework/psl-parser/format";
 import { CompletionItemKind, ConnectionError, ConnectionErrors, DiagnosticSeverity, DidChangeWatchedFilesNotification, DocumentDiagnosticReportKind, FoldingRangeKind, InsertTextFormat, LSPErrorCodes, MarkupKind, ProposedFeatures, RegistrationRequest, ResponseError, SemanticTokenModifiers, SemanticTokenTypes, TextDocumentSyncKind, TextDocuments, createConnection } from "vscode-languageserver";
 import { TextDocument } from "vscode-languageserver-textdocument";
 import { ArrayLiteralAst, AttributeArgAst, AttributeArgListAst, BooleanLiteralExprAst, CompositeTypeDeclarationAst, FieldAttributeAst, FieldDeclarationAst, FunctionCallAst, GenericBlockDeclarationAst, IdentifierAst, KeyValuePairAst, ModelAttributeAst, ModelDeclarationAst, NamespaceDeclarationAst, NumberLiteralExprAst, ObjectLiteralExprAst, StringLiteralExprAst, SyntaxNode, TypesBlockAst, any, filterChildren, findChildToken, isTrivia, nonTriviaSibling, parse, skipTriviaToken } from "@prisma/orm-framework/psl-parser/syntax";
-import { isAuthoringPslBlockDescriptor } from "@prisma/orm-framework/components/authoring";
+import { isAuthoringPslBlockDescriptor, isAuthoringTypeConstructorDescriptor } from "@prisma/orm-framework/components/authoring";
 import { assembleAttributeSpecs, buildSymbolTable, findBlockDescriptor } from "@prisma/orm-framework/psl-parser";
 import { hasPslInterpreter } from "@prisma/orm-framework/psl-parser/interpret";
 import { ProposedFeatures as ProposedFeatures$1, StreamMessageReader, StreamMessageWriter, createConnection as createConnection$1, createProtocolConnection } from "vscode-languageserver/node";
@@ -543,6 +543,16 @@ function cursorIdentifier(at, offset) {
 	const left = at.leftBiased();
 	if (left?.kind === "Ident" && left.endOffset === offset) return left;
 }
+/**
+* Presentation-level classification of a `types {}` binding: a
+* non-constructor binding whose base is a configured scalar type refines that
+* scalar (rendered as a default-library type); everything else reads as a
+* plain alias. The authoritative scalar-or-not pronouncement lives in the
+* interpreter's named-type resolution — this mirrors it for display only.
+*/
+function refinesScalarType(symbol, scalarTypes) {
+	return !symbol.isConstructor && symbol.baseType !== void 0 && scalarTypes.includes(symbol.baseType);
+}
 function modelSymbolForNode(symbolTable, node) {
 	const topLevelMatch = Object.values(symbolTable.topLevel.models).find((model) => sameSyntax(model.node.syntax, node.syntax));
 	if (topLevelMatch !== void 0) return topLevelMatch;
@@ -554,7 +564,7 @@ function modelSymbolForNode(symbolTable, node) {
 function fieldSymbolForNode(model, node) {
 	return Object.values(model.fields).find((field) => sameSyntax(field.node.syntax, node.syntax));
 }
-function localFieldNames(context, symbols) {
+function localFieldNames(context, symbols, scalarTypes, typeConstructors = {}) {
 	switch (context.kind) {
 		case "blockAttributeNamedKey":
 		case "blockAttributeArgumentSlot":
@@ -564,10 +574,10 @@ function localFieldNames(context, symbols) {
 		case "fieldAttributeValue":
 		case "modelAttributeNamedKey":
 		case "modelAttributeArgumentSlot":
-		case "modelAttributeValue": return Object.keys(modelSymbolForNode(symbols, context.model)?.fields ?? {});
+		case "modelAttributeValue": return scalarFieldNames(symbols, modelSymbolForNode(symbols, context.model), scalarTypes, typeConstructors);
 	}
 }
-function referencedFieldNames(context, symbols) {
+function referencedFieldNames(context, symbols, scalarTypes, typeConstructors = {}) {
 	switch (context.kind) {
 		case "blockAttributeNamedKey":
 		case "blockAttributeArgumentSlot":
@@ -582,10 +592,35 @@ function referencedFieldNames(context, symbols) {
 			if (model === void 0) return [];
 			const field = fieldSymbolForNode(model, context.field);
 			if (field === void 0) return [];
-			return Object.keys(referencedModel(symbols, model, field)?.fields ?? {});
+			return scalarFieldNames(symbols, referencedModel(symbols, model, field), scalarTypes, typeConstructors);
 		}
 	}
 }
+function scalarFieldNames(symbols, model, scalarTypes, typeConstructors) {
+	if (model === void 0) return [];
+	const namespaceName = model.node.syntax.findAncestor(NamespaceDeclarationAst.cast)?.name()?.name();
+	const namespace = namespaceName === void 0 ? void 0 : symbols.topLevel.namespaces[namespaceName];
+	return Object.values(model.fields).filter((field) => {
+		if (field.malformedType === true || field.typeContractSpaceId !== void 0) return false;
+		if (field.typeConstructor !== void 0) return isScalarConstructor(field.typeConstructor.path, typeConstructors);
+		if (field.typeNamespaceId !== void 0) return false;
+		const name = field.typeName;
+		if (namespace?.models[name] !== void 0 || namespace?.compositeTypes[name] !== void 0 || namespace?.blocks[name] !== void 0 || symbols.topLevel.models[name] !== void 0 || symbols.topLevel.compositeTypes[name] !== void 0 || symbols.topLevel.blocks[name] !== void 0) return false;
+		const namedType = symbols.topLevel.namedTypes[name];
+		if (namedType === void 0) return scalarTypes.includes(name);
+		return namedType.typeConstructor === void 0 ? refinesScalarType(namedType, scalarTypes) : isScalarConstructor(namedType.typeConstructor.path, typeConstructors);
+	}).map((field) => field.name);
+}
+function isScalarConstructor(path, typeConstructors) {
+	let current = typeConstructors;
+	for (const [index, segment] of path.entries()) {
+		const value = Object.hasOwn(current, segment) ? current[segment] : void 0;
+		if (value === void 0) return false;
+		if (isAuthoringTypeConstructorDescriptor(value)) return index === path.length - 1;
+		current = value;
+	}
+	return false;
+}
 function referencedModel(symbols, model, field) {
 	if (field.malformedType === true || field.typeContractSpaceId !== void 0) return void 0;
 	if (field.typeNamespaceId !== void 0) return symbols.topLevel.namespaces[field.typeNamespaceId]?.models[field.typeName];
@@ -652,11 +687,11 @@ function requiredArguments(signature) {
 	}])];
 }
 function requiredArgumentSnippet(argument, tabStop) {
-	if (argument.kind === "positional") return argSnippetPlaceholder(argument.argument.type, tabStop);
-	return `${argument.key}: ${argSnippetPlaceholder(argument.type, tabStop)}`;
+	if (argument.kind === "positional") return argSnippetPlaceholder(argument.argument.type, tabStop, argument.argument.key);
+	return `${argument.key}: ${argSnippetPlaceholder(argument.type, tabStop, argument.key)}`;
 }
-function argSnippetPlaceholder(param, tabStop) {
-	const placeholder = `\${${tabStop.toString()}:}`;
+function argSnippetPlaceholder(param, tabStop, key) {
+	const placeholder = `\${${tabStop.toString()}:${key}}`;
 	if (param.kind === "str") return `"${placeholder}"`;
 	if (param.kind === "list") return `[${placeholder}]`;
 	if (param.kind === "record") return `{ ${placeholder} }`;
@@ -706,11 +741,11 @@ function provideAttributeValueCompletionItems(input, spec) {
 	return orderedItems(resolveGrammar(spec, input.context.path).flatMap((grammar) => "kind" in grammar ? valueItems(input, grammar, input.context.syntax) : []));
 }
 function namedKeyItems(input, signature) {
-	return Object.keys(signature.named ?? {}).filter((name) => !input.context.existingNamedKeys.includes(name)).map((name) => {
+	return Object.entries(signature.named ?? {}).filter(([name]) => !input.context.existingNamedKeys.includes(name)).map(([name, param]) => {
 		const snippet = input.clientSupportsSnippets && !input.context.hasColon;
-		const value = snippet ? "${1:}" : "";
+		const value = snippet ? `\${1:${name}}` : "";
 		return {
-			...completionItem(input, name, input.context.hasColon ? name : `${name}: ${value}`, CompletionItemKind.Property, snippet),
+			...completionItem(input, name, input.context.hasColon ? name : `${name}: ${value}`, CompletionItemKind.Property, snippet, param.documentation),
 			...!input.context.hasColon && input.clientSupportsTriggerSuggestCommand === true ? { command: {
 				title: "Suggest argument values",
 				command: "editor.action.triggerSuggest"
@@ -728,7 +763,7 @@ function valueItems(input, param, syntax) {
 		const args = requiredArgumentsSnippet(type.signature) || (hasParameters ? "${1:}" : "");
 		const text = snippet ? `${type.name}(${args})` : type.name;
 		return [{
-			...completionItem(input, type.name, text, CompletionItemKind.Function, snippet),
+			...completionItem(input, type.name, text, CompletionItemKind.Function, snippet, type.signature.documentation),
 			...snippet && input.clientSupportsTriggerParameterHintsCommand === true && hasParameters ? { command: {
 				title: "Show argument hints",
 				command: "editor.action.triggerParameterHints"
@@ -737,7 +772,7 @@ function valueItems(input, param, syntax) {
 	}
 	if (syntax === "functionName") return [];
 	switch (type.kind) {
-		case "identifier": return scalarItems(input, [type.name]);
+		case "identifier": return scalarItems(input, [type.name], type.documentation);
 		case "str": return scalarItems(input, type.value === void 0 ? [] : [JSON.stringify(type.value)]);
 		case "num": return scalarItems(input, type.value === void 0 ? [] : [String(type.value)]);
 		case "bool": return scalarItems(input, ["true", "false"]);
@@ -751,14 +786,14 @@ function valueItems(input, param, syntax) {
 		case "rejecting": return [];
 	}
 }
-function scalarItems(input, labels) {
-	return labels.map((label) => completionItem(input, label, label, CompletionItemKind.Value));
+function scalarItems(input, labels, documentation) {
+	return labels.map((label) => completionItem(input, label, label, CompletionItemKind.Value, false, documentation));
 }
-function completionItem(input, label, newText, kind, snippet = false) {
+function completionItem(input, label, newText, kind, snippet = false, documentation) {
 	return {
 		label,
 		kind,
-		detail: kind === CompletionItemKind.Property ? "Attribute argument" : "PSL argument value",
+		detail: documentation ?? (kind === CompletionItemKind.Property ? "Attribute argument" : "PSL argument value"),
 		filterText: label,
 		textEdit: {
 			range: {
@@ -786,16 +821,6 @@ function orderedItems(items) {
 		sortText: index.toString().padStart(4, "0")
 	}));
 }
-/**
-* Presentation-level classification of a `types {}` binding: a
-* non-constructor binding whose base is a configured scalar type refines that
-* scalar (rendered as a default-library type); everything else reads as a
-* plain alias. The authoritative scalar-or-not pronouncement lives in the
-* interpreter's named-type resolution — this mirrors it for display only.
-*/
-function refinesScalarType(symbol, scalarTypes) {
-	return !symbol.isConstructor && symbol.baseType !== void 0 && scalarTypes.includes(symbol.baseType);
-}
 const categoryOrder = {
 	configuredScalar: 0,
 	topLevelModel: 1,
@@ -811,13 +836,13 @@ const declarationKeywordCategoryOrder = {
 	genericBlock: 1
 };
 const nameSnippetPlaceholder = "${1:Name}";
+const namespaceSnippetPlaceholder = "${1:name}";
+const namespaceNativeDeclarationKeywords = [nativeDeclarationKeyword("model", "model ", `model ${nameSnippetPlaceholder} {\n  \${0:// Fields}\n}`, "Defines a data model."), nativeDeclarationKeyword("type", "type ", `type ${nameSnippetPlaceholder} {\n  \${0:// Fields}\n}`, "Defines a reusable composite type.")];
 const documentNativeDeclarationKeywords = [
-	nativeDeclarationKeyword("model", "model ", `model ${nameSnippetPlaceholder} {\n  $0\n}`),
-	nativeDeclarationKeyword("type", "type ", `type ${nameSnippetPlaceholder} {\n  $0\n}`),
-	nativeDeclarationKeyword("types", "types ", "types {\n  $0\n}"),
-	nativeDeclarationKeyword("namespace", "namespace ", `namespace \${1:name} {\n  $0\n}`)
+	...namespaceNativeDeclarationKeywords,
+	nativeDeclarationKeyword("types", "types ", "types {\n  ${0:// Type aliases}\n}", "Defines reusable named types."),
+	nativeDeclarationKeyword("namespace", "namespace ", `namespace ${namespaceSnippetPlaceholder} {\n  \${0:// Models and types}\n}`, "Groups declarations belonging to the same database schema or database.")
 ];
-const namespaceNativeDeclarationKeywords = [nativeDeclarationKeyword("model", "model ", `model ${nameSnippetPlaceholder} {\n  $0\n}`), nativeDeclarationKeyword("type", "type ", `type ${nameSnippetPlaceholder} {\n  $0\n}`)];
 function providePslCompletionItems(input) {
 	const { context } = input;
 	switch (context.kind) {
@@ -848,7 +873,7 @@ function providePslCompletionItems(input) {
 				clientSupportsSnippets: input.clientSupportsSnippets,
 				clientSupportsTriggerSuggestCommand: input.clientSupportsTriggerSuggestCommand === true,
 				clientSupportsTriggerParameterHintsCommand: input.clientSupportsTriggerParameterHintsCommand === true,
-				fieldNames: (kind) => kind === "fieldRef" ? localFieldNames(context, input.candidates.symbolTable) : referencedFieldNames(context, input.candidates.symbolTable)
+				fieldNames: (kind) => kind === "fieldRef" ? localFieldNames(context, input.candidates.symbolTable, input.candidates.scalarTypes, input.candidates.authoringContributions?.type) : referencedFieldNames(context, input.candidates.symbolTable, input.candidates.scalarTypes, input.candidates.authoringContributions?.type)
 			}, spec);
 		}
 		case "fieldAttributeValue":
@@ -860,7 +885,7 @@ function providePslCompletionItems(input) {
 				sourceFile: input.sourceFile,
 				clientSupportsSnippets: input.clientSupportsSnippets,
 				clientSupportsTriggerParameterHintsCommand: input.clientSupportsTriggerParameterHintsCommand === true,
-				fieldNames: (kind) => kind === "fieldRef" ? localFieldNames(context, input.candidates.symbolTable) : referencedFieldNames(context, input.candidates.symbolTable)
+				fieldNames: (kind) => kind === "fieldRef" ? localFieldNames(context, input.candidates.symbolTable, input.candidates.scalarTypes, input.candidates.authoringContributions?.type) : referencedFieldNames(context, input.candidates.symbolTable, input.candidates.scalarTypes, input.candidates.authoringContributions?.type)
 			}, spec);
 		}
 		case "declarationKeyword": return provideDeclarationKeywordCompletionItems(context, input.sourceFile, input.candidates, input.clientSupportsSnippets);
@@ -877,16 +902,17 @@ function provideAttributeNameCompletionItems(context, sourceFile, source, client
 	};
 	const resolveSpec = attributeSpecResolver(context, source);
 	return names.map((name) => {
+		const spec = resolveSpec(name);
 		const newText = attributeNameEditText({
 			name,
-			spec: resolveSpec(name),
+			spec,
 			hasArgumentList: context.hasArgumentList,
 			clientSupportsSnippets
 		});
 		return {
 			label: name,
 			kind: CompletionItemKind.Function,
-			detail: "PSL attribute",
+			detail: spec?.documentation || "PSL attribute",
 			sortText: name,
 			filterText: name,
 			textEdit: {
@@ -941,25 +967,41 @@ function provideDeclarationKeywordCompletionItems(context, sourceFile, source, c
 function declarationKeywordCandidates(scope, source) {
 	return [...scope === "namespace" ? namespaceNativeDeclarationKeywords : documentNativeDeclarationKeywords, ...genericBlockDeclarationKeywordCandidates(source.pslBlockDescriptors)];
 }
-function nativeDeclarationKeyword(label, insertText, snippetText) {
+function nativeDeclarationKeyword(label, insertText, snippetText, documentation) {
 	return {
 		category: "native",
 		label,
 		insertText,
 		snippetText,
-		detail: "PSL declaration keyword",
+		detail: documentation,
 		kind: CompletionItemKind.Keyword
 	};
 }
 function genericBlockDeclarationKeywordCandidates(descriptors) {
-	return descriptorBlockKeywords(descriptors).map((keyword) => ({
-		category: "genericBlock",
-		label: keyword,
-		insertText: `${keyword} `,
-		snippetText: `${keyword} ${nameSnippetPlaceholder} {\n  $0\n}`,
-		detail: "Generic block keyword",
-		kind: CompletionItemKind.Keyword
-	}));
+	return descriptorBlockKeywords(descriptors).map((keyword) => {
+		const descriptor = findBlockDescriptor(descriptors, keyword);
+		return {
+			category: "genericBlock",
+			label: keyword,
+			insertText: `${keyword} `,
+			snippetText: genericBlockSnippet(keyword, descriptor),
+			detail: descriptor?.documentation || "Generic block keyword",
+			kind: CompletionItemKind.Keyword
+		};
+	});
+}
+function genericBlockSnippet(keyword, descriptor) {
+	const parameters = Object.entries(descriptor?.parameters ?? {}).filter(([, parameter]) => parameter.required === true).map(([name, parameter], index) => {
+		const placeholder = `\${${index + 2}:${name}}`;
+		return `  ${name} = ${parameter.kind === "list" ? `[${placeholder}]` : placeholder}`;
+	});
+	const cursor = parameters.length === 0 ? "${0:// Block parameters and attributes}" : "$0";
+	return [
+		`${keyword} ${nameSnippetPlaceholder} {`,
+		...parameters,
+		`  ${cursor}`,
+		"}"
+	].join("\n");
 }
 function descriptorBlockKeywords(descriptors) {
 	const keywords = [];
@@ -989,7 +1031,7 @@ function provideGenericBlockKeyCompletionItems(context, sourceFile, source) {
 	return Object.keys(descriptor.parameters).filter((parameterName) => !existing.has(parameterName)).map((parameterName, index) => ({
 		label: parameterName,
 		kind: CompletionItemKind.Property,
-		detail: "Generic block parameter",
+		detail: descriptor.parameters[parameterName]?.documentation || "Generic block parameter",
 		sortText: genericBlockParameterSortText(index, parameterName),
 		filterText: parameterName,
 		textEdit: {
@@ -1009,7 +1051,7 @@ function existingGenericBlockParameterNames(block, cursorOffset) {
 }
 function provideModelTypeCompletionItems(context, sourceFile, source) {
 	return modelTypeCompletionItems(context, sourceFile, [
-		...configuredScalarCandidates(source.scalarTypes),
+		...configuredScalarCandidates(source),
 		...topLevelSymbolCandidates(source.symbolTable, source.scalarTypes),
 		...allNamespaceCandidates(source.symbolTable)
 	]);
@@ -1035,13 +1077,14 @@ function modelTypeCompletionItems(context, sourceFile, candidates) {
 		}
 	}));
 }
-function configuredScalarCandidates(scalarTypes) {
-	return sortedUnique(scalarTypes).map((name) => ({
+function configuredScalarCandidates(source) {
+	const constructors = source.authoringContributions?.type ?? {};
+	return sortedUnique(source.scalarTypes).map((name) => ({
 		category: "configuredScalar",
 		label: name,
 		insertText: name,
 		filterText: name,
-		detail: "Configured scalar type",
+		detail: constructors[name] !== void 0 && isAuthoringTypeConstructorDescriptor(constructors[name]) ? constructors[name].documentation || "Configured scalar type" : "Configured scalar type",
 		kind: CompletionItemKind.Keyword
 	}));
 }
@@ -2686,4 +2729,4 @@ function startServer(streams) {
 //#endregion
 export { startServer };
 
-//# sourceMappingURL=exports-Bg8ce6Ih.mjs.map
+//# sourceMappingURL=exports-DMDyYe3P.mjs.map