chore: fix lint

gagik · gagik · commit 3bce26e23a9b · 2025-11-24T16:40:02.000+01:00
diff --git a/scripts/generateArguments.ts b/scripts/generateArguments.ts
@@ -12,7 +12,6 @@ import { readFileSync, writeFileSync } from "fs";
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";
 import { UserConfigSchema, configRegistry } from "../src/common/config/userConfig.js";
-import assert from "assert";
 import { execSync } from "child_process";
 import { OPTIONS } from "../src/common/config/argsParserOptions.js";
 
@@ -69,12 +68,8 @@ function extractZodDescriptions(): Record<string, ConfigMetadata> {
         let description = schema.description || `Configuration option: ${key}`;
 
         if ("innerType" in schema.def) {
-            // "pipe" is used for our comma-separated arrays
+            // "pipe" & innerType is assumed to be for our comma-separated arrays
             if (schema.def.innerType.def.type === "pipe") {
-                assert(
-                    description.startsWith("An array of"),
-                    `Field description for field "${key}" with array type does not start with 'An array of'`
-                );
                 description = description.replace("An array of", "Comma separated values of");
             }
         }
diff --git a/src/common/config/configOverrides.ts b/src/common/config/configOverrides.ts
@@ -1,7 +1,7 @@
 import type { UserConfig } from "./userConfig.js";
 import { UserConfigSchema, configRegistry } from "./userConfig.js";
 import type { RequestContext } from "../../transports/base.js";
-import type { OverrideBehavior } from "./configUtils.js";
+import type { ConfigFieldMeta, OverrideBehavior } from "./configUtils.js";
 
 export const CONFIG_HEADER_PREFIX = "x-mongodb-mcp-";
 export const CONFIG_QUERY_PREFIX = "mongodbMcp";
@@ -38,7 +38,7 @@ export function applyConfigOverrides({
         const behavior = getConfigMeta(key)?.overrideBehavior || "not-allowed";
         const baseValue = baseConfig[key as keyof UserConfig];
         const newValue = applyOverride(key, baseValue, overrideValue, behavior);
-        (result as any)[key] = newValue;
+        (result as Record<keyof UserConfig, unknown>)[key] = newValue;
     }
 
     return result;
@@ -87,15 +87,15 @@ function assertValidConfigKey(key: string): asserts key is keyof typeof UserConf
 /**
  * Gets the schema metadata for a config key.
  */
-export function getConfigMeta(key: keyof typeof UserConfigSchema.shape) {
+export function getConfigMeta(key: keyof typeof UserConfigSchema.shape): ConfigFieldMeta | undefined {
     return configRegistry.get(UserConfigSchema.shape[key]);
 }
 
 /**
  * Parses a string value to the appropriate type using the Zod schema.
  */
 function parseConfigValue(key: keyof typeof UserConfigSchema.shape, value: unknown): unknown {
-    const fieldSchema = UserConfigSchema.shape[key as keyof typeof UserConfigSchema.shape];
+    const fieldSchema = UserConfigSchema.shape[key];
     if (!fieldSchema) {
         throw new Error(`Invalid config key: ${key}`);
     }
@@ -114,7 +114,7 @@ export function nameToConfigKey(mode: "header" | "query", name: string): string
     if (mode === "header" && lowerCaseName.startsWith(CONFIG_HEADER_PREFIX)) {
         const normalized = lowerCaseName.substring(CONFIG_HEADER_PREFIX.length);
         // Convert kebab-case to camelCase
-        return normalized.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+        return normalized.replace(/-([a-z])/g, (_, letter: string) => letter.toUpperCase());
     }
     if (mode === "query" && name.startsWith(CONFIG_QUERY_PREFIX)) {
         const withoutPrefix = name.substring(CONFIG_QUERY_PREFIX.length);
@@ -148,7 +148,7 @@ function applyOverride(
 
         case "merge":
             if (Array.isArray(baseValue) && Array.isArray(overrideValue)) {
-                return [...baseValue, ...overrideValue];
+                return [...(baseValue as unknown[]), ...(overrideValue as unknown[])];
             }
             throw new Error("Cannot merge non-array values, did you mean to use the 'override' behavior?");
 
diff --git a/tests/integration/transports/configOverrides.test.ts b/tests/integration/transports/configOverrides.test.ts
@@ -2,21 +2,26 @@ import { StreamableHttpRunner } from "../../../src/transports/streamableHttp.js"
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import { describe, expect, it, afterEach, beforeEach } from "vitest";
-import { defaultTestConfig } from "../helpers.js";
+import { defaultTestConfig, expectDefined } from "../helpers.js";
+import type { TransportRunnerConfig, UserConfig } from "../../../src/lib.js";
+import type { RequestContext } from "../../../src/transports/base.js";
 
 describe("Config Overrides via HTTP", () => {
     let runner: StreamableHttpRunner;
     let client: Client;
     let transport: StreamableHTTPClientTransport;
 
     // Helper function to setup and start runner with config
-    async function startRunner(config: any, createSessionConfig?: any) {
+    async function startRunner(
+        config: UserConfig,
+        createSessionConfig?: TransportRunnerConfig["createSessionConfig"]
+    ): Promise<void> {
         runner = new StreamableHttpRunner({ userConfig: config, createSessionConfig });
         await runner.start();
     }
 
     // Helper function to connect client with headers
-    async function connectClient(headers: Record<string, string> = {}) {
+    async function connectClient(headers: Record<string, string> = {}): Promise<void> {
         transport = new StreamableHTTPClientTransport(new URL(`${runner.serverAddress}/mcp`), {
             requestInit: { headers },
         });
@@ -106,7 +111,8 @@ describe("Config Overrides via HTTP", () => {
             const insertTool = response.tools.find(
                 (tool) => tool.name === "insert-many" || tool.name === "find" || tool.name === "aggregate"
             );
-            expect(response.tools).is.not.empty;
+
+            expect(response.tools).not.toHaveLength(0);
             expect(insertTool).toBeUndefined();
         });
     });
@@ -228,14 +234,15 @@ describe("Config Overrides via HTTP", () => {
 
             // createSessionConfig receives the config after header overrides are applied
             // It can further modify it, but headers have already been applied
-            const createSessionConfig = async ({
+            const createSessionConfig: TransportRunnerConfig["createSessionConfig"] = ({
                 userConfig: config,
                 request,
             }: {
                 userConfig: typeof userConfig;
-                request?: any;
-            }) => {
-                expect(request).toBeDefined();
+                request?: RequestContext;
+            }): typeof userConfig => {
+                expectDefined(request);
+                expectDefined(request.headers);
                 expect(request.headers).toBeDefined();
                 config.readOnly = request.headers["x-mongodb-mcp-read-only"] === "true";
                 config.disabledTools = ["count"];
@@ -260,7 +267,7 @@ describe("Config Overrides via HTTP", () => {
             const countTool = response.tools.find((tool) => tool.name === "count");
             expect(countTool).toBeUndefined();
 
-            expect(response.tools).is.not.empty;
+            expect(response.tools).not.toHaveLength(0);
         });
 
         it("should pass request context to createSessionConfig", async () => {
@@ -269,10 +276,17 @@ describe("Config Overrides via HTTP", () => {
                 httpPort: 0,
             };
 
-            let capturedRequest: any;
-            const createSessionConfig = async ({ request }: { userConfig: typeof userConfig; request?: any }) => {
+            let capturedRequest: RequestContext | undefined;
+            const createSessionConfig: TransportRunnerConfig["createSessionConfig"] = ({
+                request,
+            }: {
+                userConfig: typeof userConfig;
+                request?: RequestContext;
+            }): Promise<typeof userConfig> => {
+                expectDefined(request);
+                expectDefined(request.headers);
                 capturedRequest = request;
-                return userConfig;
+                return Promise.resolve(userConfig);
             };
 
             await startRunner(userConfig, createSessionConfig);
@@ -282,7 +296,8 @@ describe("Config Overrides via HTTP", () => {
             });
 
             // Verify that request context was passed
-            expect(capturedRequest).toBeDefined();
+            expectDefined(capturedRequest);
+            expectDefined(capturedRequest.headers);
             expect(capturedRequest.headers["x-custom-header"]).toBe("test-value");
         });
     });
diff --git a/tests/integration/transports/createSessionConfig.test.ts b/tests/integration/transports/createSessionConfig.test.ts
@@ -2,8 +2,8 @@ import { StreamableHttpRunner } from "../../../src/transports/streamableHttp.js"
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import { afterEach, describe, expect, it } from "vitest";
-import type { TransportRunnerConfig } from "../../../src/lib.js";
-import { defaultTestConfig } from "../helpers.js";
+import type { TransportRunnerConfig, UserConfig } from "../../../src/lib.js";
+import { defaultTestConfig, expectDefined } from "../helpers.js";
 
 describe("createSessionConfig", () => {
     const userConfig = defaultTestConfig;
@@ -17,7 +17,7 @@ describe("createSessionConfig", () => {
             userConfig?: typeof userConfig;
             createSessionConfig?: TransportRunnerConfig["createSessionConfig"];
         } = {}
-    ) => {
+    ): Promise<StreamableHttpRunner> => {
         runner = new StreamableHttpRunner({
             userConfig: { ...userConfig, httpPort: 0, ...config.userConfig },
             createSessionConfig: config.createSessionConfig,
@@ -27,13 +27,13 @@ describe("createSessionConfig", () => {
     };
 
     // Helper to setup server and get user config
-    const getServerConfig = async () => {
+    const getServerConfig = async (): Promise<UserConfig> => {
         const server = await runner["setupServer"]();
         return server.userConfig;
     };
 
     // Helper to create and connect client
-    const createConnectedClient = async () => {
+    const createConnectedClient = async (): Promise<{ client: Client; transport: StreamableHTTPClientTransport }> => {
         client = new Client({ name: "test-client", version: "1.0.0" });
         transport = new StreamableHTTPClientTransport(new URL(`${runner.serverAddress}/mcp`));
         await client.connect(transport);
@@ -109,9 +109,9 @@ describe("createSessionConfig", () => {
             });
 
             await createConnectedClient();
-            const response = await client!.listTools();
+            const response = await client?.listTools();
+            expectDefined(response);
 
-            expect(response).toBeDefined();
             expect(response.tools).toBeDefined();
             expect(response.tools.length).toBeGreaterThan(0);
 
diff --git a/tests/unit/common/config/configOverrides.test.ts b/tests/unit/common/config/configOverrides.test.ts
@@ -144,7 +144,9 @@ describe("configOverrides", () => {
             it("should have some not-allowed fields", () => {
                 expect(
                     Object.keys(UserConfigSchema.shape).filter(
-                        (key) => getConfigMeta(key as any)?.overrideBehavior === "not-allowed"
+                        (key) =>
+                            getConfigMeta(key as keyof typeof UserConfigSchema.shape)?.overrideBehavior ===
+                            "not-allowed"
                     )
                 ).toEqual([
                     "apiBaseUrl",
@@ -183,8 +185,11 @@ describe("configOverrides", () => {
             it("should have certain config keys to be conditionally overridden", () => {
                 expect(
                     Object.keys(UserConfigSchema.shape)
-                        .map((key) => [key, getConfigMeta(key as any)?.overrideBehavior])
-                        .filter(([_, behavior]) => typeof behavior === "function")
+                        .map((key) => [
+                            key,
+                            getConfigMeta(key as keyof typeof UserConfigSchema.shape)?.overrideBehavior,
+                        ])
+                        .filter(([, behavior]) => typeof behavior === "function")
                         .map(([key]) => key)
                 ).toEqual(["readOnly", "indexCheck", "disableEmbeddingsValidation"]);
             });
