chore: fix formatting and lint

Author: gagik

packages/build/src/index.ts

@@ -9,6 +9,7 @@ import type { Config, PackageVariant } from './config';
 import { updateJsonFeedCTA } from './download-center';
 import Ajv from 'ajv';
 
+export { downloadCryptLibrary } from './packaging/download-crypt-library';
 export { getArtifactUrl, downloadMongoDb };
 
 const validCommands: (ReleaseCommand | 'trigger-release' | 'update-cta')[] = [

testing/.eslintrc.js

@@ -0,0 +1,10 @@
+const { fixCygwinPath } = require("@mongodb-js/eslint-config-mongosh/utils");
+
+module.exports = {
+  root: true,
+  extends: ["@mongodb-js/eslint-config-mongosh"],
+  parserOptions: {
+    tsconfigRootDir: fixCygwinPath(__dirname),
+    project: ["./tsconfig-lint.json"],
+  },
+};

testing/fake-kms.ts

@@ -1,21 +1,23 @@
-import DuplexPair from 'duplexpair';
-import http from 'http';
+import DuplexPair from "duplexpair";
+import http from "http";
 
 // Exact values specified by RFC6749 ;)
-const oauthToken = { access_token: '2YotnFZFEjr1zCsicMWpAA', expires_in: 3600 };
+const oauthToken = { access_token: "2YotnFZFEjr1zCsicMWpAA", expires_in: 3600 };
 
-type RequestData = { url: string, body: string };
+type RequestData = { url: string; body: string };
 type HandlerFunction = (data: RequestData) => any;
-type HandlerList = { host: RegExp, handler: HandlerFunction }[];
+type HandlerList = { host: RegExp; handler: HandlerFunction }[];
 type Duplex = NodeJS.ReadableStream & NodeJS.WritableStream;
 
 // Return a Duplex stream that behaves like an HTTP stream, with the 'server'
 // being provided by the handler function in this case (which is expected
 // to return JSON).
-export function makeFakeHTTPConnection(handlerList: HandlerList): Duplex & { requests: http.IncomingMessage[] } {
+export function makeFakeHTTPConnection(
+  handlerList: HandlerList
+): Duplex & { requests: http.IncomingMessage[] } {
   const { socket1, socket2 } = new DuplexPair();
   const server = makeFakeHTTPServer(handlerList);
-  server.emit('connection', socket2);
+  server.emit("connection", socket2);
   return Object.assign(socket1, { requests: server.requests });
 }
 
@@ -26,29 +28,31 @@ export function makeFakeHTTPServer(handlerList: HandlerList): FakeHTTPServer {
   const server = http.createServer((req, res) => {
     (server as FakeHTTPServer).requests.push(req);
     let foundHandler: HandlerFunction | undefined;
-    const host = req.headers['host'];
+    const host = req.headers["host"];
     for (const potentialHandler of handlerList) {
-      if (potentialHandler.host.test(host ?? '')) {
+      if (potentialHandler.host.test(host ?? "")) {
         foundHandler = potentialHandler.handler;
         break;
       }
     }
     if (!foundHandler) {
       res.writeHead(404, {
-        'Content-Type': 'text/plain'
+        "Content-Type": "text/plain",
       });
       res.end(`Host ${host} not found`);
       return;
     }
     const handler = foundHandler; // Makes TS happy
 
-    let body = '';
-    req.setEncoding('utf8').on('data', chunk => { body += chunk; });
-    req.on('end', () => {
+    let body = "";
+    req.setEncoding("utf8").on("data", (chunk) => {
+      body += chunk;
+    });
+    req.on("end", () => {
       res.writeHead(200, {
-        'Content-Type': 'application/json'
+        "Content-Type": "application/json",
       });
-      res.end(JSON.stringify(handler({ url: req.url ?? '', body })));
+      res.end(JSON.stringify(handler({ url: req.url ?? "", body })));
     });
   });
   return Object.assign(server, { requests: [] });
@@ -57,7 +61,7 @@ export function makeFakeHTTPServer(handlerList: HandlerList): FakeHTTPServer {
 export const fakeAWSHandlers: HandlerList = [
   { host: /\.amazonaws\.com$/, handler: awsHandler },
   { host: /\.microsoftonline.com$|\.azure.net$/, handler: azureHandler },
-  { host: /\.googleapis.com$/, handler: gcpHandler }
+  { host: /\.googleapis.com$/, handler: gcpHandler },
 ];
 
 function awsHandler({ body }: RequestData): any {
@@ -68,31 +72,35 @@ function awsHandler({ body }: RequestData): any {
     // both KeyId and Plaintext so that they are available for generating
     // the decryption response, which also provides the KeyId and Plaintext
     // based on the CiphertextBlob alone.
-    const CiphertextBlob = Buffer.from(request.KeyId + '\0' + request.Plaintext).toString('base64')
+    const CiphertextBlob = Buffer.from(
+      request.KeyId + "\0" + request.Plaintext
+    ).toString("base64");
     return {
       CiphertextBlob,
-      EncryptionAlgorithm: 'SYMMETRIC_DEFAULT',
-      KeyId: request.KeyId
+      EncryptionAlgorithm: "SYMMETRIC_DEFAULT",
+      KeyId: request.KeyId,
     };
   } else {
-    let [ KeyId, Plaintext ] = Buffer.from(request.CiphertextBlob, 'base64').toString().split('\0');
+    let [KeyId, Plaintext] = Buffer.from(request.CiphertextBlob, "base64")
+      .toString()
+      .split("\0");
     // Do not return invalid base64 https://jira.mongodb.org/browse/MONGOCRYPT-525
-    if (Buffer.from(KeyId, 'base64').toString('base64') !== KeyId) {
-      KeyId = 'invalid0';
+    if (Buffer.from(KeyId, "base64").toString("base64") !== KeyId) {
+      KeyId = "invalid0";
     }
-    if (Buffer.from(Plaintext, 'base64').toString('base64') !== Plaintext) {
-      Plaintext = 'invalid1';
+    if (Buffer.from(Plaintext, "base64").toString("base64") !== Plaintext) {
+      Plaintext = "invalid1";
     }
     return {
       Plaintext,
-      EncryptionAlgorithm: 'SYMMETRIC_DEFAULT',
-      KeyId
+      EncryptionAlgorithm: "SYMMETRIC_DEFAULT",
+      KeyId,
     };
   }
 }
 
 function azureHandler({ body, url }: RequestData): any {
-  if (url.endsWith('/token')) {
+  if (url.endsWith("/token")) {
     return oauthToken;
   } else if (url.match(/\/(un)?wrapkey/)) {
     // Just act as if this was encrypted.
@@ -101,12 +109,12 @@ function azureHandler({ body, url }: RequestData): any {
 }
 
 function gcpHandler({ body, url }: RequestData): any {
-  if (url.endsWith('/token')) {
+  if (url.endsWith("/token")) {
     return oauthToken;
-  } else if (url.endsWith(':encrypt')) {
+  } else if (url.endsWith(":encrypt")) {
     // Here we also just perform noop encryption.
     return { ciphertext: JSON.parse(body).plaintext };
-  } else if (url.endsWith(':decrypt')) {
+  } else if (url.endsWith(":decrypt")) {
     return { plaintext: JSON.parse(body).ciphertext };
   }
 }

testing/integration-testing-hooks.ts

@@ -1,23 +1,17 @@
+/* eslint-disable mocha/no-exports */
 import child_process from "child_process";
 import { promises as fs } from "fs";
-import { MongoClient, MongoClientOptions } from "mongodb";
+import { MongoClient, type MongoClientOptions } from "mongodb";
 import path from "path";
 import semver from "semver";
 import { promisify } from "util";
 import which from "which";
 import { ConnectionString } from "mongodb-connection-string-url";
-import { MongoCluster, MongoClusterOptions } from "mongodb-runner";
-import { downloadCryptLibrary } from "../packages/build/src/packaging/download-crypt-library";
+import { MongoCluster, type MongoClusterOptions } from "mongodb-runner";
+import { downloadCryptLibrary } from "@mongosh/build";
 
 const execFile = promisify(child_process.execFile);
 
-const isCI = !!process.env.IS_CI;
-function ciLog(...args: any[]) {
-  if (isCI) {
-    console.error(...args);
-  }
-}
-
 // Return the path to the temporary directory and ensure that it exists.
 async function getTmpdir(): Promise<string> {
   const tmpdir = path.resolve(__dirname, "..", "tmp");
@@ -26,6 +20,7 @@ async function getTmpdir(): Promise<string> {
 }
 
 // Represents one running test server instance.
+// eslint-disable-next-line mocha/no-exports
 export class MongodSetup {
   _connectionString: Promise<string>;
   _setConnectionString: (connectionString: string) => void;
@@ -34,7 +29,9 @@ export class MongodSetup {
   _bindir = "";
 
   constructor(connectionString?: string) {
-    this._setConnectionString = (connectionString: string) => {}; // Make TypeScript happy.
+    this._setConnectionString = () => {
+      // no-op to make TypeScript happy.
+    };
     this._connectionString = new Promise((resolve) => {
       this._setConnectionString = resolve;
     });
@@ -45,11 +42,11 @@ export class MongodSetup {
   }
 
   async start(): Promise<void> {
-    throw new Error("Server not managed");
+    await Promise.reject(new Error("Server not managed"));
   }
 
   async stop(): Promise<void> {
-    throw new Error("Server not managed");
+    await Promise.reject(new Error("Server not managed"));
   }
 
   async connectionString(
@@ -115,7 +112,7 @@ export class MongodSetup {
       return await fn(client);
     } finally {
       if (client) {
-        client.close();
+        await client.close();
       }
     }
   }
@@ -193,18 +190,15 @@ async function getInstalledMongodVersion(): Promise<string> {
   return version;
 }
 
-export async function downloadCurrentCryptSharedLibrary(
-  versionSpec?: string
-): Promise<string> {
+export async function downloadCurrentCryptSharedLibrary(): Promise<string> {
   if (process.platform === "linux") {
     return (
       await downloadCryptLibrary(
-        `linux-${process.arch.replace("ppc64", "ppc64le")}` as any,
-        versionSpec
+        `linux-${process.arch.replace("ppc64", "ppc64le")}` as any
       )
     ).cryptLibrary;
   }
-  return (await downloadCryptLibrary("host", versionSpec)).cryptLibrary;
+  return (await downloadCryptLibrary("host")).cryptLibrary;
 }
 
 /**

testing/tsconfig-lint.json

@@ -0,0 +1,5 @@
+{
+  "extends": "./tsconfig.json",
+  "include": ["**/*"],
+  "exclude": ["node_modules", "dist", "lib"]
+}

testing/tsconfig.json

@@ -0,0 +1,4 @@
+{
+  "extends": "@mongodb-js/tsconfig-mongosh/tsconfig.common.json",
+  "include": ["**/*", "../packages/e2e-tests/test/integration-testing-hooks.ts"]
+}