@prisma-next/language-server 0.14.0-dev.36 → 0.14.0-dev.38

package/dist/exports/index.mjs

@@ -2,11 +2,12 @@ import { join } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { findNearestConfigPathForFile, loadConfig } from "@prisma-next/config-loader";
 import { format } from "@prisma-next/psl-parser/format";
-import { DiagnosticSeverity, DidChangeWatchedFilesNotification, FoldingRangeKind, RegistrationRequest, SemanticTokenModifiers, SemanticTokenTypes, TextDocumentSyncKind, TextDocuments } from "vscode-languageserver";
+import { CompletionItemKind, DiagnosticSeverity, DidChangeWatchedFilesNotification, FoldingRangeKind, InsertTextFormat, RegistrationRequest, SemanticTokenModifiers, SemanticTokenTypes, TextDocumentSyncKind, TextDocuments } from "vscode-languageserver";
 import { TextDocument } from "vscode-languageserver-textdocument";
+import { ArrayLiteralAst, AttributeArgListAst, BooleanLiteralExprAst, CompositeTypeDeclarationAst, FieldAttributeAst, FieldDeclarationAst, FunctionCallAst, GenericBlockDeclarationAst, IdentifierAst, KeyValuePairAst, ModelAttributeAst, ModelDeclarationAst, NamespaceDeclarationAst, NumberLiteralExprAst, ObjectLiteralExprAst, StringLiteralExprAst, TypesBlockAst, any, filterChildren, findChildToken, parse, skipTriviaToken } from "@prisma-next/psl-parser/syntax";
+import { isAuthoringPslBlockDescriptor } from "@prisma-next/framework-components/authoring";
+import { buildSymbolTable, findBlockDescriptor } from "@prisma-next/psl-parser";
 import { createControlStack } from "@prisma-next/framework-components/control";
-import { ArrayLiteralAst, BooleanLiteralExprAst, CompositeTypeDeclarationAst, FieldDeclarationAst, FunctionCallAst, IdentifierAst, ModelDeclarationAst, NamespaceDeclarationAst, NumberLiteralExprAst, ObjectLiteralExprAst, StringLiteralExprAst, TypesBlockAst, filterChildren, parse } from "@prisma-next/psl-parser/syntax";
-import { buildSymbolTable } from "@prisma-next/psl-parser";
 import { ProposedFeatures, createConnection } from "vscode-languageserver/node";
 //#region src/diagnostic-mapping.ts
 const ParseDiagnosticSeverity = {
@@ -24,6 +25,414 @@ function mapParseDiagnostics(diagnostics) {
 	}));
 }
 //#endregion
+//#region src/completion-context.ts
+const UNSUPPORTED = { kind: "unsupported" };
+function classifyPslCompletionContext(input) {
+	const root = input.document.syntax;
+	const offset = input.sourceFile.offsetAt(input.position);
+	const at = root.tokenAtOffset(offset);
+	if (at.leftBiased()?.kind === "Comment") return UNSUPPORTED;
+	const edit = cursorIdentifier(at, offset);
+	const preceding = precedingToken(at, edit);
+	const precedingNode = preceding?.parent;
+	const replacementStartOffset = edit?.offset ?? offset;
+	const declarationKeywordContext = classifyDeclarationKeyword({
+		node: precedingNode,
+		offset,
+		replacementStartOffset
+	});
+	if (declarationKeywordContext !== void 0) return declarationKeywordContext;
+	const genericBlockContext = classifyGenericBlockParameter({
+		offset,
+		at,
+		precedingToken: preceding,
+		replacementStartOffset
+	});
+	if (genericBlockContext !== void 0) return genericBlockContext;
+	const field = fieldForTypeSlot(precedingNode);
+	if (field === void 0) return UNSUPPORTED;
+	if (field.syntax.findAncestor(any(ModelDeclarationAst.cast, CompositeTypeDeclarationAst.cast)) === void 0) return UNSUPPORTED;
+	return classifyModelFieldType({
+		field,
+		offset,
+		replacementStartOffset,
+		precedingToken: preceding
+	});
+}
+/**
+* Locates the field whose type position the cursor occupies. The preceding token
+* climbs to the field whether the cursor sits inside a present type (the type
+* identifier's predecessor still belongs to the field) or in the empty type slot
+* of a typeless field (whose trailing trivia lives in the enclosing block, so
+* the nearest significant token to the left is the field's own name).
+*/
+function fieldForTypeSlot(precedingNode) {
+	return precedingNode?.findAncestor(FieldDeclarationAst.cast);
+}
+function classifyModelFieldType(input) {
+	const fieldName = input.field.name();
+	if (fieldName === void 0) return UNSUPPORTED;
+	const fieldNameText = fieldName.name();
+	if (fieldNameText === void 0) return UNSUPPORTED;
+	if (fieldName.syntax.isInside(input.offset)) return UNSUPPORTED;
+	const typeAnnotation = input.field.typeAnnotation();
+	if (typeAnnotation === void 0) {
+		if (input.precedingToken !== void 0 && fieldName.syntax.isInside(input.precedingToken.offset)) return {
+			kind: "modelType",
+			offset: input.offset,
+			fieldName: fieldNameText,
+			replacementStartOffset: input.offset
+		};
+		return UNSUPPORTED;
+	}
+	if (typeAnnotation.syntax.isOutside(input.offset)) return UNSUPPORTED;
+	if (typeAnnotation.argList()?.syntax.isInside(input.offset)) return UNSUPPORTED;
+	const name = typeAnnotation.name();
+	if (name === void 0) return UNSUPPORTED;
+	if (name.syntax.isOutside(input.offset)) return UNSUPPORTED;
+	if (name.isOverQualified()) return UNSUPPORTED;
+	return classifyTypePosition(name, input.offset, fieldNameText, input.replacementStartOffset);
+}
+/**
+* Builds the type-completion context for a qualified name. Roles are read
+* straight off the separator-positional accessors: a populated namespace
+* segment is a `.`-qualified name, a populated space segment is a `:`-qualified
+* name, and the absence of both is a bare model type.
+*
+* Behaviour change: a `:`-qualified name with no `.` (e.g. `supabase:`,
+* `supabase:U`) is a `spaceMember` position rather than falling through to bare
+* model-type completions. A malformed leading-separator name (`:User`, `.User`)
+* carries no populated segment and resolves to `modelType` rather than
+* `unsupported`.
+*/
+function classifyTypePosition(name, offset, fieldName, replacementStartOffset) {
+	const namespace = name.namespace()?.name();
+	if (namespace !== void 0 && namespace.length > 0) {
+		const namespaceSpace = name.space()?.name();
+		return {
+			kind: "namespaceMember",
+			offset,
+			fieldName,
+			replacementStartOffset,
+			namespace,
+			...namespaceSpace !== void 0 && namespaceSpace.length > 0 ? { space: namespaceSpace } : {}
+		};
+	}
+	const space = name.space()?.name();
+	if (space !== void 0 && space.length > 0) return {
+		kind: "spaceMember",
+		offset,
+		fieldName,
+		replacementStartOffset,
+		space
+	};
+	return {
+		kind: "modelType",
+		offset,
+		fieldName,
+		replacementStartOffset
+	};
+}
+const declarationCast = any(ModelDeclarationAst.cast, CompositeTypeDeclarationAst.cast, TypesBlockAst.cast, GenericBlockDeclarationAst.cast, NamespaceDeclarationAst.cast);
+function classifyDeclarationKeyword(input) {
+	const precedingDeclaration = input.node?.findAncestor(declarationCast);
+	const namespace = input.node?.findAncestor(NamespaceDeclarationAst.cast);
+	const inNamespaceBody = blockBodyContainsOffset(namespace, input.offset);
+	if (precedingDeclaration !== void 0 && !canCompleteDeclaration(precedingDeclaration, input.offset, inNamespaceBody)) return;
+	return {
+		kind: "declarationKeyword",
+		offset: input.offset,
+		scope: inNamespaceBody ? "namespace" : "document",
+		replacementStartOffset: input.replacementStartOffset
+	};
+}
+/**
+* Whether a new declaration can begin at the cursor, given the nearest enclosing
+* declaration. Allowed when that declaration is still nascent (only its keyword
+* typed, no name or body yet), when it is a namespace whose body holds further
+* declarations, or when the cursor sits past its closing `}`.
+*/
+function canCompleteDeclaration(precedingDeclaration, offset, inNamespaceBody) {
+	if (precedingDeclaration.lbrace() === void 0 && (precedingDeclaration instanceof TypesBlockAst || precedingDeclaration.name() === void 0)) return true;
+	if (precedingDeclaration instanceof NamespaceDeclarationAst && inNamespaceBody) return true;
+	const rbrace = precedingDeclaration.rbrace();
+	return rbrace !== void 0 && offset >= rbrace.endOffset;
+}
+function blockBodyContainsOffset(block, offset) {
+	if (block === void 0) return false;
+	const lbrace = block.lbrace();
+	if (lbrace === void 0) return false;
+	const bodyStart = lbrace.endOffset;
+	const bodyEnd = block.rbrace()?.offset ?? block.syntax.endOffset;
+	return offset >= bodyStart && offset <= bodyEnd;
+}
+function classifyGenericBlockParameter(input) {
+	const node = input.at.leftBiased()?.parent;
+	const block = node?.findAncestor(GenericBlockDeclarationAst.cast);
+	if (block === void 0) return;
+	if (hasUnsupportedAncestor(node)) return UNSUPPORTED;
+	if (!blockBodyContainsOffset(block, input.offset)) return UNSUPPORTED;
+	if ((node?.findAncestor(FieldDeclarationAst.cast))?.syntax.isInside(input.offset)) return UNSUPPORTED;
+	const keyword = block.keyword()?.text;
+	if (keyword === void 0 || keyword.length === 0) return UNSUPPORTED;
+	if (input.precedingToken?.kind === "Equals") return {
+		kind: "genericBlockValue",
+		offset: input.offset,
+		blockKeyword: keyword,
+		replacementStartOffset: input.replacementStartOffset
+	};
+	const activePair = activeKeyValuePair(node, input.offset);
+	if (activePair !== void 0 && isAfterEquals(activePair, input.offset)) return UNSUPPORTED;
+	return {
+		kind: "genericBlockKey",
+		offset: input.offset,
+		blockKeyword: keyword,
+		replacementStartOffset: input.replacementStartOffset,
+		block
+	};
+}
+function activeKeyValuePair(node, offset) {
+	const pair = node?.findAncestor(KeyValuePairAst.cast);
+	if (pair === void 0 || pair.syntax.isOutside(offset)) return;
+	return pair;
+}
+function isAfterEquals(pair, offset) {
+	const equals = pair.equals();
+	return equals !== void 0 && offset > equals.offset;
+}
+function hasUnsupportedAncestor(node) {
+	return node?.findAncestor(any(AttributeArgListAst.cast, FieldAttributeAst.cast, ModelAttributeAst.cast)) !== void 0;
+}
+/** The significant token preceding the cursor — the in-progress edit identifier
+*  is skipped, so the result is the token the classifier anchors on. */
+function precedingToken(at, edit) {
+	const start = edit !== void 0 ? edit.prevToken : at.leftBiased();
+	return start === void 0 ? void 0 : skipTriviaToken(start, "prev");
+}
+/** The identifier token the cursor is editing, if any. */
+function cursorIdentifier(at, offset) {
+	const right = at.rightBiased();
+	if (right?.kind === "Ident" && offset < right.endOffset) return right;
+	const left = at.leftBiased();
+	if (left?.kind === "Ident" && left.endOffset === offset) return left;
+}
+//#endregion
+//#region src/completion-provider.ts
+const categoryOrder = {
+	configuredScalar: 0,
+	topLevelModel: 1,
+	topLevelCompositeType: 2,
+	scalar: 3,
+	typeAlias: 4,
+	namespace: 5,
+	namespaceModel: 6,
+	namespaceCompositeType: 7
+};
+const declarationKeywordCategoryOrder = {
+	native: 0,
+	genericBlock: 1
+};
+const nameSnippetPlaceholder = "${1:Name}";
+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}`)
+];
+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) {
+		case "unsupported": return [];
+		case "spaceMember": return [];
+		case "genericBlockValue": return [];
+		case "declarationKeyword": return provideDeclarationKeywordCompletionItems(context, input.sourceFile, input.candidates, input.clientSupportsSnippets);
+		case "genericBlockKey": return provideGenericBlockKeyCompletionItems(context, input.sourceFile, input.candidates);
+		case "modelType": return provideModelTypeCompletionItems(context, input.sourceFile, input.candidates);
+		case "namespaceMember": return provideNamespaceMemberCompletionItems(context, input.sourceFile, input.candidates);
+	}
+}
+function provideDeclarationKeywordCompletionItems(context, sourceFile, source, clientSupportsSnippets) {
+	const replacementRange = {
+		start: sourceFile.positionAt(context.replacementStartOffset),
+		end: sourceFile.positionAt(context.offset)
+	};
+	return declarationKeywordCandidates(context.scope, source).map((candidate) => ({
+		label: candidate.label,
+		kind: candidate.kind,
+		detail: candidate.detail,
+		sortText: declarationKeywordSortText(candidate),
+		filterText: candidate.label,
+		...clientSupportsSnippets ? { insertTextFormat: InsertTextFormat.Snippet } : {},
+		textEdit: {
+			range: replacementRange,
+			newText: clientSupportsSnippets ? candidate.snippetText : candidate.insertText
+		}
+	}));
+}
+function declarationKeywordCandidates(scope, source) {
+	return [...scope === "namespace" ? namespaceNativeDeclarationKeywords : documentNativeDeclarationKeywords, ...genericBlockDeclarationKeywordCandidates(source.pslBlockDescriptors)];
+}
+function nativeDeclarationKeyword(label, insertText, snippetText) {
+	return {
+		category: "native",
+		label,
+		insertText,
+		snippetText,
+		detail: "PSL declaration keyword",
+		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
+	}));
+}
+function descriptorBlockKeywords(descriptors) {
+	const keywords = [];
+	collectDescriptorBlockKeywords(descriptors, keywords);
+	return sortedUnique(keywords);
+}
+function collectDescriptorBlockKeywords(descriptors, keywords) {
+	for (const value of Object.values(descriptors)) {
+		if (isAuthoringPslBlockDescriptor(value)) {
+			keywords.push(value.keyword);
+			continue;
+		}
+		collectDescriptorBlockKeywords(value, keywords);
+	}
+}
+function declarationKeywordSortText(candidate) {
+	return `${declarationKeywordCategoryOrder[candidate.category]}:${candidate.label}`;
+}
+function provideGenericBlockKeyCompletionItems(context, sourceFile, source) {
+	const descriptor = findBlockDescriptor(source.pslBlockDescriptors, context.blockKeyword);
+	if (descriptor === void 0) return [];
+	const existing = existingGenericBlockParameterNames(context.block, context.offset);
+	const replacementRange = {
+		start: sourceFile.positionAt(context.replacementStartOffset),
+		end: sourceFile.positionAt(context.offset)
+	};
+	return Object.keys(descriptor.parameters).filter((parameterName) => !existing.has(parameterName)).map((parameterName, index) => ({
+		label: parameterName,
+		kind: CompletionItemKind.Property,
+		detail: "Generic block parameter",
+		sortText: genericBlockParameterSortText(index, parameterName),
+		filterText: parameterName,
+		textEdit: {
+			range: replacementRange,
+			newText: parameterName
+		}
+	}));
+}
+function existingGenericBlockParameterNames(block, cursorOffset) {
+	const names = /* @__PURE__ */ new Set();
+	for (const entry of block.entries()) {
+		if (!entry.syntax.isOutside(cursorOffset)) continue;
+		const name = entry.key()?.name();
+		if (name !== void 0) names.add(name);
+	}
+	return names;
+}
+function provideModelTypeCompletionItems(context, sourceFile, source) {
+	return modelTypeCompletionItems(context, sourceFile, [
+		...configuredScalarCandidates(source.scalarTypes),
+		...topLevelSymbolCandidates(source.symbolTable),
+		...allNamespaceCandidates(source.symbolTable)
+	]);
+}
+function provideNamespaceMemberCompletionItems(context, sourceFile, source) {
+	if (context.space !== void 0) return [];
+	return modelTypeCompletionItems(context, sourceFile, namespaceCandidates(source.symbolTable?.topLevel.namespaces[context.namespace]));
+}
+function modelTypeCompletionItems(context, sourceFile, candidates) {
+	const replacementRange = {
+		start: sourceFile.positionAt(context.replacementStartOffset),
+		end: sourceFile.positionAt(context.offset)
+	};
+	return candidates.map((candidate) => ({
+		label: candidate.label,
+		kind: candidate.kind,
+		detail: candidate.detail,
+		sortText: sortText(candidate),
+		filterText: candidate.filterText,
+		textEdit: {
+			range: replacementRange,
+			newText: candidate.insertText
+		}
+	}));
+}
+function configuredScalarCandidates(scalarTypes) {
+	return sortedUnique(scalarTypes).map((name) => ({
+		category: "configuredScalar",
+		label: name,
+		insertText: name,
+		filterText: name,
+		detail: "Configured scalar type",
+		kind: CompletionItemKind.Keyword
+	}));
+}
+function topLevelSymbolCandidates(symbolTable) {
+	if (symbolTable === void 0) return [];
+	const { topLevel } = symbolTable;
+	return [
+		...symbolCandidates(recordNames(topLevel.models), "topLevelModel", "Model", CompletionItemKind.Class),
+		...symbolCandidates(recordNames(topLevel.compositeTypes), "topLevelCompositeType", "Composite type", CompletionItemKind.Struct),
+		...symbolCandidates(recordNames(topLevel.scalars), "scalar", "Scalar type", CompletionItemKind.Unit),
+		...symbolCandidates(recordNames(topLevel.typeAliases), "typeAlias", "Type alias", CompletionItemKind.Reference)
+	];
+}
+function allNamespaceCandidates(symbolTable) {
+	if (symbolTable === void 0) return [];
+	return Object.values(symbolTable.topLevel.namespaces).sort((left, right) => compareNames(left.name, right.name)).map(namespaceQualifierCandidate);
+}
+function namespaceCandidates(namespace) {
+	if (namespace === void 0) return [];
+	return [...symbolCandidates(recordNames(namespace.models), "namespaceModel", `Model in namespace ${namespace.name}`, CompletionItemKind.Class), ...symbolCandidates(recordNames(namespace.compositeTypes), "namespaceCompositeType", `Composite type in namespace ${namespace.name}`, CompletionItemKind.Struct)];
+}
+function namespaceQualifierCandidate(namespace) {
+	return {
+		category: "namespace",
+		label: namespace.name,
+		insertText: namespace.name,
+		filterText: namespace.name,
+		detail: "Namespace",
+		kind: CompletionItemKind.Module
+	};
+}
+function symbolCandidates(names, category, detail, kind) {
+	return names.map((name) => ({
+		category,
+		label: name,
+		insertText: name,
+		filterText: name,
+		detail,
+		kind
+	}));
+}
+function recordNames(record) {
+	return Object.values(record).map((symbol) => symbol.name).sort(compareNames);
+}
+function sortedUnique(names) {
+	return [...new Set(names)].sort(compareNames);
+}
+function sortText(candidate) {
+	return `${categoryOrder[candidate.category]}:${candidate.label}`;
+}
+function genericBlockParameterSortText(index, label) {
+	return `${index.toString().padStart(4, "0")}:${label}`;
+}
+function compareNames(left, right) {
+	if (left < right) return -1;
+	if (left > right) return 1;
+	return 0;
+}
+//#endregion
 //#region src/schema-inputs.ts
 function hasPslInputs(config) {
 	const source = config.contract?.source;
@@ -337,13 +746,14 @@ function collectAttributes(attributes, source, tokens, namespace) {
 	for (const attribute of attributes) collectAttribute(attribute, source, tokens, namespace);
 }
 function collectAttribute(attribute, source, tokens, namespace) {
-	collectDecoratorName(attribute.name(), source.sourceFile.text, tokens);
+	const marker = findChildToken(attribute.syntax, "At") ?? findChildToken(attribute.syntax, "DoubleAt");
+	collectDecoratorName(attribute.name(), marker, tokens);
 	collectAttributeArgList(attribute.argList(), source, tokens, namespace);
 }
-function collectDecoratorName(name, sourceText, tokens) {
+function collectDecoratorName(name, marker, tokens) {
 	if (name === void 0) return;
 	const segments = identifierSegments(name);
-	for (const [index, segment] of segments.entries()) tokens.push(rangeForDecoratorIdentifier(segment.identifier, sourceText, index === 0));
+	for (const [index, segment] of segments.entries()) tokens.push(rangeForDecoratorIdentifier(segment.identifier, index === 0 ? marker : void 0));
 }
 function collectAttributeArgList(argList, source, tokens, namespace) {
 	if (argList === void 0) return;
@@ -465,12 +875,10 @@ function rangeForIdentifier(identifier, tokenType, modifierBitset = 0) {
 	if (token === void 0) return createPendingSemanticToken(identifier.syntax.offset, identifier.syntax.offset, tokenType, modifierBitset);
 	return pendingTokenForToken(token, tokenType, modifierBitset);
 }
-function rangeForDecoratorIdentifier(identifier, sourceText, includePrefix) {
+function rangeForDecoratorIdentifier(identifier, marker) {
 	const range = rangeForIdentifier(identifier, "decorator");
-	if (!includePrefix) return range;
-	let startOffset = range.startOffset;
-	while (startOffset > 0 && sourceText.charAt(startOffset - 1) === "@") startOffset--;
-	return createPendingSemanticToken(startOffset, range.endOffset, "decorator", range.modifierBitset);
+	if (marker === void 0 || marker.offset >= range.startOffset) return range;
+	return createPendingSemanticToken(marker.offset, range.endOffset, "decorator", range.modifierBitset);
 }
 function pendingTokenForToken(token, tokenType, modifierBitset = 0) {
 	return createPendingSemanticToken(token.offset, token.offset + token.text.length, tokenType, modifierBitset);
@@ -515,6 +923,16 @@ function createServer(connection) {
 	let rootPath = process.cwd();
 	let watchedConfigGlob = join(rootPath, "**", CONFIG_FILENAME);
 	let supportsWatchedFilesRegistration = false;
+	let clientSupportsSnippets = false;
+	let disposed = false;
+	function sendDiagnostics(params) {
+		if (disposed) return;
+		connection.sendDiagnostics(params);
+	}
+	function logWarn(message) {
+		if (disposed) return;
+		connection.console.warn(message);
+	}
 	async function publish(uri) {
 		const project = await resolveProjectForDocument(uri);
 		if (project === void 0) return;
@@ -525,22 +943,21 @@ function createServer(connection) {
 		}
 		const computed = project.artifacts.update(uri, document.getText(), project.inputs, project.controlStack);
 		if (computed === null) {
-			connection.sendDiagnostics({
+			sendDiagnostics({
 				uri,
 				diagnostics: []
 			});
 			return;
 		}
-		const diagnostics = computed.map((diagnostic) => ({
-			range: diagnostic.range,
-			message: diagnostic.message,
-			code: diagnostic.code,
-			severity: toLspSeverity(diagnostic.severity),
-			source: "prisma-next"
-		}));
-		connection.sendDiagnostics({
+		sendDiagnostics({
 			uri,
-			diagnostics
+			diagnostics: computed.map((diagnostic) => ({
+				range: diagnostic.range,
+				message: diagnostic.message,
+				code: diagnostic.code,
+				severity: toLspSeverity(diagnostic.severity),
+				source: "prisma-next"
+			}))
 		});
 	}
 	async function resolveProjectForDocument(uri) {
@@ -606,7 +1023,7 @@ function createServer(connection) {
 		const hadProject = projects.delete(configPath);
 		for (const document of documents.all()) if (documentConfigPaths.get(document.uri) === configPath) {
 			documentConfigPaths.delete(document.uri);
-			if (hadProject) connection.sendDiagnostics({
+			if (hadProject) sendDiagnostics({
 				uri: document.uri,
 				diagnostics: []
 			});
@@ -628,6 +1045,7 @@ function createServer(connection) {
 	}
 	function publishSafely(uri) {
 		publish(uri).catch((error) => {
+			if (disposed) return;
 			connection.console.error(error instanceof Error ? error.message : String(error));
 		});
 	}
@@ -676,10 +1094,49 @@ function createServer(connection) {
 			scalarTypes: project.controlStack.scalarTypes
 		}, range);
 	}
+	async function completeDocument(uri, position) {
+		const document = documents.get(uri);
+		if (document === void 0) return [];
+		let project;
+		try {
+			project = await resolveProjectForDocument(uri);
+		} catch {
+			return [];
+		}
+		if (project === void 0 || !project.inputs.includes(uri)) return [];
+		const cached = currentDocumentArtifact(project, uri, document.getText());
+		const symbolTable = project.artifacts.getSymbolTable();
+		if (cached === void 0 || symbolTable === void 0) return [];
+		try {
+			return [...providePslCompletionItems({
+				context: classifyPslCompletionContext({
+					document: cached.document,
+					sourceFile: cached.sourceFile,
+					position
+				}),
+				sourceFile: cached.sourceFile,
+				candidates: {
+					scalarTypes: project.controlStack.scalarTypes,
+					pslBlockDescriptors: project.controlStack.pslBlockDescriptors,
+					symbolTable
+				},
+				clientSupportsSnippets
+			})];
+		} catch {
+			return [];
+		}
+	}
+	function currentDocumentArtifact(project, uri, text) {
+		const cached = project.artifacts.getDocument(uri);
+		if (cached?.sourceFile.text === text) return cached;
+		if (project.artifacts.update(uri, text, project.inputs, project.controlStack) === null) return;
+		return project.artifacts.getDocument(uri);
+	}
 	connection.onInitialize(async (params) => {
 		rootPath = resolveRootPath(params.rootUri, params.rootPath);
 		watchedConfigGlob = join(rootPath, "**", CONFIG_FILENAME);
 		supportsWatchedFilesRegistration = clientSupportsWatchedFilesRegistration(params);
+		clientSupportsSnippets = clientSupportsCompletionSnippets(params);
 		return { capabilities: {
 			textDocumentSync: TextDocumentSyncKind.Incremental,
 			documentFormattingProvider: true,
@@ -688,7 +1145,8 @@ function createServer(connection) {
 				legend: semanticTokensLegend,
 				full: true,
 				range: true
-			}
+			},
+			completionProvider: { triggerCharacters: ["."] }
 		} };
 	});
 	connection.onInitialized(() => {
@@ -697,7 +1155,7 @@ function createServer(connection) {
 			method: DidChangeWatchedFilesNotification.type.method,
 			registerOptions: { watchers: [{ globPattern: watchedConfigGlob }] }
 		}] }).catch(() => void 0);
-		else connection.console.warn("Client does not support dynamic file-watcher registration; Prisma Next config changes will not be picked up without a restart.");
+		else logWarn("Client does not support dynamic file-watcher registration; Prisma Next config changes will not be picked up without a restart.");
 	});
 	connection.onDidChangeWatchedFiles(async (params) => {
 		const changedConfigPaths = configPathsFromWatchedChanges(params.changes.map((change) => filePathFromUri(change.uri)));
@@ -712,6 +1170,7 @@ function createServer(connection) {
 		}
 	});
 	connection.onDocumentFormatting((params) => formatDocument(params.textDocument.uri));
+	connection.onCompletion((params) => completeDocument(params.textDocument.uri, params.position));
 	connection.languages.semanticTokens.on((params) => semanticTokensForDocument(params.textDocument.uri));
 	connection.languages.semanticTokens.onRange((params) => semanticTokensForDocument(params.textDocument.uri, params.range));
 	connection.onFoldingRanges(async (params) => {
@@ -737,7 +1196,7 @@ function createServer(connection) {
 		const configPath = documentConfigPaths.get(uri);
 		if (configPath !== void 0) projects.get(configPath)?.artifacts.remove(uri);
 		documentConfigPaths.delete(uri);
-		connection.sendDiagnostics({
+		sendDiagnostics({
 			uri,
 			diagnostics: []
 		});
@@ -750,6 +1209,7 @@ function createServer(connection) {
 	}
 	return {
 		dispose: () => {
+			disposed = true;
 			connection.dispose();
 		},
 		getDocumentAst: (uri) => artifactsForDocument(uri)?.getDocument(uri),
@@ -770,6 +1230,9 @@ function toLspSeverity(severity) {
 function clientSupportsWatchedFilesRegistration(params) {
 	return params.capabilities.workspace?.didChangeWatchedFiles?.dynamicRegistration === true;
 }
+function clientSupportsCompletionSnippets(params) {
+	return params.capabilities.textDocument?.completion?.completionItem?.snippetSupport === true;
+}
 function resolveRootPath(rootUri, rootPath) {
 	if (rootUri) return fileURLToPath(rootUri);
 	if (rootPath) return rootPath;