mongodb-mcp-server 0.1.1 → 0.1.3

package/tests/integration/tools/atlas/projects.test.ts

@@ -43,7 +43,7 @@ describeWithAtlas("projects", (integration) => {
             })) as CallToolResult;
             expect(response.content).toBeArray();
             expect(response.content).toHaveLength(1);
-            expect(response.content[0].text).toContain(projName);
+            expect(response.content[0]?.text).toContain(projName);
         });
     });
     describe("atlas-list-projects", () => {
@@ -62,8 +62,8 @@ describeWithAtlas("projects", (integration) => {
                 .callTool({ name: "atlas-list-projects", arguments: {} })) as CallToolResult;
             expect(response.content).toBeArray();
             expect(response.content).toHaveLength(1);
-            expect(response.content[0].text).toContain(projName);
-            const data = parseTable(response.content[0].text as string);
+            expect(response.content[0]?.text).toContain(projName);
+            const data = parseTable(response.content[0]?.text as string);
             expect(data).toBeArray();
             expect(data.length).toBeGreaterThan(0);
             let found = false;

package/tests/integration/tools/mongodb/create/createCollection.test.ts

@@ -34,7 +34,7 @@ describeWithMongoDB("createCollection tool", (integration) => {
 
             collections = await mongoClient.db(integration.randomDbName()).listCollections().toArray();
             expect(collections).toHaveLength(1);
-            expect(collections[0].name).toEqual("bar");
+            expect(collections[0]?.name).toEqual("bar");
         });
     });
 
@@ -78,7 +78,7 @@ describeWithMongoDB("createCollection tool", (integration) => {
             expect(content).toEqual(`Collection "collection1" created in database "${integration.randomDbName()}".`);
             collections = await mongoClient.db(integration.randomDbName()).listCollections().toArray();
             expect(collections).toHaveLength(1);
-            expect(collections[0].name).toEqual("collection1");
+            expect(collections[0]?.name).toEqual("collection1");
 
             // Make sure we didn't drop the existing collection
             documents = await mongoClient.db(integration.randomDbName()).collection("collection1").find({}).toArray();

package/tests/integration/tools/mongodb/create/createIndex.test.ts

@@ -38,10 +38,10 @@ describeWithMongoDB("createIndex tool", (integration) => {
         const mongoClient = integration.mongoClient();
         const collections = await mongoClient.db(integration.randomDbName()).listCollections().toArray();
         expect(collections).toHaveLength(1);
-        expect(collections[0].name).toEqual("coll1");
+        expect(collections[0]?.name).toEqual("coll1");
         const indexes = await mongoClient.db(integration.randomDbName()).collection(collection).indexes();
         expect(indexes).toHaveLength(expected.length + 1);
-        expect(indexes[0].name).toEqual("_id_");
+        expect(indexes[0]?.name).toEqual("_id_");
         for (const index of expected) {
             const foundIndex = indexes.find((i) => i.name === index.name);
             expectDefined(foundIndex);

package/tests/integration/tools/mongodb/create/insertMany.test.ts

@@ -82,7 +82,7 @@ describeWithMongoDB("insertMany tool", (integration) => {
         const content = getResponseContent(response.content);
         expect(content).toContain("Error running insert-many");
         expect(content).toContain("duplicate key error");
-        expect(content).toContain(insertedIds[0].toString());
+        expect(content).toContain(insertedIds[0]?.toString());
     });
 
     validateAutoConnectBehavior(integration, "insert-many", () => {

package/tests/integration/tools/mongodb/delete/dropCollection.test.ts

@@ -54,7 +54,7 @@ describeWithMongoDB("dropCollection tool", (integration) => {
         );
         const collections = await integration.mongoClient().db(integration.randomDbName()).listCollections().toArray();
         expect(collections).toHaveLength(1);
-        expect(collections[0].name).toBe("coll2");
+        expect(collections[0]?.name).toBe("coll2");
     });
 
     validateAutoConnectBehavior(integration, "drop-collection", () => {

package/tests/integration/tools/mongodb/metadata/collectionSchema.test.ts

@@ -132,11 +132,11 @@ describeWithMongoDB("collectionSchema tool", (integration) => {
                 expect(items).toHaveLength(2);
 
                 // Expect to find _id, name, age
-                expect(items[0].text).toEqual(
+                expect(items[0]?.text).toEqual(
                     `Found ${Object.entries(testCase.expectedSchema).length} fields in the schema for "${integration.randomDbName()}.foo"`
                 );
 
-                const schema = JSON.parse(items[1].text) as SimplifiedSchema;
+                const schema = JSON.parse(items[1]?.text ?? "{}") as SimplifiedSchema;
                 expect(schema).toEqual(testCase.expectedSchema);
             });
         }

package/tests/integration/tools/mongodb/metadata/dbStats.test.ts

@@ -28,9 +28,9 @@ describeWithMongoDB("dbStats tool", (integration) => {
             });
             const elements = getResponseElements(response.content);
             expect(elements).toHaveLength(2);
-            expect(elements[0].text).toBe(`Statistics for database ${integration.randomDbName()}`);
+            expect(elements[0]?.text).toBe(`Statistics for database ${integration.randomDbName()}`);
 
-            const stats = JSON.parse(elements[1].text) as {
+            const stats = JSON.parse(elements[1]?.text ?? "{}") as {
                 db: string;
                 collections: number;
                 storageSize: number;
@@ -75,9 +75,9 @@ describeWithMongoDB("dbStats tool", (integration) => {
                 });
                 const elements = getResponseElements(response.content);
                 expect(elements).toHaveLength(2);
-                expect(elements[0].text).toBe(`Statistics for database ${integration.randomDbName()}`);
+                expect(elements[0]?.text).toBe(`Statistics for database ${integration.randomDbName()}`);
 
-                const stats = JSON.parse(elements[1].text) as {
+                const stats = JSON.parse(elements[1]?.text ?? "{}") as {
                     db: string;
                     collections: unknown;
                     storageSize: unknown;

package/tests/integration/tools/mongodb/metadata/explain.test.ts

@@ -89,12 +89,12 @@ describeWithMongoDB("explain tool", (integration) => {
 
                     const content = getResponseElements(response.content);
                     expect(content).toHaveLength(2);
-                    expect(content[0].text).toEqual(
+                    expect(content[0]?.text).toEqual(
                         `Here is some information about the winning plan chosen by the query optimizer for running the given \`${testCase.method}\` operation in "${integration.randomDbName()}.coll1". This information can be used to understand how the query was executed and to optimize the query performance.`
                     );
 
-                    expect(content[1].text).toContain("queryPlanner");
-                    expect(content[1].text).toContain("winningPlan");
+                    expect(content[1]?.text).toContain("queryPlanner");
+                    expect(content[1]?.text).toContain("winningPlan");
                 });
             }
         });
@@ -139,22 +139,22 @@ describeWithMongoDB("explain tool", (integration) => {
 
                         const content = getResponseElements(response.content);
                         expect(content).toHaveLength(2);
-                        expect(content[0].text).toEqual(
+                        expect(content[0]?.text).toEqual(
                             `Here is some information about the winning plan chosen by the query optimizer for running the given \`${testCase.method}\` operation in "${integration.randomDbName()}.people". This information can be used to understand how the query was executed and to optimize the query performance.`
                         );
 
-                        expect(content[1].text).toContain("queryPlanner");
-                        expect(content[1].text).toContain("winningPlan");
+                        expect(content[1]?.text).toContain("queryPlanner");
+                        expect(content[1]?.text).toContain("winningPlan");
 
                         if (indexed) {
                             if (testCase.method === "count") {
-                                expect(content[1].text).toContain("COUNT_SCAN");
+                                expect(content[1]?.text).toContain("COUNT_SCAN");
                             } else {
-                                expect(content[1].text).toContain("IXSCAN");
+                                expect(content[1]?.text).toContain("IXSCAN");
                             }
-                            expect(content[1].text).toContain("name_1");
+                            expect(content[1]?.text).toContain("name_1");
                         } else {
-                            expect(content[1].text).toContain("COLLSCAN");
+                            expect(content[1]?.text).toContain("COLLSCAN");
                         }
                     });
                 }

package/tests/integration/tools/mongodb/metadata/listCollections.test.ts

@@ -45,7 +45,7 @@ describeWithMongoDB("listCollections tool", (integration) => {
             });
             const items = getResponseElements(response.content);
             expect(items).toHaveLength(1);
-            expect(items[0].text).toContain('Name: "collection-1"');
+            expect(items[0]?.text).toContain('Name: "collection-1"');
 
             await mongoClient.db(integration.randomDbName()).createCollection("collection-2");
 

package/tests/integration/tools/mongodb/metadata/listDatabases.test.ts

@@ -65,9 +65,13 @@ describeWithMongoDB("listDatabases tool", (integration) => {
 
 function getDbNames(content: unknown): (string | null)[] {
     const responseItems = getResponseElements(content);
-
-    return responseItems.map((item) => {
-        const match = item.text.match(/Name: (.*), Size: \d+ bytes/);
-        return match ? match[1] : null;
-    });
+    return responseItems
+        .map((item) => {
+            if (item && typeof item.text === "string") {
+                const match = item.text.match(/Name: ([^,]+), Size: \d+ bytes/);
+                return match ? match[1] : null;
+            }
+            return null;
+        })
+        .filter((item): item is string | null => item !== undefined);
 }

package/tests/integration/tools/mongodb/metadata/logs.test.ts

@@ -37,11 +37,11 @@ describeWithMongoDB("logs tool", (integration) => {
 
         // Default limit is 50
         expect(elements.length).toBeLessThanOrEqual(51);
-        expect(elements[0].text).toMatch(/Found: \d+ messages/);
+        expect(elements[0]?.text).toMatch(/Found: \d+ messages/);
 
         for (let i = 1; i < elements.length; i++) {
             // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-            const log = JSON.parse(elements[i].text);
+            const log = JSON.parse(elements[i]?.text ?? "{}");
             expect(log).toHaveProperty("t");
             expect(log).toHaveProperty("msg");
         }
@@ -59,7 +59,7 @@ describeWithMongoDB("logs tool", (integration) => {
         const elements = getResponseElements(response);
         expect(elements.length).toBeLessThanOrEqual(51);
         for (let i = 1; i < elements.length; i++) {
-            const log = JSON.parse(elements[i].text) as { tags: string[] };
+            const log = JSON.parse(elements[i]?.text ?? "{}") as { tags: string[] };
             expect(log).toHaveProperty("t");
             expect(log).toHaveProperty("msg");
             expect(log).toHaveProperty("tags");
@@ -76,7 +76,7 @@ describeWithMongoDB("logs tool", (integration) => {
             validate: (content) => {
                 const elements = getResponseElements(content);
                 expect(elements.length).toBeLessThanOrEqual(51);
-                expect(elements[0].text).toMatch(/Found: \d+ messages/);
+                expect(elements[0]?.text).toMatch(/Found: \d+ messages/);
             },
         };
     });

package/tests/integration/tools/mongodb/mongodbHelpers.ts

@@ -70,6 +70,7 @@ export function setupMongoDBIntegrationTest(): MongoDBIntegrationTest {
                     tmpDir: dbsDir,
                     logDir: path.join(tmpDir, "mongodb-runner", "logs"),
                     topology: "standalone",
+                    version: "8.0.10",
                 });
 
                 return;

package/tests/integration/tools/mongodb/read/aggregate.test.ts

@@ -35,7 +35,7 @@ describeWithMongoDB("aggregate tool", (integration) => {
 
         const elements = getResponseElements(response.content);
         expect(elements).toHaveLength(1);
-        expect(elements[0].text).toEqual('Found 0 documents in the collection "people":');
+        expect(elements[0]?.text).toEqual('Found 0 documents in the collection "people":');
     });
 
     it("can run aggragation on an empty collection", async () => {
@@ -53,7 +53,7 @@ describeWithMongoDB("aggregate tool", (integration) => {
 
         const elements = getResponseElements(response.content);
         expect(elements).toHaveLength(1);
-        expect(elements[0].text).toEqual('Found 0 documents in the collection "people":');
+        expect(elements[0]?.text).toEqual('Found 0 documents in the collection "people":');
     });
 
     it("can run aggragation on an existing collection", async () => {
@@ -79,11 +79,21 @@ describeWithMongoDB("aggregate tool", (integration) => {
 
         const elements = getResponseElements(response.content);
         expect(elements).toHaveLength(3);
-        expect(elements[0].text).toEqual('Found 2 documents in the collection "people":');
-        /* eslint-disable @typescript-eslint/no-unsafe-assignment */
-        expect(JSON.parse(elements[1].text)).toEqual({ _id: expect.any(Object), name: "Søren", age: 15 });
-        expect(JSON.parse(elements[2].text)).toEqual({ _id: expect.any(Object), name: "Laura", age: 10 });
-        /* eslint-enable @typescript-eslint/no-unsafe-assignment */
+        expect(elements[0]?.text).toEqual('Found 2 documents in the collection "people":');
+        expect(asObject(JSON.parse(elements[1]?.text ?? "{}"))).toEqual(
+            expect.objectContaining({
+                _id: expect.any(Object) as object,
+                name: "Søren",
+                age: 15,
+            })
+        );
+        expect(asObject(JSON.parse(elements[2]?.text ?? "{}"))).toEqual(
+            expect.objectContaining({
+                _id: expect.any(Object) as object,
+                name: "Laura",
+                age: 10,
+            })
+        );
     });
 
     validateAutoConnectBehavior(integration, "aggregate", () => {
@@ -97,3 +107,8 @@ describeWithMongoDB("aggregate tool", (integration) => {
         };
     });
 });
+
+function asObject(val: unknown): Record<string, unknown> {
+    if (typeof val === "object" && val !== null) return val as Record<string, unknown>;
+    throw new Error("Expected an object");
+}

package/tests/integration/tools/mongodb/read/collectionIndexes.test.ts

@@ -28,7 +28,7 @@ describeWithMongoDB("collectionIndexes tool", (integration) => {
 
         const elements = getResponseElements(response.content);
         expect(elements).toHaveLength(1);
-        expect(elements[0].text).toEqual(
+        expect(elements[0]?.text).toEqual(
             'The indexes for "non-existent.people" cannot be determined because the collection does not exist.'
         );
     });
@@ -47,8 +47,8 @@ describeWithMongoDB("collectionIndexes tool", (integration) => {
 
         const elements = getResponseElements(response.content);
         expect(elements).toHaveLength(2);
-        expect(elements[0].text).toEqual('Found 1 indexes in the collection "people":');
-        expect(elements[1].text).toEqual('Name "_id_", definition: {"_id":1}');
+        expect(elements[0]?.text).toEqual('Found 1 indexes in the collection "people":');
+        expect(elements[1]?.text).toEqual('Name "_id_", definition: {"_id":1}');
     });
 
     it("returns all indexes for a collection", async () => {
@@ -74,8 +74,8 @@ describeWithMongoDB("collectionIndexes tool", (integration) => {
 
         const elements = getResponseElements(response.content);
         expect(elements).toHaveLength(indexTypes.length + 2);
-        expect(elements[0].text).toEqual(`Found ${indexTypes.length + 1} indexes in the collection "people":`);
-        expect(elements[1].text).toEqual('Name "_id_", definition: {"_id":1}');
+        expect(elements[0]?.text).toEqual(`Found ${indexTypes.length + 1} indexes in the collection "people":`);
+        expect(elements[1]?.text).toEqual('Name "_id_", definition: {"_id":1}');
 
         for (const indexType of indexTypes) {
             const index = elements.find((element) => element.text.includes(`prop_${indexType}`));

package/tests/integration/tools/mongodb/read/count.test.ts

@@ -8,16 +8,21 @@ import {
 } from "../../../helpers.js";
 
 describeWithMongoDB("count tool", (integration) => {
-    validateToolMetadata(integration, "count", "Gets the number of documents in a MongoDB collection", [
-        {
-            name: "query",
-            description:
-                "The query filter to count documents. Matches the syntax of the filter argument of db.collection.count()",
-            type: "object",
-            required: false,
-        },
-        ...databaseCollectionParameters,
-    ]);
+    validateToolMetadata(
+        integration,
+        "count",
+        "Gets the number of documents in a MongoDB collection using db.collection.count() and query as an optional filter parameter",
+        [
+            {
+                name: "query",
+                description:
+                    "A filter/query parameter. Allows users to filter the documents to count. Matches the syntax of the filter argument of db.collection.count().",
+                type: "object",
+                required: false,
+            },
+            ...databaseCollectionParameters,
+        ]
+    );
 
     validateThrowsForInvalidArguments(integration, "count", [
         {},

package/tests/integration/tools/mongodb/read/find.test.ts

@@ -149,10 +149,10 @@ describeWithMongoDB("find tool", (integration) => {
                 });
                 const elements = getResponseElements(response.content);
                 expect(elements).toHaveLength(expected.length + 1);
-                expect(elements[0].text).toEqual(`Found ${expected.length} documents in the collection "foo":`);
+                expect(elements[0]?.text).toEqual(`Found ${expected.length} documents in the collection "foo":`);
 
                 for (let i = 0; i < expected.length; i++) {
-                    expect(JSON.parse(elements[i + 1].text)).toEqual(expected[i]);
+                    expect(JSON.parse(elements[i + 1]?.text ?? "{}")).toEqual(expected[i]);
                 }
             });
         }
@@ -165,11 +165,11 @@ describeWithMongoDB("find tool", (integration) => {
             });
             const elements = getResponseElements(response.content);
             expect(elements).toHaveLength(11);
-            expect(elements[0].text).toEqual('Found 10 documents in the collection "foo":');
+            expect(elements[0]?.text).toEqual('Found 10 documents in the collection "foo":');
 
             for (let i = 0; i < 10; i++) {
                 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-                expect(JSON.parse(elements[i + 1].text).value).toEqual(i);
+                expect(JSON.parse(elements[i + 1]?.text ?? "{}").value).toEqual(i);
             }
         });
 
@@ -194,10 +194,10 @@ describeWithMongoDB("find tool", (integration) => {
 
             const elements = getResponseElements(response.content);
             expect(elements).toHaveLength(2);
-            expect(elements[0].text).toEqual('Found 1 documents in the collection "foo":');
+            expect(elements[0]?.text).toEqual('Found 1 documents in the collection "foo":');
 
             // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-            expect(JSON.parse(elements[1].text).value).toEqual(fooObject.value);
+            expect(JSON.parse(elements[1]?.text ?? "{}").value).toEqual(fooObject.value);
         });
     });
 

package/tests/integration/tools/mongodb/update/renameCollection.test.ts

@@ -94,7 +94,7 @@ describeWithMongoDB("renameCollection tool", (integration) => {
                 .find({})
                 .toArray();
             expect(docsInAfter).toHaveLength(1);
-            expect(docsInAfter[0].value).toEqual(42);
+            expect(docsInAfter[0]?.value).toEqual(42);
         });
 
         it("returns an error when renaming to an existing collection", async () => {
@@ -123,7 +123,7 @@ describeWithMongoDB("renameCollection tool", (integration) => {
                 .find({})
                 .toArray();
             expect(docsInBefore).toHaveLength(1);
-            expect(docsInBefore[0].value).toEqual(42);
+            expect(docsInBefore[0]?.value).toEqual(42);
 
             const docsInAfter = await integration
                 .mongoClient()
@@ -132,7 +132,7 @@ describeWithMongoDB("renameCollection tool", (integration) => {
                 .find({})
                 .toArray();
             expect(docsInAfter).toHaveLength(1);
-            expect(docsInAfter[0].value).toEqual(84);
+            expect(docsInAfter[0]?.value).toEqual(84);
         });
 
         it("renames to existing collection with dropTarget", async () => {
@@ -174,7 +174,7 @@ describeWithMongoDB("renameCollection tool", (integration) => {
                 .find({})
                 .toArray();
             expect(docsInAfter).toHaveLength(1);
-            expect(docsInAfter[0].value).toEqual(42);
+            expect(docsInAfter[0]?.value).toEqual(42);
         });
     });
 

package/tests/unit/EJsonTransport.test.ts

@@ -37,7 +37,7 @@ describe("EJsonTransport", () => {
         );
 
         expect(messages.length).toBe(1);
-        const message = messages[0].message;
+        const message = messages[0]?.message;
 
         expect(message).toEqual({
             jsonrpc: "2.0",

package/tests/unit/indexCheck.test.ts

@@ -0,0 +1,149 @@
+import { usesIndex, getIndexCheckErrorMessage } from "../../src/helpers/indexCheck.js";
+import { Document } from "mongodb";
+
+describe("indexCheck", () => {
+    describe("usesIndex", () => {
+        it("should return true for IXSCAN", () => {
+            const explainResult: Document = {
+                queryPlanner: {
+                    winningPlan: {
+                        stage: "IXSCAN",
+                    },
+                },
+            };
+            expect(usesIndex(explainResult)).toBe(true);
+        });
+
+        it("should return true for COUNT_SCAN", () => {
+            const explainResult: Document = {
+                queryPlanner: {
+                    winningPlan: {
+                        stage: "COUNT_SCAN",
+                    },
+                },
+            };
+            expect(usesIndex(explainResult)).toBe(true);
+        });
+
+        it("should return true for IDHACK", () => {
+            const explainResult: Document = {
+                queryPlanner: {
+                    winningPlan: {
+                        stage: "IDHACK",
+                    },
+                },
+            };
+            expect(usesIndex(explainResult)).toBe(true);
+        });
+
+        it("should return true for EXPRESS_IXSCAN (MongoDB 8.0+)", () => {
+            const explainResult: Document = {
+                queryPlanner: {
+                    winningPlan: {
+                        stage: "EXPRESS_IXSCAN",
+                    },
+                },
+            };
+            expect(usesIndex(explainResult)).toBe(true);
+        });
+
+        it("should return true for EXPRESS_CLUSTERED_IXSCAN (MongoDB 8.0+)", () => {
+            const explainResult: Document = {
+                queryPlanner: {
+                    winningPlan: {
+                        stage: "EXPRESS_CLUSTERED_IXSCAN",
+                    },
+                },
+            };
+            expect(usesIndex(explainResult)).toBe(true);
+        });
+
+        it("should return true for EXPRESS_UPDATE (MongoDB 8.0+)", () => {
+            const explainResult: Document = {
+                queryPlanner: {
+                    winningPlan: {
+                        stage: "EXPRESS_UPDATE",
+                    },
+                },
+            };
+            expect(usesIndex(explainResult)).toBe(true);
+        });
+
+        it("should return true for EXPRESS_DELETE (MongoDB 8.0+)", () => {
+            const explainResult: Document = {
+                queryPlanner: {
+                    winningPlan: {
+                        stage: "EXPRESS_DELETE",
+                    },
+                },
+            };
+            expect(usesIndex(explainResult)).toBe(true);
+        });
+
+        it("should return false for COLLSCAN", () => {
+            const explainResult: Document = {
+                queryPlanner: {
+                    winningPlan: {
+                        stage: "COLLSCAN",
+                    },
+                },
+            };
+            expect(usesIndex(explainResult)).toBe(false);
+        });
+
+        it("should return true for nested IXSCAN in inputStage", () => {
+            const explainResult: Document = {
+                queryPlanner: {
+                    winningPlan: {
+                        stage: "LIMIT",
+                        inputStage: {
+                            stage: "IXSCAN",
+                        },
+                    },
+                },
+            };
+            expect(usesIndex(explainResult)).toBe(true);
+        });
+
+        it("should return true for nested EXPRESS_IXSCAN in inputStage", () => {
+            const explainResult: Document = {
+                queryPlanner: {
+                    winningPlan: {
+                        stage: "SORT",
+                        inputStage: {
+                            stage: "EXPRESS_IXSCAN",
+                        },
+                    },
+                },
+            };
+            expect(usesIndex(explainResult)).toBe(true);
+        });
+
+        it("should return false for unknown stage types", () => {
+            const explainResult: Document = {
+                queryPlanner: {
+                    winningPlan: {
+                        stage: "UNKNOWN_STAGE",
+                    },
+                },
+            };
+            expect(usesIndex(explainResult)).toBe(false);
+        });
+
+        it("should handle missing queryPlanner", () => {
+            const explainResult: Document = {};
+            expect(usesIndex(explainResult)).toBe(false);
+        });
+    });
+
+    describe("getIndexCheckErrorMessage", () => {
+        it("should generate appropriate error message", () => {
+            const message = getIndexCheckErrorMessage("testdb", "testcoll", "find");
+            expect(message).toContain("Index check failed");
+            expect(message).toContain("testdb.testcoll");
+            expect(message).toContain("find operation");
+            expect(message).toContain("collection scan (COLLSCAN)");
+            expect(message).toContain("MDB_MCP_INDEX_CHECK");
+        });
+    });
+});

package/tests/unit/session.test.ts

@@ -53,7 +53,7 @@ describe("Session", () => {
                     typeof NodeDriverServiceProvider.connect
                 >;
                 expect(connectMock).toHaveBeenCalledOnce();
-                const connectionString = connectMock.mock.calls[0][0];
+                const connectionString = connectMock.mock.calls[0]?.[0];
                 if (testCase.expectAppName) {
                     expect(connectionString).toContain("appName=MongoDB+MCP+Server");
                 } else {

package/tsconfig.build.json

@@ -7,6 +7,7 @@
     "outDir": "./dist",
     "strict": true,
     "strictNullChecks": true,
+    "noUncheckedIndexedAccess": true,
     "esModuleInterop": true,
     "types": ["node"],
     "sourceMap": true,