chore: Add debug resource relevant events

Also add unit tests to show how to test resources.

Author: kmruiz

src/common/session.ts

@@ -17,6 +17,7 @@ export type SessionEvents = {
     connected: [];
     close: [];
     disconnect: [];
+    "connection-error": [string];
 };
 
 export class Session extends EventEmitter<SessionEvents> {
@@ -105,20 +106,27 @@ export class Session extends EventEmitter<SessionEvents> {
             connectionString,
             defaultAppName: `${packageInfo.mcpServerName} ${packageInfo.version}`,
         });
-        this.serviceProvider = await NodeDriverServiceProvider.connect(connectionString, {
-            productDocsLink: "https://github.com/mongodb-js/mongodb-mcp-server/",
-            productName: "MongoDB MCP",
-            readConcern: {
-                level: connectOptions.readConcern,
-            },
-            readPreference: connectOptions.readPreference,
-            writeConcern: {
-                w: connectOptions.writeConcern,
-            },
-            timeoutMS: connectOptions.timeoutMS,
-            proxy: { useEnvironmentVariableProxies: true },
-            applyProxyToOIDC: true,
-        });
+
+        try {
+            this.serviceProvider = await NodeDriverServiceProvider.connect(connectionString, {
+                productDocsLink: "https://github.com/mongodb-js/mongodb-mcp-server/",
+                productName: "MongoDB MCP",
+                readConcern: {
+                    level: connectOptions.readConcern,
+                },
+                readPreference: connectOptions.readPreference,
+                writeConcern: {
+                    w: connectOptions.writeConcern,
+                },
+                timeoutMS: connectOptions.timeoutMS,
+                proxy: { useEnvironmentVariableProxies: true },
+                applyProxyToOIDC: true,
+            });
+        } catch (error: unknown) {
+            const message = error instanceof Error ? error.message : `${error}`;
+            this.emit("connection-error", message);
+            throw error;
+        }
 
         this.emit("connected");
     }

src/resources/common/config.ts

@@ -16,21 +16,23 @@ export class ConfigResource extends ReactiveResource(
         events: [],
     }
 ) {
-    reduce(previous: UserConfig, eventName: undefined, event: undefined): UserConfig {
+    reduce(eventName: undefined, event: undefined): UserConfig {
+        void eventName;
         void event;
-        return previous;
+
+        return this.current;
     }
 
-    toOutput(state: UserConfig): string {
+    toOutput(): string {
         const result = {
-            telemetry: state.telemetry,
-            logPath: state.logPath,
-            connectionString: state.connectionString
+            telemetry: this.current.telemetry,
+            logPath: this.current.logPath,
+            connectionString: this.current.connectionString
                 ? "set; access to MongoDB tools are currently available to use"
                 : "not set; before using any MongoDB tool, you need to configure a connection string, alternatively you can setup MongoDB Atlas access, more info at 'https://github.com/mongodb-js/mongodb-mcp-server'.",
-            connectOptions: state.connectOptions,
+            connectOptions: this.current.connectOptions,
             atlas:
-                state.apiClientId && state.apiClientSecret
+                this.current.apiClientId && this.current.apiClientSecret
                     ? "set; MongoDB Atlas tools are currently available to use"
                     : "not set; MongoDB Atlas tools are currently unavailable, to have access to MongoDB Atlas tools like creating clusters or connecting to clusters make sure to setup credentials, more info at 'https://github.com/mongodb-js/mongodb-mcp-server'.",
         };

src/resources/common/debug.ts

@@ -1,6 +1,4 @@
 import { ReactiveResource } from "../resource.js";
-import { config } from "../../common/config.js";
-import type { UserConfig } from "../../common/config.js";
 
 type ConnectionStateDebuggingInformation = {
     readonly tag: "connected" | "connecting" | "disconnected" | "errored";
@@ -19,32 +17,43 @@ export class DebugResource extends ReactiveResource(
         },
     },
     {
-        initial: { tag: "disconnected" },
-        events: ["connected", "disconnect", "close"],
+        initial: { tag: "disconnected" } as ConnectionStateDebuggingInformation,
+        events: ["connected", "disconnect", "close", "connection-error"],
     }
 ) {
     reduce(
-        previous: ConnectionStateDebuggingInformation,
-        eventName: "connected" | "disconnect" | "close",
-        event: undefined
+        eventName: "connected" | "disconnect" | "close" | "connection-error",
+        event: string | undefined
     ): ConnectionStateDebuggingInformation {
         void event;
 
         switch (eventName) {
             case "connected":
                 return { tag: "connected" };
+            case "connection-error":
+                return { tag: "errored", errorReason: event };
             case "disconnect":
-                return { tag: "disconnected" };
             case "close":
                 return { tag: "disconnected" };
         }
     }
 
-    toOutput(state: ConnectionStateDebuggingInformation): string {
-        const result = {
-            connectionStatus: state.tag,
-        };
+    toOutput(): string {
+        let result = "";
+
+        switch (this.current.tag) {
+            case "connected":
+                result += "The user is connected to the MongoDB cluster.";
+                break;
+            case "errored":
+                result += `The user is not connected to a MongoDB cluster because of an error.\n`;
+                result += `<error>${this.current.errorReason}</error>`;
+                break;
+            case "disconnected":
+                result += "The user is not connected to a MongoDB cluster.";
+                break;
+        }
 
-        return JSON.stringify(result);
+        return result;
     }
 }

src/resources/resource.ts

@@ -23,19 +23,21 @@ export function ReactiveResource<V, KE extends readonly (keyof SessionEvents)[]>
 
     abstract class NewReactiveResource {
         private registeredResource?: RegisteredResource;
+        protected readonly session: Session;
+        protected readonly config: UserConfig;
 
         constructor(
             protected readonly server: Server,
-            protected readonly session: Session,
-            protected readonly config: UserConfig,
             protected readonly telemetry: Telemetry,
-            private current?: V
+            protected current: V
         ) {
             this.current = initial;
+            this.session = server.session;
+            this.config = server.userConfig;
 
             for (const event of events) {
                 this.session.on(event, (...args: SessionEvents[typeof event]) => {
-                    this.current = this.reduce(this.current, event, (args as unknown[])[0] as PayloadOf<typeof event>);
+                    this.reduceApply(event, (args as unknown[])[0] as PayloadOf<typeof event>);
                     this.triggerUpdate();
                 });
             }
@@ -53,7 +55,7 @@ export function ReactiveResource<V, KE extends readonly (keyof SessionEvents)[]>
         private resourceCallback: ReadResourceCallback = (uri) => ({
             contents: [
                 {
-                    text: this.toOutput(this.current),
+                    text: this.toOutput(),
                     mimeType: "application/json",
                     uri: uri.href,
                 },
@@ -65,8 +67,12 @@ export function ReactiveResource<V, KE extends readonly (keyof SessionEvents)[]>
             this.server.mcpServer.sendResourceListChanged();
         }
 
-        abstract reduce(previous: V | undefined, eventName: E, ...event: PayloadOf<E>[]): V;
-        abstract toOutput(state: V | undefined): string;
+        reduceApply(eventName: E, ...event: PayloadOf<E>[]): void {
+            this.current = this.reduce(eventName, ...event);
+        }
+
+        protected abstract reduce(eventName: E, ...event: PayloadOf<E>[]): V;
+        abstract toOutput(): string;
     }
 
     return NewReactiveResource;

src/server.ts

@@ -157,7 +157,7 @@ export class Server {
 
     private registerResources() {
         for (const resourceConstructor of Resources) {
-            const resource = new resourceConstructor(this, this.session, this.userConfig, this.telemetry);
+            const resource = new resourceConstructor(this, this.telemetry);
             resource.register();
         }
     }

tests/unit/resources/common/debug.test.ts

@@ -0,0 +1,43 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { DebugResource } from "../../../../src/resources/common/debug.js";
+import { Session } from "../../../../src/common/session.js";
+import { Server } from "../../../../src/server.js";
+import { Telemetry } from "../../../../src/telemetry/telemetry.js";
+import { config } from "../../../../src/common/config.js";
+
+describe("debug resource", () => {
+    let session = new Session({} as any);
+    let server = new Server({ session } as any);
+    let telemetry = Telemetry.create(session, { ...config, telemetry: "disabled" });
+
+    let debugResource: DebugResource = new DebugResource(server, telemetry, { tag: "disconnected" });
+
+    it("should be connected when a connected event happens", () => {
+        debugResource.reduceApply("connected", undefined);
+        const output = debugResource.toOutput();
+
+        expect(output).toContain(`The user is connected to the MongoDB cluster.`);
+    });
+
+    it("should be disconnected when a disconnect event happens", () => {
+        debugResource.reduceApply("disconnect", undefined);
+        const output = debugResource.toOutput();
+
+        expect(output).toContain(`The user is not connected to a MongoDB cluster.`);
+    });
+
+    it("should be disconnected when a close event happens", () => {
+        debugResource.reduceApply("close", undefined);
+        const output = debugResource.toOutput();
+
+        expect(output).toContain(`The user is not connected to a MongoDB cluster.`);
+    });
+
+    it("should be disconnected and contain an error when an error event occurred", () => {
+        debugResource.reduceApply("connection-error", "Error message from the server");
+        const output = debugResource.toOutput();
+
+        expect(output).toContain(`The user is not connected to a MongoDB cluster because of an error.`);
+        expect(output).toContain(`<error>Error message from the server</error>`);
+    });
+});