mongodb-mcp-server 0.0.5 → 0.0.6

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

@@ -1,14 +1,18 @@
 import { Session } from "../../../../src/session.js";
 import { expectDefined } from "../../helpers.js";
-import { describeWithAtlas, withProject, sleep, randomId } from "./atlasHelpers.js";
+import { describeWithAtlas, withProject, randomId } from "./atlasHelpers.js";
 import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 
+function sleep(ms: number) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
 async function deleteAndWaitCluster(session: Session, projectId: string, clusterName: string) {
     await session.apiClient.deleteCluster({
         params: {
             path: {
                 groupId: projectId,
-                clusterName: clusterName,
+                clusterName,
             },
         },
     });
@@ -18,7 +22,7 @@ async function deleteAndWaitCluster(session: Session, projectId: string, cluster
                 params: {
                     path: {
                         groupId: projectId,
-                        clusterName: clusterName,
+                        clusterName,
                     },
                 },
             });
@@ -29,6 +33,23 @@ async function deleteAndWaitCluster(session: Session, projectId: string, cluster
     }
 }
 
+async function waitClusterState(session: Session, projectId: string, clusterName: string, state: string) {
+    while (true) {
+        const cluster = await session.apiClient.getCluster({
+            params: {
+                path: {
+                    groupId: projectId,
+                    clusterName,
+                },
+            },
+        });
+        if (cluster?.stateName === state) {
+            return;
+        }
+        await sleep(1000);
+    }
+}
+
 describeWithAtlas("clusters", (integration) => {
     withProject(integration, ({ getProjectId }) => {
         const clusterName = "ClusterTest-" + randomId;
@@ -66,7 +87,7 @@ describeWithAtlas("clusters", (integration) => {
                     },
                 })) as CallToolResult;
                 expect(response.content).toBeArray();
-                expect(response.content).toHaveLength(1);
+                expect(response.content).toHaveLength(2);
                 expect(response.content[0].text).toContain("has been created");
             });
         });
@@ -117,5 +138,48 @@ describeWithAtlas("clusters", (integration) => {
                 expect(response.content[1].text).toContain(`${clusterName} | `);
             });
         });
+
+        describe("atlas-connect-cluster", () => {
+            beforeAll(async () => {
+                const projectId = getProjectId();
+                await waitClusterState(integration.mcpServer().session, projectId, clusterName, "IDLE");
+                await integration.mcpServer().session.apiClient.createProjectIpAccessList({
+                    params: {
+                        path: {
+                            groupId: projectId,
+                        },
+                    },
+                    body: [
+                        {
+                            comment: "MCP test",
+                            cidrBlock: "0.0.0.0/0",
+                        },
+                    ],
+                });
+            });
+
+            it("should have correct metadata", async () => {
+                const { tools } = await integration.mcpClient().listTools();
+                const connectCluster = tools.find((tool) => tool.name === "atlas-connect-cluster");
+
+                expectDefined(connectCluster);
+                expect(connectCluster.inputSchema.type).toBe("object");
+                expectDefined(connectCluster.inputSchema.properties);
+                expect(connectCluster.inputSchema.properties).toHaveProperty("projectId");
+                expect(connectCluster.inputSchema.properties).toHaveProperty("clusterName");
+            });
+
+            it("connects to cluster", async () => {
+                const projectId = getProjectId();
+
+                const response = (await integration.mcpClient().callTool({
+                    name: "atlas-connect-cluster",
+                    arguments: { projectId, clusterName },
+                })) as CallToolResult;
+                expect(response.content).toBeArray();
+                expect(response.content).toHaveLength(1);
+                expect(response.content[0].text).toContain(`Connected to cluster "${clusterName}"`);
+            });
+        });
     });
 });

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

@@ -1,147 +1,132 @@
 import { describeWithMongoDB } from "../mongodbHelpers.js";
-
-import { getResponseContent, validateToolMetadata } from "../../../helpers.js";
-
+import { getResponseContent, validateThrowsForInvalidArguments, validateToolMetadata } from "../../../helpers.js";
 import { config } from "../../../../../src/config.js";
 
-describeWithMongoDB("Connect tool", (integration) => {
-    validateToolMetadata(integration, "connect", "Connect to a MongoDB instance", [
-        {
-            name: "options",
-            description:
-                "Options for connecting to MongoDB. If not provided, the connection string from the config://connection-string resource will be used. If the user hasn't specified Atlas cluster name or a connection string explicitly and the `config://connection-string` resource is present, always invoke this with no arguments.",
-            type: "array",
-            required: false,
-        },
-    ]);
-
-    describe("without arguments", () => {
-        it("prompts for connection string if not set", async () => {
-            const response = await integration.mcpClient().callTool({ name: "connect" });
-            const content = getResponseContent(response.content);
-            expect(content).toContain("No connection details provided");
+// These tests are temporarily skipped because the connect tool is disabled for the initial release.
+// TODO: https://github.com/mongodb-js/mongodb-mcp-server/issues/141 - reenable when the connect tool is reenabled
+describeWithMongoDB(
+    "switchConnection tool",
+    (integration) => {
+        beforeEach(() => {
+            integration.mcpServer().userConfig.connectionString = integration.connectionString();
         });
 
-        it("connects to the database if connection string is set", async () => {
-            config.connectionString = integration.connectionString();
-
-            const response = await integration.mcpClient().callTool({ name: "connect" });
-            const content = getResponseContent(response.content);
-            expect(content).toContain("Successfully connected");
-            expect(content).toContain(integration.connectionString());
-        });
-    });
+        validateToolMetadata(
+            integration,
+            "switch-connection",
+            "Switch to a different MongoDB connection. If the user has configured a connection string or has previously called the connect tool, a connection is already established and there's no need to call this tool unless the user has explicitly requested to switch to a new instance.",
+            [
+                {
+                    name: "connectionString",
+                    description: "MongoDB connection string to switch to (in the mongodb:// or mongodb+srv:// format)",
+                    type: "string",
+                    required: false,
+                },
+            ]
+        );
 
-    describe("with default config", () => {
-        describe("without connection string", () => {
-            it("prompts for connection string", async () => {
-                const response = await integration.mcpClient().callTool({ name: "connect", arguments: {} });
-                const content = getResponseContent(response.content);
-                expect(content).toContain("No connection details provided");
-            });
-        });
+        validateThrowsForInvalidArguments(integration, "switch-connection", [{ connectionString: 123 }]);
 
-        describe("with connection string", () => {
+        describe("without arguments", () => {
             it("connects to the database", async () => {
-                const response = await integration.mcpClient().callTool({
-                    name: "connect",
-                    arguments: {
-                        options: [
-                            {
-                                connectionString: integration.connectionString(),
-                            },
-                        ],
-                    },
-                });
+                const response = await integration.mcpClient().callTool({ name: "switch-connection" });
                 const content = getResponseContent(response.content);
                 expect(content).toContain("Successfully connected");
-                expect(content).toContain(integration.connectionString());
             });
         });
 
-        describe("with invalid connection string", () => {
-            it("returns error message", async () => {
-                const response = await integration.mcpClient().callTool({
-                    name: "connect",
-                    arguments: { options: [{ connectionString: "mongodb://localhost:12345" }] },
-                });
-                const content = getResponseContent(response.content);
-                expect(content).toContain("Error running connect");
-
-                // Should not suggest using the config connection string (because we don't have one)
-                expect(content).not.toContain("Your config lists a different connection string");
-            });
+        it("doesn't have the connect tool registered", async () => {
+            const { tools } = await integration.mcpClient().listTools();
+            const tool = tools.find((tool) => tool.name === "connect");
+            expect(tool).toBeUndefined();
         });
-    });
 
-    describe("with connection string in config", () => {
-        beforeEach(() => {
-            config.connectionString = integration.connectionString();
-        });
-
-        it("uses the connection string from config", async () => {
-            const response = await integration.mcpClient().callTool({ name: "connect", arguments: {} });
+        it("defaults to the connection string from config", async () => {
+            const response = await integration.mcpClient().callTool({ name: "switch-connection", arguments: {} });
             const content = getResponseContent(response.content);
             expect(content).toContain("Successfully connected");
-            expect(content).toContain(integration.connectionString());
         });
 
-        it("prefers connection string from arguments", async () => {
+        it("switches to the connection string from the arguments", async () => {
             const newConnectionString = `${integration.connectionString()}?appName=foo-bar`;
             const response = await integration.mcpClient().callTool({
-                name: "connect",
+                name: "switch-connection",
                 arguments: {
-                    options: [
-                        {
-                            connectionString: newConnectionString,
-                        },
-                    ],
+                    connectionString: newConnectionString,
                 },
             });
             const content = getResponseContent(response.content);
             expect(content).toContain("Successfully connected");
-            expect(content).toContain(newConnectionString);
         });
 
         describe("when the arugment connection string is invalid", () => {
-            it("suggests the config connection string if set", async () => {
+            it("returns error message", async () => {
                 const response = await integration.mcpClient().callTool({
-                    name: "connect",
+                    name: "switch-connection",
                     arguments: {
-                        options: [
-                            {
-                                connectionString: "mongodb://localhost:12345",
-                            },
-                        ],
+                        connectionString: "mongodb://localhost:12345",
                     },
                 });
+
                 const content = getResponseContent(response.content);
-                expect(content).toContain("Failed to connect to MongoDB at 'mongodb://localhost:12345'");
-                expect(content).toContain(
-                    `Your config lists a different connection string: '${config.connectionString}' - do you want to try connecting to it instead?`
-                );
+
+                expect(content).toContain("Error running switch-connection");
             });
+        });
+    },
+    (mdbIntegration) => ({
+        ...config,
+        connectionString: mdbIntegration.connectionString(),
+    }),
+    describe.skip
+);
+describeWithMongoDB(
+    "Connect tool",
+    (integration) => {
+        validateToolMetadata(integration, "connect", "Connect to a MongoDB instance", [
+            {
+                name: "connectionString",
+                description: "MongoDB connection string (in the mongodb:// or mongodb+srv:// format)",
+                type: "string",
+                required: true,
+            },
+        ]);
+
+        validateThrowsForInvalidArguments(integration, "connect", [{}, { connectionString: 123 }]);
+
+        it("doesn't have the switch-connection tool registered", async () => {
+            const { tools } = await integration.mcpClient().listTools();
+            const tool = tools.find((tool) => tool.name === "switch-connection");
+            expect(tool).toBeUndefined();
+        });
 
-            it("returns error message if the config connection string matches the argument", async () => {
-                config.connectionString = "mongodb://localhost:12345";
+        describe("with connection string", () => {
+            it("connects to the database", async () => {
                 const response = await integration.mcpClient().callTool({
                     name: "connect",
                     arguments: {
-                        options: [
-                            {
-                                connectionString: "mongodb://localhost:12345",
-                            },
-                        ],
+                        connectionString: integration.connectionString(),
                     },
                 });
-
                 const content = getResponseContent(response.content);
+                expect(content).toContain("Successfully connected");
+            });
+        });
 
-                // Should be handled by default error handler and not suggest the config connection string
-                // because it matches the argument connection string
+        describe("with invalid connection string", () => {
+            it("returns error message", async () => {
+                const response = await integration.mcpClient().callTool({
+                    name: "connect",
+                    arguments: { connectionString: "mongodb://localhost:12345" },
+                });
+                const content = getResponseContent(response.content);
                 expect(content).toContain("Error running connect");
+
+                // Should not suggest using the config connection string (because we don't have one)
                 expect(content).not.toContain("Your config lists a different connection string");
             });
         });
-    });
-});
+    },
+    () => config,
+    describe.skip
+);

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

@@ -3,29 +3,47 @@ import path from "path";
 import fs from "fs/promises";
 import { MongoClient, ObjectId } from "mongodb";
 import { getResponseContent, IntegrationTest, setupIntegrationTest } from "../../helpers.js";
-import { config } from "../../../../src/config.js";
+import { config, UserConfig } from "../../../../src/config.js";
 
 interface MongoDBIntegrationTest {
     mongoClient: () => MongoClient;
     connectionString: () => string;
-    connectMcpClient: () => Promise<void>;
     randomDbName: () => string;
 }
 
 export function describeWithMongoDB(
     name: string,
-    fn: (integration: IntegrationTest & MongoDBIntegrationTest) => void
-): void {
-    describe("mongodb", () => {
-        const integration = setupIntegrationTest();
-        const mdbIntegration = setupMongoDBIntegrationTest(integration);
-        describe(name, () => {
-            fn({ ...integration, ...mdbIntegration });
+    fn: (integration: IntegrationTest & MongoDBIntegrationTest & { connectMcpClient: () => Promise<void> }) => void,
+    getUserConfig: (mdbIntegration: MongoDBIntegrationTest) => UserConfig = () => config,
+    describeFn = describe
+) {
+    describeFn(name, () => {
+        const mdbIntegration = setupMongoDBIntegrationTest();
+        const integration = setupIntegrationTest(() => ({
+            ...getUserConfig(mdbIntegration),
+            connectionString: mdbIntegration.connectionString(),
+        }));
+
+        beforeEach(() => {
+            integration.mcpServer().userConfig.connectionString = mdbIntegration.connectionString();
+        });
+
+        fn({
+            ...integration,
+            ...mdbIntegration,
+            connectMcpClient: async () => {
+                // TODO: https://github.com/mongodb-js/mongodb-mcp-server/issues/141 - reenable when
+                // the connect tool is reenabled
+                // await integration.mcpClient().callTool({
+                //     name: "connect",
+                //     arguments: { connectionString: mdbIntegration.connectionString() },
+                // });
+            },
         });
     });
 }
 
-export function setupMongoDBIntegrationTest(integration: IntegrationTest): MongoDBIntegrationTest {
+export function setupMongoDBIntegrationTest(): MongoDBIntegrationTest {
     let mongoCluster: // TODO: Fix this type once mongodb-runner is updated.
     | {
               connectionString: string;
@@ -40,9 +58,6 @@ export function setupMongoDBIntegrationTest(integration: IntegrationTest): Mongo
     });
 
     afterEach(async () => {
-        await integration.mcpServer().session.close();
-        config.connectionString = undefined;
-
         await mongoClient?.close();
         mongoClient = undefined;
     });
@@ -108,12 +123,7 @@ export function setupMongoDBIntegrationTest(integration: IntegrationTest): Mongo
             return mongoClient;
         },
         connectionString: getConnectionString,
-        connectMcpClient: async () => {
-            await integration.mcpClient().callTool({
-                name: "connect",
-                arguments: { options: [{ connectionString: getConnectionString() }] },
-            });
-        },
+
         randomDbName: () => randomDbName,
     };
 }
@@ -128,13 +138,14 @@ export function validateAutoConnectBehavior(
     },
     beforeEachImpl?: () => Promise<void>
 ): void {
-    describe("when not connected", () => {
+    // TODO: https://github.com/mongodb-js/mongodb-mcp-server/issues/141 - reenable when the connect tool is reenabled
+    describe.skip("when not connected", () => {
         if (beforeEachImpl) {
             beforeEach(() => beforeEachImpl());
         }
 
         it("connects automatically if connection string is configured", async () => {
-            config.connectionString = integration.connectionString();
+            integration.mcpServer().userConfig.connectionString = integration.connectionString();
 
             const validationInfo = validation();
 

package/tests/unit/telemetry.test.ts

@@ -0,0 +1,200 @@
+import { ApiClient } from "../../src/common/atlas/apiClient.js";
+import { Session } from "../../src/session.js";
+import { 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";
+
+// Mock the ApiClient to avoid real API calls
+jest.mock("../../src/common/atlas/apiClient.js");
+const MockApiClient = ApiClient as jest.MockedClass<typeof ApiClient>;
+
+// Mock EventCache to control and verify caching behavior
+jest.mock("../../src/telemetry/eventCache.js");
+const MockEventCache = EventCache as jest.MockedClass<typeof EventCache>;
+
+describe("Telemetry", () => {
+    let mockApiClient: jest.Mocked<ApiClient>;
+    let mockEventCache: jest.Mocked<EventCache>;
+    let session: Session;
+    let telemetry: Telemetry;
+
+    // Helper function to create properly typed test events
+    function createTestEvent(options?: {
+        source?: string;
+        result?: TelemetryResult;
+        component?: string;
+        category?: string;
+        command?: string;
+        duration_ms?: number;
+    }): BaseEvent {
+        return {
+            timestamp: new Date().toISOString(),
+            source: options?.source || "mdbmcp",
+            properties: {
+                component: options?.component || "test-component",
+                duration_ms: options?.duration_ms || 100,
+                result: options?.result || "success",
+                category: options?.category || "test",
+                command: options?.command || "test-command",
+            },
+        };
+    }
+
+    // Helper function to verify mock calls to reduce duplication
+    function verifyMockCalls({
+        sendEventsCalls = 0,
+        clearEventsCalls = 0,
+        appendEventsCalls = 0,
+        sendEventsCalledWith = undefined,
+        appendEventsCalledWith = undefined,
+    } = {}) {
+        const { calls: sendEvents } = mockApiClient.sendEvents.mock;
+        const { calls: clearEvents } = mockEventCache.clearEvents.mock;
+        const { calls: appendEvents } = mockEventCache.appendEvents.mock;
+
+        expect(sendEvents.length).toBe(sendEventsCalls);
+        expect(clearEvents.length).toBe(clearEventsCalls);
+        expect(appendEvents.length).toBe(appendEventsCalls);
+
+        if (sendEventsCalledWith) {
+            expect(sendEvents[0]?.[0]).toEqual(sendEventsCalledWith);
+        }
+
+        if (appendEventsCalledWith) {
+            expect(appendEvents[0]?.[0]).toEqual(appendEventsCalledWith);
+        }
+    }
+
+    beforeEach(() => {
+        // Reset mocks before each test
+        jest.clearAllMocks();
+
+        // Setup mocked API client
+        mockApiClient = new MockApiClient() as jest.Mocked<ApiClient>;
+        mockApiClient.sendEvents = jest.fn().mockResolvedValue(undefined);
+        mockApiClient.hasCredentials = jest.fn().mockReturnValue(true);
+
+        // Setup mocked EventCache
+        mockEventCache = new MockEventCache() as jest.Mocked<EventCache>;
+        mockEventCache.getEvents = jest.fn().mockReturnValue([]);
+        mockEventCache.clearEvents = jest.fn().mockResolvedValue(undefined);
+        mockEventCache.appendEvents = jest.fn().mockResolvedValue(undefined);
+        MockEventCache.getInstance = jest.fn().mockReturnValue(mockEventCache);
+
+        // Create a simplified session with our mocked API client
+        session = {
+            apiClient: mockApiClient,
+            sessionId: "test-session-id",
+            agentRunner: { name: "test-agent", version: "1.0.0" } as const,
+            close: jest.fn().mockResolvedValue(undefined),
+            setAgentRunner: jest.fn().mockResolvedValue(undefined),
+        } as unknown as Session;
+
+        // Create the telemetry instance with mocked dependencies
+        telemetry = new Telemetry(session, mockEventCache);
+
+        config.telemetry = "enabled";
+    });
+
+    describe("when telemetry is enabled", () => {
+        it("should send events successfully", async () => {
+            const testEvent = createTestEvent();
+
+            await telemetry.emitEvents([testEvent]);
+
+            verifyMockCalls({
+                sendEventsCalls: 1,
+                clearEventsCalls: 1,
+                sendEventsCalledWith: [testEvent],
+            });
+        });
+
+        it("should cache events when sending fails", async () => {
+            mockApiClient.sendEvents.mockRejectedValueOnce(new Error("API error"));
+
+            const testEvent = createTestEvent();
+
+            await telemetry.emitEvents([testEvent]);
+
+            verifyMockCalls({
+                sendEventsCalls: 1,
+                appendEventsCalls: 1,
+                appendEventsCalledWith: [testEvent],
+            });
+        });
+
+        it("should include cached events when sending", async () => {
+            const cachedEvent = createTestEvent({
+                command: "cached-command",
+                component: "cached-component",
+            });
+
+            const newEvent = createTestEvent({
+                command: "new-command",
+                component: "new-component",
+            });
+
+            // Set up mock to return cached events
+            mockEventCache.getEvents.mockReturnValueOnce([cachedEvent]);
+
+            await telemetry.emitEvents([newEvent]);
+
+            verifyMockCalls({
+                sendEventsCalls: 1,
+                clearEventsCalls: 1,
+                sendEventsCalledWith: [cachedEvent, newEvent],
+            });
+        });
+    });
+
+    describe("when telemetry is disabled", () => {
+        beforeEach(() => {
+            config.telemetry = "disabled";
+        });
+
+        it("should not send events", async () => {
+            const testEvent = createTestEvent();
+
+            await telemetry.emitEvents([testEvent]);
+
+            verifyMockCalls();
+        });
+    });
+
+    it("should correctly add common properties to events", () => {
+        const commonProps = telemetry.getCommonProperties();
+
+        // Use explicit type assertion
+        const expectedProps: Record<string, string> = {
+            mcp_client_version: "1.0.0",
+            mcp_client_name: "test-agent",
+            session_id: "test-session-id",
+            config_atlas_auth: "true",
+            config_connection_string: expect.any(String) as unknown as string,
+        };
+
+        expect(commonProps).toMatchObject(expectedProps);
+    });
+
+    describe("when DO_NOT_TRACK environment variable is set", () => {
+        let originalEnv: string | undefined;
+
+        beforeEach(() => {
+            originalEnv = process.env.DO_NOT_TRACK;
+            process.env.DO_NOT_TRACK = "1";
+        });
+
+        afterEach(() => {
+            process.env.DO_NOT_TRACK = originalEnv;
+        });
+
+        it("should not send events", async () => {
+            const testEvent = createTestEvent();
+
+            await telemetry.emitEvents([testEvent]);
+
+            verifyMockCalls();
+        });
+    });
+});

package/dist/tools/atlas/createAccessList.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"createAccessList.js","sourceRoot":"","sources":["../../../src/tools/atlas/createAccessList.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAG/C,MAAM,eAAe,GAAG,oBAAoB,CAAC;AAE7C,MAAM,OAAO,oBAAqB,SAAQ,aAAa;IAAvD;;QACc,SAAI,GAAG,0BAA0B,CAAC;QAClC,gBAAW,GAAG,6DAA6D,CAAC;QAC5E,kBAAa,GAAkB,QAAQ,CAAC;QACxC,cAAS,GAAG;YAClB,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,kBAAkB,CAAC;YAClD,WAAW,EAAE,CAAC;iBACT,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC;iBACvC,QAAQ,CAAC,mCAAmC,CAAC;iBAC7C,QAAQ,EAAE;YACf,UAAU,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,CAAC,QAAQ,CAAC,kCAAkC,CAAC,CAAC,QAAQ,EAAE;YAC9F,gBAAgB,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,CAAC,4BAA4B,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC;YACnF,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,qCAAqC,CAAC,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC,QAAQ,EAAE;SAC1G,CAAC;IAuDN,CAAC;IArDa,KAAK,CAAC,OAAO,CAAC,EACpB,SAAS,EACT,WAAW,EACX,UAAU,EACV,OAAO,EACP,gBAAgB,GACc;QAC9B,IAAI,CAAC,WAAW,EAAE,MAAM,IAAI,CAAC,UAAU,EAAE,MAAM,IAAI,CAAC,gBAAgB,EAAE,CAAC;YACnE,MAAM,IAAI,KAAK,CAAC,qEAAqE,CAAC,CAAC;QAC3F,CAAC;QAED,MAAM,QAAQ,GAAG,CAAC,WAAW,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC;YACrD,OAAO,EAAE,SAAS;YAClB,SAAS;YACT,OAAO,EAAE,OAAO,IAAI,eAAe;SACtC,CAAC,CAAC,CAAC;QAEJ,IAAI,gBAAgB,EAAE,CAAC;YACnB,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,SAAS,EAAE,CAAC;YAC3D,MAAM,KAAK,GAAG;gBACV,OAAO,EAAE,SAAS;gBAClB,SAAS,EAAE,SAAS,CAAC,kBAAkB;gBACvC,OAAO,EAAE,OAAO,IAAI,eAAe;aACtC,CAAC;YACF,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACzB,CAAC;QAED,MAAM,UAAU,GAAG,CAAC,UAAU,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC;YACtD,OAAO,EAAE,SAAS;YAClB,SAAS;YACT,OAAO,EAAE,OAAO,IAAI,eAAe;SACtC,CAAC,CAAC,CAAC;QAEJ,MAAM,MAAM,GAAG,CAAC,GAAG,QAAQ,EAAE,GAAG,UAAU,CAAC,CAAC;QAE5C,MAAM,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,yBAAyB,CAAC;YACnD,MAAM,EAAE;gBACJ,IAAI,EAAE;oBACF,OAAO,EAAE,SAAS;iBACrB;aACJ;YACD,IAAI,EAAE,MAAM;SACf,CAAC,CAAC;QAEH,OAAO;YACH,OAAO,EAAE;gBACL;oBACI,IAAI,EAAE,MAAM;oBACZ,IAAI,EAAE,mDAAmD,SAAS,GAAG;iBACxE;aACJ;SACJ,CAAC;IACN,CAAC;CACJ"}

package/dist/tools/atlas/createDBUser.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"createDBUser.js","sourceRoot":"","sources":["../../../src/tools/atlas/createDBUser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAI/C,MAAM,OAAO,gBAAiB,SAAQ,aAAa;IAAnD;;QACc,SAAI,GAAG,sBAAsB,CAAC;QAC9B,gBAAW,GAAG,uCAAuC,CAAC;QACtD,kBAAa,GAAkB,QAAQ,CAAC;QACxC,cAAS,GAAG;YAClB,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,kBAAkB,CAAC;YAClD,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,2BAA2B,CAAC;YAC1D,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,2BAA2B,CAAC;YAC1D,KAAK,EAAE,CAAC;iBACH,KAAK,CACF,CAAC,CAAC,MAAM,CAAC;gBACL,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,WAAW,CAAC;gBAC1C,YAAY,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC;gBACnE,cAAc,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,iBAAiB,CAAC,CAAC,QAAQ,EAAE;aACpE,CAAC,CACL;iBACA,QAAQ,CAAC,wBAAwB,CAAC;YACvC,QAAQ,EAAE,CAAC;iBACN,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;iBACjB,QAAQ,CAAC,wEAAwE,CAAC;iBAClF,QAAQ,EAAE;SAClB,CAAC;IAwCN,CAAC;IAtCa,KAAK,CAAC,OAAO,CAAC,EACpB,SAAS,EACT,QAAQ,EACR,QAAQ,EACR,KAAK,EACL,QAAQ,GACsB;QAC9B,MAAM,KAAK,GAAG;YACV,OAAO,EAAE,SAAS;YAClB,UAAU,EAAE,MAAM;YAClB,YAAY,EAAE,OAAO;YACrB,YAAY,EAAE,MAAM;YACpB,YAAY,EAAE,MAAM;YACpB,QAAQ,EAAE,MAAM;YAChB,QAAQ;YACR,QAAQ;YACR,KAAK,EAAE,KAAsC;YAC7C,MAAM,EAAE,QAAQ,EAAE,MAAM;gBACpB,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;oBACvB,IAAI,EAAE,SAAS;oBACf,IAAI,EAAE,OAAO;iBAChB,CAAC,CAAC;gBACL,CAAC,CAAC,SAAS;SACG,CAAC;QAEvB,MAAM,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,kBAAkB,CAAC;YAC5C,MAAM,EAAE;gBACJ,IAAI,EAAE;oBACF,OAAO,EAAE,SAAS;iBACrB;aACJ;YACD,IAAI,EAAE,KAAK;SACd,CAAC,CAAC;QAEH,OAAO;YACH,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,QAAQ,wBAAwB,EAAE,CAAC;SAC/E,CAAC;IACN,CAAC;CACJ"}

package/dist/tools/atlas/createFreeCluster.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"createFreeCluster.js","sourceRoot":"","sources":["../../../src/tools/atlas/createFreeCluster.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAI/C,MAAM,OAAO,qBAAsB,SAAQ,aAAa;IAAxD;;QACc,SAAI,GAAG,2BAA2B,CAAC;QACnC,gBAAW,GAAG,qCAAqC,CAAC;QACpD,kBAAa,GAAkB,QAAQ,CAAC;QACxC,cAAS,GAAG;YAClB,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,2CAA2C,CAAC;YAC3E,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,qBAAqB,CAAC;YAChD,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,uBAAuB,CAAC,CAAC,OAAO,CAAC,WAAW,CAAC;SAC5E,CAAC;IAsCN,CAAC;IApCa,KAAK,CAAC,OAAO,CAAC,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,EAAmC;QAChF,MAAM,KAAK,GAAG;YACV,OAAO,EAAE,SAAS;YAClB,IAAI;YACJ,WAAW,EAAE,YAAY;YACzB,gBAAgB,EAAE;gBACd;oBACI,QAAQ,EAAE,QAAQ;oBAClB,aAAa,EAAE;wBACX;4BACI,YAAY,EAAE,QAAQ;4BACtB,mBAAmB,EAAE,KAAK;4BAC1B,UAAU,EAAE,MAAM;4BAClB,cAAc,EAAE;gCACZ,YAAY,EAAE,IAAI;6BACrB;yBACJ;qBACJ;iBACJ;aACJ;YACD,4BAA4B,EAAE,KAAK;SACG,CAAC;QAE3C,MAAM,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,aAAa,CAAC;YACvC,MAAM,EAAE;gBACJ,IAAI,EAAE;oBACF,OAAO,EAAE,SAAS;iBACrB;aACJ;YACD,IAAI,EAAE,KAAK;SACd,CAAC,CAAC;QAEH,OAAO;YACH,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,IAAI,iCAAiC,MAAM,IAAI,EAAE,CAAC;SACjG,CAAC;IACN,CAAC;CACJ"}

package/dist/tools/atlas/createProject.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"createProject.js","sourceRoot":"","sources":["../../../src/tools/atlas/createProject.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAI/C,MAAM,OAAO,iBAAkB,SAAQ,aAAa;IAApD;;QACc,SAAI,GAAG,sBAAsB,CAAC;QAC9B,gBAAW,GAAG,gCAAgC,CAAC;QAC/C,kBAAa,GAAkB,QAAQ,CAAC;QACxC,cAAS,GAAG;YAClB,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,0BAA0B,CAAC;YACvE,cAAc,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,qCAAqC,CAAC;SACxF,CAAC;IAgDN,CAAC;IA9Ca,KAAK,CAAC,OAAO,CAAC,EAAE,WAAW,EAAE,cAAc,EAAmC;QACpF,IAAI,UAAU,GAAG,KAAK,CAAC;QAEvB,IAAI,CAAC,WAAW,EAAE,CAAC;YACf,WAAW,GAAG,eAAe,CAAC;QAClC,CAAC;QAED,IAAI,CAAC,cAAc,EAAE,CAAC;YAClB,IAAI,CAAC;gBACD,MAAM,aAAa,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,iBAAiB,EAAE,CAAC;gBACvE,IAAI,CAAC,aAAa,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC;oBAClC,MAAM,IAAI,KAAK,CACX,iGAAiG,CACpG,CAAC;gBACN,CAAC;gBACD,cAAc,GAAG,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;gBAC7C,UAAU,GAAG,IAAI,CAAC;YACtB,CAAC;YAAC,MAAM,CAAC;gBACL,MAAM,IAAI,KAAK,CACX,0HAA0H,CAC7H,CAAC;YACN,CAAC;QACL,CAAC;QAED,MAAM,KAAK,GAAG;YACV,IAAI,EAAE,WAAW;YACjB,KAAK,EAAE,cAAc;SACf,CAAC;QAEX,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,aAAa,CAAC;YACrD,IAAI,EAAE,KAAK;SACd,CAAC,CAAC;QAEH,IAAI,CAAC,KAAK,EAAE,EAAE,EAAE,CAAC;YACb,MAAM,IAAI,KAAK,CAAC,0BAA0B,CAAC,CAAC;QAChD,CAAC;QAED,OAAO;YACH,OAAO,EAAE;gBACL;oBACI,IAAI,EAAE,MAAM;oBACZ,IAAI,EAAE,YAAY,WAAW,yBAAyB,UAAU,CAAC,CAAC,CAAC,0BAA0B,cAAc,IAAI,CAAC,CAAC,CAAC,EAAE,GAAG;iBAC1H;aACJ;SACJ,CAAC;IACN,CAAC;CACJ"}