chore: use custom overrides

Author: gagik

src/common/config/configOverrides.ts

@@ -132,13 +132,15 @@ function applyOverride(
     behavior: OverrideBehavior
 ): unknown {
     if (typeof behavior === "function") {
-        const shouldApply = behavior(baseValue, overrideValue);
-        if (!shouldApply) {
+        // Custom logic function returns the value to use (potentially transformed)
+        // or throws an error if the override cannot be applied
+        try {
+            return behavior(baseValue, overrideValue);
+        } catch (error) {
             throw new Error(
-                `Config override validation failed for ${key}: cannot override from ${JSON.stringify(baseValue)} to ${JSON.stringify(overrideValue)}`
+                `Cannot apply override for ${key} from ${JSON.stringify(baseValue)} to ${JSON.stringify(overrideValue)}: ${error instanceof Error ? error.message : String(error)}`
             );
         }
-        return overrideValue;
     }
     switch (behavior) {
         case "override":

src/common/config/configUtils.ts

@@ -5,8 +5,9 @@ import * as levenshteinModule from "ts-levenshtein";
 const levenshtein = levenshteinModule.default;
 
 /// Custom logic function to apply the override value.
-/// Returns true if the override should be applied, false otherwise.
-export type CustomOverrideLogic = (oldValue: unknown, newValue: unknown) => boolean;
+/// Returns the value to use (which may be transformed from newValue).
+/// Should throw an error if the override cannot be applied.
+export type CustomOverrideLogic = (oldValue: unknown, newValue: unknown) => unknown;
 
 /**
  * Defines how a config field can be overridden via HTTP headers or query parameters.

src/common/config/userConfig.ts

@@ -89,9 +89,9 @@ export const UserConfigSchema = z4.object({
             overrideBehavior: (oldValue, newValue) => {
                 // Only allow override if setting to true from false
                 if (oldValue === false && newValue === true) {
-                    return true;
+                    return newValue;
                 }
-                return false;
+                throw new Error("Cannot disable readOnly mode");
             },
         }),
     indexCheck: z4
@@ -103,10 +103,10 @@ export const UserConfigSchema = z4.object({
         .register(configRegistry, {
             overrideBehavior: (oldValue, newValue) => {
                 // Only allow override if setting to true from false
-                if (oldValue === false && newValue === true) {
-                    return true;
+                if (newValue === true) {
+                    return newValue;
                 }
-                return false;
+                throw new Error("Cannot disable indexCheck mode");
             },
         }),
     telemetry: z4
@@ -200,10 +200,10 @@ export const UserConfigSchema = z4.object({
         .register(configRegistry, {
             overrideBehavior: (oldValue, newValue) => {
                 // Only allow override if setting to false from true (making more restrictive)
-                if (oldValue === true && newValue === false) {
-                    return true;
+                if (newValue === false) {
+                    return newValue;
                 }
-                return false;
+                throw new Error("Cannot disable disableEmbeddingsValidation");
             },
         }),
     vectorSearchDimensions: z4.coerce

tests/integration/transports/configOverrides.test.ts

@@ -68,27 +68,6 @@ describe("Config Overrides via HTTP", () => {
             expect(readTools.length).toBe(1);
         });
 
-        it("should NOT override readOnly from true to false", async () => {
-            await startRunner({
-                ...defaultTestConfig,
-                httpPort: 0,
-                readOnly: true,
-            });
-
-            try {
-                await connectClient({
-                    ["x-mongodb-mcp-read-only"]: "false",
-                });
-                expect.fail("Expected an error to be thrown");
-            } catch (error) {
-                if (!(error instanceof Error)) {
-                    throw new Error("Expected an error to be thrown");
-                }
-                expect(error.message).toContain("Error POSTing to endpoint (HTTP 400)");
-                expect(error.message).toContain(`Config override validation failed for readOnly`);
-            }
-        });
-
         it("should override connectionString via header", async () => {
             await startRunner({
                 ...defaultTestConfig,
@@ -350,7 +329,9 @@ describe("Config Overrides via HTTP", () => {
                     throw new Error("Expected an error to be thrown");
                 }
                 expect(error.message).toContain("Error POSTing to endpoint (HTTP 400)");
-                expect(error.message).toContain(`Config override validation failed for readOnly`);
+                expect(error.message).toContain(
+                    `Cannot apply override for readOnly from true to false: Cannot disable readOnly mode`
+                );
             }
         });
     });

tests/unit/common/config/configOverrides.test.ts

@@ -141,6 +141,28 @@ describe("configOverrides", () => {
         });
 
         describe("not-allowed behavior", () => {
+            it("shoud have some not-allowed fields", () => {
+                expect(
+                    Object.keys(UserConfigSchema.shape).filter(
+                        (key) => getConfigMeta(key as any)?.overrideBehavior === "not-allowed"
+                    )
+                ).toEqual([
+                    "apiBaseUrl",
+                    "apiClientId",
+                    "apiClientSecret",
+                    "logPath",
+                    "telemetry",
+                    "transport",
+                    "httpPort",
+                    "httpHost",
+                    "httpHeaders",
+                    "maxBytesPerQuery",
+                    "maxDocumentsPerQuery",
+                    "exportsPath",
+                    "voyageApiKey",
+                ]);
+            });
+
             it("should throw an error for not-allowed fields", () => {
                 const request: RequestContext = {
                     headers: {
@@ -157,7 +179,7 @@ describe("configOverrides", () => {
             });
         });
 
-        describe("conditional overrides", () => {
+        describe("custom overrides", () => {
             it("should have certain config keys to be conditionally overridden", () => {
                 expect(
                     Object.keys(UserConfigSchema.shape)
@@ -180,7 +202,7 @@ describe("configOverrides", () => {
                 const request: RequestContext = { headers: { "x-mongodb-mcp-read-only": "false" } };
                 expect(() =>
                     applyConfigOverrides({ baseConfig: { ...baseConfig, readOnly: true } as UserConfig, request })
-                ).toThrow("Config override validation failed for readOnly");
+                ).toThrow("Cannot apply override for readOnly from true to false: Cannot disable readOnly mode");
             });
 
             it("should allow indexCheck override from false to true", () => {
@@ -196,7 +218,7 @@ describe("configOverrides", () => {
                 const request: RequestContext = { headers: { "x-mongodb-mcp-index-check": "false" } };
                 expect(() =>
                     applyConfigOverrides({ baseConfig: { ...baseConfig, indexCheck: true } as UserConfig, request })
-                ).toThrow("Config override validation failed for indexCheck");
+                ).toThrow("Cannot apply override for indexCheck from true to false: Cannot disable indexCheck mode");
             });
 
             it("should allow disableEmbeddingsValidation override from true to false", () => {
@@ -215,7 +237,9 @@ describe("configOverrides", () => {
                         baseConfig: { ...baseConfig, disableEmbeddingsValidation: false } as UserConfig,
                         request,
                     })
-                ).toThrow("Config override validation failed for disableEmbeddingsValidation");
+                ).toThrow(
+                    "Cannot apply override for disableEmbeddingsValidation from false to true: Cannot disable disableEmbeddingsValidation"
+                );
             });
         });