pass in an optional fallback servicesHost from tests

Author: lerouxb

packages/mongodb-ts-autocomplete/src/autocompleter.spec.ts

@@ -1,3 +1,4 @@
+import * as ts from 'typescript';
 import { MongoDBAutocompleter } from './index';
 import type { AutocompletionContext } from './autocompletion-context';
 import { analyzeDocuments } from 'mongodb-schema';
@@ -14,17 +15,67 @@ const connectionId = 'connection-1';
 const databaseName = "my-'\ndatabaseName";
 const collectionName = "my-'\ncollectionName";
 
+type EncounteredPaths = {
+  getScriptSnapshot: string[];
+  fileExists: string[];
+  readFile: string[];
+};
+
 describe('MongoDBAutocompleter', function () {
+  let fallbackServiceHost: ts.LanguageServiceHost;
   let autocompleterContext: AutocompletionContext;
   let autocompleter: MongoDBAutocompleter;
-
-  before(function () {
-    // make sure that we fall back to the default ts.sys file methods so that
-    // encounteredPaths will be filled
-    process.env.CI = 'true';
-  });
+  let encounteredPaths: EncounteredPaths;
 
   beforeEach(function () {
+    encounteredPaths = {
+      getScriptSnapshot: [],
+      fileExists: [],
+      readFile: [],
+    };
+
+    fallbackServiceHost = {
+      // most of these are required by the type, but we won't be using them
+      getDefaultLibFileName: (options) => {
+        return ts.getDefaultLibFilePath(options);
+      },
+      getScriptFileNames: () => [],
+      getScriptVersion: () => '1',
+      getCurrentDirectory: () => process.cwd(),
+      getCompilationSettings: () => ({}),
+
+      // these we'll call as fallbacks
+      getScriptSnapshot: (fileName) => {
+        const result = ts.ScriptSnapshot.fromString(
+          // NOTE: some files do not exist. A good example is "typescript/lib/es2023.ts"
+          ts.sys.readFile(fileName) || '',
+        );
+
+        encounteredPaths.getScriptSnapshot.push(fileName);
+        return result;
+      },
+      fileExists: (fileName: string) => {
+        const result = ts.sys.fileExists(fileName);
+        if (result) {
+          encounteredPaths.fileExists.push(fileName);
+        }
+        return result;
+      },
+      readFile: (fileName: string) => {
+        const result = ts.sys.readFile(fileName);
+        encounteredPaths.readFile.push(fileName);
+        return result;
+      },
+      readDirectory: (...args) => {
+        return ts.sys.readDirectory(...args);
+      },
+      directoryExists: (...args) => {
+        return ts.sys.directoryExists(...args);
+      },
+      getDirectories: (...args) => {
+        return ts.sys.getDirectories(...args);
+      },
+    };
     autocompleterContext = {
       currentDatabaseAndConnection: () => ({
         connectionId,
@@ -75,12 +126,12 @@ describe('MongoDBAutocompleter', function () {
 
     autocompleter = new MongoDBAutocompleter({
       context: autocompleterContext,
+      fallbackServiceHost,
     });
   });
 
   afterEach(function () {
     // this is what tells us what we're missing in extract-types.ts
-    const encounteredPaths = autocompleter.listEncounteredPaths();
     expect(encounteredPaths).to.deep.equal({
       fileExists: [],
       getScriptSnapshot: [],

packages/mongodb-ts-autocomplete/src/autocompleter.ts

@@ -1,5 +1,6 @@
 import createDebug from 'debug';
 import _ from 'lodash';
+import type { LanguageServiceHost } from 'typescript';
 import Autocompleter from '@mongodb-js/ts-autocomplete';
 import type { AutoCompletion } from '@mongodb-js/ts-autocomplete';
 import autocompleteTypes from './fixtures/autocomplete-types';
@@ -21,6 +22,7 @@ const debug = createDebug('mongodb-ts-autocomplete');
 
 type MongoDBAutocompleterOptions = {
   context: AutocompletionContext;
+  fallbackServiceHost?: LanguageServiceHost;
 };
 
 class DatabaseSchema {
@@ -175,9 +177,12 @@ export class MongoDBAutocompleter {
     | undefined;
   private previousCollectionName: string | undefined;
 
-  constructor({ context }: MongoDBAutocompleterOptions) {
+  constructor({ context, fallbackServiceHost }: MongoDBAutocompleterOptions) {
     this.context = CachingAutocompletionContext.caching(context);
-    this.autocompleter = new Autocompleter({ filter: filterStartingWith });
+    this.autocompleter = new Autocompleter({
+      filter: filterStartingWith,
+      fallbackServiceHost,
+    });
 
     this.connectionSchemas = Object.create(null);
 
@@ -333,10 +338,6 @@ declare global {
 
     return this.autocompleter.autocomplete(code);
   }
-
-  listEncounteredPaths() {
-    return this.autocompleter.listEncounteredPaths();
-  }
 }
 
 function adjustShellApiForConnection(ShellApiText: string): string {

packages/ts-autocomplete/src/index.spec.ts

@@ -21,10 +21,6 @@ describe('Autocompleter', function () {
   let CODE_TS: string;
 
   before(async function () {
-    // make sure that we fall back to the default ts.sys file methods so that ts
-    // will load the lib files from disk
-    process.env.CI = 'true';
-
     CODE_TS = await fs.readFile(
       path.resolve(__dirname, '..', 'test', 'fixtures', 'code.ts'),
       'utf8',

packages/ts-autocomplete/src/index.ts

@@ -23,17 +23,12 @@ function relativeNodePath(fileName: string): string {
   return parts[parts.length - 1];
 }
 
-type EncounteredPaths = {
-  getScriptSnapshot: string[];
-  fileExists: string[];
-  readFile: string[];
-};
-
-function getVirtualLanguageService(): {
+function getVirtualLanguageService(
+  fallbackServiceHost?: ts.LanguageServiceHost,
+): {
   languageService: ts.LanguageService;
   updateCode: UpdateDefinitionFunction;
   listFiles: () => string[];
-  listEncounteredPaths: () => EncounteredPaths;
 } {
   // as an optimization, the contents of a file can be string or true. This is
   // because some files are only checked for existence during module resolution,
@@ -61,19 +56,7 @@ function getVirtualLanguageService(): {
     return Object.keys(codeHolder);
   };
 
-  const encounteredPaths: EncounteredPaths = {
-    getScriptSnapshot: [],
-    fileExists: [],
-    readFile: [],
-  };
-  const listEncounteredPaths = (): EncounteredPaths => {
-    encounteredPaths.getScriptSnapshot.sort();
-    encounteredPaths.fileExists.sort();
-    encounteredPaths.readFile.sort();
-    return encounteredPaths;
-  };
-
-  const servicesHost: ts.LanguageServiceHost = {
+  const serviceHost: ts.LanguageServiceHost = {
     getScriptFileNames: () => {
       return Object.keys(codeHolder);
     },
@@ -87,14 +70,8 @@ function getVirtualLanguageService(): {
         return ts.ScriptSnapshot.fromString(codeHolder[fileName].toString());
       }
 
-      if (process.env.CI) {
-        const result = ts.ScriptSnapshot.fromString(
-          // NOTE: some files do not exist. A good example is "typescript/lib/es2023.ts"
-          ts.sys.readFile(fileName) || '',
-        );
-
-        encounteredPaths.getScriptSnapshot.push(relativeNodePath(fileName));
-        return result;
+      if (fallbackServiceHost) {
+        return fallbackServiceHost.getScriptSnapshot(fileName);
       }
     },
     getCurrentDirectory: () => process.cwd(),
@@ -108,12 +85,8 @@ function getVirtualLanguageService(): {
         return true;
       }
 
-      if (process.env.CI) {
-        const result = ts.sys.fileExists(fileName);
-        if (result) {
-          encounteredPaths.fileExists.push(relativeNodePath(fileName));
-        }
-        return result;
+      if (fallbackServiceHost) {
+        return fallbackServiceHost.fileExists(fileName);
       }
 
       return false;
@@ -124,27 +97,25 @@ function getVirtualLanguageService(): {
         return codeHolder[fileName].toString();
       }
 
-      if (process.env.CI) {
-        const result = ts.sys.readFile(fileName);
-        encounteredPaths.readFile.push(relativeNodePath(fileName));
-        return result;
+      if (fallbackServiceHost) {
+        return fallbackServiceHost.readFile(fileName);
       }
     },
     readDirectory: (...args) => {
-      if (process.env.CI) {
-        return ts.sys.readDirectory(...args);
+      if (fallbackServiceHost && fallbackServiceHost.readDirectory) {
+        return fallbackServiceHost.readDirectory(...args);
       }
       return [];
     },
     directoryExists: (...args) => {
-      if (process.env.CI) {
-        return ts.sys.directoryExists(...args);
+      if (fallbackServiceHost && fallbackServiceHost.directoryExists) {
+        return fallbackServiceHost.directoryExists(...args);
       }
       return false;
     },
     getDirectories: (...args) => {
-      if (process.env.CI) {
-        return ts.sys.getDirectories(...args);
+      if (fallbackServiceHost && fallbackServiceHost.getDirectories) {
+        return fallbackServiceHost.getDirectories(...args);
       }
       return [];
     },
@@ -155,12 +126,11 @@ function getVirtualLanguageService(): {
 
   return {
     languageService: ts.createLanguageService(
-      servicesHost,
+      serviceHost,
       ts.createDocumentRegistry(),
     ),
     updateCode,
     listFiles,
-    listEncounteredPaths,
   };
 }
 
@@ -233,6 +203,7 @@ type AutocompleteFilterFunction = (
 
 export type AutocompleterOptions = {
   filter?: AutocompleteFilterFunction;
+  fallbackServiceHost?: ts.LanguageServiceHost;
 };
 
 function filterDiagnostics(diagnostics: ts.Diagnostic[]): {
@@ -259,16 +230,14 @@ export default class Autocompleter {
   private readonly languageService: ts.LanguageService;
   readonly updateCode: UpdateDefinitionFunction;
   readonly listFiles: () => string[];
-  readonly listEncounteredPaths: () => EncounteredPaths;
 
-  constructor({ filter }: AutocompleterOptions = {}) {
+  constructor({ filter, fallbackServiceHost }: AutocompleterOptions = {}) {
     this.filter = filter ?? (() => true);
     ({
       languageService: this.languageService,
       updateCode: this.updateCode,
       listFiles: this.listFiles,
-      listEncounteredPaths: this.listEncounteredPaths,
-    } = getVirtualLanguageService());
+    } = getVirtualLanguageService(fallbackServiceHost));
   }
 
   autocomplete(code: string): AutoCompletion[] {