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

package/src/linting.ts

@@ -1,57 +1,113 @@
-import { validateSyntax } from '@neo4j-cypher/language-support';
+import type {
+  SymbolTable,
+  SyntaxDiagnostic,
+} from '@neo4j-cypher/language-support';
+import {
+  clampUnsafePositions,
+  isNotParamError,
+} from '@neo4j-cypher/language-support';
+import type { Neo4jSchemaPoller } from '@neo4j-cypher/query-tools';
 import debounce from 'lodash.debounce';
 import { join } from 'path';
-import { Diagnostic, TextDocumentChangeEvent } from 'vscode-languageserver';
-import { TextDocument } from 'vscode-languageserver-textdocument';
+import type { Diagnostic } from 'vscode-languageserver';
+import type { TextDocument } from 'vscode-languageserver-textdocument';
 import workerpool from 'workerpool';
-import { LinterTask, LintWorker } from './lint-worker';
+import type { LinterTask, LintWorker } from '@neo4j-cypher/lint-worker';
+import { convertDbSchema } from '@neo4j-cypher/lint-worker';
+import { languageService } from './server';
 
-const pool = workerpool.pool(join(__dirname, 'lint-worker.js'), {
+const defaultWorkerPath = join(__dirname, 'lintWorker.cjs');
+
+let pool = workerpool.pool(defaultWorkerPath, {
   minWorkers: 2,
-  workerTerminateTimeout: 2000,
+  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(
-  change: TextDocumentChangeEvent<TextDocument>,
+  document: TextDocument,
   sendDiagnostics: (diagnostics: Diagnostic[]) => void,
+  notifySymbolTableDone: (symbolTable: SymbolTable[]) => Promise<void>,
+  neo4j: Neo4jSchemaPoller,
 ) {
-  const { document } = change;
-
   const query = document.getText();
   if (query.length === 0) {
+    sendDiagnostics([]);
     return;
   }
 
-  const syntaxErrors = validateSyntax(query, {});
+  const dbSchema = neo4j.metadata?.dbSchema ?? {};
+  try {
+    if (lastSemanticJob !== undefined && !lastSemanticJob.resolved) {
+      void lastSemanticJob.cancel();
+    }
 
-  sendDiagnostics(syntaxErrors);
+    const proxyWorker = (await pool.proxy()) as unknown as LintWorker;
 
-  if (syntaxErrors.length === 0) {
-    try {
-      if (lastSemanticJob !== undefined && !lastSemanticJob.resolved) {
-        void lastSemanticJob.cancel();
-      }
+    const fixedDbSchema = convertDbSchema(dbSchema, linterVersion);
+    lastSemanticJob = proxyWorker.lintCypherQuery(query, fixedDbSchema, {
+      consoleCommands: false,
+    });
+    const result = await lastSemanticJob;
 
-      const proxyWorker = (await pool.proxy()) as unknown as LintWorker;
-      lastSemanticJob = proxyWorker.validateSemantics(query);
-      const result = await lastSemanticJob;
+    // Pass the computed symbol tables to the parser
+    if (result.symbolTables) {
+      languageService.setSymbolsInfo(
+        {
+          query,
+          symbolTables: result.symbolTables,
+        },
+        notifySymbolTableDone,
+      );
+    }
 
-      sendDiagnostics(result);
-    } catch (err) {
-      if (!(err instanceof workerpool.Promise.CancellationError)) {
-        console.error(err);
-      }
+    sendDiagnostics(
+      filterLintResult(
+        result.diagnostics,
+        dbSchema?.databaseNames?.length ? false : true,
+        document,
+      ),
+    );
+  } catch (err) {
+    if (!(err instanceof workerpool.Promise.CancellationError)) {
+      console.error(err);
     }
   }
 }
 
-export const lintDocument = debounce(rawLintDocument, 600, {
-  leading: false,
-  trailing: true,
-});
+function filterLintResult(
+  diagnostics: SyntaxDiagnostic[],
+  dontWarnOnParams: boolean,
+  document: TextDocument,
+) {
+  return dontWarnOnParams
+    ? clampUnsafePositions(diagnostics.filter(isNotParamError), document)
+    : clampUnsafePositions(diagnostics, document);
+}
+
+export const lintDocument: typeof rawLintDocument = debounce(
+  rawLintDocument,
+  600,
+  {
+    leading: false,
+    trailing: true,
+  },
+);
 
-export const cleanupWorkers = () => {
-  void pool.terminate();
+export const cleanupWorkers = async () => {
+  await pool.terminate();
 };

package/src/server.ts

@@ -1,32 +1,161 @@
+import type {
+  Diagnostic,
+  Hover,
+  HoverParams,
+  InitializeResult,
+  SemanticTokensRegistrationOptions,
+} from 'vscode-languageserver/node';
 import {
   createConnection,
-  Diagnostic,
   DidChangeConfigurationNotification,
-  InitializeResult,
   ProposedFeatures,
-  SemanticTokensRegistrationOptions,
   SemanticTokensRegistrationType,
   TextDocuments,
   TextDocumentSyncKind,
 } from 'vscode-languageserver/node';
 
 import { TextDocument } from 'vscode-languageserver-textdocument';
-
-import { syntaxColouringLegend } from '@neo4j-cypher/language-support';
-import { Neo4jSchemaPoller } from '@neo4j-cypher/schema-poller';
+import type { DbSchema, SymbolTable } from '@neo4j-cypher/language-support';
+import {
+  syntaxHighlightingLegend,
+  CypherLanguageService,
+} from '@neo4j-cypher/language-support';
+import { Neo4jSchemaPoller } from '@neo4j-cypher/query-tools';
 import { doAutoCompletion } from './autocompletion';
+import { formatDocument } from './formatting';
+import { cleanupWorkers, lintDocument, setLintWorker } from './linting';
 import { doSignatureHelp } from './signatureHelp';
-import { applySyntaxColouringForDocument } from './syntaxColouring';
-import { Neo4jSettings } from './types';
+import { highlightSyntaxForDocument } from './syntaxHighlighting';
+import type {
+  LintWorkerSettings,
+  Neo4jConnectionSettings,
+  Neo4jParameters,
+  Neo4jSettings,
+} from './types';
+import workerpool from 'workerpool';
+import type { LintWorker } from '@neo4j-cypher/lint-worker';
+import { convertDbSchema } from '@neo4j-cypher/lint-worker';
+import { join } from 'path';
+import { doHoverInfo } from './hoverInfo.js';
 
-const connection = createConnection(ProposedFeatures.all);
+const defaultWorkerPath: string = join(__dirname, 'lintWorker.cjs');
+let workerPath = defaultWorkerPath;
+export const languageService = new CypherLanguageService({
+  consoleCommandsEnabled: false,
+});
 
-import { cleanupWorkers, lintDocument } from './linting';
+class SymbolFetcher {
+  private processing = false;
+  private nextJob:
+    | {
+        query: string;
+        uri: string;
+        schema: DbSchema;
+      }
+    | undefined;
+  private symbolTablePool = workerpool.pool(defaultWorkerPath, {
+    maxWorkers: 1,
+    workerTerminateTimeout: 0,
+  });
+  private linterVersion: string | undefined;
+
+  public setLintWorker(
+    lintWorkerPath: string | undefined = defaultWorkerPath,
+    linterVersion: string | undefined,
+  ) {
+    this.linterVersion = linterVersion;
+    this.symbolTablePool = workerpool.pool(lintWorkerPath, {
+      maxWorkers: 1,
+      workerTerminateTimeout: 0,
+    });
+  }
+
+  public queueSymbolJob(query: string, uri: string, schema: DbSchema) {
+    this.nextJob = { query, uri, schema };
+    if (!this.processing) {
+      void this.processJobQueue();
+    }
+  }
+
+  private 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()) as unknown as LintWorker;
+        const fixedDbSchema = 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)
+        ) {
+          languageService.setSymbolsInfo(
+            {
+              query,
+              symbolTables: result.symbolTables,
+            },
+            async (symbolTables: SymbolTable[]) =>
+              await connection.sendNotification('symbolTableDone', {
+                symbolTables,
+              }),
+          );
+        }
+      } catch {
+        //eslint-disable-next-line
+        console.log('Symbol table calculation failed');
+      }
+    }
+    this.processing = false;
+  }
+}
+
+const connection = createConnection(ProposedFeatures.all);
+let settings: Neo4jSettings | undefined = undefined;
 
 // Create a simple text document manager.
 const documents: TextDocuments<TextDocument> = new TextDocuments(TextDocument);
+const neo4jSchemaPoller = new Neo4jSchemaPoller();
+const symbolFetcher = new SymbolFetcher();
+
+async function lintSingleDocument(document: TextDocument): Promise<void> {
+  symbolFetcher.queueSymbolJob(
+    document.getText(),
+    document.uri,
+    neo4jSchemaPoller?.metadata?.dbSchema,
+  );
+  if (settings?.features?.linting) {
+    return lintDocument(
+      document,
+      (diagnostics: Diagnostic[]) => {
+        void connection.sendDiagnostics({
+          uri: document.uri,
+          diagnostics,
+        });
+      },
+      async (symbolTables: SymbolTable[]) =>
+        await connection.sendNotification('symbolTableDone', {
+          symbolTables: symbolTables,
+        }),
+      neo4jSchemaPoller,
+    );
+  } else {
+    void connection.sendDiagnostics({
+      uri: document.uri,
+      diagnostics: [],
+    });
+  }
+}
 
-const neo4jSdk = new Neo4jSchemaPoller();
+function relintAllDocuments() {
+  void documents.all().map(lintSingleDocument);
+}
 
 connection.onInitialize(() => {
   const result: InitializeResult = {
@@ -35,11 +164,11 @@ connection.onInitialize(() => {
       // Tell the client what features does the server support
       completionProvider: {
         resolveProvider: false,
-        triggerCharacters: ['.'],
+        triggerCharacters: ['.', ':', '{', '$', ')', ' ', ']', '-', '<'],
       },
       semanticTokensProvider: {
-        documentSelector: null,
-        legend: syntaxColouringLegend,
+        documentSelector: [{ language: 'cypher' }],
+        legend: syntaxHighlightingLegend,
         range: false,
         full: {
           delta: false,
@@ -48,6 +177,8 @@ connection.onInitialize(() => {
       signatureHelpProvider: {
         triggerCharacters: ['(', ',', ')'],
       },
+      hoverProvider: true,
+      documentFormattingProvider: true,
     },
   };
 
@@ -60,8 +191,8 @@ connection.onInitialized(() => {
   });
 
   const registrationOptions: SemanticTokensRegistrationOptions = {
-    documentSelector: null,
-    legend: syntaxColouringLegend,
+    documentSelector: [{ language: 'cypher' }],
+    legend: syntaxHighlightingLegend,
     range: false,
     full: {
       delta: false,
@@ -73,53 +204,107 @@ connection.onInitialized(() => {
   );
 });
 
-documents.onDidChangeContent((change) =>
-  lintDocument(change, (diagnostics: Diagnostic[]) => {
-    void connection.sendDiagnostics({
-      uri: change.document.uri,
-      diagnostics,
-    });
-  }),
-);
+connection.onDidChangeConfiguration((params) => {
+  settings = params.settings?.neo4j as Neo4jSettings;
+  relintAllDocuments();
+});
 
-// Trigger the syntax colouring
-connection.languages.semanticTokens.on(
-  applySyntaxColouringForDocument(documents),
-);
+documents.onDidChangeContent((change) => lintSingleDocument(change.document));
+
+// Trigger the syntax highlighting
+connection.languages.semanticTokens.on(highlightSyntaxForDocument(documents));
 
 // Trigger the signature help, providing info about functions / procedures
-connection.onSignatureHelp(doSignatureHelp(documents, neo4jSdk));
+connection.onSignatureHelp(doSignatureHelp(documents, neo4jSchemaPoller));
 // Trigger the auto completion
-connection.onCompletion(doAutoCompletion(documents, neo4jSdk));
-
-connection.onDidChangeConfiguration(
-  (params: { settings: { neo4j: Neo4jSettings } }) => {
-    neo4jSdk.disconnect();
-
-    const neo4jConfig = params.settings.neo4j;
-    if (
-      neo4jSdk.connection === undefined &&
-      neo4jConfig.connect &&
-      neo4jConfig.password &&
-      neo4jConfig.URL &&
-      neo4jConfig.user
-    ) {
-      void neo4jSdk.persistentConnect(
-        neo4jConfig.URL,
-        {
-          username: neo4jConfig.user,
-          password: neo4jConfig.password,
-        },
-        { appName: 'cypher-language-server' },
-      );
+connection.onCompletion(doAutoCompletion(documents, neo4jSchemaPoller));
+
+connection.onNotification(
+  'updateLintWorker',
+  (linterSettings: LintWorkerSettings) => {
+    const lintWorkerPath = linterSettings.lintWorkerPath;
+    const linterVersion = linterSettings.linterVersion;
+    if (lintWorkerPath !== workerPath) {
+      workerPath = lintWorkerPath;
+      void (async () => {
+        symbolFetcher.setLintWorker(workerPath, linterVersion);
+        await setLintWorker(workerPath, linterVersion);
+        relintAllDocuments();
+      })();
     }
   },
 );
 
+connection.onNotification(
+  'connectionUpdated',
+  (connectionSettings: Neo4jConnectionSettings) => {
+    changeConnection(connectionSettings);
+    neo4jSchemaPoller.events.once('schemaFetched', relintAllDocuments);
+  },
+);
+
+connection.onHover((params: HoverParams): Hover | null => {
+  return doHoverInfo(documents, neo4jSchemaPoller, params);
+});
+
+connection.onNotification(
+  'fetchSymbolTable',
+  (params: {
+    query: string;
+    uri: string;
+    version: number;
+    schema: DbSchema;
+  }) => {
+    neo4jSchemaPoller.events.once('schemaFetched', () =>
+      symbolFetcher.queueSymbolJob(params.query, params.uri, params.schema),
+    );
+  },
+);
+
+connection.onNotification('updateParameters', (parameters: Neo4jParameters) => {
+  neo4jSchemaPoller.setParameters(parameters);
+  relintAllDocuments();
+});
+
+connection.onDocumentFormatting((params) => {
+  return formatDocument(params, documents);
+});
+
+connection.onNotification('connectionDisconnected', () => {
+  disconnect();
+  relintAllDocuments();
+});
+
 documents.listen(connection);
 
 connection.listen();
 
 connection.onExit(() => {
-  cleanupWorkers();
+  void cleanupWorkers();
 });
+
+const changeConnection = (connectionSettings: Neo4jConnectionSettings) => {
+  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();
+};

package/src/signatureHelp.ts

@@ -1,14 +1,14 @@
-import { signatureHelp } from '@neo4j-cypher/language-support';
-import {
+import type {
   SignatureHelp,
   SignatureHelpParams,
   TextDocuments,
 } from 'vscode-languageserver/node';
 
-import { Neo4jSchemaPoller } from '@neo4j-cypher/schema-poller';
-import { TextDocument } from 'vscode-languageserver-textdocument';
+import type { Neo4jSchemaPoller } from '@neo4j-cypher/query-tools';
+import type { TextDocument } from 'vscode-languageserver-textdocument';
+import { languageService } from './server';
 
-export const emptyResult: SignatureHelp = {
+const emptyResult: SignatureHelp = {
   signatures: [],
   activeSignature: undefined,
   activeParameter: undefined,
@@ -26,10 +26,10 @@ export function doSignatureHelp(
     const position = params.position;
     const offset = textDocument.offsetAt(position);
 
-    return signatureHelp(
+    return languageService.getSignatureHelp(
       textDocument.getText(),
       neo4j.metadata?.dbSchema ?? {},
-      offset,
+      { caretPosition: offset },
     );
   };
 }

package/src/{syntaxColouring.ts → syntaxHighlighting.ts}

@@ -1,22 +1,20 @@
-import {
-  applySyntaxColouring,
-  mapCypherToSemanticTokenIndex,
-} from '@neo4j-cypher/language-support';
-import {
-  SemanticTokensBuilder,
+import { mapCypherToSemanticTokenIndex } from '@neo4j-cypher/language-support';
+import type {
   SemanticTokensParams,
   TextDocument,
   TextDocuments,
 } from 'vscode-languageserver';
+import { SemanticTokensBuilder } from 'vscode-languageserver';
+import { languageService } from './server';
 
-export function applySyntaxColouringForDocument(
+export function highlightSyntaxForDocument(
   documents: TextDocuments<TextDocument>,
 ) {
   return (params: SemanticTokensParams) => {
     const textDocument = documents.get(params.textDocument.uri);
     if (textDocument === undefined) return { data: [] };
 
-    const tokens = applySyntaxColouring(textDocument.getText());
+    const tokens = languageService.highlightSyntax(textDocument.getText());
 
     const builder = new SemanticTokensBuilder();