cleanup

Author: lerouxb

packages/mongodb-ts-autocomplete/scripts/extract-types.ts

@@ -189,31 +189,35 @@ const deps: Record<string, string[]> = {
   ],
 };
 
+function resolveModulePath(moduleName: string): string {
+  const { resolvedModule } = resolve(moduleName);
+  if (!resolvedModule) {
+    console.log(resolve(moduleName));
+    throw new Error(`Could not resolve module: ${moduleName}`);
+  }
+  return resolvedModule.resolvedFileName;
+}
+
 async function run() {
-  // TODO: switch require.resolve() to resolve()
+  const mqlPath = path.join(
+    path.dirname(resolveModulePath('@mongodb-js/mql-typescript')),
+    '..',
+    'out',
+    'schema.d.ts',
+  );
+
   const input: Record<string, string> = {
     // mql imports bson but right now so does shell-api. We could bake the types
     // those use into the files we generate using api-extractor, but maybe
     // including it just once is not so bad.
-    '/bson.ts': path.join(require.resolve('bson'), '..', '..', 'bson.d.ts'),
+    '/bson.ts': resolveModulePath('bson'),
     // mql imports the mongodb driver. We could also use api-extractor there to
     // bake the few mongodb types we use into the schema.
-    '/mongodb.ts': path.join(
-      require.resolve('mongodb'),
-      '..',
-      '..',
-      'mongodb.d.ts',
-    ),
+    '/mongodb.ts': resolveModulePath('mongodb'),
     // We wouldn't have to include mql if we used it straight from shell-api,
     // but since we're using it straight here for now to bypass the complicated
     // generics on the shell-api side it is included here for now.
-    '/mql.ts': path.join(
-      require.resolve('@mongodb-js/mql-typescript'),
-      '..',
-      '..',
-      'out',
-      'schema.d.ts',
-    ),
+    '/mql.ts': mqlPath,
   };
   for (const [moduleName, filePaths] of Object.entries(deps)) {
     const { resolvedModule } = resolve(moduleName);
@@ -225,10 +229,8 @@ async function run() {
       0,
       -resolvedModule.packageId.subModuleName.length,
     );
-    //console.log({ basePath});
     for (const filePath of filePaths) {
       const fullPath = path.join(basePath, filePath);
-      //console.log({ fullPath });
       // these are in the format import of typescript imports
       input[`${moduleName}/${filePath}`] = fullPath;
     }

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

@@ -18,6 +18,12 @@ describe('MongoDBAutocompleter', function () {
   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';
+  });
+
   beforeEach(function () {
     autocompleterContext = {
       currentDatabaseAndConnection: () => ({
@@ -72,6 +78,16 @@ describe('MongoDBAutocompleter', function () {
     });
   });
 
+  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: [],
+      readFile: [],
+    });
+  });
+
   it('deals with no connection', async function () {
     // The body of tests are all wrapped in loops so that we exercise the
     // caching logic in the autocompleter.
@@ -202,18 +218,6 @@ describe('MongoDBAutocompleter', function () {
           result: 'db.foo.find({ foo',
         },
       ]);
-
-      // this is what tells us what we're missing in extract-types.ts
-      const encounteredPaths = autocompleter.listEncounteredPaths();
-      if (
-        encounteredPaths.getScriptSnapshot.length ||
-        encounteredPaths.fileExists.length ||
-        encounteredPaths.readFile.length
-      ) {
-        // eslint-disable-next-line no-console
-        console.log(JSON.stringify(encounteredPaths, null, 2));
-        expect.fail('There should be no encountered paths left over');
-      }
     }
 
     // then hit a different collection to make sure the caching works

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

@@ -1,7 +1,6 @@
 export function replaceImports(code: string) {
   // mql uses these and we have to make sure the language server finds our
   // copies at runtime.
-
   return code
     .replace(/'bson'/g, "'/bson.ts'")
     .replace(/'mongodb'/g, "'/mongodb.ts'");

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

@@ -21,6 +21,10 @@ 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

@@ -9,19 +9,11 @@ const debugError = createDebug('ts-autocomplete:error');
 
 type TypeFilename = string;
 
-type UpdateDefinitionFunction = (newDef: Record<TypeFilename, string>) => void;
-
-// TODO
-/*
-function createIOError(code: string, details = ""): NodeJS.ErrnoException {
-    const err: NodeJS.ErrnoException = new Error(`${code} ${details}`);
-    err.code = code;
-    if (Error.captureStackTrace) Error.captureStackTrace(err, createIOError);
-    return err;
-}
-    */
+type UpdateDefinitionFunction = (
+  newDef: Record<TypeFilename, string | true>,
+) => void;
+
 function relativeNodePath(fileName: string): string {
-  //console.log(fileName);
   const parts = fileName.split(/\/node_modules\//g);
   if (parts.length === 1 && fileName.endsWith('package.json')) {
     // special case: when it looks up this package itself it isn't going to find
@@ -35,9 +27,6 @@ type EncounteredPaths = {
   getScriptSnapshot: string[];
   fileExists: string[];
   readFile: string[];
-  //readDirectory: string[],
-  //directoryExists: string[],
-  //getDirectories: string[]
 };
 
 function getVirtualLanguageService(): {
@@ -60,7 +49,7 @@ function getVirtualLanguageService(): {
     allowImportingTsExtensions: true,
   };
 
-  const updateCode = (newDef: Record<TypeFilename, string>): void => {
+  const updateCode = (newDef: Record<TypeFilename, string | true>): void => {
     for (const [key, value] of Object.entries(newDef)) {
       codeHolder[key] = value;
       versions[key] = (versions[key] ?? 0) + 1;
@@ -75,9 +64,6 @@ function getVirtualLanguageService(): {
     getScriptSnapshot: [],
     fileExists: [],
     readFile: [],
-    //readDirectory: [], // unused
-    //directoryExists: [], // unused
-    //getDirectories: [] // unused
   };
   const listEncounteredPaths = (): EncounteredPaths => {
     encounteredPaths.getScriptSnapshot.sort();
@@ -100,61 +86,66 @@ function getVirtualLanguageService(): {
         return ts.ScriptSnapshot.fromString(codeHolder[fileName].toString());
       }
 
-      // TODO: this should not be encountered outside of CI
-      const result = ts.ScriptSnapshot.fromString(
-        // NOTE: some files do not exist. A good example is "typescript/lib/es2023.ts"
-        ts.sys.readFile(fileName) || '',
-      );
+      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;
+        encounteredPaths.getScriptSnapshot.push(relativeNodePath(fileName));
+        return result;
+      }
     },
     getCurrentDirectory: () => process.cwd(),
     getCompilationSettings: () => options,
     getDefaultLibFileName: (options) => {
-      const defaultLibFileName = ts.getDefaultLibFilePath(options);
-      //console.log({ defaultLibFileName })
-      //return '/lib.es2022.full.d.ts'
-      return defaultLibFileName;
+      return ts.getDefaultLibFilePath(options);
     },
     fileExists: (fileName) => {
       fileName = relativeNodePath(fileName);
       if (fileName in codeHolder) {
         return true;
       }
 
-      // TODO: this should not be encountered outside of CI when tests will fail
-      const result = ts.sys.fileExists(fileName);
-      if (result) {
-        encounteredPaths.fileExists.push(relativeNodePath(fileName));
+      if (process.env.CI) {
+        const result = ts.sys.fileExists(fileName);
+        if (result) {
+          encounteredPaths.fileExists.push(relativeNodePath(fileName));
+        }
+        return result;
       }
-      return result;
+
+      return false;
     },
     readFile: (fileName) => {
       fileName = relativeNodePath(fileName);
       if (fileName in codeHolder) {
         return codeHolder[fileName].toString();
       }
 
-      // TODO: this should not be encountered outside of CI when tests will fail
-      const result = ts.sys.readFile(fileName);
-      encounteredPaths.readFile.push(relativeNodePath(fileName));
-      return result;
+      if (process.env.CI) {
+        const result = ts.sys.readFile(fileName);
+        encounteredPaths.readFile.push(relativeNodePath(fileName));
+        return result;
+      }
     },
     readDirectory: (...args) => {
-      // TODO: this should not be encountered outside of CI when tests will fail
-      const result = ts.sys.readDirectory(...args);
-      return result;
+      if (process.env.CI) {
+        return ts.sys.readDirectory(...args);
+      }
+      return [];
     },
     directoryExists: (...args) => {
-      // TODO: this should not be encountered outside of CI when tests will fail
-      const result = ts.sys.directoryExists(...args);
-      return result;
+      if (process.env.CI) {
+        return ts.sys.directoryExists(...args);
+      }
+      return false;
     },
     getDirectories: (...args) => {
-      // TODO: this should not be encountered outside of CI when tests will fail
-      const result = ts.sys.getDirectories(...args);
-      return result;
+      if (process.env.CI) {
+        return ts.sys.getDirectories(...args);
+      }
+      return [];
     },
     log: (...args) => debugLog(args),
     trace: (...args) => debugTrace(args),