@neo4j-cypher/language-server 2.0.0-next.3 → 2.0.0-next.31

package/dist/server.js

@@ -0,0 +1,204 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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 syntaxColouring_1 = require("./syntaxColouring");
+const workerpool_1 = __importDefault(require("workerpool"));
+const lint_worker_1 = require("@neo4j-cypher/lint-worker");
+const path_1 = require("path");
+const defaultWorkerPath = (0, path_1.join)(__dirname, 'lintWorker.cjs');
+let workerPath = defaultWorkerPath;
+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 proxyWorker = (await this.symbolTablePool.proxy());
+                const query = this.nextJob.query;
+                const dbSchema = this.nextJob.schema;
+                const docUri = this.nextJob.uri;
+                this.nextJob = undefined;
+                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)) {
+                    language_support_1.parserWrapper.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.syntaxColouringLegend,
+                range: false,
+                full: {
+                    delta: false,
+                },
+            },
+            signatureHelpProvider: {
+                triggerCharacters: ['(', ',', ')'],
+            },
+            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.syntaxColouringLegend,
+        range: false,
+        full: {
+            delta: false,
+        },
+    };
+    void connection.client.register(node_1.SemanticTokensRegistrationType.type, registrationOptions);
+});
+connection.onDidChangeConfiguration((params) => {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    settings = params.settings?.neo4j;
+    relintAllDocuments();
+});
+documents.onDidChangeContent((change) => lintSingleDocument(change.document));
+// Trigger the syntax colouring
+connection.languages.semanticTokens.on((0, syntaxColouring_1.applySyntaxColouringForDocument)(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.onNotification('fetchSymbolTable', (params) => {
+    neo4jSchemaPoller.events.once('schemaFetched', 
+    // oxlint-disable-next-line typescript-eslint/no-meaningless-void-operator
+    void 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.31",
   "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,42 +27,33 @@
     "LICENSE.md",
     "CHANGELOG.md"
   ],
-  "keywords": [
-    "neo4j",
-    "cypher",
-    "language server"
-  ],
-  "version": "2.0.0-next.3",
   "main": "./dist/server.js",
   "types": "src/server.ts",
-  "repository": {
-    "type": "git",
-    "url": "git://github.com/neo4j/cypher-language-support.git"
+  "dependencies": {
+    "axios": "^1.9.0",
+    "lodash.debounce": "^4.0.8",
+    "neo4j-driver": "6.0.1",
+    "vscode-languageserver": "^8.1.0",
+    "vscode-languageserver-textdocument": "^1.0.8",
+    "workerpool": "^9.3.3",
+    "@neo4j-cypher/query-tools": "2.0.0-next.30",
+    "@neo4j-cypher/language-support": "2.0.0-next.30",
+    "@neo4j-cypher/lint-worker": "1.10.1-next.7"
   },
-  "bugs": {
-    "url": "https://github.com/neo4j/cypher-language-support/issues"
+  "devDependencies": {
+    "@types/lodash.debounce": "^4.0.9",
+    "copyfiles": "^2.4.1"
   },
-  "engineStrict": true,
   "engines": {
-    "node": ">=18.18.2"
-  },
-  "bin": {
-    "cypher-language-server": "./dist/cypher-language-server"
-  },
-  "dependencies": {
-    "@neo4j-cypher/language-support": "2.0.0-next.2",
-    "neo4j-driver": "^5.3.0",
-    "vscode-languageserver": "^8.1.0",
-    "vscode-languageserver-textdocument": "^1.0.8"
+    "node": ">=24.11.1"
   },
+  "engineStrict": true,
   "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",
+    "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",
     "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"
-  },
-  "devDependencies": {
-    "esbuild": "^0.19.4"
+    "clean": "rm -rf {dist,tsconfig.tsbuildinfo}"
   }
-}
+}

package/src/autocompletion.ts

@@ -1,34 +1,55 @@
 import {
+  CompletionParams,
+  CompletionTriggerKind,
   Position,
-  TextDocumentPositionParams,
   TextDocuments,
 } 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 type { CompletionItem } from '@neo4j-cypher/language-support';
+import {
+  autocomplete,
+  shouldAutoCompleteYield,
+} from '@neo4j-cypher/language-support';
+import { Neo4jSchemaPoller } from '@neo4j-cypher/query-tools';
 import { TextDocument } from 'vscode-languageserver-textdocument';
 
 export function doAutoCompletion(
   documents: TextDocuments<TextDocument>,
   neo4j: Neo4jSchemaPoller,
 ) {
-  return (textDocumentPosition: TextDocumentPositionParams) => {
-    const textDocument = documents.get(textDocumentPosition.textDocument.uri);
+  return (completionParams: CompletionParams) => {
+    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[] = autocomplete(
+        textDocument.getText(),
+        neo4j.metadata?.dbSchema ?? {},
+        offset,
+        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;
+    }
   };
 }

package/src/formatting.ts

@@ -0,0 +1,34 @@
+import { formatQuery } from '@neo4j-cypher/language-support';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import {
+  DocumentFormattingParams,
+  TextDocuments,
+  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/linting.ts

@@ -0,0 +1,105 @@
+import {
+  _internalFeatureFlags,
+  clampUnsafePositions,
+  parserWrapper,
+  SymbolTable,
+} from '@neo4j-cypher/language-support';
+import { Neo4jSchemaPoller } from '@neo4j-cypher/query-tools';
+import debounce from 'lodash.debounce';
+import { join } from 'path';
+import { Diagnostic } from 'vscode-languageserver';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import workerpool from 'workerpool';
+import {
+  convertDbSchema,
+  LinterTask,
+  LintWorker,
+} from '@neo4j-cypher/lint-worker';
+
+const defaultWorkerPath = join(__dirname, 'lintWorker.cjs');
+
+let pool = workerpool.pool(defaultWorkerPath, {
+  minWorkers: 2,
+  workerTerminateTimeout: 0,
+});
+let linterVersion: string | undefined = undefined;
+let lastSemanticJob: LinterTask | undefined;
+
+/**Sets the lintworker to the one specified by the given path, reverting to default if the path is undefined */
+export async function setLintWorker(
+  lintWorkerPath: string | undefined = defaultWorkerPath,
+  linter: string | undefined,
+) {
+  await cleanupWorkers();
+  linterVersion = linter;
+  pool = workerpool.pool(lintWorkerPath, {
+    minWorkers: 2,
+    workerTerminateTimeout: 0,
+  });
+}
+
+async function rawLintDocument(
+  document: TextDocument,
+  sendDiagnostics: (diagnostics: Diagnostic[]) => void,
+  notifySymbolTableDone: (symbolTable: SymbolTable[]) => Promise<void>,
+  neo4j: Neo4jSchemaPoller,
+) {
+  const query = document.getText();
+  if (query.length === 0) {
+    sendDiagnostics([]);
+    return;
+  }
+
+  const dbSchema = neo4j.metadata?.dbSchema ?? {};
+  try {
+    if (lastSemanticJob !== undefined && !lastSemanticJob.resolved) {
+      void lastSemanticJob.cancel();
+    }
+
+    const proxyWorker = (await pool.proxy()) as unknown as LintWorker;
+
+    const fixedDbSchema = convertDbSchema(dbSchema, linterVersion);
+    lastSemanticJob = proxyWorker.lintCypherQuery(
+      query,
+      fixedDbSchema,
+      _internalFeatureFlags,
+    );
+    const result = await lastSemanticJob;
+
+    //marks the entire text if any position is negative
+    const positionSafeResult = clampUnsafePositions(
+      result.diagnostics,
+      document,
+    );
+
+    // Pass the computed symbol tables to the parser
+    if (result.symbolTables) {
+      parserWrapper.setSymbolsInfo(
+        {
+          query,
+          symbolTables: result.symbolTables,
+        },
+        notifySymbolTableDone,
+      );
+    }
+
+    sendDiagnostics(positionSafeResult);
+  } catch (err) {
+    if (!(err instanceof workerpool.Promise.CancellationError)) {
+      console.error(err);
+    }
+  }
+}
+
+export const lintDocument: typeof rawLintDocument = debounce(
+  rawLintDocument,
+  600,
+  {
+    leading: false,
+    trailing: true,
+  },
+);
+
+export const cleanupWorkers = async () => {
+  await pool.terminate();
+};