feat: initial feature-flagged, new autocompleter MONGOSH-2036

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

@@ -49,6 +49,8 @@ import { Script, createContext, runInContext } from 'vm';
 import { installPasteSupport } from './repl-paste-support';
 import util from 'util';
 
+import { MongoDBAutocompleter } from '@mongodb-js/mongodb-ts-autocomplete';
+
 declare const __non_webpack_require__: any;
 
 /**
@@ -131,6 +133,53 @@ type Mutable<T> = {
   -readonly [P in keyof T]: T[P];
 };
 
+function filterStartingWith({
+  kind,
+  name,
+  trigger,
+}: {
+  kind: string;
+  name: string;
+  trigger: string;
+}): boolean {
+  name = name.toLocaleLowerCase();
+  trigger = trigger.toLocaleLowerCase();
+
+  /*
+  1. If the trigger was blank and the kind is not property/method filter out the
+     result. This way if you autocomplete db.test.find({ you don't get all the
+     global variables, just the known collection field names and mql but you can
+     still autocomplete global variables and functions if you type part of the
+     name.
+  2. Don't filter out exact matches (where filter === name) so that we match the
+     behaviour of the node completer.
+  3. Make sure the name starts with the trigger, otherwise it will return every
+     possible property/name that's available at that level. ie. all the "peer"
+     properties of the things that match.
+  */
+  //console.log(name, kind);
+  // TODO: This can be improved further if we first see if there are any
+  // property/method kind completions and then just use those, then if there
+  // aren't return all completions. The reason is that db.test.find({m makes it
+  // through this filter and then you get all globals starting with m anyway.
+  // But to properly solve it we need more context. ie. if you're after { (ie.
+  // inside an object literal) and you're to the left of a : (or there isn't
+  // one) then you probably don't want globals regardless. If you're to the
+  // right of a : it is probably fine because you could be using a variable.
+  return (
+    (trigger !== '' || kind === 'property' || kind === 'method') &&
+    name.startsWith(trigger)
+  );
+}
+
+function transformAutocompleteResults(
+  line: string,
+  results: { result: string }[]
+): [string[], string] | [string[], string, 'exclusive'] {
+  // TODO: actually use 'exclusive' when we should
+  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
@@ -430,10 +479,22 @@ class MongoshNodeRepl implements EvaluationListener {
     this.outputFinishString += installPasteSupport(repl);
 
     const origReplCompleter = promisify(repl.completer.bind(repl)); // repl.completer is callback-style
-    const mongoshCompleter = completer.bind(
-      null,
-      instanceState.getAutocompleteParameters()
-    );
+    let newMongoshCompleter: MongoDBAutocompleter;
+    let oldMongoshCompleter: (
+      line: string
+    ) => Promise<[string[], string, 'exclusive'] | [string[], string]>;
+    if (process.env.USE_NEW_AUTOCOMPLETE) {
+      const autocompletionContext = instanceState.getAutocompletionContext();
+      newMongoshCompleter = new MongoDBAutocompleter({
+        context: autocompletionContext,
+        autocompleterOptions: { filter: filterStartingWith },
+      });
+    } else {
+      oldMongoshCompleter = completer.bind(
+        null,
+        instanceState.getAutocompleteParameters()
+      );
+    }
     const innerCompleter = async (
       text: string
     ): Promise<[string[], string]> => {
@@ -442,8 +503,19 @@ class MongoshNodeRepl implements EvaluationListener {
         [replResults, replOrig],
         [mongoshResults, , mongoshResultsExclusive],
       ] = await Promise.all([
-        (async () => (await origReplCompleter(text)) || [[]])(),
-        (async () => await mongoshCompleter(text))(),
+        (async () => {
+          const nodeResults = (await origReplCompleter(text)) || [[]];
+          return nodeResults;
+        })(),
+        (async () => {
+          if (process.env.USE_NEW_AUTOCOMPLETE) {
+            const results = await newMongoshCompleter.autocomplete(text);
+            const transformed = transformAutocompleteResults(text, results);
+            return transformed;
+          } else {
+            return oldMongoshCompleter(text);
+          }
+        })(),
       ]);
       this.bus.emit('mongosh:autocompletion-complete'); // For testing.
 

packages/shell-api/package.json

@@ -45,7 +45,8 @@
     "@mongosh/history": "2.4.6",
     "@mongosh/i18n": "2.9.1",
     "@mongosh/service-provider-core": "3.1.0",
-    "mongodb-redact": "^1.1.5"
+    "mongodb-redact": "^1.1.5",
+    "mongodb-schema": "^12.5.2"
   },
   "devDependencies": {
     "@mongodb-js/eslint-config-mongosh": "^1.0.0",

packages/shell-api/src/collection.ts

@@ -100,6 +100,7 @@ export default class Collection extends ShellApiWithMongoClass {
   _mongo: Mongo;
   _database: Database;
   _name: string;
+  _cachedSampleDocs: Document[] = [];
   constructor(mongo: Mongo, database: Database, name: string) {
     super();
     this._mongo = mongo;
@@ -2497,6 +2498,29 @@ export default class Collection extends ShellApiWithMongoClass {
       definition
     );
   }
+
+  async _getSampleDocs(): Promise<Document[]> {
+    this._cachedSampleDocs = await (await this.aggregate([])).toArray();
+    return this._cachedSampleDocs;
+  }
+
+  async _getSampleDocsForCompletion(): Promise<Document[]> {
+    return await Promise.race([
+      (async () => {
+        return await this._getSampleDocs();
+      })(),
+      (async () => {
+        // 200ms should be a good compromise between giving the server a chance
+        // to reply and responsiveness for human perception. It's not the end
+        // of the world if we end up using the cached results; usually, they
+        // are not going to differ from fresh ones, and even if they do, a
+        // subsequent autocompletion request will almost certainly have at least
+        // the new cached results.
+        await new Promise((resolve) => setTimeout(resolve, 200)?.unref?.());
+        return this._cachedSampleDocs;
+      })(),
+    ]);
+  }
 }
 
 export type GetShardDistributionResult = {