wip

Author: gagik

package-lock.json

@@ -3,7 +3,6 @@ import createClient, { Client, FetchOptions, Middleware } from "openapi-fetch";
 import { AccessToken, ClientCredentials } from "simple-oauth2";
 
 import { paths, operations } from "./openapi.js";
-import { State } from "../../state.js";
 
 const ATLAS_API_VERSION = "2025-03-12";
 
@@ -70,7 +69,8 @@ export class ApiClient {
                 // ignore not availble tokens, API will return 401
             }
         },
-    };
+    });
+
     private readonly errorMiddleware: Middleware = {
         async onResponse({ response }) {
             if (!response.ok) {
@@ -79,7 +79,7 @@ export class ApiClient {
         },
     };
 
-    constructor(options?: ApiClientOptions) {
+    constructor(options: ApiClientOptions) {
         const defaultOptions = {
             baseUrl: "https://cloud.mongodb.com/",
             userAgent: `AtlasMCP/${config.version} (${process.platform}; ${process.arch}; ${process.env.HOSTNAME || "unknown"})`,
@@ -110,7 +110,7 @@ export class ApiClient {
             });
             this.client.use(this.authMiddleware(this));
         }
-        this.client.use(this.errorMiddleware());
+        this.client.use(this.errorMiddleware);
     }
 
     public async getIpInfo(): Promise<{

src/common/atlas/apiClient.ts

@@ -60,7 +60,10 @@ function getLogPath(): string {
 // to SNAKE_UPPER_CASE.
 function getEnvConfig(): Partial<UserConfig> {
     function setValue(obj: Record<string, unknown>, path: string[], value: string): void {
-        const currentField = path.shift()!;
+        const currentField = path.shift();
+        if (!currentField) {
+            return;
+        }
         if (path.length === 0) {
             const numberValue = Number(value);
             if (!isNaN(numberValue)) {

src/config.ts

@@ -11,21 +11,15 @@ import { Server } from "./server.js";
 
 try {
     const state = new State();
-    await state.loadCredentials();
-
-    const apiClient = ApiClient.fromState(state);
-
     const mcpServer = new McpServer({
         name: "MongoDB Atlas",
         version: config.version,
     });
-
     const transport = new StdioServerTransport();
 
-    const server = new Server({
+    const server = new Seriver({
         mcpServer,
         state,
-        apiClient,
         transport,
     });
 

src/index.ts

@@ -1,14 +1,20 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import defaultState, { State } from "./state.js";
+import { State } from "./state.js";
 import { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
 import { registerAtlasTools } from "./tools/atlas/tools.js";
 import { registerMongoDBTools } from "./tools/mongodb/index.js";
 import logger, { initializeLogger } from "./logger.js";
 import { mongoLogId } from "mongodb-log-writer";
+import { ApiClient } from "./common/atlas/apiClient.js";
 
 export class Server {
-    state: State = defaultState;
-    private server?: McpServer;
+    public readonly state: State;
+    private readonly mcpServer: McpServer;
+
+    constructor({ mcpServer, state, transport }: { mcpServer: McpServer; state: State; transport: Transport }) {
+        this.mcpServer = server;
+        this.state = new State();
+    }
 
     async connect(transport: Transport) {
         this.server = new McpServer({

src/server.ts

@@ -3,7 +3,6 @@ import { ApiClient } from "./common/atlas/apiClient.js";
 import config from "./config.js";
 
 export class State {
-    serviceProvider?: NodeDriverServiceProvider;
     apiClient?: ApiClient;
 
     ensureApiClient(): asserts this is { apiClient: ApiClient } {

src/state.ts

@@ -57,7 +57,7 @@ export class ConnectTool extends MongoDBToolBase {
             throw new MongoDBError(ErrorCodes.InvalidParams, "Invalid connection options");
         }
 
-        await this.connectToMongoDB(connectionString, this.state);
+        await this.connectToMongoDB(connectionString);
 
         return {
             content: [{ type: "text", text: `Successfully connected to ${connectionString}.` }],

src/tools/mongodb/connect.ts

@@ -1,6 +1,5 @@
 import { z } from "zod";
 import { ToolBase } from "../tool.js";
-import { State } from "../../state.js";
 import { NodeDriverServiceProvider } from "@mongosh/service-provider-node-driver";
 import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import { ErrorCodes, MongoDBError } from "../../errors.js";
@@ -14,23 +13,22 @@ export const DbOperationArgs = {
 export type DbOperationType = "metadata" | "read" | "create" | "update" | "delete";
 
 export abstract class MongoDBToolBase extends ToolBase {
-    constructor(state: State) {
-        super(state);
+    constructor(private serviceProvider: NodeDriverServiceProvider | undefined) {
+        super();
     }
 
     protected abstract operationType: DbOperationType;
 
     protected async ensureConnected(): Promise<NodeDriverServiceProvider> {
-        const provider = this.state.serviceProvider;
-        if (!provider && config.connectionString) {
-            await this.connectToMongoDB(config.connectionString, this.state);
+        if (!this.serviceProvider && config.connectionString) {
+            this.serviceProvider = await this.connectToMongoDB(config.connectionString);
         }
 
-        if (!provider) {
+        if (!this.serviceProvider) {
             throw new MongoDBError(ErrorCodes.NotConnectedToMongoDB, "Not connected to MongoDB");
         }
 
-        return provider;
+        return this.serviceProvider;
     }
 
     protected handleError(error: unknown): Promise<CallToolResult> | CallToolResult {
@@ -53,8 +51,8 @@ export abstract class MongoDBToolBase extends ToolBase {
         return super.handleError(error);
     }
 
-    protected async connectToMongoDB(connectionString: string, state: State): Promise<void> {
-        const provider = await NodeDriverServiceProvider.connect(connectionString, {
+    protected async connectToMongoDB(connectionString: string): Promise<NodeDriverServiceProvider> {
+        return NodeDriverServiceProvider.connect(connectionString, {
             productDocsLink: "https://docs.mongodb.com/todo-mcp",
             productName: "MongoDB MCP",
             readConcern: {
@@ -66,7 +64,5 @@ export abstract class MongoDBToolBase extends ToolBase {
             },
             timeoutMS: config.connectOptions.timeoutMS,
         });
-
-        state.serviceProvider = provider;
     }
 }

src/tools/mongodb/mongodbTool.ts

@@ -1,7 +1,6 @@
 import { McpServer, ToolCallback } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z, ZodNever, ZodRawShape } from "zod";
 import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
-import { State } from "../state.js";
 import logger from "../logger.js";
 import { mongoLogId } from "mongodb-log-writer";
 
@@ -16,7 +15,7 @@ export abstract class ToolBase {
 
     protected abstract execute(...args: Parameters<ToolCallback<typeof this.argsShape>>): Promise<CallToolResult>;
 
-    protected constructor(protected state: State) {}
+    protected constructor() {}
 
     public register(server: McpServer): void {
         const callback: ToolCallback<typeof this.argsShape> = async (...args) => {