@executor-js/emulate 0.6.0 → 0.7.0

package/dist/{dist-RMPDKZUA.js → dist-OT6R2YO2.js}

@@ -247,8 +247,8 @@ function dataApiRoutes(ctx) {
     let results = docs.map((d) => d.data);
     for (const stage of pipeline) {
       if ("$match" in stage) {
-        const filter = stage.$match;
-        results = results.filter((d) => matchesFilter(d, filter));
+        const filter2 = stage.$match;
+        results = results.filter((d) => matchesFilter(d, filter2));
       } else if ("$limit" in stage) {
         results = results.slice(0, stage.$limit);
       } else if ("$skip" in stage) {
@@ -277,8 +277,8 @@ function ensureCollectionExists(ms, clusterId, database, collection) {
     ms().collections.insert({ cluster_id: clusterId, database, name: collection });
   }
 }
-function matchesFilter(data, filter) {
-  for (const [key, value] of Object.entries(filter)) {
+function matchesFilter(data, filter2) {
+  for (const [key, value] of Object.entries(filter2)) {
     if (key === "$and") {
       const conditions = value;
       if (!conditions.every((cond) => matchesFilter(data, cond))) return false;
@@ -357,9 +357,9 @@ function getNestedValue(obj, path) {
   }
   return current;
 }
-function matchFilter(docs, filter) {
-  if (!filter || Object.keys(filter).length === 0) return null;
-  return docs.filter((d) => matchesFilter(d.data, filter));
+function matchFilter(docs, filter2) {
+  if (!filter2 || Object.keys(filter2).length === 0) return null;
+  return docs.filter((d) => matchesFilter(d.data, filter2));
 }
 function applyProjection(data, projection) {
   if (!projection || Object.keys(projection).length === 0) return data;
@@ -505,9 +505,9 @@ function sortBySpec(docs, sortSpec, accessor) {
     return 0;
   });
 }
-function extractEqualityFields(filter) {
+function extractEqualityFields(filter2) {
   const result = {};
-  for (const [key, value] of Object.entries(filter)) {
+  for (const [key, value] of Object.entries(filter2)) {
     if (key.startsWith("$")) continue;
     if (value !== null && typeof value === "object" && !Array.isArray(value)) {
       const ops = value;
@@ -528,10 +528,10 @@ function adminRoutes(ctx) {
     });
   });
   app.get("/api/atlas/v2/groups/:groupId", (c) => {
-    const groupId = c.req.param("groupId");
-    const project = ms().projects.findOneBy("group_id", groupId);
+    const groupId2 = c.req.param("groupId");
+    const project = ms().projects.findOneBy("group_id", groupId2);
     if (!project) {
-      return mongoError(c, "GROUP_NOT_FOUND", `Group '${groupId}' not found.`, 404);
+      return mongoError(c, "GROUP_NOT_FOUND", `Group '${groupId2}' not found.`, 404);
     }
     return mongoOk(c, formatProject(project));
   });
@@ -544,9 +544,9 @@ function adminRoutes(ctx) {
     if (existing) {
       return mongoError(c, "DUPLICATE_GROUP_NAME", `Group name '${body.name}' already exists.`, 409);
     }
-    const groupId = generateGroupId();
+    const groupId2 = generateGroupId();
     const project = ms().projects.insert({
-      group_id: groupId,
+      group_id: groupId2,
       name: body.name,
       org_id: body.orgId ?? "default_org",
       cluster_count: 0
@@ -554,12 +554,12 @@ function adminRoutes(ctx) {
     return mongoOk(c, formatProject(project), 201);
   });
   app.delete("/api/atlas/v2/groups/:groupId", (c) => {
-    const groupId = c.req.param("groupId");
-    const project = ms().projects.findOneBy("group_id", groupId);
+    const groupId2 = c.req.param("groupId");
+    const project = ms().projects.findOneBy("group_id", groupId2);
     if (!project) {
-      return mongoError(c, "GROUP_NOT_FOUND", `Group '${groupId}' not found.`, 404);
+      return mongoError(c, "GROUP_NOT_FOUND", `Group '${groupId2}' not found.`, 404);
     }
-    const clusters = ms().clusters.all().filter((cl) => cl.group_id === groupId);
+    const clusters = ms().clusters.all().filter((cl) => cl.group_id === groupId2);
     for (const cluster of clusters) {
       deleteClusterData(ms, cluster.cluster_id);
       ms().clusters.delete(cluster.id);
@@ -568,37 +568,37 @@ function adminRoutes(ctx) {
     return c.body(null, 204);
   });
   app.get("/api/atlas/v2/groups/:groupId/clusters", (c) => {
-    const groupId = c.req.param("groupId");
-    const project = ms().projects.findOneBy("group_id", groupId);
+    const groupId2 = c.req.param("groupId");
+    const project = ms().projects.findOneBy("group_id", groupId2);
     if (!project) {
-      return mongoError(c, "GROUP_NOT_FOUND", `Group '${groupId}' not found.`, 404);
+      return mongoError(c, "GROUP_NOT_FOUND", `Group '${groupId2}' not found.`, 404);
     }
-    const clusters = ms().clusters.all().filter((cl) => cl.group_id === groupId);
+    const clusters = ms().clusters.all().filter((cl) => cl.group_id === groupId2);
     return mongoOk(c, {
       results: clusters.map(formatCluster),
       totalCount: clusters.length
     });
   });
   app.get("/api/atlas/v2/groups/:groupId/clusters/:clusterName", (c) => {
-    const groupId = c.req.param("groupId");
-    const clusterName = c.req.param("clusterName");
-    const cluster = ms().clusters.all().find((cl) => cl.group_id === groupId && cl.name === clusterName);
+    const groupId2 = c.req.param("groupId");
+    const clusterName2 = c.req.param("clusterName");
+    const cluster = ms().clusters.all().find((cl) => cl.group_id === groupId2 && cl.name === clusterName2);
     if (!cluster) {
-      return mongoError(c, "CLUSTER_NOT_FOUND", `Cluster '${clusterName}' not found.`, 404);
+      return mongoError(c, "CLUSTER_NOT_FOUND", `Cluster '${clusterName2}' not found.`, 404);
     }
     return mongoOk(c, formatCluster(cluster));
   });
   app.post("/api/atlas/v2/groups/:groupId/clusters", async (c) => {
-    const groupId = c.req.param("groupId");
-    const project = ms().projects.findOneBy("group_id", groupId);
+    const groupId2 = c.req.param("groupId");
+    const project = ms().projects.findOneBy("group_id", groupId2);
     if (!project) {
-      return mongoError(c, "GROUP_NOT_FOUND", `Group '${groupId}' not found.`, 404);
+      return mongoError(c, "GROUP_NOT_FOUND", `Group '${groupId2}' not found.`, 404);
     }
     const body = await c.req.json();
     if (!body.name?.trim()) {
       return mongoError(c, "INVALID_PARAMETER", "name is required");
     }
-    const existing = ms().clusters.all().find((cl) => cl.group_id === groupId && cl.name === body.name);
+    const existing = ms().clusters.all().find((cl) => cl.group_id === groupId2 && cl.name === body.name);
     if (existing) {
       return mongoError(c, "DUPLICATE_CLUSTER_NAME", `Cluster '${body.name}' already exists.`, 409);
     }
@@ -606,7 +606,7 @@ function adminRoutes(ctx) {
     const cluster = ms().clusters.insert({
       cluster_id: clusterId,
       name: body.name,
-      group_id: groupId,
+      group_id: groupId2,
       state: "IDLE",
       mongo_uri: `mongodb+srv://${body.name}.emulate.mongodb.net`,
       connection_strings: {
@@ -626,11 +626,11 @@ function adminRoutes(ctx) {
     return mongoOk(c, formatCluster(cluster), 201);
   });
   app.patch("/api/atlas/v2/groups/:groupId/clusters/:clusterName", async (c) => {
-    const groupId = c.req.param("groupId");
-    const clusterName = c.req.param("clusterName");
-    const cluster = ms().clusters.all().find((cl) => cl.group_id === groupId && cl.name === clusterName);
+    const groupId2 = c.req.param("groupId");
+    const clusterName2 = c.req.param("clusterName");
+    const cluster = ms().clusters.all().find((cl) => cl.group_id === groupId2 && cl.name === clusterName2);
     if (!cluster) {
-      return mongoError(c, "CLUSTER_NOT_FOUND", `Cluster '${clusterName}' not found.`, 404);
+      return mongoError(c, "CLUSTER_NOT_FOUND", `Cluster '${clusterName2}' not found.`, 404);
     }
     const body = await c.req.json();
     const updates = {};
@@ -648,44 +648,44 @@ function adminRoutes(ctx) {
     return mongoOk(c, formatCluster(updated));
   });
   app.delete("/api/atlas/v2/groups/:groupId/clusters/:clusterName", (c) => {
-    const groupId = c.req.param("groupId");
-    const clusterName = c.req.param("clusterName");
-    const cluster = ms().clusters.all().find((cl) => cl.group_id === groupId && cl.name === clusterName);
+    const groupId2 = c.req.param("groupId");
+    const clusterName2 = c.req.param("clusterName");
+    const cluster = ms().clusters.all().find((cl) => cl.group_id === groupId2 && cl.name === clusterName2);
     if (!cluster) {
-      return mongoError(c, "CLUSTER_NOT_FOUND", `Cluster '${clusterName}' not found.`, 404);
+      return mongoError(c, "CLUSTER_NOT_FOUND", `Cluster '${clusterName2}' not found.`, 404);
     }
     deleteClusterData(ms, cluster.cluster_id);
     ms().clusters.delete(cluster.id);
-    const project = ms().projects.findOneBy("group_id", groupId);
+    const project = ms().projects.findOneBy("group_id", groupId2);
     if (project) {
       ms().projects.update(project.id, { cluster_count: Math.max(0, project.cluster_count - 1) });
     }
     return c.body(null, 204);
   });
   app.get("/api/atlas/v2/groups/:groupId/databaseUsers", (c) => {
-    const groupId = c.req.param("groupId");
-    const users = ms().users.all().filter((u) => u.group_id === groupId);
+    const groupId2 = c.req.param("groupId");
+    const users = ms().users.all().filter((u) => u.group_id === groupId2);
     return mongoOk(c, {
       results: users.map(formatUser),
       totalCount: users.length
     });
   });
   app.get("/api/atlas/v2/groups/:groupId/databaseUsers/admin/:username", (c) => {
-    const groupId = c.req.param("groupId");
-    const username = c.req.param("username");
-    const user = ms().users.all().find((u) => u.group_id === groupId && u.username === username);
+    const groupId2 = c.req.param("groupId");
+    const username2 = c.req.param("username");
+    const user = ms().users.all().find((u) => u.group_id === groupId2 && u.username === username2);
     if (!user) {
-      return mongoError(c, "USER_NOT_FOUND", `Database user '${username}' not found.`, 404);
+      return mongoError(c, "USER_NOT_FOUND", `Database user '${username2}' not found.`, 404);
     }
     return mongoOk(c, formatUser(user));
   });
   app.post("/api/atlas/v2/groups/:groupId/databaseUsers", async (c) => {
-    const groupId = c.req.param("groupId");
+    const groupId2 = c.req.param("groupId");
     const body = await c.req.json();
     if (!body.username?.trim()) {
       return mongoError(c, "INVALID_PARAMETER", "username is required");
     }
-    const existing = ms().users.all().find((u) => u.group_id === groupId && u.username === body.username);
+    const existing = ms().users.all().find((u) => u.group_id === groupId2 && u.username === body.username);
     if (existing) {
       return mongoError(c, "DUPLICATE_USER", `User '${body.username}' already exists.`, 409);
     }
@@ -693,27 +693,27 @@ function adminRoutes(ctx) {
     const user = ms().users.insert({
       user_id: userId,
       username: body.username,
-      group_id: groupId,
+      group_id: groupId2,
       roles: (body.roles ?? []).map((r) => ({ database_name: r.databaseName, role_name: r.roleName }))
     });
     return mongoOk(c, formatUser(user), 201);
   });
   app.delete("/api/atlas/v2/groups/:groupId/databaseUsers/admin/:username", (c) => {
-    const groupId = c.req.param("groupId");
-    const username = c.req.param("username");
-    const user = ms().users.all().find((u) => u.group_id === groupId && u.username === username);
+    const groupId2 = c.req.param("groupId");
+    const username2 = c.req.param("username");
+    const user = ms().users.all().find((u) => u.group_id === groupId2 && u.username === username2);
     if (!user) {
-      return mongoError(c, "USER_NOT_FOUND", `Database user '${username}' not found.`, 404);
+      return mongoError(c, "USER_NOT_FOUND", `Database user '${username2}' not found.`, 404);
     }
     ms().users.delete(user.id);
     return c.body(null, 204);
   });
   app.get("/api/atlas/v2/groups/:groupId/clusters/:clusterName/databases", (c) => {
-    const groupId = c.req.param("groupId");
-    const clusterName = c.req.param("clusterName");
-    const cluster = ms().clusters.all().find((cl) => cl.group_id === groupId && cl.name === clusterName);
+    const groupId2 = c.req.param("groupId");
+    const clusterName2 = c.req.param("clusterName");
+    const cluster = ms().clusters.all().find((cl) => cl.group_id === groupId2 && cl.name === clusterName2);
     if (!cluster) {
-      return mongoError(c, "CLUSTER_NOT_FOUND", `Cluster '${clusterName}' not found.`, 404);
+      return mongoError(c, "CLUSTER_NOT_FOUND", `Cluster '${clusterName2}' not found.`, 404);
     }
     const databases = ms().databases.all().filter((db) => db.cluster_id === cluster.cluster_id);
     return mongoOk(c, {
@@ -722,16 +722,16 @@ function adminRoutes(ctx) {
     });
   });
   app.get("/api/atlas/v2/groups/:groupId/clusters/:clusterName/databases/:databaseName/collections", (c) => {
-    const groupId = c.req.param("groupId");
-    const clusterName = c.req.param("clusterName");
-    const databaseName = c.req.param("databaseName");
-    const cluster = ms().clusters.all().find((cl) => cl.group_id === groupId && cl.name === clusterName);
+    const groupId2 = c.req.param("groupId");
+    const clusterName2 = c.req.param("clusterName");
+    const databaseName2 = c.req.param("databaseName");
+    const cluster = ms().clusters.all().find((cl) => cl.group_id === groupId2 && cl.name === clusterName2);
     if (!cluster) {
-      return mongoError(c, "CLUSTER_NOT_FOUND", `Cluster '${clusterName}' not found.`, 404);
+      return mongoError(c, "CLUSTER_NOT_FOUND", `Cluster '${clusterName2}' not found.`, 404);
     }
-    const collections = ms().collections.all().filter((col) => col.cluster_id === cluster.cluster_id && col.database === databaseName);
+    const collections = ms().collections.all().filter((col) => col.cluster_id === cluster.cluster_id && col.database === databaseName2);
     return mongoOk(c, {
-      results: collections.map((col) => ({ collectionName: col.name, databaseName })),
+      results: collections.map((col) => ({ collectionName: col.name, databaseName: databaseName2 })),
       totalCount: collections.length
     });
   });
@@ -783,6 +783,362 @@ function formatUser(u) {
     roles: u.roles.map((r) => ({ databaseName: r.database_name, roleName: r.role_name }))
   };
 }
+function openapiRoutes({ app, baseUrl }) {
+  app.get("/openapi.json", (c) => c.json(buildSpec(baseUrl)));
+}
+var ok = (description) => ({
+  description,
+  content: { "application/json": { schema: { type: "object" } } }
+});
+var deleted = { description: "Deleted (no content)." };
+var groupId = { name: "groupId", in: "path", required: true, schema: { type: "string" } };
+var clusterName = { name: "clusterName", in: "path", required: true, schema: { type: "string" } };
+var username = { name: "username", in: "path", required: true, schema: { type: "string" } };
+var databaseName = { name: "databaseName", in: "path", required: true, schema: { type: "string" } };
+var jsonBody = (properties, required, description) => ({
+  required: true,
+  description,
+  content: {
+    "application/json": {
+      schema: { type: "object", properties, required: [...required] }
+    }
+  }
+});
+var dataApiTarget = {
+  dataSource: { type: "string", description: "Cluster name, e.g. Cluster0." },
+  database: { type: "string" },
+  collection: { type: "string" }
+};
+var filter = { type: "object", description: "MongoDB query filter." };
+function buildSpec(baseUrl) {
+  return {
+    openapi: "3.1.0",
+    info: {
+      title: "MongoDB Atlas Administration API (Emulated)",
+      version: "1.0.0",
+      description: "Emulated subset of the MongoDB Atlas Administration API v2 and Atlas Data API v1. Real Atlas uses HTTP digest (API key pair) or service-account bearer tokens; the emulator accepts `Authorization: Bearer <token>` for every surface (mint a token at POST /_emulate/credentials)."
+    },
+    servers: [{ url: baseUrl }],
+    components: {
+      securitySchemes: {
+        bearerAuth: {
+          type: "http",
+          scheme: "bearer",
+          description: "Atlas API token, sent as `Authorization: Bearer emu_mongoatlas_\u2026`. Stands in for Atlas digest or service-account auth."
+        }
+      }
+    },
+    security: [{ bearerAuth: [] }],
+    paths: {
+      "/api/atlas/v2/groups": {
+        get: {
+          operationId: "listProjects",
+          tags: ["projects"],
+          summary: "List projects",
+          responses: { "200": ok("Project list.") }
+        },
+        post: {
+          operationId: "createProject",
+          tags: ["projects"],
+          summary: "Create a project",
+          requestBody: jsonBody(
+            { name: { type: "string" }, orgId: { type: "string" } },
+            ["name"],
+            "The project to create."
+          ),
+          responses: { "201": ok("The created project."), "409": ok("Duplicate project name.") }
+        }
+      },
+      "/api/atlas/v2/groups/{groupId}": {
+        get: {
+          operationId: "getProject",
+          tags: ["projects"],
+          summary: "Retrieve a project",
+          parameters: [groupId],
+          responses: { "200": ok("The project."), "404": ok("Not found.") }
+        },
+        delete: {
+          operationId: "deleteProject",
+          tags: ["projects"],
+          summary: "Delete a project and its clusters",
+          parameters: [groupId],
+          responses: { "204": deleted, "404": ok("Not found.") }
+        }
+      },
+      "/api/atlas/v2/groups/{groupId}/clusters": {
+        get: {
+          operationId: "listClusters",
+          tags: ["clusters"],
+          summary: "List clusters in a project",
+          parameters: [groupId],
+          responses: { "200": ok("Cluster list."), "404": ok("Project not found.") }
+        },
+        post: {
+          operationId: "createCluster",
+          tags: ["clusters"],
+          summary: "Create a cluster",
+          parameters: [groupId],
+          requestBody: jsonBody(
+            {
+              name: { type: "string" },
+              clusterType: { type: "string", enum: ["REPLICASET", "SHARDED"] },
+              providerSettings: {
+                type: "object",
+                properties: {
+                  providerName: { type: "string" },
+                  instanceSizeName: { type: "string" },
+                  regionName: { type: "string" }
+                }
+              },
+              diskSizeGB: { type: "number" },
+              mongoDBMajorVersion: { type: "string" }
+            },
+            ["name"],
+            "The cluster to create."
+          ),
+          responses: {
+            "201": ok("The created cluster."),
+            "404": ok("Project not found."),
+            "409": ok("Duplicate cluster name.")
+          }
+        }
+      },
+      "/api/atlas/v2/groups/{groupId}/clusters/{clusterName}": {
+        get: {
+          operationId: "getCluster",
+          tags: ["clusters"],
+          summary: "Retrieve a cluster",
+          parameters: [groupId, clusterName],
+          responses: { "200": ok("The cluster."), "404": ok("Not found.") }
+        },
+        patch: {
+          operationId: "updateCluster",
+          tags: ["clusters"],
+          summary: "Update a cluster (instance size, region, disk size)",
+          parameters: [groupId, clusterName],
+          requestBody: jsonBody(
+            {
+              providerSettings: {
+                type: "object",
+                properties: {
+                  instanceSizeName: { type: "string" },
+                  regionName: { type: "string" }
+                }
+              },
+              diskSizeGB: { type: "number" }
+            },
+            [],
+            "Fields to update; other cluster fields are immutable in the emulator."
+          ),
+          responses: { "200": ok("The updated cluster."), "404": ok("Not found.") }
+        },
+        delete: {
+          operationId: "deleteCluster",
+          tags: ["clusters"],
+          summary: "Delete a cluster and its data",
+          parameters: [groupId, clusterName],
+          responses: { "204": deleted, "404": ok("Not found.") }
+        }
+      },
+      "/api/atlas/v2/groups/{groupId}/databaseUsers": {
+        get: {
+          operationId: "listDatabaseUsers",
+          tags: ["database-users"],
+          summary: "List database users in a project",
+          parameters: [groupId],
+          responses: { "200": ok("Database user list.") }
+        },
+        post: {
+          operationId: "createDatabaseUser",
+          tags: ["database-users"],
+          summary: "Create a database user",
+          parameters: [groupId],
+          requestBody: jsonBody(
+            {
+              username: { type: "string" },
+              password: { type: "string" },
+              databaseName: { type: "string" },
+              roles: {
+                type: "array",
+                items: {
+                  type: "object",
+                  properties: { databaseName: { type: "string" }, roleName: { type: "string" } }
+                }
+              }
+            },
+            ["username"],
+            "The database user to create."
+          ),
+          responses: { "201": ok("The created database user."), "409": ok("Duplicate username.") }
+        }
+      },
+      "/api/atlas/v2/groups/{groupId}/databaseUsers/admin/{username}": {
+        get: {
+          operationId: "getDatabaseUser",
+          tags: ["database-users"],
+          summary: "Retrieve a database user",
+          parameters: [groupId, username],
+          responses: { "200": ok("The database user."), "404": ok("Not found.") }
+        },
+        delete: {
+          operationId: "deleteDatabaseUser",
+          tags: ["database-users"],
+          summary: "Delete a database user",
+          parameters: [groupId, username],
+          responses: { "204": deleted, "404": ok("Not found.") }
+        }
+      },
+      "/api/atlas/v2/groups/{groupId}/clusters/{clusterName}/databases": {
+        get: {
+          operationId: "listDatabases",
+          tags: ["databases"],
+          summary: "List databases in a cluster",
+          parameters: [groupId, clusterName],
+          responses: { "200": ok("Database list."), "404": ok("Cluster not found.") }
+        }
+      },
+      "/api/atlas/v2/groups/{groupId}/clusters/{clusterName}/databases/{databaseName}/collections": {
+        get: {
+          operationId: "listCollections",
+          tags: ["databases"],
+          summary: "List collections in a database",
+          parameters: [groupId, clusterName, databaseName],
+          responses: { "200": ok("Collection list."), "404": ok("Cluster not found.") }
+        }
+      },
+      "/app/data-api/v1/action/findOne": {
+        post: {
+          operationId: "findOne",
+          tags: ["data-api"],
+          summary: "Find a single document",
+          requestBody: jsonBody(
+            { ...dataApiTarget, filter, projection: { type: "object" } },
+            ["dataSource", "database", "collection"],
+            "Where to look and what to match."
+          ),
+          responses: { "200": ok("`{ document }` (null when nothing matches)."), "404": ok("Cluster not found.") }
+        }
+      },
+      "/app/data-api/v1/action/find": {
+        post: {
+          operationId: "find",
+          tags: ["data-api"],
+          summary: "Find multiple documents",
+          requestBody: jsonBody(
+            {
+              ...dataApiTarget,
+              filter,
+              projection: { type: "object" },
+              sort: { type: "object" },
+              limit: { type: "integer" },
+              skip: { type: "integer" }
+            },
+            ["dataSource", "database", "collection"],
+            "Where to look, what to match, and how to page."
+          ),
+          responses: { "200": ok("`{ documents }`."), "404": ok("Cluster not found.") }
+        }
+      },
+      "/app/data-api/v1/action/insertOne": {
+        post: {
+          operationId: "insertOne",
+          tags: ["data-api"],
+          summary: "Insert a single document",
+          requestBody: jsonBody(
+            { ...dataApiTarget, document: { type: "object" } },
+            ["dataSource", "database", "collection", "document"],
+            "The document to insert."
+          ),
+          responses: { "201": ok("`{ insertedId }`."), "404": ok("Cluster not found.") }
+        }
+      },
+      "/app/data-api/v1/action/insertMany": {
+        post: {
+          operationId: "insertMany",
+          tags: ["data-api"],
+          summary: "Insert multiple documents",
+          requestBody: jsonBody(
+            { ...dataApiTarget, documents: { type: "array", items: { type: "object" } } },
+            ["dataSource", "database", "collection", "documents"],
+            "The documents to insert."
+          ),
+          responses: { "201": ok("`{ insertedIds }`."), "404": ok("Cluster not found.") }
+        }
+      },
+      "/app/data-api/v1/action/updateOne": {
+        post: {
+          operationId: "updateOne",
+          tags: ["data-api"],
+          summary: "Update a single document",
+          requestBody: jsonBody(
+            { ...dataApiTarget, filter, update: { type: "object" }, upsert: { type: "boolean" } },
+            ["dataSource", "database", "collection", "update"],
+            "What to match and how to update it ($set, $unset, $inc, $push, $pull, $rename, or replacement)."
+          ),
+          responses: {
+            "200": ok("`{ matchedCount, modifiedCount }` (plus `upsertedId` on upsert)."),
+            "404": ok("Cluster not found.")
+          }
+        }
+      },
+      "/app/data-api/v1/action/updateMany": {
+        post: {
+          operationId: "updateMany",
+          tags: ["data-api"],
+          summary: "Update multiple documents",
+          requestBody: jsonBody(
+            { ...dataApiTarget, filter, update: { type: "object" }, upsert: { type: "boolean" } },
+            ["dataSource", "database", "collection", "update"],
+            "What to match and how to update it ($set, $unset, $inc, $push, $pull, $rename, or replacement)."
+          ),
+          responses: {
+            "200": ok("`{ matchedCount, modifiedCount }` (plus `upsertedId` on upsert)."),
+            "404": ok("Cluster not found.")
+          }
+        }
+      },
+      "/app/data-api/v1/action/deleteOne": {
+        post: {
+          operationId: "deleteOne",
+          tags: ["data-api"],
+          summary: "Delete a single document",
+          requestBody: jsonBody(
+            { ...dataApiTarget, filter },
+            ["dataSource", "database", "collection"],
+            "What to match."
+          ),
+          responses: { "200": ok("`{ deletedCount }`."), "404": ok("Cluster not found.") }
+        }
+      },
+      "/app/data-api/v1/action/deleteMany": {
+        post: {
+          operationId: "deleteMany",
+          tags: ["data-api"],
+          summary: "Delete multiple documents",
+          requestBody: jsonBody(
+            { ...dataApiTarget, filter },
+            ["dataSource", "database", "collection"],
+            "What to match."
+          ),
+          responses: { "200": ok("`{ deletedCount }`."), "404": ok("Cluster not found.") }
+        }
+      },
+      "/app/data-api/v1/action/aggregate": {
+        post: {
+          operationId: "aggregate",
+          tags: ["data-api"],
+          summary: "Run an aggregation pipeline (subset: $match, $limit, $skip, $sort, $project, $count)",
+          requestBody: jsonBody(
+            { ...dataApiTarget, pipeline: { type: "array", items: { type: "object" } } },
+            ["dataSource", "database", "collection"],
+            "The pipeline to run; unsupported stages are ignored."
+          ),
+          responses: { "200": ok("`{ documents }`."), "404": ok("Cluster not found.") }
+        }
+      }
+    }
+  };
+}
 var manifest = {
   id: "mongoatlas",
   name: "MongoDB Atlas",
@@ -798,6 +1154,7 @@ var manifest = {
       kind: "openapi",
       title: "Atlas Administration API v2 subset",
       coverage: "hand-authored",
+      url: "/openapi.json",
       operations: [
         { operationId: "listProjects", method: "GET", path: "/api/atlas/v2/groups", status: "hand-authored" },
         { operationId: "getProject", method: "GET", path: "/api/atlas/v2/groups/:groupId", status: "hand-authored" },
@@ -880,6 +1237,7 @@ var manifest = {
       kind: "openapi",
       title: "Atlas Data API v1 subset",
       coverage: "hand-authored",
+      url: "/openapi.json",
       operations: [
         { operationId: "findOne", method: "POST", path: "/app/data-api/v1/action/findOne", status: "hand-authored" },
         { operationId: "find", method: "POST", path: "/app/data-api/v1/action/find", status: "hand-authored" },
@@ -1027,9 +1385,9 @@ var manifest = {
 };
 function seedDefaults(store, _baseUrl) {
   const ms = getMongoAtlasStore(store);
-  const groupId = generateGroupId();
+  const groupId2 = generateGroupId();
   ms.projects.insert({
-    group_id: groupId,
+    group_id: groupId2,
     name: "Project0",
     org_id: "default_org",
     cluster_count: 1
@@ -1038,7 +1396,7 @@ function seedDefaults(store, _baseUrl) {
   ms.clusters.insert({
     cluster_id: clusterId,
     name: "Cluster0",
-    group_id: groupId,
+    group_id: groupId2,
     state: "IDLE",
     mongo_uri: "mongodb+srv://Cluster0.emulate.mongodb.net",
     connection_strings: {
@@ -1057,7 +1415,7 @@ function seedDefaults(store, _baseUrl) {
   ms.users.insert({
     user_id: generateUserId(),
     username: "admin",
-    group_id: groupId,
+    group_id: groupId2,
     roles: [{ database_name: "admin", role_name: "atlasAdmin" }]
   });
   ms.databases.insert({ cluster_id: clusterId, name: "test" });
@@ -1073,14 +1431,14 @@ function seedFromConfig(store, _baseUrl, config) {
         projectIdMap.set(p.name, existing.group_id);
         continue;
       }
-      const groupId = generateGroupId();
+      const groupId2 = generateGroupId();
       ms.projects.insert({
-        group_id: groupId,
+        group_id: groupId2,
         name: p.name,
         org_id: p.org_id ?? "default_org",
         cluster_count: 0
       });
-      projectIdMap.set(p.name, groupId);
+      projectIdMap.set(p.name, groupId2);
     }
   }
   const defaultProject = ms.projects.all()[0];
@@ -1090,9 +1448,9 @@ function seedFromConfig(store, _baseUrl, config) {
   const clusterIdMap = /* @__PURE__ */ new Map();
   if (config.clusters) {
     for (const cl of config.clusters) {
-      const groupId = projectIdMap.get(cl.project);
-      if (!groupId) continue;
-      const existing = ms.clusters.all().find((ec) => ec.group_id === groupId && ec.name === cl.name);
+      const groupId2 = projectIdMap.get(cl.project);
+      if (!groupId2) continue;
+      const existing = ms.clusters.all().find((ec) => ec.group_id === groupId2 && ec.name === cl.name);
       if (existing) {
         clusterIdMap.set(cl.name, existing.cluster_id);
         continue;
@@ -1101,7 +1459,7 @@ function seedFromConfig(store, _baseUrl, config) {
       ms.clusters.insert({
         cluster_id: clusterId,
         name: cl.name,
-        group_id: groupId,
+        group_id: groupId2,
         state: "IDLE",
         mongo_uri: `mongodb+srv://${cl.name}.emulate.mongodb.net`,
         connection_strings: {
@@ -1118,7 +1476,7 @@ function seedFromConfig(store, _baseUrl, config) {
         mongodb_version: cl.mongodb_version ?? "8.0"
       });
       clusterIdMap.set(cl.name, clusterId);
-      const project = ms.projects.findOneBy("group_id", groupId);
+      const project = ms.projects.findOneBy("group_id", groupId2);
       if (project) {
         ms.projects.update(project.id, { cluster_count: project.cluster_count + 1 });
       }
@@ -1130,14 +1488,14 @@ function seedFromConfig(store, _baseUrl, config) {
   }
   if (config.database_users) {
     for (const u of config.database_users) {
-      const groupId = projectIdMap.get(u.project);
-      if (!groupId) continue;
-      const existing = ms.users.all().find((eu) => eu.group_id === groupId && eu.username === u.username);
+      const groupId2 = projectIdMap.get(u.project);
+      if (!groupId2) continue;
+      const existing = ms.users.all().find((eu) => eu.group_id === groupId2 && eu.username === u.username);
       if (existing) continue;
       ms.users.insert({
         user_id: generateUserId(),
         username: u.username,
-        group_id: groupId,
+        group_id: groupId2,
         roles: u.roles ?? [{ database_name: "admin", role_name: "readWriteAnyDatabase" }]
       });
     }
@@ -1167,6 +1525,7 @@ var mongoatlasPlugin = {
     const ctx = { app, store, webhooks, baseUrl, tokenMap };
     adminRoutes(ctx);
     dataApiRoutes(ctx);
+    openapiRoutes(ctx);
   },
   seed(store, baseUrl) {
     seedDefaults(store, baseUrl);
@@ -1180,4 +1539,4 @@ export {
   mongoatlasPlugin,
   seedFromConfig
 };
-//# sourceMappingURL=dist-RMPDKZUA.js.map
+//# sourceMappingURL=dist-OT6R2YO2.js.map