@executor-js/emulate 0.6.0 → 0.7.0

package/dist/{dist-XM5HSBDC.js → dist-TWJXVA7X.js}

@@ -154,14 +154,14 @@ function emailRoutes(ctx) {
     return c.json(resendList(allEmails.map(formatEmail)));
   });
   app.get("/emails/:id", (c) => {
-    const id = c.req.param("id");
-    const email = rs().emails.findOneBy("uuid", id);
+    const id2 = c.req.param("id");
+    const email = rs().emails.findOneBy("uuid", id2);
     if (!email) return resendError(c, 404, "not_found", "Email not found");
     return c.json(formatEmail(email));
   });
   app.post("/emails/:id/cancel", (c) => {
-    const id = c.req.param("id");
-    const email = rs().emails.findOneBy("uuid", id);
+    const id2 = c.req.param("id");
+    const email = rs().emails.findOneBy("uuid", id2);
     if (!email) return resendError(c, 404, "not_found", "Email not found");
     if (email.status !== "scheduled") {
       return resendError(c, 422, "validation_error", "Only scheduled emails can be canceled");
@@ -255,14 +255,14 @@ function domainRoutes(ctx) {
     return c.json(resendList(allDomains.map(formatDomain)));
   });
   app.get("/domains/:id", (c) => {
-    const id = c.req.param("id");
-    const domain = rs().domains.findOneBy("uuid", id);
+    const id2 = c.req.param("id");
+    const domain = rs().domains.findOneBy("uuid", id2);
     if (!domain) return resendError(c, 404, "not_found", "Domain not found");
     return c.json(formatDomain(domain));
   });
   app.delete("/domains/:id", async (c) => {
-    const id = c.req.param("id");
-    const domain = rs().domains.findOneBy("uuid", id);
+    const id2 = c.req.param("id");
+    const domain = rs().domains.findOneBy("uuid", id2);
     if (!domain) return resendError(c, 404, "not_found", "Domain not found");
     rs().domains.delete(domain.id);
     await webhooks.dispatch(
@@ -274,8 +274,8 @@ function domainRoutes(ctx) {
     return c.json({ object: "domain", id: domain.uuid, deleted: true });
   });
   app.post("/domains/:id/verify", (c) => {
-    const id = c.req.param("id");
-    const domain = rs().domains.findOneBy("uuid", id);
+    const id2 = c.req.param("id");
+    const domain = rs().domains.findOneBy("uuid", id2);
     if (!domain) return resendError(c, 404, "not_found", "Domain not found");
     const verifiedRecords = domain.records.map((r) => ({ ...r, status: "verified" }));
     rs().domains.update(domain.id, {
@@ -331,8 +331,8 @@ function apiKeyRoutes(ctx) {
     );
   });
   app.delete("/api-keys/:id", (c) => {
-    const id = c.req.param("id");
-    const apiKey = rs().apiKeys.findOneBy("uuid", id);
+    const id2 = c.req.param("id");
+    const apiKey = rs().apiKeys.findOneBy("uuid", id2);
     if (!apiKey) return resendError(c, 404, "not_found", "API key not found");
     rs().apiKeys.delete(apiKey.id);
     return c.json({ deleted: true });
@@ -371,15 +371,15 @@ function contactRoutes(ctx) {
     );
   });
   app.delete("/audiences/:id", (c) => {
-    const id = c.req.param("id");
-    const audience = rs().audiences.findOneBy("uuid", id);
+    const id2 = c.req.param("id");
+    const audience = rs().audiences.findOneBy("uuid", id2);
     if (!audience) return resendError(c, 404, "not_found", "Audience not found");
     rs().audiences.delete(audience.id);
     return c.json({ object: "audience", id: audience.uuid, deleted: true });
   });
   app.post("/audiences/:audience_id/contacts", async (c) => {
-    const audienceId = c.req.param("audience_id");
-    const audience = rs().audiences.findOneBy("uuid", audienceId);
+    const audienceId2 = c.req.param("audience_id");
+    const audience = rs().audiences.findOneBy("uuid", audienceId2);
     if (!audience) return resendError(c, 404, "not_found", "Audience not found");
     const body = await parseResendBody(c);
     const email = body.email;
@@ -387,7 +387,7 @@ function contactRoutes(ctx) {
     const uuid = generateUuid();
     const contact = rs().contacts.insert({
       uuid,
-      audience_id: audienceId,
+      audience_id: audienceId2,
       email,
       first_name: body.first_name ?? null,
       last_name: body.last_name ?? null,
@@ -396,7 +396,7 @@ function contactRoutes(ctx) {
     await webhooks.dispatch(
       "contact.created",
       void 0,
-      { type: "contact.created", data: { id: uuid, email, audience_id: audienceId } },
+      { type: "contact.created", data: { id: uuid, email, audience_id: audienceId2 } },
       "resend"
     );
     return c.json(
@@ -409,10 +409,10 @@ function contactRoutes(ctx) {
     );
   });
   app.get("/audiences/:audience_id/contacts", (c) => {
-    const audienceId = c.req.param("audience_id");
-    const audience = rs().audiences.findOneBy("uuid", audienceId);
+    const audienceId2 = c.req.param("audience_id");
+    const audience = rs().audiences.findOneBy("uuid", audienceId2);
     if (!audience) return resendError(c, 404, "not_found", "Audience not found");
-    const contacts = rs().contacts.findBy("audience_id", audienceId);
+    const contacts = rs().contacts.findBy("audience_id", audienceId2);
     return c.json(
       resendList(
         contacts.map((ct) => ({
@@ -428,17 +428,17 @@ function contactRoutes(ctx) {
     );
   });
   app.delete("/audiences/:audience_id/contacts/:id", async (c) => {
-    const audienceId = c.req.param("audience_id");
+    const audienceId2 = c.req.param("audience_id");
     const contactId = c.req.param("id");
     const contact = rs().contacts.findOneBy("uuid", contactId);
-    if (!contact || contact.audience_id !== audienceId) {
+    if (!contact || contact.audience_id !== audienceId2) {
       return resendError(c, 404, "not_found", "Contact not found");
     }
     rs().contacts.delete(contact.id);
     await webhooks.dispatch(
       "contact.deleted",
       void 0,
-      { type: "contact.deleted", data: { id: contact.uuid, email: contact.email, audience_id: audienceId } },
+      { type: "contact.deleted", data: { id: contact.uuid, email: contact.email, audience_id: audienceId2 } },
       "resend"
     );
     return c.json({ object: "contact", id: contact.uuid, deleted: true });
@@ -809,8 +809,8 @@ function inboxRoutes(ctx) {
     return c.html(html);
   });
   app.get("/inbox/:id", (c) => {
-    const id = c.req.param("id");
-    const email = rs().emails.findOneBy("uuid", id);
+    const id2 = c.req.param("id");
+    const email = rs().emails.findOneBy("uuid", id2);
     if (!email) {
       const html2 = renderCardPage(
         "Not Found",
@@ -866,6 +866,242 @@ ${previewContent}
     return c.html(html);
   });
 }
+function openapiRoutes({ app, baseUrl }) {
+  app.get("/openapi.json", (c) => c.json(buildSpec(baseUrl)));
+}
+var ok = (description) => ({
+  description,
+  content: { "application/json": { schema: { type: "object" } } }
+});
+var id = { name: "id", in: "path", required: true, schema: { type: "string" } };
+var audienceId = { name: "audience_id", in: "path", required: true, schema: { type: "string" } };
+var jsonBody = (properties, required, description) => ({
+  required: true,
+  description,
+  content: {
+    "application/json": {
+      schema: { type: "object", properties, required: [...required] }
+    }
+  }
+});
+function buildSpec(baseUrl) {
+  return {
+    openapi: "3.1.0",
+    info: {
+      title: "Resend API (Emulated)",
+      version: "1.0.0",
+      description: "Emulated subset of the Resend REST API. Authenticate with a bearer API key (mint one at POST /_emulate/credentials)."
+    },
+    servers: [{ url: baseUrl }],
+    components: {
+      securitySchemes: {
+        bearerAuth: {
+          type: "http",
+          scheme: "bearer",
+          description: "Resend API key, sent as `Authorization: Bearer re_\u2026`."
+        }
+      }
+    },
+    security: [{ bearerAuth: [] }],
+    paths: {
+      "/emails": {
+        post: {
+          operationId: "emails.send",
+          tags: ["emails"],
+          summary: "Send an email",
+          requestBody: jsonBody(
+            {
+              from: { type: "string" },
+              to: { type: ["string", "array"], items: { type: "string" } },
+              subject: { type: "string" },
+              html: { type: "string" },
+              text: { type: "string" },
+              cc: { type: ["string", "array"], items: { type: "string" } },
+              bcc: { type: ["string", "array"], items: { type: "string" } },
+              reply_to: { type: ["string", "array"], items: { type: "string" } },
+              scheduled_at: { type: "string" }
+            },
+            ["from", "to", "subject"],
+            "The email to send."
+          ),
+          responses: { "200": ok("The created email."), "422": ok("Validation error.") }
+        },
+        get: {
+          operationId: "emails.list",
+          tags: ["emails"],
+          summary: "List sent emails",
+          responses: { "200": ok("Email list.") }
+        }
+      },
+      "/emails/batch": {
+        post: {
+          operationId: "emails.sendBatch",
+          tags: ["emails"],
+          summary: "Send up to 100 emails at once",
+          requestBody: {
+            required: true,
+            description: "An array of email objects (same shape as emails.send).",
+            content: {
+              "application/json": {
+                schema: { type: "array", items: { type: "object" } }
+              }
+            }
+          },
+          responses: { "200": ok("The created emails."), "422": ok("Validation error.") }
+        }
+      },
+      "/emails/{id}": {
+        get: {
+          operationId: "emails.get",
+          tags: ["emails"],
+          summary: "Retrieve a sent email",
+          parameters: [id],
+          responses: { "200": ok("The email."), "404": ok("Not found.") }
+        }
+      },
+      "/emails/{id}/cancel": {
+        post: {
+          operationId: "emails.cancel",
+          tags: ["emails"],
+          summary: "Cancel a scheduled email",
+          parameters: [id],
+          responses: { "200": ok("The canceled email."), "404": ok("Not found.") }
+        }
+      },
+      "/domains": {
+        post: {
+          operationId: "domains.create",
+          tags: ["domains"],
+          summary: "Add a sending domain",
+          requestBody: jsonBody(
+            { name: { type: "string" }, region: { type: "string" } },
+            ["name"],
+            "The domain to add."
+          ),
+          responses: { "201": ok("The created domain."), "422": ok("Validation error.") }
+        },
+        get: {
+          operationId: "domains.list",
+          tags: ["domains"],
+          summary: "List domains",
+          responses: { "200": ok("Domain list.") }
+        }
+      },
+      "/domains/{id}": {
+        get: {
+          operationId: "domains.get",
+          tags: ["domains"],
+          summary: "Retrieve a domain",
+          parameters: [id],
+          responses: { "200": ok("The domain."), "404": ok("Not found.") }
+        },
+        delete: {
+          operationId: "domains.remove",
+          tags: ["domains"],
+          summary: "Remove a domain",
+          parameters: [id],
+          responses: { "200": ok("Deletion confirmation."), "404": ok("Not found.") }
+        }
+      },
+      "/domains/{id}/verify": {
+        post: {
+          operationId: "domains.verify",
+          tags: ["domains"],
+          summary: "Trigger domain verification",
+          parameters: [id],
+          responses: { "200": ok("Verification state."), "404": ok("Not found.") }
+        }
+      },
+      "/api-keys": {
+        post: {
+          operationId: "apiKeys.create",
+          tags: ["api-keys"],
+          summary: "Create an API key",
+          requestBody: jsonBody(
+            { name: { type: "string" }, permission: { type: "string" } },
+            ["name"],
+            "The API key to create."
+          ),
+          responses: { "201": ok("The created key (token shown once).") }
+        },
+        get: {
+          operationId: "apiKeys.list",
+          tags: ["api-keys"],
+          summary: "List API keys",
+          responses: { "200": ok("API key list.") }
+        }
+      },
+      "/api-keys/{id}": {
+        delete: {
+          operationId: "apiKeys.remove",
+          tags: ["api-keys"],
+          summary: "Remove an API key",
+          parameters: [id],
+          responses: { "200": ok("Deletion confirmation."), "404": ok("Not found.") }
+        }
+      },
+      "/audiences": {
+        post: {
+          operationId: "audiences.create",
+          tags: ["audiences"],
+          summary: "Create an audience",
+          requestBody: jsonBody({ name: { type: "string" } }, ["name"], "The audience to create."),
+          responses: { "201": ok("The created audience.") }
+        },
+        get: {
+          operationId: "audiences.list",
+          tags: ["audiences"],
+          summary: "List audiences",
+          responses: { "200": ok("Audience list.") }
+        }
+      },
+      "/audiences/{id}": {
+        delete: {
+          operationId: "audiences.remove",
+          tags: ["audiences"],
+          summary: "Remove an audience",
+          parameters: [id],
+          responses: { "200": ok("Deletion confirmation."), "404": ok("Not found.") }
+        }
+      },
+      "/audiences/{audience_id}/contacts": {
+        post: {
+          operationId: "contacts.create",
+          tags: ["contacts"],
+          summary: "Add a contact to an audience",
+          parameters: [audienceId],
+          requestBody: jsonBody(
+            {
+              email: { type: "string" },
+              first_name: { type: "string" },
+              last_name: { type: "string" },
+              unsubscribed: { type: "boolean" }
+            },
+            ["email"],
+            "The contact to add."
+          ),
+          responses: { "201": ok("The created contact."), "422": ok("Validation error.") }
+        },
+        get: {
+          operationId: "contacts.list",
+          tags: ["contacts"],
+          summary: "List contacts in an audience",
+          parameters: [audienceId],
+          responses: { "200": ok("Contact list."), "404": ok("Audience not found.") }
+        }
+      },
+      "/audiences/{audience_id}/contacts/{id}": {
+        delete: {
+          operationId: "contacts.remove",
+          tags: ["contacts"],
+          summary: "Remove a contact from an audience",
+          parameters: [audienceId, id],
+          responses: { "200": ok("Deletion confirmation."), "404": ok("Not found.") }
+        }
+      }
+    }
+  };
+}
 var manifest = {
   id: "resend",
   name: "Resend",
@@ -882,6 +1118,7 @@ var manifest = {
       kind: "openapi",
       title: "Resend REST API subset",
       coverage: "hand-authored",
+      url: "/openapi.json",
       operations: [
         { operationId: "emails.send", method: "POST", path: "/emails", status: "hand-authored" },
         { operationId: "emails.sendBatch", method: "POST", path: "/emails/batch", status: "hand-authored" },
@@ -1047,17 +1284,17 @@ function seedFromConfig(store, _baseUrl, config) {
       defaultAudience = rs.audiences.insert({ uuid: generateUuid(), name: "Default" });
     }
     for (const ct of config.contacts) {
-      let audienceId = defaultAudience.uuid;
+      let audienceId2 = defaultAudience.uuid;
       if (ct.audience) {
         let audience = rs.audiences.findOneBy("name", ct.audience);
         if (!audience) {
           audience = rs.audiences.insert({ uuid: generateUuid(), name: ct.audience });
         }
-        audienceId = audience.uuid;
+        audienceId2 = audience.uuid;
       }
       rs.contacts.insert({
         uuid: generateUuid(),
-        audience_id: audienceId,
+        audience_id: audienceId2,
         email: ct.email,
         first_name: ct.first_name ?? null,
         last_name: ct.last_name ?? null,
@@ -1075,6 +1312,7 @@ var resendPlugin = {
     apiKeyRoutes(ctx);
     contactRoutes(ctx);
     inboxRoutes(ctx);
+    openapiRoutes(ctx);
   },
   seed(_store, _baseUrl) {
   }
@@ -1087,4 +1325,4 @@ export {
   resendPlugin,
   seedFromConfig
 };
-//# sourceMappingURL=dist-XM5HSBDC.js.map
+//# sourceMappingURL=dist-TWJXVA7X.js.map