feat: clear completions cache on Refresh action on the sidebar VSCODE-408 (#517)

* feat: clear completions cache on Refresh action on the sidebar VSCODE-408

* refactor: use async await

* refactor: reuse ClearCompletionsCache type

Author: alenakhineika

src/language/languageServerController.ts

@@ -1,23 +1,27 @@
 import * as vscode from 'vscode';
 import * as path from 'path';
 import type { MongoClientOptions } from 'mongodb';
-import {
-  LanguageClient,
+import type {
   LanguageClientOptions,
   ServerOptions,
+} from 'vscode-languageclient/node';
+import {
+  LanguageClient,
   TransportKind,
   CancellationTokenSource,
 } from 'vscode-languageclient/node';
-import { workspace, ExtensionContext } from 'vscode';
+import type { ExtensionContext } from 'vscode';
+import { workspace } from 'vscode';
 
 import { createLogger } from '../logging';
-import {
+import type {
   PlaygroundEvaluateParams,
   ShellEvaluateResult,
   ExportToLanguageMode,
   ExportToLanguageNamespace,
   PlaygroundTextAndSelection,
 } from '../types/playgroundType';
+import type { ClearCompletionsCache } from '../types/completionsCache';
 import { ServerCommands } from './serverCommands';
 
 const log = createLogger('language server controller');
@@ -185,6 +189,13 @@ export default class LanguageServerController {
     );
   }
 
+  async resetCache(clear: ClearCompletionsCache): Promise<void> {
+    await this._client.sendRequest(
+      ServerCommands.CLEAR_CACHED_COMPLETIONS,
+      clear
+    );
+  }
+
   cancelAll(): void {
     // Send a request for cancellation. As a result
     // the associated CancellationToken will be notified of the cancellation,

src/language/mongoDBService.ts

@@ -33,6 +33,7 @@ import type {
   PlaygroundTextAndSelection,
   MongoClientOptions,
 } from '../types/playgroundType';
+import type { ClearCompletionsCache } from '../types/completionsCache';
 import { Visitor } from './visitor';
 import type { CompletionState } from './visitor';
 
@@ -134,10 +135,11 @@ export default class MongoDBService {
    * Disconnect from CliServiceProvider.
    */
   async disconnectFromServiceProvider(): Promise<void> {
-    this._clearCachedDatabases();
-    this._clearCachedCollections();
-    this._clearCachedFields();
-
+    this.clearCachedCompletions({
+      databases: true,
+      collections: true,
+      fields: true,
+    });
     await this._clearCurrentConnection();
   }
 
@@ -148,7 +150,7 @@ export default class MongoDBService {
     params: PlaygroundEvaluateParams,
     token: CancellationToken
   ): Promise<ShellEvaluateResult | undefined> {
-    this._clearCachedFields();
+    this.clearCachedFields();
 
     return new Promise((resolve) => {
       if (this._connectionId !== params.connectionId) {
@@ -511,7 +513,7 @@ export default class MongoDBService {
         );
 
         // Create and cache field completion items.
-        this._cacheFields(namespace, schemaFields);
+        this.cacheFields(namespace, schemaFields);
       }
     }
   }
@@ -1021,7 +1023,7 @@ export default class MongoDBService {
   /**
    * Convert schema field names to Completion Items and cache them.
    */
-  _cacheFields(namespace: string, fields: string[]): void {
+  cacheFields(namespace: string, fields: string[]): void {
     if (namespace) {
       this._fields[namespace] = fields ? fields : [];
     }
@@ -1045,15 +1047,15 @@ export default class MongoDBService {
     this._collections[database] = collections.map((item) => item.name);
   }
 
-  _clearCachedFields(): void {
+  clearCachedFields(): void {
     this._fields = {};
   }
 
-  _clearCachedDatabases(): void {
+  clearCachedDatabases(): void {
     this._databaseCompletionItems = [];
   }
 
-  _clearCachedCollections(): void {
+  clearCachedCollections(): void {
     this._collections = {};
   }
 
@@ -1068,4 +1070,16 @@ export default class MongoDBService {
       await serviceProvider.close(true);
     }
   }
+
+  clearCachedCompletions(clear: ClearCompletionsCache): void {
+    if (clear.fields) {
+      this._fields = {};
+    }
+    if (clear.databases) {
+      this._databaseCompletionItems = [];
+    }
+    if (clear.collections) {
+      this._collections = {};
+    }
+  }
 }

src/language/server.ts

@@ -1,24 +1,26 @@
+import type {
+  InitializeParams,
+  CompletionItem,
+  TextDocumentPositionParams,
+  Connection,
+} from 'vscode-languageserver/node';
 import {
   createConnection,
   TextDocuments,
   ProposedFeatures,
-  InitializeParams,
   DidChangeConfigurationNotification,
-  CompletionItem,
-  TextDocumentPositionParams,
   RequestType,
   TextDocumentSyncKind,
-  Connection,
 } from 'vscode-languageserver/node';
 import { TextDocument } from 'vscode-languageserver-textdocument';
 
 import MongoDBService from './mongoDBService';
-
 import { ServerCommands } from './serverCommands';
-import {
+import type {
   PlaygroundEvaluateParams,
   PlaygroundTextAndSelection,
 } from '../types/playgroundType';
+import type { ClearCompletionsCache } from '../types/completionsCache';
 
 // Create a connection for the server. The connection uses Node's IPC as a transport.
 // Also include all preview / proposed LSP features.
@@ -180,7 +182,7 @@ connection.onRequest(ServerCommands.DISCONNECT_TO_SERVICE_PROVIDER, () => {
 connection.onRequest(
   ServerCommands.UPDATE_CURRENT_SESSION_FIELDS,
   ({ namespace, schemaFields }) => {
-    return mongoDBService._cacheFields(namespace, schemaFields);
+    return mongoDBService.cacheFields(namespace, schemaFields);
   }
 );
 
@@ -200,6 +202,14 @@ connection.onRequest(
   }
 );
 
+// Clear cached completions by provided cache names.
+connection.onRequest(
+  ServerCommands.CLEAR_CACHED_COMPLETIONS,
+  (clear: ClearCompletionsCache) => {
+    return mongoDBService.clearCachedCompletions(clear);
+  }
+);
+
 // Provide MongoDB completion items.
 connection.onCompletion((params: TextDocumentPositionParams) => {
   const document = documents.get(params.textDocument.uri);

src/language/serverCommands.ts

@@ -9,6 +9,7 @@ export enum ServerCommands {
   GET_NAMESPACE_FOR_SELECTION = 'GET_NAMESPACE_FOR_SELECTION',
   GET_EXPORT_TO_LANGUAGE_MODE = 'GET_EXPORT_TO_LANGUAGE_MODE',
   UPDATE_CURRENT_SESSION_FIELDS = 'UPDATE_CURRENT_SESSION_FIELDS',
+  CLEAR_CACHED_COMPLETIONS = 'CLEAR_CACHED_COMPLETIONS',
 }
 
 export type PlaygroundRunParameters = {

src/mdbExtensionController.ts

@@ -306,11 +306,16 @@ export default class MDBExtensionController implements vscode.Disposable {
     );
     this.registerCommand(
       EXTENSION_COMMANDS.MDB_REFRESH_CONNECTION,
-      (connectionTreeItem: ConnectionTreeItem): Promise<boolean> => {
+      async (connectionTreeItem: ConnectionTreeItem): Promise<boolean> => {
         connectionTreeItem.resetCache();
         this._explorerController.refresh();
+        await this._languageServerController.resetCache({
+          databases: true,
+          collections: true,
+          fields: true,
+        });
 
-        return Promise.resolve(true);
+        return true;
       }
     );
     this.registerCommand(
@@ -410,11 +415,15 @@ export default class MDBExtensionController implements vscode.Disposable {
     );
     this.registerCommand(
       EXTENSION_COMMANDS.MDB_REFRESH_DATABASE,
-      (databaseTreeItem: DatabaseTreeItem): Promise<boolean> => {
+      async (databaseTreeItem: DatabaseTreeItem): Promise<boolean> => {
         databaseTreeItem.resetCache();
         this._explorerController.refresh();
+        await this._languageServerController.resetCache({
+          collections: true,
+          fields: true,
+        });
 
-        return Promise.resolve(true);
+        return true;
       }
     );
     this.registerCommand(
@@ -473,11 +482,12 @@ export default class MDBExtensionController implements vscode.Disposable {
     );
     this.registerCommand(
       EXTENSION_COMMANDS.MDB_REFRESH_COLLECTION,
-      (collectionTreeItem: CollectionTreeItem): Promise<boolean> => {
+      async (collectionTreeItem: CollectionTreeItem): Promise<boolean> => {
         collectionTreeItem.resetCache();
         this._explorerController.refresh();
+        await this._languageServerController.resetCache({ fields: true });
 
-        return Promise.resolve(true);
+        return true;
       }
     );
     this.registerCommand(
@@ -505,8 +515,9 @@ export default class MDBExtensionController implements vscode.Disposable {
       async (documentsListTreeItem: DocumentListTreeItem): Promise<boolean> => {
         await documentsListTreeItem.resetCache();
         this._explorerController.refresh();
+        await this._languageServerController.resetCache({ fields: true });
 
-        return Promise.resolve(true);
+        return true;
       }
     );
     this.registerCommand(
@@ -522,11 +533,12 @@ export default class MDBExtensionController implements vscode.Disposable {
     );
     this.registerCommand(
       EXTENSION_COMMANDS.MDB_REFRESH_SCHEMA,
-      (schemaTreeItem: SchemaTreeItem): Promise<boolean> => {
+      async (schemaTreeItem: SchemaTreeItem): Promise<boolean> => {
         schemaTreeItem.resetCache();
         this._explorerController.refresh();
+        await this._languageServerController.resetCache({ fields: true });
 
-        return Promise.resolve(true);
+        return true;
       }
     );
     this.registerCommand(