add create project tool

src/tools/atlas/createProject.ts

@@ -0,0 +1,32 @@
+import { z } from "zod";
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { AtlasToolBase } from "./atlasTool.js";
+import { ToolArgs, OperationType } from "../tool.js";
+import { Group } from "../../common/atlas/openapi.js";
+
+export class CreateProjectTool extends AtlasToolBase {
+    protected name = "atlas-create-project";
+    protected description = "Create a MongoDB Atlas project";
+    protected operationType: OperationType = "create";
+    protected argsShape = {
+        projectName: z.string().describe("Name for the new project"),
+        organizationId: z.string().describe("Organization ID for the new project"),
+    };
+
+    protected async execute({ projectName, organizationId }: ToolArgs<typeof this.argsShape>): Promise<CallToolResult> {
+        this.session.ensureAuthenticated();
+
+        const input = {
+            name: projectName,
+            orgId: organizationId,
+        } as Group;
+
+        await this.session.apiClient.createProject({
+            body: input,
+        });
+
+        return {
+            content: [{ type: "text", text: `Project "${projectName}" created successfully.` }],
+        };
+    }
+}

src/tools/atlas/tools.ts

@@ -6,6 +6,7 @@ import { CreateAccessListTool } from "./createAccessList.js";
 import { InspectAccessListTool } from "./inspectAccessList.js";
 import { ListDBUsersTool } from "./listDBUsers.js";
 import { CreateDBUserTool } from "./createDBUser.js";
+import { CreateProjectTool } from "./createProject.js";
 
 export const AtlasTools = [
     ListClustersTool,
@@ -16,4 +17,5 @@ export const AtlasTools = [
     InspectAccessListTool,
     ListDBUsersTool,
     CreateDBUserTool,
+    CreateProjectTool,
 ];

tests/integration/helpers.ts

@@ -7,7 +7,9 @@ import fs from "fs/promises";
 import { Session } from "../../src/session.js";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { MongoClient } from "mongodb";
+import { ApiClient } from "../../src/common/atlas/apiClient.js";
 import { toIncludeAllMembers } from "jest-extended";
+import { Group } from "../../src/common/atlas/openapi.js";
 
 interface ParameterInfo {
     name: string;
@@ -21,6 +23,7 @@ type ToolInfo = Awaited<ReturnType<Client["listTools"]>>["tools"][number];
 export function jestTestMCPClient(): () => Client {
     let client: Client | undefined;
     let server: Server | undefined;
+    let session: Session | undefined;
 
     beforeEach(async () => {
         const clientTransport = new InMemoryTransport();
@@ -42,13 +45,16 @@ export function jestTestMCPClient(): () => Client {
             }
         );
 
+        session = jestTestSession();
+
         server = new Server({
             mcpServer: new McpServer({
                 name: "test-server",
                 version: "1.2.3",
             }),
-            session: new Session(),
+            session,
         });
+
         await server.connect(serverTransport);
         await client.connect(clientTransport);
     });
@@ -59,13 +65,15 @@ export function jestTestMCPClient(): () => Client {
 
         await server?.close();
         server = undefined;
+
+        session = undefined;
+        jest.restoreAllMocks();
     });
 
     return () => {
         if (!client) {
             throw new Error("beforeEach() hook not ran yet");
         }
-
         return client;
     };
 }
@@ -196,3 +204,48 @@ export function validateParameters(tool: ToolInfo, parameters: ParameterInfo[]):
     expect(toolParameters).toHaveLength(parameters.length);
     expect(toolParameters).toIncludeAllMembers(parameters);
 }
+
+const jestTestAtlasData = {
+    project: {
+        id: "test-project-id",
+        name: "test-project",
+        orgId: "test-org-id",
+        clusterCount: 0,
+        created: new Date().toISOString(),
+        regionUsageRestrictions: "COMMERCIAL_FEDRAMP_REGIONS_ONLY" as const,
+        withDefaultAlertsSettings: true,
+    } satisfies Group,
+    projects: {
+        results: [],
+        totalCount: 0,
+    },
+};
+
+function jestTestAtlasClient(): ApiClient {
+    const apiClient = new ApiClient({
+        baseUrl: "http://localhost:3000",
+        userAgent: "AtlasMCP-Test",
+        credentials: {
+            clientId: "test-client-id",
+            clientSecret: "test-client-secret",
+        },
+    });
+
+    jest.spyOn(apiClient, "createProject").mockResolvedValue(jestTestAtlasData.project);
+    jest.spyOn(apiClient, "listProjects").mockResolvedValue(jestTestAtlasData.projects);
+    jest.spyOn(apiClient, "getProject").mockResolvedValue(jestTestAtlasData.project);
+
+    return apiClient;
+}
+
+function jestTestSession(): Session {
+    const session = new Session();
+    const apiClient = jestTestAtlasClient();
+
+    Object.defineProperty(session, "apiClient", {
+        get: () => apiClient,
+        configurable: true,
+    });
+
+    return session;
+}

tests/integration/tools/atlas/createProject.test.ts

@@ -0,0 +1,70 @@
+import { jestTestMCPClient, validateParameters, getResponseContent } from "../../helpers.js";
+import { McpError } from "@modelcontextprotocol/sdk/types.js";
+
+describe("createProject tool", () => {
+    const client = jestTestMCPClient();
+    // atlas client mockk
+
+    it("should have correct metadata", async () => {
+        const { tools } = await client().listTools();
+        const createProject = tools.find((tool) => tool.name === "atlas-create-project")!;
+        expect(createProject).toBeDefined();
+        expect(createProject.description).toBe("Create a MongoDB Atlas project");
+
+        // Validate the parameters match the schema
+        validateParameters(createProject, [
+            {
+                name: "projectName",
+                type: "string",
+                description: "Name for the new project",
+                required: true,
+            },
+            {
+                name: "organizationId",
+                type: "string",
+                description: "Organization ID for the new project",
+                required: true,
+            },
+        ]);
+    });
+
+    describe("with invalid arguments", () => {
+        const args = [
+            {}, // Empty args
+            { projectName: 123, organizationId: "org-1" }, // Invalid projectName type
+            { projectName: "Test Project" }, // Missing organizationId
+            { projectName: "Test Project", organizationId: 456 }, // Invalid organizationId type
+            { projectName: "", organizationId: "org-1" }, // Empty projectName
+        ];
+
+        for (const arg of args) {
+            it(`throws a schema error for: ${JSON.stringify(arg)}`, async () => {
+                try {
+                    await client().callTool({ name: "atlas-create-project", arguments: arg });
+                    expect.fail("Expected an error to be thrown");
+                } catch (error) {
+                    expect(error).toBeInstanceOf(McpError);
+                    const mcpError = error as McpError;
+                    expect(mcpError.code).toEqual(-32602);
+                    expect(mcpError.message).toContain("Invalid arguments for tool atlas-create-project");
+                }
+            });
+        }
+    });
+
+    describe("with valid arguments", () => {
+        it("creates a new project", async () => {
+            const projectName = "Test Project";
+            const organizationId = "test-org-id";
+
+            const response = await client().callTool({
+                name: "atlas-create-project",
+                arguments: { projectName, organizationId },
+            });
+
+            expect(response).toBeDefined();
+            const content = getResponseContent(response.content);
+            expect(content).toEqual(`Project "${projectName}" created successfully.`);
+        });
+    });
+});