port autocomplete direct commands and browser-runtime-core

Author: lerouxb

packages/autocomplete/src/direct-command-completer.ts

@@ -0,0 +1,52 @@
+import type { AutocompletionContext } from '@mongodb-js/mongodb-ts-autocomplete';
+import type { TypeSignature } from '@mongosh/shell-api';
+import { signatures as shellSignatures } from '@mongosh/shell-api';
+
+type TypeSignatureAttributes = { [key: string]: TypeSignature };
+
+export async function directCommandCompleter(
+  context: AutocompletionContext,
+  line: string
+): Promise<string[]> {
+  const SHELL_COMPLETIONS = shellSignatures.ShellApi
+    .attributes as TypeSignatureAttributes;
+
+  // Split at space-to-non-space transitions when looking at this as a command,
+  // because multiple spaces (e.g. 'show  collections') are valid in commands.
+  // This split keeps the spaces intact so we can join them back later.
+  const splitLineWhitespace = line.split(/(?<!\S)(?=\S)/);
+  const command = splitLineWhitespace[0].trim();
+  if (!SHELL_COMPLETIONS[command]?.isDirectShellCommand) {
+    return [];
+  }
+
+  // If the shell API provides us with a completer, use it.
+  // examples: use, show, snippet
+  const completer = SHELL_COMPLETIONS[command].newShellCommandCompleter;
+  if (!completer) {
+    // examples without a custom completer: exit, quit, it, cls
+    return [line];
+  }
+
+  if (splitLineWhitespace.length === 1) {
+    if (splitLineWhitespace[0].trimEnd() === splitLineWhitespace[0]) {
+      // Treat e.g. 'show' like 'show '.
+      splitLineWhitespace[0] += ' ';
+    }
+
+    // Complete the first argument after the command.
+    splitLineWhitespace.push('');
+  }
+  const hits =
+    (await completer(
+      context,
+      splitLineWhitespace.map((item) => item.trim())
+    )) || [];
+  // Adjust to full input, because `completer` only completed the last item
+  // in the line, e.g. ['profile'] -> ['show profile']
+  const fullLineHits = hits.map((hit) =>
+    [...splitLineWhitespace.slice(0, -1), hit].join('')
+  );
+
+  return fullLineHits;
+}

packages/autocomplete/src/index.ts

@@ -1,5 +1,6 @@
 import type { Topologies, TypeSignature } from '@mongosh/shell-api';
 import { signatures as shellSignatures } from '@mongosh/shell-api';
+import type { AutocompletionContext } from '@mongodb-js/mongodb-ts-autocomplete';
 import semver from 'semver';
 import {
   CONVERSION_OPERATORS,
@@ -13,6 +14,7 @@ import {
   ON_PREM,
   DATABASE,
 } from '@mongodb-js/mongodb-constants';
+import { directCommandCompleter } from './direct-command-completer';
 
 type TypeSignatureAttributes = { [key: string]: TypeSignature };
 
@@ -78,7 +80,7 @@ const GROUP = '$group';
  *
  * @returns {array} Matching Completions, Current User Input.
  */
-async function completer(
+export async function completer(
   params: AutocompleteParameters,
   line: string
 ): Promise<[string[], string, 'exclusive'] | [string[], string]> {
@@ -398,4 +400,51 @@ function filterShellAPI(
   return hits;
 }
 
-export default completer;
+type AutocompleteShellInstanceState = {
+  getAutocompleteParameters: () => AutocompleteParameters;
+  getAutocompletionContext: () => AutocompletionContext;
+};
+
+function transformAutocompleteResults(
+  line: string,
+  results: { result: string }[]
+): [string[], string] {
+  return [results.map((result) => result.result), line];
+}
+
+export type CompletionResults =
+  | [string[], string, 'exclusive']
+  | [string[], string];
+
+export async function initNewAutocompleter(
+  instanceState: Pick<
+    AutocompleteShellInstanceState,
+    'getAutocompletionContext'
+  >
+): Promise<(text: string) => Promise<CompletionResults>> {
+  // only import the autocompleter code the first time we need it to
+  // hide the time it takes from the initial startup time
+  const { MongoDBAutocompleter } = await import(
+    '@mongodb-js/mongodb-ts-autocomplete'
+  );
+
+  const autocompletionContext = instanceState.getAutocompletionContext();
+  const mongoDBCompleter = new MongoDBAutocompleter({
+    context: autocompletionContext,
+  });
+
+  return async (text: string): Promise<CompletionResults> => {
+    const directResults = await directCommandCompleter(
+      autocompletionContext,
+      text
+    );
+
+    if (directResults.length) {
+      return [directResults, text, 'exclusive'];
+    }
+
+    const results = await mongoDBCompleter.autocomplete(text);
+    const transformed = transformAutocompleteResults(text, results);
+    return transformed;
+  };
+}

packages/browser-runtime-core/src/autocompleter/shell-api-autocompleter.spec.ts

@@ -1,8 +1,10 @@
 import { ShellApiAutocompleter } from './shell-api-autocompleter';
 import { expect } from 'chai';
 import { Topologies } from '@mongosh/shell-api';
+import type { AutocompleteParameters } from '@mongosh/autocomplete';
+import type { AutocompletionContext } from '@mongodb-js/mongodb-ts-autocomplete';
 
-const standalone440 = {
+const standalone440Parameters: AutocompleteParameters = {
   topology: () => Topologies.Standalone,
   apiVersionInfo: () => undefined,
   connectionInfo: () => ({
@@ -11,16 +13,40 @@ const standalone440 = {
     server_version: '4.4.0',
     is_local_atlas: false,
   }),
-  getCollectionCompletionsForCurrentDb: () => ['bananas'],
-  getDatabaseCompletions: () => ['databaseOne'],
+  getCollectionCompletionsForCurrentDb: () => Promise.resolve(['bananas']),
+  getDatabaseCompletions: () => Promise.resolve(['databaseOne']),
+};
+
+const standalone440Context: AutocompletionContext = {
+  currentDatabaseAndConnection: () => ({
+    connectionId: 'connection-1',
+    databaseName: 'databaseOne',
+  }),
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  databasesForConnection: (connectionId: string) =>
+    Promise.resolve(['databaseOne']),
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  collectionsForDatabase: (connectionId: string, dtabaseName: string) =>
+    Promise.resolve(['bananas', 'coll1']),
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  schemaInformationForCollection: (
+    connectionId: string,
+    databaseName: string,
+    collectionName: string
+  ) => Promise.resolve({}),
+};
+
+const shellInstanceState = {
+  getAutocompleteParameters: () => standalone440Parameters,
+  getAutocompletionContext: () => standalone440Context,
 };
 
 describe('Autocompleter', function () {
   describe('getCompletions', function () {
     let autocompleter: ShellApiAutocompleter;
 
     beforeEach(function () {
-      autocompleter = new ShellApiAutocompleter(standalone440);
+      autocompleter = new ShellApiAutocompleter(shellInstanceState);
     });
 
     it('returns completions for text before cursor', async function () {

packages/browser-runtime-core/src/autocompleter/shell-api-autocompleter.ts

@@ -1,20 +1,52 @@
-import type { AutocompleteParameters } from '@mongosh/autocomplete';
-import cliReplCompleter from '@mongosh/autocomplete';
+import type { AutocompletionContext } from '@mongodb-js/mongodb-ts-autocomplete';
+import type {
+  AutocompleteParameters,
+  CompletionResults,
+} from '@mongosh/autocomplete';
+import { completer, initNewAutocompleter } from '@mongosh/autocomplete';
 import type { Autocompleter, Completion } from './autocompleter';
 
+type AutocompleteShellInstanceState = {
+  getAutocompleteParameters: () => AutocompleteParameters;
+  getAutocompletionContext: () => AutocompletionContext;
+};
+
 export class ShellApiAutocompleter implements Autocompleter {
-  private parameters: AutocompleteParameters;
+  private shellInstanceState: AutocompleteShellInstanceState;
+
+  // old autocomplete only:
+  private parameters: AutocompleteParameters | undefined;
+
+  // new autocomplete only:
+  private newMongoshCompleter:
+    | ((line: string) => Promise<CompletionResults>)
+    | undefined;
 
-  constructor(parameters: AutocompleteParameters) {
-    this.parameters = parameters;
+  constructor(shellInstanceState: AutocompleteShellInstanceState) {
+    this.shellInstanceState = shellInstanceState;
   }
 
   async getCompletions(code: string): Promise<Completion[]> {
     if (!code) {
       return [];
     }
 
-    const completions = await cliReplCompleter(this.parameters, code);
+    let completions: CompletionResults;
+
+    if (process.env.USE_NEW_AUTOCOMPLETE) {
+      if (!this.newMongoshCompleter) {
+        this.newMongoshCompleter = await initNewAutocompleter(
+          this.shellInstanceState
+        );
+      }
+
+      completions = await this.newMongoshCompleter(code);
+    } else {
+      if (!this.parameters) {
+        this.parameters = this.shellInstanceState.getAutocompleteParameters();
+      }
+      completions = await completer(this.parameters, code);
+    }
 
     if (!completions || !completions.length) {
       return [];

packages/browser-runtime-core/src/open-context-runtime.ts

@@ -29,7 +29,6 @@ export interface InterpreterEnvironment {
  */
 export class OpenContextRuntime implements Runtime {
   private interpreterEnvironment: InterpreterEnvironment;
-  // TODO(MONGOSH-2205): we have to also port this to the new autocomplete
   private autocompleter: ShellApiAutocompleter | null = null;
   private shellEvaluator: ShellEvaluator;
   private instanceState: ShellInstanceState;
@@ -53,9 +52,7 @@ export class OpenContextRuntime implements Runtime {
 
   async getCompletions(code: string): Promise<Completion[]> {
     if (!this.autocompleter) {
-      this.autocompleter = new ShellApiAutocompleter(
-        this.instanceState.getAutocompleteParameters()
-      );
+      this.autocompleter = new ShellApiAutocompleter(this.instanceState);
       this.updatedConnectionInfoPromise ??=
         this.instanceState.fetchConnectionInfo();
       await this.updatedConnectionInfoPromise;

packages/cli-repl/src/cli-repl.spec.ts

@@ -2620,11 +2620,6 @@ describe('CliRepl', function () {
       });
 
       it('completes shell commands', async function () {
-        if (process.env.USE_NEW_AUTOCOMPLETE) {
-          // TODO(MONGOSH-2035): not supported yet
-          this.skip();
-        }
-
         input.write('const dSomeVariableStartingWithD = 10;\n');
         await waitEval(cliRepl.bus);
 
@@ -2636,11 +2631,6 @@ describe('CliRepl', function () {
       });
 
       it('completes use <db>', async function () {
-        if (process.env.USE_NEW_AUTOCOMPLETE) {
-          // TODO(MONGOSH-2035): not supported yet
-          this.skip();
-        }
-
         if (!hasDatabaseNames) return this.skip();
         input.write('db.getMongo()._listDatabases()\n'); // populate database cache
         await waitEval(cliRepl.bus);

packages/cli-repl/src/mongosh-repl.ts

@@ -1,4 +1,5 @@
-import completer from '@mongosh/autocomplete';
+import type { CompletionResults } from '@mongosh/autocomplete';
+import { completer, initNewAutocompleter } from '@mongosh/autocomplete';
 import { MongoshInternalError, MongoshWarning } from '@mongosh/errors';
 import { changeHistory } from '@mongosh/history';
 import type {
@@ -49,8 +50,6 @@ import { Script, createContext, runInContext } from 'vm';
 import { installPasteSupport } from './repl-paste-support';
 import util from 'util';
 
-import type { MongoDBAutocompleter } from '@mongodb-js/mongodb-ts-autocomplete';
-
 declare const __non_webpack_require__: any;
 
 /**
@@ -133,13 +132,6 @@ type Mutable<T> = {
   -readonly [P in keyof T]: T[P];
 };
 
-function transformAutocompleteResults(
-  line: string,
-  results: { result: string }[]
-): [string[], string] {
-  return [results.map((result) => result.result), line];
-}
-
 /**
  * An instance of a `mongosh` REPL, without any of the actual I/O.
  * Specifically, code called by this class should not do any
@@ -440,18 +432,14 @@ class MongoshNodeRepl implements EvaluationListener {
 
     const origReplCompleter = promisify(repl.completer.bind(repl)); // repl.completer is callback-style
 
-    let newMongoshCompleter: MongoDBAutocompleter | undefined;
-    let oldMongoshCompleter: (
-      line: string
-    ) => Promise<[string[], string, 'exclusive'] | [string[], string]>;
+    let newMongoshCompleter: (line: string) => Promise<CompletionResults>;
+    let oldMongoshCompleter: (line: string) => Promise<CompletionResults>;
 
     if (process.env.USE_NEW_AUTOCOMPLETE) {
       // we will lazily instantiate the new autocompleter on first use
     } else {
-      oldMongoshCompleter = completer.bind(
-        null,
-        instanceState.getAutocompleteParameters()
-      );
+      const autocompleteParams = instanceState.getAutocompleteParameters();
+      oldMongoshCompleter = completer.bind(null, autocompleteParams);
     }
 
     const innerCompleter = async (
@@ -469,22 +457,10 @@ class MongoshNodeRepl implements EvaluationListener {
         (async () => {
           if (process.env.USE_NEW_AUTOCOMPLETE) {
             if (!newMongoshCompleter) {
-              // only import the autocompleter code the first time we need it to
-              // hide the time it takes from the initial startup time
-              const { MongoDBAutocompleter } = await import(
-                '@mongodb-js/mongodb-ts-autocomplete'
-              );
-
-              const autocompletionContext =
-                instanceState.getAutocompletionContext();
-              newMongoshCompleter = new MongoDBAutocompleter({
-                context: autocompletionContext,
-              });
+              newMongoshCompleter = await initNewAutocompleter(instanceState);
             }
 
-            const results = await newMongoshCompleter.autocomplete(text);
-            const transformed = transformAutocompleteResults(text, results);
-            return transformed;
+            return newMongoshCompleter(text);
           } else {
             return oldMongoshCompleter(text);
           }