chore: model Resources the same way as Tools

himanshusinghs · himanshusinghs · commit 816fb0cf056e · 2025-08-08T12:11:21.000+02:00
diff --git a/src/common/sessionExportsManager.ts b/src/common/sessionExportsManager.ts
@@ -241,11 +241,11 @@ export class SessionExportsManager extends EventEmitter<SessionExportsManagerEve
             : undefined;
     }
 
-    private docToEJSONStream(ejsonOptions: EJSONOptions | undefined) {
+    private docToEJSONStream(ejsonOptions: EJSONOptions | undefined): Transform {
         let docsTransformed = 0;
         return new Transform({
             objectMode: true,
-            transform: function (chunk: unknown, encoding, callback) {
+            transform: function (chunk: unknown, encoding, callback): void {
                 ++docsTransformed;
                 try {
                     const doc: string = EJSON.stringify(chunk, undefined, undefined, ejsonOptions);
@@ -256,7 +256,7 @@ export class SessionExportsManager extends EventEmitter<SessionExportsManagerEve
                     callback(err as Error);
                 }
             },
-            final: function (callback) {
+            final: function (callback): void {
                 this.push("]");
                 callback(null);
             },
@@ -291,7 +291,7 @@ export class SessionExportsManager extends EventEmitter<SessionExportsManagerEve
         }
     }
 
-    private async silentlyRemoveExport(exportPath: string) {
+    private async silentlyRemoveExport(exportPath: string): Promise<void> {
         try {
             await fs.unlink(exportPath);
         } catch (error) {
@@ -335,6 +335,6 @@ export function validateExportName(nameWithExtension: string): string {
     return decodedName;
 }
 
-export function isExportExpired(createdAt: number, exportTimeoutMs: number) {
+export function isExportExpired(createdAt: number, exportTimeoutMs: number): boolean {
     return Date.now() - createdAt > exportTimeoutMs;
 }
diff --git a/src/resources/common/config.ts b/src/resources/common/config.ts
@@ -1,27 +1,27 @@
 import { ReactiveResource } from "../resource.js";
-import { config } from "../../common/config.js";
 import type { UserConfig } from "../../common/config.js";
-import type { Server } from "../../server.js";
 import type { Telemetry } from "../../telemetry/telemetry.js";
+import type { Session } from "../../lib.js";
 
 export class ConfigResource extends ReactiveResource<UserConfig, readonly []> {
-    constructor(server: Server, telemetry: Telemetry) {
-        super(
-            {
+    constructor(session: Session, config: UserConfig, telemetry: Telemetry) {
+        super({
+            resourceConfiguration: {
                 name: "config",
                 uri: "config://config",
                 config: {
                     description:
                         "Server configuration, supplied by the user either as environment variables or as startup arguments",
                 },
             },
-            {
+            options: {
                 initial: { ...config },
                 events: [],
             },
-            server,
-            telemetry
-        );
+            session,
+            config,
+            telemetry,
+        });
     }
     reduce(eventName: undefined, event: undefined): UserConfig {
         void eventName;
diff --git a/src/resources/common/debug.ts b/src/resources/common/debug.ts
@@ -1,6 +1,6 @@
 import { ReactiveResource } from "../resource.js";
-import type { Server } from "../../server.js";
 import type { Telemetry } from "../../telemetry/telemetry.js";
+import { Session, UserConfig } from "../../lib.js";
 
 type ConnectionStateDebuggingInformation = {
     readonly tag: "connected" | "connecting" | "disconnected" | "errored";
@@ -14,23 +14,24 @@ export class DebugResource extends ReactiveResource<
     ConnectionStateDebuggingInformation,
     readonly ["connect", "disconnect", "close", "connection-error"]
 > {
-    constructor(server: Server, telemetry: Telemetry) {
-        super(
-            {
+    constructor(session: Session, config: UserConfig, telemetry: Telemetry) {
+        super({
+            resourceConfiguration: {
                 name: "debug-mongodb",
                 uri: "debug://mongodb",
                 config: {
                     description:
                         "Debugging information for MongoDB connectivity issues. Tracks the last connectivity error and attempt information.",
                 },
             },
-            {
+            options: {
                 initial: { tag: "disconnected" },
                 events: ["connect", "disconnect", "close", "connection-error"],
             },
-            server,
-            telemetry
-        );
+            session,
+            config,
+            telemetry,
+        });
     }
     reduce(
         eventName: "connect" | "disconnect" | "close" | "connection-error",
diff --git a/src/resources/common/exportedData.ts b/src/resources/common/exportedData.ts
@@ -6,25 +6,28 @@ import {
 } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { Server } from "../../server.js";
 import { LogId } from "../../common/logger.js";
+import { Session } from "../../common/session.js";
 
 export class ExportedData {
     private readonly name = "exported-data";
     private readonly description = "Data files exported in the current session.";
     private readonly uri = "exported-data://{exportName}";
+    private server?: Server;
 
-    constructor(private readonly server: Server) {
-        this.server.session.exportsManager.on("export-available", (uri) => {
-            this.server.mcpServer.sendResourceListChanged();
-            void this.server.mcpServer.server.sendResourceUpdated({
+    constructor(private readonly session: Session) {
+        this.session.exportsManager.on("export-available", (uri) => {
+            this.server?.mcpServer.sendResourceListChanged();
+            void this.server?.mcpServer.server.sendResourceUpdated({
                 uri,
             });
         });
-        this.server.session.exportsManager.on("export-expired", () => {
-            this.server.mcpServer.sendResourceListChanged();
+        this.session.exportsManager.on("export-expired", () => {
+            this.server?.mcpServer.sendResourceListChanged();
         });
     }
 
-    public register(): void {
+    public register(server: Server): void {
+        this.server = server;
         this.server.mcpServer.registerResource(
             this.name,
             new ResourceTemplate(this.uri, {
@@ -48,15 +51,15 @@ export class ExportedData {
     private listResourcesCallback: ListResourcesCallback = () => {
         try {
             return {
-                resources: this.server.session.exportsManager.availableExports.map(({ exportName, exportURI }) => ({
+                resources: this.session.exportsManager.availableExports.map(({ exportName, exportURI }) => ({
                     name: exportName,
                     description: this.exportNameToDescription(exportName),
                     uri: exportURI,
                     mimeType: "application/json",
                 })),
             };
         } catch (error) {
-            this.server.session.logger.error({
+            this.session.logger.error({
                 id: LogId.exportedDataListError,
                 context: "Error when listing exported data resources",
                 message: error instanceof Error ? error.message : String(error),
@@ -69,11 +72,11 @@ export class ExportedData {
 
     private autoCompleteExportName: CompleteResourceTemplateCallback = (value) => {
         try {
-            return this.server.session.exportsManager.availableExports
+            return this.session.exportsManager.availableExports
                 .filter(({ exportName }) => exportName.startsWith(value))
                 .map(({ exportName }) => exportName);
         } catch (error) {
-            this.server.session.logger.error({
+            this.session.logger.error({
                 id: LogId.exportedDataAutoCompleteError,
                 context: "Error when autocompleting exported data",
                 message: error instanceof Error ? error.message : String(error),
@@ -88,7 +91,7 @@ export class ExportedData {
                 throw new Error("Cannot retrieve exported data, exportName not provided.");
             }
 
-            const content = await this.server.session.exportsManager.readExport(exportName);
+            const content = await this.session.exportsManager.readExport(exportName);
 
             return {
                 contents: [
@@ -112,7 +115,7 @@ export class ExportedData {
         }
     };
 
-    private exportNameToDescription(exportName: string) {
+    private exportNameToDescription(exportName: string): string {
         const match = exportName.match(/^(.+)\.(\d+)\.json$/);
         if (!match) return "Exported data for an unknown namespace.";
 
diff --git a/src/resources/resource.ts b/src/resources/resource.ts
@@ -20,28 +20,41 @@ export type ReactiveResourceOptions<Value, RelevantEvents extends readonly (keyo
 };
 
 export abstract class ReactiveResource<Value, RelevantEvents extends readonly (keyof SessionEvents)[]> {
-    protected readonly session: Session;
-    protected readonly config: UserConfig;
+    protected server?: Server;
+    protected session: Session;
+    protected config: UserConfig;
+    protected telemetry: Telemetry;
+
     protected current: Value;
     protected readonly name: string;
     protected readonly uri: string;
     protected readonly resourceConfig: ResourceMetadata;
     protected readonly events: RelevantEvents;
 
-    constructor(
-        resourceConfiguration: ResourceConfiguration,
-        options: ReactiveResourceOptions<Value, RelevantEvents>,
-        protected readonly server: Server,
-        protected readonly telemetry: Telemetry,
-        current?: Value
-    ) {
+    constructor({
+        resourceConfiguration,
+        options,
+        session,
+        config,
+        telemetry,
+        current,
+    }: {
+        resourceConfiguration: ResourceConfiguration;
+        options: ReactiveResourceOptions<Value, RelevantEvents>;
+        session: Session;
+        config: UserConfig;
+        telemetry: Telemetry;
+        current?: Value;
+    }) {
+        this.session = session;
+        this.config = config;
+        this.telemetry = telemetry;
+
         this.name = resourceConfiguration.name;
         this.uri = resourceConfiguration.uri;
         this.resourceConfig = resourceConfiguration.config;
         this.events = options.events;
         this.current = current ?? options.initial;
-        this.session = server.session;
-        this.config = server.userConfig;
 
         this.setupEventListeners();
     }
@@ -55,7 +68,8 @@ export abstract class ReactiveResource<Value, RelevantEvents extends readonly (k
         }
     }
 
-    public register(): void {
+    public register(server: Server): void {
+        this.server = server;
         this.server.mcpServer.registerResource(this.name, this.uri, this.resourceConfig, this.resourceCallback);
     }
 
@@ -71,8 +85,8 @@ export abstract class ReactiveResource<Value, RelevantEvents extends readonly (k
 
     private async triggerUpdate(): Promise<void> {
         try {
-            await this.server.mcpServer.server.sendResourceUpdated({ uri: this.uri });
-            this.server.mcpServer.sendResourceListChanged();
+            await this.server?.mcpServer.server.sendResourceUpdated({ uri: this.uri });
+            this.server?.mcpServer.sendResourceListChanged();
         } catch (error: unknown) {
             this.session.logger.warning({
                 id: LogId.resourceUpdateFailure,
diff --git a/src/server.ts b/src/server.ts
@@ -146,8 +146,8 @@ export class Server {
 
     private registerResources(): void {
         for (const resourceConstructor of Resources) {
-            const resource = new resourceConstructor(this, this.telemetry);
-            resource.register();
+            const resource = new resourceConstructor(this.session, this.userConfig, this.telemetry);
+            resource.register(this);
         }
     }
 
diff --git a/tests/integration/helpers.ts b/tests/integration/helpers.ts
@@ -271,7 +271,7 @@ function validateToolAnnotations(tool: ToolInfo, name: string, description: stri
     }
 }
 
-export function timeout(ms: number) {
+export function timeout(ms: number): Promise<void> {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
diff --git a/tests/unit/common/sessionExportsManager.test.ts b/tests/unit/common/sessionExportsManager.test.ts
@@ -25,7 +25,15 @@ const exportsManagerConfig: SessionExportsManagerConfig = {
     exportCleanupIntervalMs: config.exportCleanupIntervalMs,
 } as const;
 
-function getExportNameAndPath(sessionId: string, timestamp: number) {
+function getExportNameAndPath(
+    sessionId: string,
+    timestamp: number
+): {
+    sessionExportsPath: string;
+    exportName: string;
+    exportPath: string;
+    exportURI: string;
+} {
     const exportName = `foo.bar.${timestamp}.json`;
     const sessionExportsPath = path.join(exportsPath, sessionId);
     const exportPath = path.join(sessionExportsPath, exportName);
@@ -44,7 +52,7 @@ function createDummyFindCursor(
     let index = 0;
     const readable = new Readable({
         objectMode: true,
-        async read() {
+        async read(): Promise<void> {
             if (index < dataArray.length) {
                 if (chunkPushTimeoutMs) {
                     await timeout(chunkPushTimeoutMs);
@@ -61,7 +69,7 @@ function createDummyFindCursor(
 
     let notifyClose: () => Promise<void>;
     const cursorCloseNotification = new Promise<void>((resolve) => {
-        notifyClose = async () => {
+        notifyClose = async (): Promise<void> => {
             await timeout(10);
             resolve();
         };
@@ -81,7 +89,7 @@ function createDummyFindCursor(
     };
 }
 
-async function fileExists(filePath: string) {
+async function fileExists(filePath: string): Promise<boolean> {
     try {
         await fs.access(filePath);
         return true;
@@ -288,11 +296,11 @@ describe("SessionExportsManager unit test", () => {
             it("should remove the partial export and never make it available", async () => {
                 const emitSpy = vi.spyOn(manager, "emit");
                 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
-                (manager as any).docToEJSONStream = function (ejsonOptions: EJSONOptions | undefined) {
+                (manager as any).docToEJSONStream = function (ejsonOptions: EJSONOptions | undefined): Transform {
                     let docsTransformed = 0;
                     return new Transform({
                         objectMode: true,
-                        transform: function (chunk: unknown, encoding, callback) {
+                        transform: function (chunk: unknown, encoding, callback): void {
                             ++docsTransformed;
                             try {
                                 if (docsTransformed === 1) {
@@ -306,7 +314,7 @@ describe("SessionExportsManager unit test", () => {
                                 callback(err as Error);
                             }
                         },
-                        final: function (callback) {
+                        final: function (callback): void {
                             this.push("]");
                             callback(null);
                         },
diff --git a/tests/unit/resources/common/debug.test.ts b/tests/unit/resources/common/debug.test.ts
@@ -1,21 +1,18 @@
 import { beforeEach, describe, expect, it } 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";
+import { CompositeLogger } from "../../../../src/common/logger.js";
 
 describe("debug resource", () => {
-    // eslint-disable-next-line
-    const session = new Session({} as any);
-    // eslint-disable-next-line
-    const server = new Server({ session } as any);
+    const session = new Session({ apiBaseUrl: "", logger: new CompositeLogger() });
     const telemetry = Telemetry.create(session, { ...config, telemetry: "disabled" });
 
-    let debugResource: DebugResource = new DebugResource(server, telemetry);
+    let debugResource: DebugResource = new DebugResource(session, config, telemetry);
 
     beforeEach(() => {
-        debugResource = new DebugResource(server, telemetry);
+        debugResource = new DebugResource(session, config, telemetry);
     });
 
     it("should be connected when a connected event happens", () => {

Original file line number	Diff line number	Diff line change
`@@ -241,11 +241,11 @@ export class SessionExportsManager extends EventEmitter<SessionExportsManagerEve`
`241`	`241`	`: undefined;`
`242`	`242`	`}`
`243`	`243`
`244`		`- private docToEJSONStream(ejsonOptions: EJSONOptions \| undefined) {`
	`244`	`+ private docToEJSONStream(ejsonOptions: EJSONOptions \| undefined): Transform {`
`245`	`245`	`let docsTransformed = 0;`
`246`	`246`	`return new Transform({`
`247`	`247`	`objectMode: true,`
`248`		`- transform: function (chunk: unknown, encoding, callback) {`
	`248`	`+ transform: function (chunk: unknown, encoding, callback): void {`
`249`	`249`	`++docsTransformed;`
`250`	`250`	`try {`
`251`	`251`	`const doc: string = EJSON.stringify(chunk, undefined, undefined, ejsonOptions);`
`@@ -256,7 +256,7 @@ export class SessionExportsManager extends EventEmitter<SessionExportsManagerEve`
`256`	`256`	`callback(err as Error);`
`257`	`257`	`}`
`258`	`258`	`},`
`259`		`- final: function (callback) {`
	`259`	`+ final: function (callback): void {`
`260`	`260`	`this.push("]");`
`261`	`261`	`callback(null);`
`262`	`262`	`},`
`@@ -291,7 +291,7 @@ export class SessionExportsManager extends EventEmitter<SessionExportsManagerEve`
`291`	`291`	`}`
`292`	`292`	`}`
`293`	`293`
`294`		`- private async silentlyRemoveExport(exportPath: string) {`
	`294`	`+ private async silentlyRemoveExport(exportPath: string): Promise<void> {`
`295`	`295`	`try {`
`296`	`296`	`await fs.unlink(exportPath);`
`297`	`297`	`} catch (error) {`
`@@ -335,6 +335,6 @@ export function validateExportName(nameWithExtension: string): string {`
`335`	`335`	`return decodedName;`
`336`	`336`	`}`
`337`	`337`
`338`		`-export function isExportExpired(createdAt: number, exportTimeoutMs: number) {`
	`338`	`+export function isExportExpired(createdAt: number, exportTimeoutMs: number): boolean {`
`339`	`339`	`return Date.now() - createdAt > exportTimeoutMs;`
`340`	`340`	`}`
Original file line number	Diff line number	Diff line change
`@@ -146,8 +146,8 @@ export class Server {`
`146`	`146`
`147`	`147`	`private registerResources(): void {`
`148`	`148`	`for (const resourceConstructor of Resources) {`
`149`		`- const resource = new resourceConstructor(this, this.telemetry);`
`150`		`- resource.register();`
	`149`	`+ const resource = new resourceConstructor(this.session, this.userConfig, this.telemetry);`
	`150`	`+ resource.register(this);`
`151`	`151`	`}`
`152`	`152`	`}`
`153`	`153`
Original file line number	Diff line number	Diff line change
`@@ -271,7 +271,7 @@ function validateToolAnnotations(tool: ToolInfo, name: string, description: stri`
`271`	`271`	`}`
`272`	`272`	`}`
`273`	`273`
`274`		`-export function timeout(ms: number) {`
	`274`	`+export function timeout(ms: number): Promise<void> {`
`275`	`275`	`return new Promise((resolve) => setTimeout(resolve, ms));`
`276`	`276`	`}`
`277`	`277`