mongodb-mcp-server 0.1.2 → 0.2.0

package/tests/unit/common/managedTimeout.test.ts

@@ -0,0 +1,67 @@
+import { afterAll, beforeAll, describe, expect, it, vi } from "vitest";
+import { setManagedTimeout } from "../../../src/common/managedTimeout.js";
+
+describe("setManagedTimeout", () => {
+    beforeAll(() => {
+        vi.useFakeTimers();
+    });
+
+    afterAll(() => {
+        vi.useRealTimers();
+    });
+
+    it("calls the timeout callback", () => {
+        const callback = vi.fn();
+
+        setManagedTimeout(callback, 1000);
+
+        vi.advanceTimersByTime(1000);
+        expect(callback).toHaveBeenCalled();
+    });
+
+    it("does not call the timeout callback if the timeout is cleared", () => {
+        const callback = vi.fn();
+
+        const timeout = setManagedTimeout(callback, 1000);
+
+        vi.advanceTimersByTime(500);
+        timeout.cancel();
+        vi.advanceTimersByTime(500);
+
+        expect(callback).not.toHaveBeenCalled();
+    });
+
+    it("does not call the timeout callback if the timeout is reset", () => {
+        const callback = vi.fn();
+
+        const timeout = setManagedTimeout(callback, 1000);
+
+        vi.advanceTimersByTime(500);
+        timeout.restart();
+        vi.advanceTimersByTime(500);
+        expect(callback).not.toHaveBeenCalled();
+    });
+
+    describe("if timeout is reset", () => {
+        it("does not call the timeout callback within the timeout period", () => {
+            const callback = vi.fn();
+
+            const timeout = setManagedTimeout(callback, 1000);
+
+            vi.advanceTimersByTime(500);
+            timeout.restart();
+            vi.advanceTimersByTime(500);
+            expect(callback).not.toHaveBeenCalled();
+        });
+        it("calls the timeout callback after the timeout period", () => {
+            const callback = vi.fn();
+
+            const timeout = setManagedTimeout(callback, 1000);
+
+            vi.advanceTimersByTime(500);
+            timeout.restart();
+            vi.advanceTimersByTime(1000);
+            expect(callback).toHaveBeenCalled();
+        });
+    });
+});

package/tests/unit/{session.test.ts → common/session.test.ts}

@@ -1,10 +1,10 @@
-import { jest } from "@jest/globals";
+import { beforeEach, describe, expect, it, vi } from "vitest";
 import { NodeDriverServiceProvider } from "@mongosh/service-provider-node-driver";
-import { Session } from "../../src/session.js";
-import { config } from "../../src/config.js";
+import { Session } from "../../../src/common/session.js";
+import { config } from "../../../src/common/config.js";
 
-jest.mock("@mongosh/service-provider-node-driver");
-const MockNodeDriverServiceProvider = NodeDriverServiceProvider as jest.MockedClass<typeof NodeDriverServiceProvider>;
+vi.mock("@mongosh/service-provider-node-driver");
+const MockNodeDriverServiceProvider = vi.mocked(NodeDriverServiceProvider);
 
 describe("Session", () => {
     let session: Session;
@@ -14,9 +14,7 @@ describe("Session", () => {
             apiBaseUrl: "https://api.test.com",
         });
 
-        MockNodeDriverServiceProvider.connect = jest.fn(() =>
-            Promise.resolve({} as unknown as NodeDriverServiceProvider)
-        );
+        MockNodeDriverServiceProvider.connect = vi.fn().mockResolvedValue({} as unknown as NodeDriverServiceProvider);
     });
 
     describe("connectToMongoDB", () => {
@@ -48,10 +46,7 @@ describe("Session", () => {
                 await session.connectToMongoDB(testCase.connectionString, config.connectOptions);
                 expect(session.serviceProvider).toBeDefined();
 
-                // eslint-disable-next-line @typescript-eslint/unbound-method
-                const connectMock = MockNodeDriverServiceProvider.connect as jest.Mock<
-                    typeof NodeDriverServiceProvider.connect
-                >;
+                const connectMock = MockNodeDriverServiceProvider.connect;
                 expect(connectMock).toHaveBeenCalledOnce();
                 const connectionString = connectMock.mock.calls[0]?.[0];
                 if (testCase.expectAppName) {

package/tests/unit/helpers/indexCheck.test.ts

@@ -0,0 +1,150 @@
+import { describe, expect, it } from "vitest";
+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/telemetry.test.ts

@@ -1,36 +1,37 @@
 import { ApiClient } from "../../src/common/atlas/apiClient.js";
-import { Session } from "../../src/session.js";
-import { Telemetry } from "../../src/telemetry/telemetry.js";
+import { Session } from "../../src/common/session.js";
+import { DEVICE_ID_TIMEOUT, Telemetry } from "../../src/telemetry/telemetry.js";
 import { BaseEvent, TelemetryResult } from "../../src/telemetry/types.js";
 import { EventCache } from "../../src/telemetry/eventCache.js";
-import { config } from "../../src/config.js";
-import { jest } from "@jest/globals";
-import logger, { LogId } from "../../src/logger.js";
+import { config } from "../../src/common/config.js";
+import { afterEach, beforeEach, describe, it, vi, expect } from "vitest";
+import logger, { LogId } from "../../src/common/logger.js";
 import { createHmac } from "crypto";
+import type { MockedFunction } from "vitest";
 
 // Mock the ApiClient to avoid real API calls
-jest.mock("../../src/common/atlas/apiClient.js");
-const MockApiClient = ApiClient as jest.MockedClass<typeof ApiClient>;
+vi.mock("../../src/common/atlas/apiClient.js");
+const MockApiClient = vi.mocked(ApiClient);
 
 // Mock EventCache to control and verify caching behavior
-jest.mock("../../src/telemetry/eventCache.js");
-const MockEventCache = EventCache as jest.MockedClass<typeof EventCache>;
-
-const nextTick = () => new Promise((resolve) => process.nextTick(resolve));
+vi.mock("../../src/telemetry/eventCache.js");
+const MockEventCache = vi.mocked(EventCache);
 
 describe("Telemetry", () => {
     const machineId = "test-machine-id";
     const hashedMachineId = createHmac("sha256", machineId.toUpperCase()).update("atlascli").digest("hex");
 
-    let mockApiClient: jest.Mocked<ApiClient>;
-    let mockEventCache: jest.Mocked<EventCache>;
+    let mockApiClient: {
+        sendEvents: MockedFunction<(events: BaseEvent[]) => Promise<void>>;
+        hasCredentials: MockedFunction<() => boolean>;
+    };
+    let mockEventCache: {
+        getEvents: MockedFunction<() => BaseEvent[]>;
+        clearEvents: MockedFunction<() => Promise<void>>;
+        appendEvents: MockedFunction<(events: BaseEvent[]) => Promise<void>>;
+    };
     let session: Session;
     let telemetry: Telemetry;
-    let telemetryConfig: {
-        eventCache: EventCache;
-        getRawMachineId: () => Promise<string>;
-        getContainerEnv: () => Promise<boolean>;
-    };
 
     // Helper function to create properly typed test events
     function createTestEvent(options?: {
@@ -84,53 +85,52 @@ describe("Telemetry", () => {
         expect(appendEvents.length).toBe(appendEventsCalls);
 
         if (sendEventsCalledWith) {
-            expect(sendEvents[0]?.[0]).toMatchObject(sendEventsCalledWith);
+            expect(sendEvents[0]?.[0]).toEqual(
+                sendEventsCalledWith.map((event) => ({
+                    ...event,
+                    properties: {
+                        ...telemetry.getCommonProperties(),
+                        ...event.properties,
+                    },
+                }))
+            );
         }
 
         if (appendEventsCalledWith) {
-            expect(appendEvents[0]?.[0]).toMatchObject(appendEventsCalledWith);
+            expect(appendEvents[0]?.[0]).toEqual(appendEventsCalledWith);
         }
     }
 
     beforeEach(() => {
         // Reset mocks before each test
-        jest.clearAllMocks();
+        vi.clearAllMocks();
 
         // Setup mocked API client
-        mockApiClient = new MockApiClient({ baseUrl: "" }) as jest.Mocked<ApiClient>;
-        //@ts-expect-error This is a workaround
-        mockApiClient.sendEvents = jest.fn<() => undefined>().mockResolvedValue(undefined);
-        mockApiClient.hasCredentials = jest.fn<() => boolean>().mockReturnValue(true);
+        mockApiClient = vi.mocked(new MockApiClient({ baseUrl: "" }));
+
+        mockApiClient.sendEvents = vi.fn().mockResolvedValue(undefined);
+        mockApiClient.hasCredentials = vi.fn().mockReturnValue(true);
 
         // Setup mocked EventCache
-        mockEventCache = new MockEventCache() as jest.Mocked<EventCache>;
-        //@ts-expect-error This is a workaround
-        mockEventCache.getEvents = jest.fn().mockReturnValue([]);
-        //@ts-expect-error This is a workaround
-        mockEventCache.clearEvents = jest.fn().mockResolvedValue(undefined);
-        //@ts-expect-error This is a workaround
-        mockEventCache.appendEvents = jest.fn().mockResolvedValue(undefined);
-        //@ts-expect-error This is a workaround
-        MockEventCache.getInstance = jest.fn().mockReturnValue(mockEventCache);
+        mockEventCache = new MockEventCache() as unknown as typeof mockEventCache;
+        mockEventCache.getEvents = vi.fn().mockReturnValue([]);
+        mockEventCache.clearEvents = vi.fn().mockResolvedValue(undefined);
+        mockEventCache.appendEvents = vi.fn().mockResolvedValue(undefined);
+        MockEventCache.getInstance = vi.fn().mockReturnValue(mockEventCache as unknown as EventCache);
 
         // Create a simplified session with our mocked API client
         session = {
-            apiClient: mockApiClient,
+            apiClient: mockApiClient as unknown as ApiClient,
             sessionId: "test-session-id",
             agentRunner: { name: "test-agent", version: "1.0.0" } as const,
-            //@ts-expect-error This is a workaround
-            close: jest.fn().mockResolvedValue(undefined),
-            //@ts-expect-error This is a workaround
-            setAgentRunner: jest.fn().mockResolvedValue(undefined),
+            close: vi.fn().mockResolvedValue(undefined),
+            setAgentRunner: vi.fn().mockResolvedValue(undefined),
         } as unknown as Session;
 
-        telemetryConfig = {
-            eventCache: mockEventCache,
+        telemetry = Telemetry.create(session, config, {
+            eventCache: mockEventCache as unknown as EventCache,
             getRawMachineId: () => Promise.resolve(machineId),
-            getContainerEnv: () => Promise.resolve(false),
-        };
-
-        telemetry = Telemetry.create(session, config, telemetryConfig);
+        });
 
         config.telemetry = "enabled";
     });
@@ -140,8 +140,9 @@ describe("Telemetry", () => {
             it("should send events successfully", async () => {
                 const testEvent = createTestEvent();
 
-                telemetry.emitEvents([testEvent]);
-                await nextTick(); // wait for the event to be sent
+                await telemetry.setupPromise;
+
+                await telemetry.emitEvents([testEvent]);
 
                 verifyMockCalls({
                     sendEventsCalls: 1,
@@ -155,8 +156,9 @@ describe("Telemetry", () => {
 
                 const testEvent = createTestEvent();
 
-                telemetry.emitEvents([testEvent]);
-                await nextTick(); // wait for the event to be sent
+                await telemetry.setupPromise;
+
+                await telemetry.emitEvents([testEvent]);
 
                 verifyMockCalls({
                     sendEventsCalls: 1,
@@ -179,8 +181,9 @@ describe("Telemetry", () => {
                 // Set up mock to return cached events
                 mockEventCache.getEvents.mockReturnValueOnce([cachedEvent]);
 
-                telemetry.emitEvents([newEvent]);
-                await nextTick(); // wait for the event to be sent
+                await telemetry.setupPromise;
+
+                await telemetry.emitEvents([newEvent]);
 
                 verifyMockCalls({
                     sendEventsCalls: 1,
@@ -190,6 +193,10 @@ describe("Telemetry", () => {
             });
 
             it("should correctly add common properties to events", async () => {
+                await telemetry.setupPromise;
+
+                const commonProps = telemetry.getCommonProperties();
+
                 // Use explicit type assertion
                 const expectedProps: Record<string, string> = {
                     mcp_client_version: "1.0.0",
@@ -200,86 +207,48 @@ describe("Telemetry", () => {
                     device_id: hashedMachineId,
                 };
 
-                const testEvent = createTestEvent();
-
-                telemetry.emitEvents([testEvent]);
-                await nextTick(); // wait for the event to be sent
-
-                const checkEvent = {
-                    ...testEvent,
-                    properties: {
-                        ...testEvent.properties,
-                        ...expectedProps,
-                    },
-                };
-
-                verifyMockCalls({
-                    sendEventsCalls: 1,
-                    clearEventsCalls: 1,
-                    sendEventsCalledWith: [checkEvent],
-                });
+                expect(commonProps).toMatchObject(expectedProps);
             });
 
-            it("should send cache new event while sending another event", async () => {
-                const newEvent = createTestEvent({
-                    command: "new-command",
-                    component: "new-component",
+            describe("machine ID resolution", () => {
+                beforeEach(() => {
+                    vi.clearAllMocks();
+                    vi.useFakeTimers();
                 });
 
-                const newEvent2 = createTestEvent({
-                    command: "new-command-2",
-                    component: "new-component-2",
+                afterEach(() => {
+                    vi.clearAllMocks();
+                    vi.useRealTimers();
                 });
 
-                telemetry.emitEvents([newEvent]);
-                telemetry.emitEvents([newEvent2]);
+                it("should successfully resolve the machine ID", async () => {
+                    telemetry = Telemetry.create(session, config, {
+                        getRawMachineId: () => Promise.resolve(machineId),
+                    });
 
-                await nextTick(); // wait for the event to be sent
+                    expect(telemetry["isBufferingEvents"]).toBe(true);
+                    expect(telemetry.getCommonProperties().device_id).toBe(undefined);
 
-                verifyMockCalls({
-                    sendEventsCalls: 1,
-                    clearEventsCalls: 1,
-                    appendEventsCalls: 1,
-                    sendEventsCalledWith: [newEvent],
-                    appendEventsCalledWith: [newEvent2],
-                });
-            });
+                    await telemetry.setupPromise;
 
-            describe("machine ID resolution", () => {
-                it("should successfully resolve the machine ID", async () => {
-                    const testEvent = createTestEvent();
-
-                    telemetry.emitEvents([testEvent]);
-                    await nextTick(); // wait for the event to be sent
-
-                    const checkEvent = {
-                        ...testEvent,
-                        properties: {
-                            ...testEvent.properties,
-                            device_id: hashedMachineId,
-                        },
-                    };
-
-                    verifyMockCalls({
-                        sendEventsCalls: 1,
-                        clearEventsCalls: 1,
-                        sendEventsCalledWith: [checkEvent],
-                    });
+                    expect(telemetry["isBufferingEvents"]).toBe(false);
+                    expect(telemetry.getCommonProperties().device_id).toBe(hashedMachineId);
                 });
 
                 it("should handle machine ID resolution failure", async () => {
-                    const loggerSpy = jest.spyOn(logger, "debug");
+                    const loggerSpy = vi.spyOn(logger, "debug");
 
                     telemetry = Telemetry.create(session, config, {
-                        ...telemetryConfig,
                         getRawMachineId: () => Promise.reject(new Error("Failed to get device ID")),
                     });
 
-                    const testEvent = createTestEvent();
+                    expect(telemetry["isBufferingEvents"]).toBe(true);
+                    expect(telemetry.getCommonProperties().device_id).toBe(undefined);
 
-                    telemetry.emitEvents([testEvent]);
+                    await telemetry.setupPromise;
 
-                    await nextTick(); // wait for the event to be sent
+                    expect(telemetry["isBufferingEvents"]).toBe(false);
+                    expect(telemetry.getCommonProperties().device_id).toBe("unknown");
 
                     expect(loggerSpy).toHaveBeenCalledWith(
                         LogId.telemetryDeviceIdFailure,
@@ -288,28 +257,27 @@ describe("Telemetry", () => {
                     );
                 });
 
-                it("should timeout if machine ID resolution takes too long", () => {
-                    const loggerSpy = jest.spyOn(logger, "debug");
-
-                    jest.useFakeTimers();
+                it("should timeout if machine ID resolution takes too long", async () => {
+                    const loggerSpy = vi.spyOn(logger, "debug");
 
-                    telemetry = Telemetry.create(session, config, {
-                        ...telemetryConfig,
-                        getRawMachineId: () => new Promise(() => {}), // Never resolves
-                    });
+                    telemetry = Telemetry.create(session, config, { getRawMachineId: () => new Promise(() => {}) });
 
-                    const testEvent = createTestEvent();
+                    expect(telemetry["isBufferingEvents"]).toBe(true);
+                    expect(telemetry.getCommonProperties().device_id).toBe(undefined);
 
-                    telemetry.emitEvents([testEvent]);
+                    vi.advanceTimersByTime(DEVICE_ID_TIMEOUT / 2);
 
-                    jest.advanceTimersByTime(5000);
+                    // Make sure the timeout doesn't happen prematurely.
+                    expect(telemetry["isBufferingEvents"]).toBe(true);
+                    expect(telemetry.getCommonProperties().device_id).toBe(undefined);
 
-                    jest.useRealTimers();
+                    vi.advanceTimersByTime(DEVICE_ID_TIMEOUT);
 
-                    expect(loggerSpy).toHaveBeenCalledTimes(2);
+                    await telemetry.setupPromise;
 
-                    expect(loggerSpy).toHaveBeenNthCalledWith(
-                        2,
+                    expect(telemetry.getCommonProperties().device_id).toBe("unknown");
+                    expect(telemetry["isBufferingEvents"]).toBe(false);
+                    expect(loggerSpy).toHaveBeenCalledWith(
                         LogId.telemetryDeviceIdTimeout,
                         "telemetry",
                         "Device ID retrieval timed out"
@@ -330,12 +298,9 @@ describe("Telemetry", () => {
             it("should not send events", async () => {
                 const testEvent = createTestEvent();
 
-                telemetry.emitEvents([testEvent]);
-                await nextTick(); // wait for the event to be sent
+                await telemetry.emitEvents([testEvent]);
 
-                verifyMockCalls({
-                    sendEventsCalls: 0,
-                });
+                verifyMockCalls();
             });
         });
 
@@ -358,12 +323,9 @@ describe("Telemetry", () => {
             it("should not send events", async () => {
                 const testEvent = createTestEvent();
 
-                telemetry.emitEvents([testEvent]);
-                await nextTick(); // wait for the event to be sent
+                await telemetry.emitEvents([testEvent]);
 
-                verifyMockCalls({
-                    sendEventsCalls: 0,
-                });
+                verifyMockCalls();
             });
         });
     });

package/tests/unit/{EJsonTransport.test.ts → transports/stdio.test.ts}

@@ -1,15 +1,15 @@
 import { Decimal128, MaxKey, MinKey, ObjectId, Timestamp, UUID } from "bson";
-import { createEJsonTransport, EJsonReadBuffer } from "../../src/helpers/EJsonTransport.js";
+import { createStdioTransport, EJsonReadBuffer } from "../../../src/transports/stdio.js";
 import { JSONRPCMessage } from "@modelcontextprotocol/sdk/types.js";
 import { AuthInfo } from "@modelcontextprotocol/sdk/server/auth/types.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { Readable } from "stream";
 import { ReadBuffer } from "@modelcontextprotocol/sdk/shared/stdio.js";
-
-describe("EJsonTransport", () => {
+import { describe, expect, it, beforeEach, afterEach } from "vitest";
+describe("stdioTransport", () => {
     let transport: StdioServerTransport;
     beforeEach(async () => {
-        transport = createEJsonTransport();
+        transport = createStdioTransport();
         await transport.start();
     });
 

package/tests/vitest.d.ts

@@ -0,0 +1,11 @@
+import "vitest";
+
+declare module "vitest" {
+    interface Assertion<T = unknown> {
+        toIncludeSameMembers<U>(expected: U[]): T;
+    }
+
+    interface AsymmetricMatchersContaining {
+        toIncludeSameMembers<T>(expected: T[]): unknown;
+    }
+}

package/tsconfig.json

@@ -2,7 +2,6 @@
   "extends": "./tsconfig.build.json",
   "compilerOptions": {
     "rootDir": ".",
-    "types": ["jest"],
     "skipLibCheck": true
   },
   "include": ["**/*"]

package/{tsconfig.jest.json → tsconfig.test.json}

@@ -2,8 +2,7 @@
   "extends": "./tsconfig.build.json",
   "compilerOptions": {
     "isolatedModules": true,
-    "allowSyntheticDefaultImports": true,
-    "types": ["jest", "jest-extended"]
+    "allowSyntheticDefaultImports": true
   },
   "include": ["src/**/*.ts", "tests/**/*.ts"]
 }