@neo4j-cypher/language-server 2.0.0-next.21 → 2.0.0-next.23

package/dist/server.js

@@ -9,9 +9,6 @@ const formatting_1 = require("./formatting");
 const linting_1 = require("./linting");
 const signatureHelp_1 = require("./signatureHelp");
 const syntaxColouring_1 = require("./syntaxColouring");
-if (process.env.CYPHER_25 === 'true') {
-    language_support_1._internalFeatureFlags.cypher25 = true;
-}
 const connection = (0, node_1.createConnection)(node_1.ProposedFeatures.all);
 let settings = undefined;
 // Create a simple text document manager.
@@ -24,7 +21,7 @@ async function lintSingleDocument(document) {
                 uri: document.uri,
                 diagnostics,
             });
-        }, neo4jSchemaPoller);
+        }, neo4jSchemaPoller, settings?.features?.useVersionedLinters);
     }
     else {
         void connection.sendDiagnostics({
@@ -87,6 +84,14 @@ connection.languages.semanticTokens.on((0, syntaxColouring_1.applySyntaxColourin
 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;
+    void (async () => {
+        await (0, linting_1.setLintWorker)(lintWorkerPath, linterVersion);
+        relintAllDocuments();
+    })();
+});
 connection.onNotification('connectionUpdated', (connectionSettings) => {
     changeConnection(connectionSettings);
     neo4jSchemaPoller.events.once('schemaFetched', relintAllDocuments);
@@ -105,7 +110,7 @@ connection.onNotification('connectionDisconnected', () => {
 documents.listen(connection);
 connection.listen();
 connection.onExit(() => {
-    (0, linting_1.cleanupWorkers)();
+    void (0, linting_1.cleanupWorkers)();
 });
 const changeConnection = (connectionSettings) => {
     disconnect();

package/package.json

@@ -16,7 +16,7 @@
     "cypher",
     "language server"
   ],
-  "version": "2.0.0-next.21",
+  "version": "2.0.0-next.23",
   "main": "./dist/server.js",
   "types": "src/server.ts",
   "repository": {
@@ -28,7 +28,7 @@
   },
   "engineStrict": true,
   "engines": {
-    "node": ">=18.18.2"
+    "node": ">=22.15.0"
   },
   "bin": {
     "cypher-language-server": "./dist/cypher-language-server"
@@ -39,16 +39,20 @@
     "vscode-languageserver": "^8.1.0",
     "vscode-languageserver-textdocument": "^1.0.8",
     "workerpool": "^9.0.4",
-    "@neo4j-cypher/language-support": "2.0.0-next.20",
-    "@neo4j-cypher/query-tools": "2.0.0-next.20"
+    "axios": "^1.9.0",
+    "@neo4j-cypher/language-support": "2.0.0-next.22",
+    "@neo4j-cypher/lint-worker": "0.1.0-next.0",
+    "@neo4j-cypher/query-tools": "2.0.0-next.22"
   },
   "devDependencies": {
-    "@types/lodash.debounce": "^4.0.9"
+    "@types/lodash.debounce": "^4.0.9",
+    "copyfiles": "^2.4.1"
   },
   "scripts": {
-    "build": "tsc -b && pnpm bundle && pnpm make-executable && pnpm bundle-worker",
+    "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",
-    "bundle-worker": "esbuild ./src/lintWorker.ts --bundle --format=cjs --platform=node --conditions=require --outfile=dist/lintWorker.js --minify",
+    "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,tsconfig.tsbuildinfo}"
   }

package/src/formatting.ts

@@ -16,7 +16,7 @@ export const formatDocument = (
   }
 
   const text = document.getText();
-  const formattedText = formatQuery(text);
+  const formattedText = formatQuery(text).formattedQuery;
 
   if (text === formattedText) {
     return [];

package/src/linting.ts

@@ -1,23 +1,52 @@
-import { _internalFeatureFlags } from '@neo4j-cypher/language-support';
+import {
+  _internalFeatureFlags,
+  clampUnsafePositions,
+  parserWrapper,
+} 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 { LinterTask, LintWorker } from './lintWorker';
+import {
+  convertDbSchema,
+  LinterTask,
+  LintWorker,
+} from '@neo4j-cypher/lint-worker';
 
-const pool = workerpool.pool(join(__dirname, 'lintWorker.js'), {
+const defaultWorkerPath = join(__dirname, 'lintWorker.cjs');
+
+let pool = workerpool.pool(defaultWorkerPath, {
   minWorkers: 2,
   workerTerminateTimeout: 2000,
 });
-
+export let workerPath = defaultWorkerPath;
+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,
+  linter: string | undefined,
+) {
+  lintWorkerPath = lintWorkerPath ? lintWorkerPath : defaultWorkerPath;
+  if (lintWorkerPath !== workerPath) {
+    await cleanupWorkers();
+    workerPath = lintWorkerPath;
+    linterVersion = linter;
+    pool = workerpool.pool(workerPath, {
+      minWorkers: 2,
+      workerTerminateTimeout: 2000,
+    });
+  }
+}
+
 async function rawLintDocument(
   document: TextDocument,
   sendDiagnostics: (diagnostics: Diagnostic[]) => void,
   neo4j: Neo4jSchemaPoller,
+  versionedLinters: boolean,
 ) {
   const query = document.getText();
   if (query.length === 0) {
@@ -32,14 +61,33 @@ async function rawLintDocument(
     }
 
     const proxyWorker = (await pool.proxy()) as unknown as LintWorker;
+
+    const fixedDbSchema = versionedLinters
+      ? convertDbSchema(dbSchema, linterVersion)
+      : dbSchema;
     lastSemanticJob = proxyWorker.lintCypherQuery(
       query,
-      dbSchema,
+      fixedDbSchema,
       _internalFeatureFlags,
     );
+
     const result = await lastSemanticJob;
 
-    sendDiagnostics(result);
+    //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,
+      });
+    }
+
+    sendDiagnostics(positionSafeResult);
   } catch (err) {
     if (!(err instanceof workerpool.Promise.CancellationError)) {
       console.error(err);
@@ -56,6 +104,6 @@ export const lintDocument: typeof rawLintDocument = debounce(
   },
 );
 
-export const cleanupWorkers = () => {
-  void pool.terminate();
+export const cleanupWorkers = async () => {
+  await pool.terminate();
 };

package/src/server.ts

@@ -11,27 +11,20 @@ import {
 } from 'vscode-languageserver/node';
 
 import { TextDocument } from 'vscode-languageserver-textdocument';
-
-import {
-  _internalFeatureFlags,
-  syntaxColouringLegend,
-} from '@neo4j-cypher/language-support';
+import { syntaxColouringLegend } from '@neo4j-cypher/language-support';
 import { Neo4jSchemaPoller } from '@neo4j-cypher/query-tools';
 import { doAutoCompletion } from './autocompletion';
 import { formatDocument } from './formatting';
-import { cleanupWorkers, lintDocument } from './linting';
+import { cleanupWorkers, lintDocument, setLintWorker } from './linting';
 import { doSignatureHelp } from './signatureHelp';
 import { applySyntaxColouringForDocument } from './syntaxColouring';
 import {
+  LintWorkerSettings,
   Neo4jConnectionSettings,
   Neo4jParameters,
   Neo4jSettings,
 } from './types';
 
-if (process.env.CYPHER_25 === 'true') {
-  _internalFeatureFlags.cypher25 = true;
-}
-
 const connection = createConnection(ProposedFeatures.all);
 let settings: Neo4jSettings | undefined = undefined;
 
@@ -50,6 +43,7 @@ async function lintSingleDocument(document: TextDocument): Promise<void> {
         });
       },
       neo4jSchemaPoller,
+      settings?.features?.useVersionedLinters,
     );
   } else {
     void connection.sendDiagnostics({
@@ -127,6 +121,19 @@ connection.onSignatureHelp(doSignatureHelp(documents, neo4jSchemaPoller));
 // Trigger the auto completion
 connection.onCompletion(doAutoCompletion(documents, neo4jSchemaPoller));
 
+connection.onNotification(
+  'updateLintWorker',
+  (linterSettings: LintWorkerSettings) => {
+    const lintWorkerPath = linterSettings.lintWorkerPath;
+    const linterVersion = linterSettings.linterVersion;
+
+    void (async () => {
+      await setLintWorker(lintWorkerPath, linterVersion);
+      relintAllDocuments();
+    })();
+  },
+);
+
 connection.onNotification(
   'connectionUpdated',
   (connectionSettings: Neo4jConnectionSettings) => {
@@ -154,7 +161,7 @@ documents.listen(connection);
 connection.listen();
 
 connection.onExit(() => {
-  cleanupWorkers();
+  void cleanupWorkers();
 });
 
 const changeConnection = (connectionSettings: Neo4jConnectionSettings) => {

package/src/types.ts

@@ -7,11 +7,16 @@ export type Neo4jConnectionSettings = {
   database?: string;
 };
 
+export type LintWorkerSettings = {
+  lintWorkerPath: string;
+  linterVersion: string;
+};
+
 export type Neo4jSettings = {
   trace: {
     server: 'off' | 'messages' | 'verbose';
   };
-  features: { linting: boolean };
+  features: { linting: boolean; useVersionedLinters?: boolean };
 };
 
 export type Neo4jParameters = Record<string, unknown>;

package/src/lintWorker.ts

@@ -1,31 +0,0 @@
-import {
-  DbSchema,
-  lintCypherQuery as _lintCypherQuery,
-  _internalFeatureFlags,
-} from '@neo4j-cypher/language-support';
-import workerpool from 'workerpool';
-
-function lintCypherQuery(
-  query: string,
-  dbSchema: DbSchema,
-  featureFlags: { consoleCommands?: boolean; cypher25?: boolean } = {},
-) {
-  // We allow to override the consoleCommands feature flag
-  if (featureFlags.consoleCommands !== undefined) {
-    _internalFeatureFlags.consoleCommands = featureFlags.consoleCommands;
-  }
-  if (featureFlags.cypher25 !== undefined) {
-    _internalFeatureFlags.cypher25 = featureFlags.cypher25;
-  }
-  return _lintCypherQuery(query, dbSchema);
-}
-
-workerpool.worker({ lintCypherQuery });
-
-type LinterArgs = Parameters<typeof lintCypherQuery>;
-
-export type LinterTask = workerpool.Promise<ReturnType<typeof lintCypherQuery>>;
-
-export type LintWorker = {
-  lintCypherQuery: (...args: LinterArgs) => LinterTask;
-};