cleanup

Author: lerouxb

packages/mongodb-ts-autocomplete/.depcheckrc

@@ -1,4 +1,5 @@
 ignores:
+ - '@mongodb-js/mql-typescript'
  - '@mongodb-js/prettier-config-devtools'
  - '@mongodb-js/tsconfig-devtools'
  - '@types/chai'

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

@@ -5,7 +5,7 @@ import path from 'path';
 import { replaceImports } from '../src/utils';
 
 async function loadSources(sources: Record<string, string>) {
-  const result: Record<string, string | true> = {};
+  const result: Record<string, string | boolean> = {};
 
   for (const [key, filePath] of Object.entries(sources)) {
     // for .js filepaths we're never going to read them, so just make the
@@ -28,6 +28,23 @@ async function loadSources(sources: Record<string, string>) {
 }
 
 function resolve(moduleName: string) {
+  if (moduleName === '@mongodb-js/mongodb-ts-autocomplete') {
+    // There's a chicken-and-egg problem here: we can't compile this module
+    // itself without the extracted types and we can't extract it before it is
+    // compiled because the module is not compiled, so its dist/index.js does
+    // not exist yet. With this workaround we're resolving the package.json
+    // which definitely already exists.
+    const result = {
+      resolvedModule: {
+        resolvedFileName: path.resolve(__dirname, '..', 'package.json'),
+        packageId: {
+          subModuleName: 'package.json',
+        },
+      },
+    };
+
+    return result;
+  }
   const result = ts.resolveModuleName(
     moduleName,
     __filename,
@@ -41,6 +58,14 @@ function resolve(moduleName: string) {
   return result;
 }
 
+function resolveModulePath(moduleName: string): string {
+  const { resolvedModule } = resolve(moduleName);
+  if (!resolvedModule) {
+    throw new Error(`Could not resolve module: ${moduleName}`);
+  }
+  return resolvedModule.resolvedFileName;
+}
+
 const deps: Record<string, string[]> = {
   '@mongodb-js/mongodb-ts-autocomplete': [
     // the module resolution won't be addressing this module by name, but we'll
@@ -190,30 +215,25 @@ const deps: Record<string, string[]> = {
 };
 
 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 +245,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 | boolean>,
+) => 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(): {
@@ -49,7 +38,8 @@ function getVirtualLanguageService(): {
   // 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,
   // but never loaded. In that case the contents is true, not a string.
-  const codeHolder: Record<TypeFilename, string | true> = Object.create(null);
+  const codeHolder: Record<TypeFilename, string | boolean> =
+    Object.create(null);
   const versions: Record<TypeFilename, number> = Object.create(null);
   const options: ts.CompilerOptions = {
     target: ts.ScriptTarget.ES2022,
@@ -60,7 +50,7 @@ function getVirtualLanguageService(): {
     allowImportingTsExtensions: true,
   };
 
-  const updateCode = (newDef: Record<TypeFilename, string>): void => {
+  const updateCode = (newDef: Record<TypeFilename, string | boolean>): void => {
     for (const [key, value] of Object.entries(newDef)) {
       codeHolder[key] = value;
       versions[key] = (versions[key] ?? 0) + 1;
@@ -75,9 +65,6 @@ function getVirtualLanguageService(): {
     getScriptSnapshot: [],
     fileExists: [],
     readFile: [],
-    //readDirectory: [], // unused
-    //directoryExists: [], // unused
-    //getDirectories: [] // unused
   };
   const listEncounteredPaths = (): EncounteredPaths => {
     encounteredPaths.getScriptSnapshot.sort();
@@ -100,61 +87,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),