Prototyping a runtime strategy to allow different runtime behaviours in the language server

packages/language-server/src/autocompletion.ts

@@ -7,14 +7,15 @@ import {
 
 import type { CompletionItem } from '@neo4j-cypher/language-support';
 import { autocomplete } from '@neo4j-cypher/language-support';
-import { Neo4jSchemaPoller } from '@neo4j-cypher/schema-poller';
 import { TextDocument } from 'vscode-languageserver-textdocument';
+import { RuntimeStrategy } from './runtime/runtimeStrategy';
 
 export function doAutoCompletion(
   documents: TextDocuments<TextDocument>,
-  neo4j: Neo4jSchemaPoller,
+  runtime: RuntimeStrategy,
 ) {
   return (completionParams: CompletionParams) => {
+    const dbSchema = runtime.getDbSchema();
     const textDocument = documents.get(completionParams.textDocument.uri);
     if (textDocument === undefined) return [];
 
@@ -23,7 +24,7 @@ export function doAutoCompletion(
 
     const completions: CompletionItem[] = autocomplete(
       textDocument.getText(),
-      neo4j.metadata?.dbSchema ?? {},
+      dbSchema,
       offset,
       completionParams.context.triggerKind === CompletionTriggerKind.Invoked,
     );

packages/language-server/src/linting.ts

@@ -1,11 +1,11 @@
 import { validateSyntax } from '@neo4j-cypher/language-support';
-import { Neo4jSchemaPoller } from '@neo4j-cypher/schema-poller';
 import debounce from 'lodash.debounce';
 import { join } from 'path';
 import { Diagnostic, TextDocumentChangeEvent } from 'vscode-languageserver';
 import { TextDocument } from 'vscode-languageserver-textdocument';
 import workerpool from 'workerpool';
 import { LinterTask, LintWorker } from './lintWorker';
+import { RuntimeStrategy } from './runtime/runtimeStrategy';
 
 const pool = workerpool.pool(join(__dirname, 'lintWorker.js'), {
   minWorkers: 2,
@@ -17,8 +17,9 @@ let lastSemanticJob: LinterTask | undefined;
 async function rawLintDocument(
   change: TextDocumentChangeEvent<TextDocument>,
   sendDiagnostics: (diagnostics: Diagnostic[]) => void,
-  neo4j: Neo4jSchemaPoller,
+  runtime: RuntimeStrategy,
 ) {
+  const dbSchema = runtime.getDbSchema();
   const { document } = change;
 
   const query = document.getText();
@@ -27,7 +28,6 @@ async function rawLintDocument(
     return;
   }
 
-  const dbSchema = neo4j.metadata?.dbSchema ?? {};
   const syntaxErrors = validateSyntax(query, dbSchema);
 
   sendDiagnostics(syntaxErrors);

packages/language-server/src/runtime/extensionRuntime.ts

@@ -0,0 +1,17 @@
+import { DbSchema } from '@neo4j-cypher/language-support';
+import { _Connection } from 'vscode-languageserver';
+import { RuntimeStrategy } from './runtimeStrategy';
+
+export class ExtensionRuntime implements RuntimeStrategy {
+  private _dbSchema: DbSchema | undefined;
+
+  constructor(connection: _Connection) {
+    connection.onNotification('schemaFetched', (dbSchema: DbSchema) => {
+      this._dbSchema = dbSchema;
+    });
+  }
+
+  getDbSchema(): DbSchema {
+    return this._dbSchema ?? {};
+  }
+}

packages/language-server/src/runtime/runtimeFactory.ts

@@ -0,0 +1,16 @@
+import { _Connection } from 'vscode-languageserver';
+import { ExtensionRuntime } from './extensionRuntime';
+import { RuntimeStrategy } from './runtimeStrategy';
+import { StandaloneRuntime } from './standaloneRuntime';
+
+export function getRuntime(
+  clientName: string,
+  connection: _Connection,
+): RuntimeStrategy {
+  switch (clientName) {
+    case 'Visual Studio Code':
+      return new ExtensionRuntime(connection);
+    default:
+      return new StandaloneRuntime(connection);
+  }
+}

packages/language-server/src/runtime/runtimeStrategy.ts

@@ -0,0 +1,5 @@
+import { DbSchema } from '@neo4j-cypher/language-support';
+
+export interface RuntimeStrategy {
+  getDbSchema(): DbSchema;
+}

packages/language-server/src/runtime/standaloneRuntime.ts

@@ -0,0 +1,49 @@
+import { DbSchema } from '@neo4j-cypher/language-support';
+import { Neo4jSchemaPoller } from '@neo4j-cypher/schema-poller';
+import { _Connection } from 'vscode-languageserver';
+import { Neo4jSettings } from '../types';
+import { RuntimeStrategy } from './runtimeStrategy';
+
+export class StandaloneRuntime implements RuntimeStrategy {
+  private _schemaPoller: Neo4jSchemaPoller;
+
+  constructor(connection: _Connection) {
+    this._schemaPoller = new Neo4jSchemaPoller();
+
+    connection.onDidChangeConfiguration(
+      (params: { settings: { neo4j: Neo4jSettings } }) => {
+        this.changeConnection(params.settings.neo4j);
+      },
+    );
+  }
+
+  getDbSchema(): DbSchema {
+    return this._schemaPoller.metadata?.dbSchema ?? {};
+  }
+
+  changeConnection(connectionSettings: Neo4jSettings): void {
+    this.disconnect();
+
+    if (
+      this._schemaPoller.connection === undefined &&
+      connectionSettings.connect &&
+      connectionSettings.password &&
+      connectionSettings.connectURL &&
+      connectionSettings.user
+    ) {
+      void this._schemaPoller.persistentConnect(
+        connectionSettings.connectURL,
+        {
+          username: connectionSettings.user,
+          password: connectionSettings.password,
+        },
+        { appName: 'cypher-language-server' },
+        connectionSettings.database,
+      );
+    }
+  }
+
+  disconnect(): void {
+    this._schemaPoller.disconnect();
+  }
+}

packages/language-server/src/server.ts

@@ -2,6 +2,7 @@ import {
   createConnection,
   Diagnostic,
   DidChangeConfigurationNotification,
+  InitializeParams,
   InitializeResult,
   ProposedFeatures,
   SemanticTokensRegistrationOptions,
@@ -13,22 +14,24 @@ import {
 import { TextDocument } from 'vscode-languageserver-textdocument';
 
 import { syntaxColouringLegend } from '@neo4j-cypher/language-support';
-import { Neo4jSchemaPoller } from '@neo4j-cypher/schema-poller';
 import { doAutoCompletion } from './autocompletion';
 import { doSignatureHelp } from './signatureHelp';
 import { applySyntaxColouringForDocument } from './syntaxColouring';
-import { Neo4jSettings } from './types';
 
 const connection = createConnection(ProposedFeatures.all);
 
 import { cleanupWorkers, lintDocument } from './linting';
+import { getRuntime } from './runtime/runtimeFactory';
+import { RuntimeStrategy } from './runtime/runtimeStrategy';
 
 // Create a simple text document manager.
 const documents: TextDocuments<TextDocument> = new TextDocuments(TextDocument);
 
-const neo4jSchemaPoller = new Neo4jSchemaPoller();
+let runtimeStrategy: RuntimeStrategy;
+
+connection.onInitialize((params: InitializeParams): InitializeResult => {
+  runtimeStrategy = getRuntime(params.clientInfo?.name ?? '', connection);
 
-connection.onInitialize(() => {
   const result: InitializeResult = {
     capabilities: {
       textDocumentSync: TextDocumentSyncKind.Full,
@@ -71,72 +74,37 @@ connection.onInitialized(() => {
     SemanticTokensRegistrationType.type,
     registrationOptions,
   );
-});
 
-documents.onDidChangeContent((change) =>
-  lintDocument(
-    change,
-    (diagnostics: Diagnostic[]) => {
-      void connection.sendDiagnostics({
-        uri: change.document.uri,
-        diagnostics,
-      });
-    },
-    neo4jSchemaPoller,
-  ),
-);
-
-// Trigger the syntax colouring
-connection.languages.semanticTokens.on(
-  applySyntaxColouringForDocument(documents),
-);
-
-// Trigger the signature help, providing info about functions / procedures
-connection.onSignatureHelp(doSignatureHelp(documents, neo4jSchemaPoller));
-// Trigger the auto completion
-connection.onCompletion(doAutoCompletion(documents, neo4jSchemaPoller));
-
-connection.onNotification(
-  'connectionUpdated',
-  (connectionSettings: Neo4jSettings) => {
-    changeConnection(connectionSettings);
-  },
-);
-
-connection.onNotification('connectionDisconnected', () => {
-  disconnect();
-});
+  // Trigger linting
+  documents.onDidChangeContent((change) =>
+    lintDocument(
+      change,
+      (diagnostics: Diagnostic[]) => {
+        void connection.sendDiagnostics({
+          uri: change.document.uri,
+          diagnostics,
+        });
+      },
+      runtimeStrategy,
+    ),
+  );
+
+  // Trigger the signature help, providing info about functions / procedures
+  connection.onSignatureHelp(doSignatureHelp(documents, runtimeStrategy));
 
-documents.listen(connection);
+  // Trigger the auto completion
+  connection.onCompletion(doAutoCompletion(documents, runtimeStrategy));
+
+  // Trigger the syntax colouring
+  connection.languages.semanticTokens.on(
+    applySyntaxColouringForDocument(documents),
+  );
+
+  documents.listen(connection);
+});
 
 connection.listen();
 
 connection.onExit(() => {
   cleanupWorkers();
 });
-
-const changeConnection = (connectionSettings: Neo4jSettings) => {
-  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();
-};

packages/language-server/src/signatureHelp.ts

@@ -5,8 +5,8 @@ import {
   TextDocuments,
 } from 'vscode-languageserver/node';
 
-import { Neo4jSchemaPoller } from '@neo4j-cypher/schema-poller';
 import { TextDocument } from 'vscode-languageserver-textdocument';
+import { RuntimeStrategy } from './runtime/runtimeStrategy';
 
 export const emptyResult: SignatureHelp = {
   signatures: [],
@@ -16,20 +16,17 @@ export const emptyResult: SignatureHelp = {
 
 export function doSignatureHelp(
   documents: TextDocuments<TextDocument>,
-  neo4j: Neo4jSchemaPoller,
+  runtime: RuntimeStrategy,
 ) {
   return (params: SignatureHelpParams) => {
+    const dbSchema = runtime.getDbSchema();
     const textDocument = documents.get(params.textDocument.uri);
     const endOfTriggerHelp = params.context?.triggerCharacter === ')';
     if (textDocument === undefined || endOfTriggerHelp) return emptyResult;
 
     const position = params.position;
     const offset = textDocument.offsetAt(position);
 
-    return signatureHelp(
-      textDocument.getText(),
-      neo4j.metadata?.dbSchema ?? {},
-      offset,
-    );
+    return signatureHelp(textDocument.getText(), dbSchema, offset);
   };
 }

packages/schema-poller/src/index.ts

@@ -1,6 +1,6 @@
 export { FRIENDLY_ERROR_MESSAGES } from './connectionErrorHandler';
 export type { ConnectionError } from './connectionErrorHandler';
-export type { MetadataPoller } from './metadataPoller';
+export { MetadataPoller } from './metadataPoller';
 export type { Neo4jConnection } from './neo4jConnection';
 export type { Database } from './queries/databases';
 export { Neo4jSchemaPoller } from './schemaPoller';

packages/vscode-extension/e2e_tests/mocks/mockLanguageClient.ts

@@ -1,12 +1,11 @@
-import { Neo4jSettings } from '@neo4j-cypher/language-server/src/types';
+import { DbSchema } from '@neo4j-cypher/language-support/dist/types';
 
 export class MockLanguageClient {
   async sendNotification(
     methodName: string,
-    settings?: Neo4jSettings,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    dbSchema?: DbSchema,
   ): Promise<void> {
-    await Promise.resolve(
-      `sending notification using ${methodName} with ${settings?.connectURL}, ${settings?.connect}, ${settings?.database}, ${settings?.password}, ${settings?.trace.server}, ${settings?.user}`,
-    );
+    await Promise.resolve(`sending notification using ${methodName}`);
   }
 }