@neo4j-cypher/language-server 2.0.0-next.4 → 2.0.0-next.40

package/dist/server.js

@@ -0,0 +1,210 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.languageService = void 0;
+const node_1 = require("vscode-languageserver/node");
+const vscode_languageserver_textdocument_1 = require("vscode-languageserver-textdocument");
+const language_support_1 = require("@neo4j-cypher/language-support");
+const query_tools_1 = require("@neo4j-cypher/query-tools");
+const autocompletion_1 = require("./autocompletion");
+const formatting_1 = require("./formatting");
+const linting_1 = require("./linting");
+const signatureHelp_1 = require("./signatureHelp");
+const syntaxHighlighting_1 = require("./syntaxHighlighting");
+const workerpool_1 = __importDefault(require("workerpool"));
+const lint_worker_1 = require("@neo4j-cypher/lint-worker");
+const path_1 = require("path");
+const hoverInfo_js_1 = require("./hoverInfo.js");
+const defaultWorkerPath = (0, path_1.join)(__dirname, 'lintWorker.cjs');
+let workerPath = defaultWorkerPath;
+exports.languageService = new language_support_1.CypherLanguageService({
+    consoleCommandsEnabled: false,
+});
+class SymbolFetcher {
+    processing = false;
+    nextJob;
+    symbolTablePool = workerpool_1.default.pool(defaultWorkerPath, {
+        maxWorkers: 1,
+        workerTerminateTimeout: 0,
+    });
+    linterVersion;
+    setLintWorker(lintWorkerPath = defaultWorkerPath, linterVersion) {
+        this.linterVersion = linterVersion;
+        this.symbolTablePool = workerpool_1.default.pool(lintWorkerPath, {
+            maxWorkers: 1,
+            workerTerminateTimeout: 0,
+        });
+    }
+    queueSymbolJob(query, uri, schema) {
+        this.nextJob = { query, uri, schema };
+        if (!this.processing) {
+            void this.processJobQueue();
+        }
+    }
+    async processJobQueue() {
+        this.processing = true;
+        while (this.nextJob) {
+            try {
+                const query = this.nextJob.query;
+                const dbSchema = this.nextJob.schema;
+                const docUri = this.nextJob.uri;
+                this.nextJob = undefined;
+                const proxyWorker = (await this.symbolTablePool.proxy());
+                const fixedDbSchema = (0, lint_worker_1.convertDbSchema)(dbSchema, this.linterVersion);
+                const result = await proxyWorker.lintCypherQuery(query, fixedDbSchema);
+                if (
+                //if this.nextJob has new doc, our result is no longer valid
+                result.symbolTables &&
+                    !(this.nextJob && this.nextJob.uri != docUri)) {
+                    exports.languageService.setSymbolsInfo({
+                        query,
+                        symbolTables: result.symbolTables,
+                    }, async (symbolTables) => await connection.sendNotification('symbolTableDone', {
+                        symbolTables,
+                    }));
+                }
+            }
+            catch {
+                //eslint-disable-next-line
+                console.log('Symbol table calculation failed');
+            }
+        }
+        this.processing = false;
+    }
+}
+const connection = (0, node_1.createConnection)(node_1.ProposedFeatures.all);
+let settings = undefined;
+// Create a simple text document manager.
+const documents = new node_1.TextDocuments(vscode_languageserver_textdocument_1.TextDocument);
+const neo4jSchemaPoller = new query_tools_1.Neo4jSchemaPoller();
+const symbolFetcher = new SymbolFetcher();
+async function lintSingleDocument(document) {
+    symbolFetcher.queueSymbolJob(document.getText(), document.uri, neo4jSchemaPoller?.metadata?.dbSchema);
+    if (settings?.features?.linting) {
+        return (0, linting_1.lintDocument)(document, (diagnostics) => {
+            void connection.sendDiagnostics({
+                uri: document.uri,
+                diagnostics,
+            });
+        }, async (symbolTables) => await connection.sendNotification('symbolTableDone', {
+            symbolTables: symbolTables,
+        }), neo4jSchemaPoller);
+    }
+    else {
+        void connection.sendDiagnostics({
+            uri: document.uri,
+            diagnostics: [],
+        });
+    }
+}
+function relintAllDocuments() {
+    void documents.all().map(lintSingleDocument);
+}
+connection.onInitialize(() => {
+    const result = {
+        capabilities: {
+            textDocumentSync: node_1.TextDocumentSyncKind.Full,
+            // Tell the client what features does the server support
+            completionProvider: {
+                resolveProvider: false,
+                triggerCharacters: ['.', ':', '{', '$', ')', ' ', ']', '-', '<'],
+            },
+            semanticTokensProvider: {
+                documentSelector: [{ language: 'cypher' }],
+                legend: language_support_1.syntaxHighlightingLegend,
+                range: false,
+                full: {
+                    delta: false,
+                },
+            },
+            signatureHelpProvider: {
+                triggerCharacters: ['(', ',', ')'],
+            },
+            hoverProvider: true,
+            documentFormattingProvider: true,
+        },
+    };
+    return result;
+});
+connection.onInitialized(() => {
+    void connection.client.register(node_1.DidChangeConfigurationNotification.type, {
+        section: 'neo4j',
+    });
+    const registrationOptions = {
+        documentSelector: [{ language: 'cypher' }],
+        legend: language_support_1.syntaxHighlightingLegend,
+        range: false,
+        full: {
+            delta: false,
+        },
+    };
+    void connection.client.register(node_1.SemanticTokensRegistrationType.type, registrationOptions);
+});
+connection.onDidChangeConfiguration((params) => {
+    settings = params.settings?.neo4j;
+    relintAllDocuments();
+});
+documents.onDidChangeContent((change) => lintSingleDocument(change.document));
+// Trigger the syntax highlighting
+connection.languages.semanticTokens.on((0, syntaxHighlighting_1.highlightSyntaxForDocument)(documents));
+// Trigger the signature help, providing info about functions / procedures
+connection.onSignatureHelp((0, signatureHelp_1.doSignatureHelp)(documents, neo4jSchemaPoller));
+// Trigger the auto completion
+connection.onCompletion((0, autocompletion_1.doAutoCompletion)(documents, neo4jSchemaPoller));
+connection.onNotification('updateLintWorker', (linterSettings) => {
+    const lintWorkerPath = linterSettings.lintWorkerPath;
+    const linterVersion = linterSettings.linterVersion;
+    if (lintWorkerPath !== workerPath) {
+        workerPath = lintWorkerPath;
+        void (async () => {
+            symbolFetcher.setLintWorker(workerPath, linterVersion);
+            await (0, linting_1.setLintWorker)(workerPath, linterVersion);
+            relintAllDocuments();
+        })();
+    }
+});
+connection.onNotification('connectionUpdated', (connectionSettings) => {
+    changeConnection(connectionSettings);
+    neo4jSchemaPoller.events.once('schemaFetched', relintAllDocuments);
+});
+connection.onHover((params) => {
+    return (0, hoverInfo_js_1.doHoverInfo)(documents, neo4jSchemaPoller, params);
+});
+connection.onNotification('fetchSymbolTable', (params) => {
+    neo4jSchemaPoller.events.once('schemaFetched', () => symbolFetcher.queueSymbolJob(params.query, params.uri, params.schema));
+});
+connection.onNotification('updateParameters', (parameters) => {
+    neo4jSchemaPoller.setParameters(parameters);
+    relintAllDocuments();
+});
+connection.onDocumentFormatting((params) => {
+    return (0, formatting_1.formatDocument)(params, documents);
+});
+connection.onNotification('connectionDisconnected', () => {
+    disconnect();
+    relintAllDocuments();
+});
+documents.listen(connection);
+connection.listen();
+connection.onExit(() => {
+    void (0, linting_1.cleanupWorkers)();
+});
+const changeConnection = (connectionSettings) => {
+    disconnect();
+    if (neo4jSchemaPoller.connection === undefined &&
+        connectionSettings.connect &&
+        connectionSettings.password &&
+        connectionSettings.connectURL &&
+        connectionSettings.user) {
+        void neo4jSchemaPoller.persistentConnect(connectionSettings.connectURL, {
+            username: connectionSettings.user,
+            password: connectionSettings.password,
+        }, { appName: 'cypher-language-server' }, connectionSettings.database);
+    }
+};
+const disconnect = () => {
+    neo4jSchemaPoller.disconnect();
+};
+//# sourceMappingURL=server.js.map

package/package.json

@@ -1,8 +1,24 @@
 {
   "name": "@neo4j-cypher/language-server",
+  "version": "2.0.0-next.40",
   "description": "Cypher Language Server",
-  "author": "Neo4j Inc.",
+  "keywords": [
+    "cypher",
+    "language server",
+    "neo4j"
+  ],
+  "bugs": {
+    "url": "https://github.com/neo4j/cypher-language-support/issues"
+  },
   "license": "Apache-2.0",
+  "author": "Neo4j Inc.",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/neo4j/cypher-language-support.git"
+  },
+  "bin": {
+    "cypher-language-server": "./dist/cypher-language-server"
+  },
   "files": [
     "./dist/cypher-language-server",
     "./src",
@@ -11,45 +27,31 @@
     "LICENSE.md",
     "CHANGELOG.md"
   ],
-  "keywords": [
-    "neo4j",
-    "cypher",
-    "language server"
-  ],
-  "version": "2.0.0-next.4",
   "main": "./dist/server.js",
   "types": "src/server.ts",
-  "repository": {
-    "type": "git",
-    "url": "git://github.com/neo4j/cypher-language-support.git"
-  },
-  "bugs": {
-    "url": "https://github.com/neo4j/cypher-language-support/issues"
-  },
-  "engineStrict": true,
-  "engines": {
-    "node": ">=18.18.2"
-  },
-  "bin": {
-    "cypher-language-server": "./dist/cypher-language-server"
-  },
   "dependencies": {
-    "@neo4j-cypher/language-support": "2.0.0-next.3",
     "lodash.debounce": "^4.0.8",
-    "neo4j-driver": "^5.3.0",
     "vscode-languageserver": "^8.1.0",
     "vscode-languageserver-textdocument": "^1.0.8",
-    "workerpool": "^9.0.4"
-  },
-  "scripts": {
-    "build": "tsc -b && npm run bundle && npm run make-executable",
-    "bundle": "esbuild ./src/server.ts --bundle --format=cjs --platform=node --outfile=dist/cypher-language-server.js --minify",
-    "make-executable": "cd dist && echo '#!/usr/bin/env node' > cypher-language-server && cat cypher-language-server.js >> cypher-language-server",
-    "clean": "rm -rf dist",
-    "watch": "tsc -b -w"
+    "workerpool": "^9.3.3",
+    "@neo4j-cypher/lint-worker": "1.10.1-next.16",
+    "@neo4j-cypher/language-support": "2.0.0-next.39",
+    "@neo4j-cypher/query-tools": "2.0.0-next.39"
   },
   "devDependencies": {
     "@types/lodash.debounce": "^4.0.9",
-    "esbuild": "^0.19.4"
+    "copyfiles": "^2.4.1"
+  },
+  "engines": {
+    "node": ">=24.11.1"
+  },
+  "scripts": {
+    "build": "tsc -b && pnpm bundle && pnpm make-executable && pnpm copy-lint-worker",
+    "copy-lint-worker": "copyfiles -u 4 ../lint-worker/dist/cjs/lintWorker.cjs dist/",
+    "bundle": "esbuild ./src/server.ts --bundle --format=cjs --platform=node --outfile=dist/cypher-language-server.js --minify --conditions=require",
+    "dev": "tsc --watch",
+    "test": "vitest run",
+    "make-executable": "cd dist && echo '#!/usr/bin/env node' > cypher-language-server && cat cypher-language-server.js >> cypher-language-server",
+    "clean": "rm -rf dist tsconfig*.tsbuildinfo"
   }
-}
+}

package/src/autocompletion.ts

@@ -1,34 +1,58 @@
-import {
+import type {
+  CompletionParams,
   Position,
-  TextDocumentPositionParams,
   TextDocuments,
 } from 'vscode-languageserver/node';
+import { CompletionTriggerKind } from 'vscode-languageserver/node';
 
-import { Range } from 'vscode-languageserver-types';
-
-import { autocomplete } from '@neo4j-cypher/language-support';
-import { Neo4jSchemaPoller } from '@neo4j-cypher/schema-poller';
-import { TextDocument } from 'vscode-languageserver-textdocument';
+import type { CompletionItem } from '@neo4j-cypher/language-support';
+import { shouldAutoCompleteYield } from '@neo4j-cypher/language-support';
+import type { Neo4jSchemaPoller } from '@neo4j-cypher/query-tools';
+import type { TextDocument } from 'vscode-languageserver-textdocument';
+import { languageService } from './server';
 
 export function doAutoCompletion(
   documents: TextDocuments<TextDocument>,
   neo4j: Neo4jSchemaPoller,
 ) {
-  return (textDocumentPosition: TextDocumentPositionParams) => {
-    const textDocument = documents.get(textDocumentPosition.textDocument.uri);
+  return (completionParams: CompletionParams): CompletionItem[] | undefined => {
+    const textDocument = documents.get(completionParams.textDocument.uri);
     if (textDocument === undefined) return [];
 
-    const position: Position = textDocumentPosition.position;
-    const range: Range = {
-      // TODO Nacho: We are parsing from the begining of the file.
-      // Do we need to parse from the begining of the current query?
-      start: Position.create(0, 0),
-      end: position,
-    };
-
-    return autocomplete(
-      textDocument.getText(range),
-      neo4j.metadata?.dbSchema ?? {},
+    const position: Position = completionParams.position;
+    const offset = textDocument.offsetAt(position);
+    const yieldTriggered = shouldAutoCompleteYield(
+      textDocument.getText(),
+      offset,
     );
+    const manualOrCharacterOrInwordTriggered =
+      completionParams.context?.triggerCharacter !== ' ';
+    if (yieldTriggered || manualOrCharacterOrInwordTriggered) {
+      const completions: CompletionItem[] = languageService.autocomplete(
+        textDocument.getText(),
+        neo4j.metadata?.dbSchema ?? {},
+        {
+          caretPosition: offset,
+          manual:
+            completionParams.context.triggerKind ===
+            CompletionTriggerKind.Invoked,
+        },
+      );
+
+      const result = completions.map((item) => {
+        if (item.signature) {
+          return {
+            ...item,
+            detail: item.detail + ' ' + item.signature,
+            signature: undefined,
+          };
+        } else {
+          return item;
+        }
+      });
+
+      return result;
+    }
+    return undefined;
   };
 }

package/src/descriptionToMarkdown.ts

@@ -0,0 +1,55 @@
+/**
+ * Descriptions in hover info are rendered as markdown in VS Code, which eats
+ * the wildcard '*' usages some of them have, as in dbms.queryJmx' "(e.g.
+ * '*:*,name=*neo4j*' for all metrics)", so we escape those. Not the asterisks a
+ * description means as markup though - in a code span, or as a bullet - where
+ * the backslash would show up instead. Backslashes are escaped along with them.
+ *
+ * Some descriptions are map-style objects (often configs) rather than prose.
+ * Markdown would put those on one line, so we tag them as 'text' code blocks
+ * and let their own layout through.
+ */
+
+const bulletMarker = '* ';
+
+/* A code span, or the prose up to the next backtick. Pairing left to right, as
+   markdown does, leaves the stray backtick a few descriptions have
+   (apoc.nodes.rels', apoc.path.expandConfig') as prose. */
+const codeSpanOrProse = /(`[^`]*`)|([^`]+|`)/g;
+
+export function escapeDescriptionForMarkdown(description: string): string {
+  // Line by line, so that an unclosed backtick cannot reach the lines below
+  return description.split('\n').map(escapeLine).join('\n');
+}
+
+function escapeLine(line: string): string {
+  const bullet = line.startsWith(bulletMarker) ? bulletMarker : '';
+
+  return (
+    bullet +
+    line.slice(bullet.length).replace(
+      codeSpanOrProse,
+      /* Escaping inside a code span would show the backslash, and descriptions
+         put wildcards there too, e.g. 'use `*:*` to find all JMX beans'. */
+      (_matched, codeSpan: string | undefined, prose: string) =>
+        codeSpan ?? prose.replace(/[\\*]/g, '\\$&'),
+    )
+  );
+}
+
+/* For example a map-style description, laid out over several lines */
+function hasInnerNewlines(description: string): boolean {
+  const lines = description.trimEnd().split('\n');
+  return lines.length > 1;
+}
+
+export function formatLineForMarkdown(
+  name: string,
+  description: string,
+): string[] {
+  const bullet = `- \`${name}\` -`;
+
+  return hasInnerNewlines(description)
+    ? [bullet, '```text', description.trimEnd(), '```']
+    : [`${bullet} ${escapeLine(description)}`];
+}

package/src/formatting.ts

@@ -0,0 +1,34 @@
+import { formatQuery } from '@neo4j-cypher/language-support';
+import type { TextDocument } from 'vscode-languageserver-textdocument';
+import type {
+  DocumentFormattingParams,
+  TextDocuments,
+} from 'vscode-languageserver/node';
+import { TextEdit } from 'vscode-languageserver/node';
+
+export const formatDocument = (
+  params: DocumentFormattingParams,
+  documents: TextDocuments<TextDocument>,
+): TextEdit[] => {
+  const document = documents.get(params.textDocument.uri);
+  if (!document) {
+    return [];
+  }
+
+  const text = document.getText();
+  const formattedText = formatQuery(text).formattedQuery;
+
+  if (text === formattedText) {
+    return [];
+  }
+
+  return [
+    TextEdit.replace(
+      {
+        start: { line: 0, character: 0 },
+        end: { line: document.lineCount, character: 0 },
+      },
+      formattedText,
+    ),
+  ];
+};

package/src/hoverInfo.ts

@@ -0,0 +1,29 @@
+import type { Hover, HoverParams, TextDocuments } from 'vscode-languageserver';
+import { MarkupKind } from 'vscode-languageserver';
+import type { TextDocument } from 'vscode-languageserver-textdocument';
+import { languageService } from './server.js';
+import type { Neo4jSchemaPoller } from '@neo4j-cypher/query-tools';
+import { hoverInfoToMarkdown } from './hoverMarkdown.js';
+
+export function doHoverInfo(
+  documents: TextDocuments<TextDocument>,
+  neo4jSchemaPoller: Neo4jSchemaPoller,
+  params: HoverParams,
+): Hover | null {
+  const textDocument = documents.get(params.textDocument.uri);
+  if (textDocument === undefined) return null;
+  const position = params.position;
+  const offset = textDocument.offsetAt(position);
+  const hoverInfo = languageService.hoverInfo(textDocument.getText(), {
+    caretPosition: offset,
+    dbSchema: neo4jSchemaPoller.metadata?.dbSchema ?? {},
+  });
+  if (!hoverInfo) return null;
+
+  return {
+    contents: {
+      kind: MarkupKind.Markdown,
+      value: hoverInfoToMarkdown(hoverInfo),
+    },
+  };
+}

package/src/hoverMarkdown.ts

@@ -0,0 +1,56 @@
+import type {
+  HoverDescription,
+  HoverInfo,
+} from '@neo4j-cypher/language-support';
+import {
+  escapeDescriptionForMarkdown,
+  formatLineForMarkdown,
+} from './descriptionToMarkdown.js';
+
+function cypherCodeBlock(fragment: string): string[] {
+  return ['```cypher', fragment, '```'];
+}
+
+export function hoverInfoToMarkdown(info: HoverInfo): string {
+  if (info.kind === 'variable') {
+    const typeLine = ['`', `${info.variable}: ${info.types.join(', ')}`, '`'];
+    return (
+      info.labelExpression === undefined
+        ? typeLine
+        : [...typeLine, '', ...cypherCodeBlock(info.labelExpression)]
+    ).join('\n');
+  }
+
+  return [
+    ...cypherCodeBlock(info.signature),
+    `${info.isDeprecated ? '(_deprecated_) ' : ''}${escapeDescriptionForMarkdown(
+      info.description,
+    )}`,
+    '',
+    ...descriptionsToMarkdown('**Parameters**', info.parameters),
+    '',
+    ...(info.kind === 'function'
+      ? functionReturn(info.returnType)
+      : descriptionsToMarkdown('**Returns**', info.returnValues)),
+  ].join('\n');
+}
+
+function descriptionsToMarkdown(
+  heading: string,
+  descriptions: HoverDescription[],
+): string[] {
+  if (descriptions.length === 0) {
+    return [];
+  }
+
+  return [
+    heading,
+    ...descriptions.flatMap(({ name, description }) =>
+      formatLineForMarkdown(name, description),
+    ),
+  ];
+}
+
+function functionReturn(returnType: string): string[] {
+  return returnType ? [`**Returns:** \`${returnType}\``] : [];
+}