chore: Probe of concept for reactive resources based on the session

It can listen to events on the session and their arguments, and
reduces the current state with the argument to provide a new state.

Author: kmruiz

src/common/session.ts

@@ -13,10 +13,13 @@ export interface SessionOptions {
     apiClientSecret?: string;
 }
 
-export class Session extends EventEmitter<{
+export type SessionEvents = {
+    connected: [];
     close: [];
     disconnect: [];
-}> {
+};
+
+export class Session extends EventEmitter<SessionEvents> {
     sessionId?: string;
     serviceProvider?: NodeDriverServiceProvider;
     apiClient: ApiClient;
@@ -116,5 +119,7 @@ export class Session extends EventEmitter<{
             proxy: { useEnvironmentVariableProxies: true },
             applyProxyToOIDC: true,
         });
+
+        this.emit("connected");
     }
 }

src/resources/common/config.ts

@@ -0,0 +1,40 @@
+import { ReactiveResource } from "../resource.js";
+import { config } from "../../common/config.js";
+import type { UserConfig } from "../../common/config.js";
+
+export class ConfigResource extends ReactiveResource(
+    {
+        name: "config",
+        uri: "config://config",
+        config: {
+            description:
+                "Server configuration, supplied by the user either as environment variables or as startup arguments",
+        },
+    },
+    {
+        initial: { ...config },
+        events: [],
+    }
+) {
+    reduce(previous: UserConfig, eventName: undefined, event: undefined): UserConfig {
+        void event;
+        return previous;
+    }
+
+    toOutput(state: UserConfig): string {
+        const result = {
+            telemetry: state.telemetry,
+            logPath: state.logPath,
+            connectionString: state.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,
+            atlas:
+                state.apiClientId && state.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'.",
+        };
+
+        return JSON.stringify(result);
+    }
+}

src/resources/common/debug.ts

@@ -0,0 +1,50 @@
+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";
+    readonly connectionStringAuthType?: "scram" | "ldap" | "kerberos" | "oidc-auth-flow" | "oidc-device-flow" | "x.509";
+    readonly oidcLoginUrl?: string;
+    readonly oidcUserCode?: string;
+    readonly errorReason?: string;
+};
+
+export class DebugResource extends ReactiveResource(
+    {
+        name: "debug",
+        uri: "config://debug",
+        config: {
+            description: "Debugging information for connectivity issues.",
+        },
+    },
+    {
+        initial: { tag: "disconnected" },
+        events: ["connected", "disconnect", "close"],
+    }
+) {
+    reduce(
+        previous: ConnectionStateDebuggingInformation,
+        eventName: "connected" | "disconnect" | "close",
+        event: undefined
+    ): ConnectionStateDebuggingInformation {
+        void event;
+
+        switch (eventName) {
+            case "connected":
+                return { tag: "connected" };
+            case "disconnect":
+                return { tag: "disconnected" };
+            case "close":
+                return { tag: "disconnected" };
+        }
+    }
+
+    toOutput(state: ConnectionStateDebuggingInformation): string {
+        const result = {
+            connectionStatus: state.tag,
+        };
+
+        return JSON.stringify(result);
+    }
+}

src/resources/resource.ts

@@ -0,0 +1,73 @@
+import { Server } from "../server.js";
+import { Session } from "../common/session.js";
+import { UserConfig } from "../common/config.js";
+import { Telemetry } from "../telemetry/telemetry.js";
+import type { SessionEvents } from "../common/session.js";
+import { ReadResourceCallback, RegisteredResource, ResourceMetadata } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+type PayloadOf<K extends keyof SessionEvents> = SessionEvents[K][0];
+
+type ResourceConfiguration = { name: string; uri: string; config: ResourceMetadata };
+
+export function ReactiveResource<V, KE extends readonly (keyof SessionEvents)[]>(
+    { name, uri, config: resourceConfig }: ResourceConfiguration,
+    {
+        initial,
+        events,
+    }: {
+        initial: V;
+        events: KE;
+    }
+) {
+    type E = KE[number];
+
+    abstract class NewReactiveResource {
+        private registeredResource?: RegisteredResource;
+
+        constructor(
+            protected readonly server: Server,
+            protected readonly session: Session,
+            protected readonly config: UserConfig,
+            protected readonly telemetry: Telemetry,
+            private current?: V
+        ) {
+            this.current = initial;
+
+            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.triggerUpdate();
+                });
+            }
+        }
+
+        public register(): void {
+            this.registeredResource = this.server.mcpServer.registerResource(
+                name,
+                uri,
+                resourceConfig,
+                this.resourceCallback
+            );
+        }
+
+        private resourceCallback: ReadResourceCallback = (uri) => ({
+            contents: [
+                {
+                    text: this.toOutput(this.current),
+                    mimeType: "application/json",
+                    uri: uri.href,
+                },
+            ],
+        });
+
+        private triggerUpdate() {
+            this.registeredResource?.update({});
+            this.server.mcpServer.sendResourceListChanged();
+        }
+
+        abstract reduce(previous: V | undefined, eventName: E, ...event: PayloadOf<E>[]): V;
+        abstract toOutput(state: V | undefined): string;
+    }
+
+    return NewReactiveResource;
+}

src/resources/resources.ts

@@ -0,0 +1,4 @@
+import { ConfigResource } from "./common/config.js";
+import { DebugResource } from "./common/debug.js";
+
+export const Resources = [ConfigResource, DebugResource] as const;

src/server.ts

@@ -3,6 +3,7 @@ import { Session } from "./common/session.js";
 import { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
 import { AtlasTools } from "./tools/atlas/tools.js";
 import { MongoDbTools } from "./tools/mongodb/tools.js";
+import { Resources } from "./resources/resources.js";
 import logger, { LogId, LoggerBase, McpLogger, DiskLogger, ConsoleLogger } from "./common/logger.js";
 import { ObjectId } from "mongodb";
 import { Telemetry } from "./telemetry/telemetry.js";
@@ -155,37 +156,10 @@ export class Server {
     }
 
     private registerResources() {
-        this.mcpServer.resource(
-            "config",
-            "config://config",
-            {
-                description:
-                    "Server configuration, supplied by the user either as environment variables or as startup arguments",
-            },
-            (uri) => {
-                const result = {
-                    telemetry: this.userConfig.telemetry,
-                    logPath: this.userConfig.logPath,
-                    connectionString: this.userConfig.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: this.userConfig.connectOptions,
-                    atlas:
-                        this.userConfig.apiClientId && this.userConfig.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'.",
-                };
-                return {
-                    contents: [
-                        {
-                            text: JSON.stringify(result),
-                            mimeType: "application/json",
-                            uri: uri.href,
-                        },
-                    ],
-                };
-            }
-        );
+        for (const resourceConstructor of Resources) {
+            const resource = new resourceConstructor(this, this.session, this.userConfig, this.telemetry);
+            resource.register();
+        }
     }
 
     private async validateConfig(): Promise<void> {