@groundmail/groundhog 0.0.0-stage → 0.1.0

package/dist/providers/groundmail.js

@@ -0,0 +1,169 @@
+import { ingestApiSend, newId, toAddress, toAddressList, uuid } from '../mime.js';
+import { isResendClient, resendBatchRoute, resendGetRoute, resendSendRoute } from './resend.js';
+import { groundmailSignature } from '../signing.js';
+import { attachment, fromString, headerRecord, str, unixSeconds } from './common.js';
+const EVENT_NAMES = {
+    delivered: 'email.delivered',
+    bounced: 'email.bounced',
+    complained: 'email.complained',
+    opened: 'email.opened',
+    clicked: 'email.clicked',
+};
+function error(status, code, message, hint) {
+    return { status, body: { error: { message, code, ...(hint ? { hint } : {}) } } };
+}
+function tagsOf(input) {
+    if (!Array.isArray(input))
+        return [];
+    return input
+        .map((tag) => (typeof tag === 'string' ? tag : tag && typeof tag === 'object' ? `${tag.name}:${tag.value}` : ''))
+        .filter(Boolean);
+}
+export async function groundmailSendFromBody(body, via) {
+    const from = toAddress(body.from);
+    const to = toAddressList(body.to);
+    if (!from)
+        return via === 'resend' ? resendValidation('Missing `from` field.') : error(422, 'validation_error', '`from` is required');
+    if (!to.length)
+        return via === 'resend' ? resendValidation('Missing `to` field.') : error(422, 'validation_error', '`to` is required');
+    const html = str(body.html ?? body.htmlBody ?? body.html_body);
+    const text = str(body.text ?? body.textBody ?? body.text_body ?? body.plain_body);
+    const attachments = Array.isArray(body.attachments)
+        ? body.attachments.map((a) => attachment(a.filename ?? a.name, a.content ?? a.data, a.content_type ?? a.contentType, a.content_id ?? a.contentId ?? a.cid))
+        : undefined;
+    const metadata = {};
+    if (body.metadata && typeof body.metadata === 'object') {
+        for (const [key, value] of Object.entries(body.metadata))
+            metadata[key] = String(value);
+    }
+    const id = via === 'resend' ? uuid() : newId('msg');
+    return ingestApiSend({
+        from,
+        to,
+        cc: toAddressList(body.cc),
+        bcc: toAddressList(body.bcc),
+        replyTo: toAddressList(body.reply_to ?? body.replyTo),
+        subject: str(body.subject) ?? '',
+        html: html ?? null,
+        text: text ?? null,
+        headers: headerRecord(body.headers),
+        attachments,
+        tags: tagsOf(body.tags),
+        metadata,
+    }, { via, providerMessageId: id });
+}
+function resendValidation(message) {
+    return { status: 422, body: { statusCode: 422, name: 'validation_error', message } };
+}
+export function isResult(value) {
+    return 'status' in value && typeof value.status === 'number' && !('via' in value);
+}
+export function emailView(email) {
+    return {
+        id: email.providerMessageId,
+        from: fromString(email),
+        to: email.to.map((a) => a.address),
+        cc: email.cc.map((a) => a.address),
+        bcc: email.bcc.map((a) => a.address),
+        reply_to: email.replyTo.map((a) => a.address),
+        subject: email.subject,
+        status: 'delivered',
+        last_event: 'email.delivered',
+        bounce_reason: null,
+        bounce_type: null,
+        held_back: [],
+        test: true,
+        tags: email.tags,
+        scheduled_at: null,
+        cancelled_at: null,
+        created_at: email.createdAt,
+        sent_at: email.createdAt,
+        delivered_at: email.createdAt,
+        bounced_at: null,
+        opened_at: null,
+        clicked_at: null,
+    };
+}
+/** Groundmail's own API. Mounted at `/` and `/groundmail`. */
+export const groundmail = {
+    id: 'groundmail',
+    eventNames: EVENT_NAMES,
+    register(router, hub) {
+        for (const base of ['', '/groundmail']) {
+            router.post(`${base}/emails`, async (ctx) => {
+                // RESEND_BASE_URL=http://localhost:3025 (no /resend) lands here too.
+                if (!base && isResendClient(ctx))
+                    return resendSendRoute(ctx, hub);
+                if (await hub.guard(ctx, groundmail))
+                    return;
+                const result = await groundmailSendFromBody(await ctx.json(), 'groundmail');
+                if (isResult(result))
+                    return result;
+                hub.ingest(result);
+                return { status: 200, body: { id: result.providerMessageId, status: 'sent' } };
+            });
+            router.post(`${base}/emails/batch`, async (ctx) => {
+                if (!base && isResendClient(ctx))
+                    return resendBatchRoute(ctx, hub);
+                if (await hub.guard(ctx, groundmail))
+                    return;
+                const body = await ctx.json();
+                const emails = Array.isArray(body) ? body : (body.emails ?? []);
+                const data = [];
+                for (const [index, item] of emails.entries()) {
+                    const result = await groundmailSendFromBody(item, 'groundmail');
+                    if (isResult(result)) {
+                        data.push({ index, error: result.body.error });
+                        continue;
+                    }
+                    hub.ingest(result);
+                    data.push({ index, id: result.providerMessageId, status: 'sent' });
+                }
+                return { status: 200, body: { data } };
+            });
+            router.get(`${base}/emails/:id`, (ctx) => {
+                if (!base && isResendClient(ctx))
+                    return resendGetRoute(ctx, hub);
+                const email = hub.get(ctx.params.id);
+                if (!email)
+                    return error(404, 'not_found', 'Email not found');
+                return { status: 200, body: { email: emailView(email) } };
+            });
+        }
+    },
+    fail(kind) {
+        switch (kind) {
+            case 'rate_limit':
+                return { ...error(429, 'rate_limited', 'Too many requests. Slow down and retry after the Retry-After header.'), headers: { 'Retry-After': '1' } };
+            case 'invalid_recipient':
+                return error(422, 'invalid_recipient', 'The recipient address is not valid.', 'Check the `to` address.');
+            case 'unauthorized':
+                return error(401, 'invalid_api_key', 'Invalid API key.', 'Check GROUNDMAIL_API_KEY.');
+            case 'outage':
+                return error(503, 'service_unavailable', 'Groundmail is temporarily unavailable. Retry with backoff.');
+        }
+    },
+    webhook(event, email, ctx) {
+        const timestamp = unixSeconds();
+        const payload = {
+            type: EVENT_NAMES[event],
+            created_at: new Date().toISOString(),
+            data: {
+                email_id: email.providerMessageId,
+                to: email.to.map((a) => a.address),
+                from: fromString(email),
+                subject: email.subject,
+                status: event === 'bounced' ? 'bounced' : event === 'complained' ? 'complained' : 'delivered',
+                ...(event === 'bounced' ? { bounce_reason: '550 5.1.1 The email account that you tried to reach does not exist.', bounce_type: 'hard' } : {}),
+                ...(event === 'clicked' ? { link: ctx.link } : {}),
+                test: true,
+            },
+        };
+        const body = JSON.stringify(payload);
+        return {
+            eventId: newId('evt'),
+            body,
+            headers: { 'Content-Type': 'application/json', 'Groundmail-Signature': groundmailSignature(ctx.secrets.groundmail, body, timestamp) },
+        };
+    },
+};

package/dist/providers/index.d.ts

@@ -0,0 +1,12 @@
+import { groundmail } from './groundmail.js';
+import { mailgun } from './mailgun.js';
+import { postmark } from './postmark.js';
+import { resend } from './resend.js';
+import { sendgrid } from './sendgrid.js';
+import { ses } from './ses.js';
+import type { ProviderModule } from './types.js';
+export type WebhookFormat = 'groundmail' | 'sendgrid' | 'postmark' | 'mailgun' | 'resend' | 'ses';
+export declare const WEBHOOK_FORMATS: WebhookFormat[];
+export declare const HTTP_PROVIDERS: ProviderModule[];
+export declare const PROVIDER_MODULES: Record<WebhookFormat, ProviderModule>;
+export { groundmail, mailgun, postmark, resend, sendgrid, ses };

package/dist/providers/index.js

@@ -0,0 +1,10 @@
+import { groundmail } from './groundmail.js';
+import { mailgun } from './mailgun.js';
+import { postmark } from './postmark.js';
+import { resend } from './resend.js';
+import { sendgrid } from './sendgrid.js';
+import { ses } from './ses.js';
+export const WEBHOOK_FORMATS = ['groundmail', 'sendgrid', 'postmark', 'mailgun', 'resend', 'ses'];
+export const HTTP_PROVIDERS = [groundmail, resend, sendgrid, postmark, mailgun, ses];
+export const PROVIDER_MODULES = { groundmail, sendgrid, postmark, mailgun, resend, ses };
+export { groundmail, mailgun, postmark, resend, sendgrid, ses };

package/dist/providers/mailgun.d.ts

@@ -0,0 +1,3 @@
+import type { ProviderModule } from './types.js';
+/** Mailgun's Messages API, at `/mailgun/v3/<domain>/messages`. */
+export declare const mailgun: ProviderModule;

package/dist/providers/mailgun.js

@@ -0,0 +1,150 @@
+import { randomBytes } from 'node:crypto';
+import { ingestApiSend, parseEmail, toAddress, toAddressList } from '../mime.js';
+import { mailgunSignature } from '../signing.js';
+import { allRecipients, fromString, recipient } from './common.js';
+const EVENT_NAMES = {
+    delivered: 'delivered',
+    bounced: 'failed',
+    complained: 'complained',
+    opened: 'opened',
+    clicked: 'clicked',
+};
+function error(status, message) {
+    return { status, body: { message } };
+}
+function mailgunId(domain) {
+    const stamp = new Date().toISOString().replace(/\D/g, '').slice(0, 14);
+    return `${stamp}.${randomBytes(8).toString('hex')}@${domain}`;
+}
+function all(fields, name) {
+    return fields.filter(([key]) => key === name || key === `${name}[]`).map(([, value]) => value);
+}
+function one(fields, name) {
+    return all(fields, name)[0];
+}
+async function send(ctx, hub) {
+    if (await hub.guard(ctx, mailgun))
+        return;
+    const domain = ctx.params.domain;
+    const { fields, files } = await ctx.multipart();
+    const from = toAddress(one(fields, 'from'));
+    const to = toAddressList(all(fields, 'to'));
+    if (!from)
+        return error(400, "from parameter is missing");
+    if (!to.length)
+        return error(400, "to parameter is missing");
+    const headers = {};
+    const metadata = {};
+    for (const [key, value] of fields) {
+        if (key.startsWith('h:'))
+            headers[key.slice(2)] = value;
+        if (key.startsWith('v:'))
+            metadata[key.slice(2)] = value;
+    }
+    const variables = one(fields, 'h:X-Mailgun-Variables');
+    if (variables) {
+        try {
+            for (const [key, value] of Object.entries(JSON.parse(variables)))
+                metadata[key] = String(value);
+        }
+        catch {
+            // Not JSON: keep it as a header only.
+        }
+    }
+    let html = one(fields, 'html');
+    let text = one(fields, 'text');
+    const template = one(fields, 'template');
+    if (!html && !text && template) {
+        text = `Sent with Mailgun template ${template}. Groundhog can't render stored templates; the variables it was sent with:\n\n${one(fields, 't:variables') ?? '{}'}`;
+    }
+    const id = mailgunId(domain);
+    const email = await ingestApiSend({
+        from,
+        to,
+        cc: toAddressList(all(fields, 'cc')),
+        bcc: toAddressList(all(fields, 'bcc')),
+        replyTo: toAddressList(one(fields, 'h:Reply-To')),
+        subject: one(fields, 'subject') ?? '',
+        html: html ?? null,
+        text: text ?? null,
+        headers,
+        attachments: files
+            .filter((file) => file.field === 'attachment' || file.field === 'inline')
+            .map((file) => ({ filename: file.filename, content: file.content, contentType: file.contentType, cid: file.field === 'inline' ? file.filename : undefined })),
+    }, { via: 'mailgun', providerMessageId: id, tags: all(fields, 'o:tag'), metadata });
+    hub.ingest(email);
+    return { status: 200, body: { id: `<${id}>`, message: 'Queued. Thank you.' } };
+}
+async function sendMime(ctx, hub) {
+    if (await hub.guard(ctx, mailgun))
+        return;
+    const { fields, files } = await ctx.multipart();
+    const message = files.find((file) => file.field === 'message')?.content ?? (one(fields, 'message') ? Buffer.from(one(fields, 'message')) : null);
+    if (!message)
+        return error(400, "'message' parameter is missing");
+    const id = mailgunId(ctx.params.domain);
+    const email = await parseEmail(message, { via: 'mailgun', providerMessageId: id, envelopeTo: toAddressList(all(fields, 'to')), tags: all(fields, 'o:tag') });
+    hub.ingest(email);
+    return { status: 200, body: { id: `<${id}>`, message: 'Queued. Thank you.' } };
+}
+/** Mailgun's Messages API, at `/mailgun/v3/<domain>/messages`. */
+export const mailgun = {
+    id: 'mailgun',
+    eventNames: EVENT_NAMES,
+    register(router, hub) {
+        router.post('/mailgun/v3/:domain/messages', (ctx) => send(ctx, hub));
+        router.post('/mailgun/v3/:domain/messages.mime', (ctx) => sendMime(ctx, hub));
+    },
+    fail(kind) {
+        switch (kind) {
+            case 'rate_limit':
+                return error(429, 'Too many requests');
+            case 'invalid_recipient':
+                return error(400, "to parameter is not a valid address. please check documentation");
+            case 'unauthorized':
+                return { status: 401, headers: { 'Content-Type': 'text/plain' }, body: 'Forbidden' };
+            case 'outage':
+                return error(503, 'Service Unavailable');
+        }
+    },
+    webhook(event, email, ctx) {
+        const timestamp = (Date.now() / 1000).toFixed(6);
+        const token = randomBytes(25).toString('hex');
+        const sigTimestamp = String(Math.floor(Number(timestamp)));
+        const to = recipient(email);
+        const eventId = randomBytes(11).toString('base64url');
+        const data = {
+            id: eventId,
+            timestamp: Number(timestamp),
+            'log-level': event === 'bounced' ? 'error' : event === 'complained' ? 'warn' : 'info',
+            event: EVENT_NAMES[event],
+            recipient: to,
+            'recipient-domain': to.split('@')[1] ?? '',
+            tags: email.tags,
+            'user-variables': email.metadata,
+            envelope: { sender: email.from?.address ?? '', transport: 'smtp', targets: allRecipients(email).join(',') },
+            message: {
+                headers: { to: email.to.map((a) => a.address).join(', '), 'message-id': email.providerMessageId, from: fromString(email), subject: email.subject },
+                attachments: [],
+                size: email.size,
+            },
+            flags: { 'is-routed': false, 'is-authenticated': true, 'is-system-test': false, 'is-test-mode': false },
+        };
+        if (event === 'delivered')
+            data['delivery-status'] = { code: 250, message: 'OK', description: '', 'attempt-no': 1, tls: true, 'mx-host': 'localhost' };
+        if (event === 'bounced') {
+            Object.assign(data, { severity: 'permanent', reason: 'bounce' });
+            data['delivery-status'] = { code: 550, message: '5.1.1 The email account that you tried to reach does not exist.', description: '', 'attempt-no': 1, 'bounce-type': 'hard' };
+        }
+        if (event === 'opened' || event === 'clicked') {
+            Object.assign(data, { ip: '127.0.0.1', 'client-info': { 'client-type': 'browser', 'client-os': 'Local', 'device-type': 'desktop', 'client-name': 'Groundhog', 'user-agent': 'Groundhog' }, geolocation: { country: 'Unknown', region: 'Unknown', city: 'Unknown' } });
+        }
+        if (event === 'clicked')
+            data.url = ctx.link;
+        const body = JSON.stringify({
+            signature: { timestamp: sigTimestamp, token, signature: mailgunSignature(ctx.secrets.mailgun, sigTimestamp, token) },
+            'event-data': data,
+        });
+        return { eventId, body, headers: { 'Content-Type': 'application/json' } };
+    },
+};

package/dist/providers/postmark.d.ts

@@ -0,0 +1,3 @@
+import type { ProviderModule } from './types.js';
+/** Postmark's Email API, at `/postmark`. */
+export declare const postmark: ProviderModule;

package/dist/providers/postmark.js

@@ -0,0 +1,147 @@
+import { ingestApiSend, toAddress, toAddressList, uuid } from '../mime.js';
+import { attachment, headerRecord, recipient, str } from './common.js';
+const EVENT_NAMES = {
+    delivered: 'Delivery',
+    bounced: 'Bounce',
+    complained: 'SpamComplaint',
+    opened: 'Open',
+    clicked: 'Click',
+};
+function error(status, code, message) {
+    return { status, body: { ErrorCode: code, Message: message } };
+}
+async function toEmail(body, template = false) {
+    const from = toAddress(str(body.From));
+    const to = toAddressList(body.To);
+    if (!from)
+        return error(422, 300, "Invalid 'From' address: ''.");
+    if (!to.length)
+        return error(422, 300, 'Zero recipients specified');
+    let html = str(body.HtmlBody);
+    let text = str(body.TextBody);
+    let subject = str(body.Subject) ?? '';
+    if (template) {
+        const ref = str(body.TemplateAlias) ?? str(body.TemplateId) ?? 'unknown';
+        const model = body.TemplateModel ?? {};
+        subject = subject || `Postmark template ${ref}`;
+        html = undefined;
+        text = `Sent with Postmark template ${ref}. Groundhog can't render stored templates; the model it was sent with:\n\n${JSON.stringify(model, null, 2)}`;
+    }
+    const metadata = {};
+    if (body.Metadata && typeof body.Metadata === 'object') {
+        for (const [key, value] of Object.entries(body.Metadata))
+            metadata[key] = String(value);
+    }
+    if (body.MessageStream)
+        metadata.MessageStream = String(body.MessageStream);
+    return ingestApiSend({
+        from,
+        to,
+        cc: toAddressList(body.Cc),
+        bcc: toAddressList(body.Bcc),
+        replyTo: toAddressList(body.ReplyTo),
+        subject,
+        html: html ?? null,
+        text: text ?? null,
+        headers: headerRecord(body.Headers),
+        attachments: Array.isArray(body.Attachments)
+            ? body.Attachments.map((a) => attachment(a.Name, a.Content, a.ContentType, a.ContentID))
+            : undefined,
+    }, { via: 'postmark', providerMessageId: uuid(), tags: body.Tag ? [String(body.Tag)] : [], metadata });
+}
+function isError(value) {
+    return !('via' in value);
+}
+function sent(email) {
+    return {
+        To: email.to.map((a) => a.address).join(', '),
+        SubmittedAt: email.createdAt,
+        MessageID: email.providerMessageId,
+        ErrorCode: 0,
+        Message: 'OK',
+    };
+}
+async function single(ctx, hub, template) {
+    if (await hub.guard(ctx, postmark))
+        return;
+    const result = await toEmail(await ctx.json(), template);
+    if (isError(result))
+        return result;
+    hub.ingest(result);
+    return { status: 200, body: sent(result) };
+}
+async function batch(ctx, hub, template) {
+    if (await hub.guard(ctx, postmark))
+        return;
+    const body = await ctx.json();
+    const items = (template ? body.Messages : body);
+    const out = [];
+    for (const item of items ?? []) {
+        const result = await toEmail(item, template);
+        if (isError(result)) {
+            out.push({ ...result.body, To: str(item.To) ?? '' });
+            continue;
+        }
+        hub.ingest(result);
+        out.push(sent(result));
+    }
+    return { status: 200, body: out };
+}
+/** Postmark's Email API, at `/postmark`. */
+export const postmark = {
+    id: 'postmark',
+    eventNames: EVENT_NAMES,
+    register(router, hub) {
+        router.post('/postmark/email', (ctx) => single(ctx, hub, false));
+        router.post('/postmark/email/withTemplate', (ctx) => single(ctx, hub, true));
+        router.post('/postmark/email/batch', (ctx) => batch(ctx, hub, false));
+        router.post('/postmark/email/batchWithTemplates', (ctx) => batch(ctx, hub, true));
+    },
+    fail(kind) {
+        switch (kind) {
+            case 'rate_limit':
+                return error(429, 429, 'Rate limit exceeded. Please slow down your requests.');
+            case 'invalid_recipient':
+                return error(422, 300, "Invalid 'To' address: 'not-an-address'.");
+            case 'unauthorized':
+                return error(401, 10, 'Request does not contain a valid Server token.');
+            case 'outage':
+                return error(503, 0, 'Service Unavailable');
+        }
+    },
+    webhook(event, email, ctx) {
+        const now = new Date().toISOString();
+        const stream = email.metadata.MessageStream ?? 'outbound';
+        const metadata = Object.fromEntries(Object.entries(email.metadata).filter(([key]) => key !== 'MessageStream'));
+        const common = { MessageID: email.providerMessageId, ServerID: 1, MessageStream: stream, Tag: email.tags[0] ?? '', Metadata: metadata };
+        const client = { Client: { Name: 'Groundhog', Company: 'Groundmail', Family: 'Groundhog' }, OS: { Name: 'Local', Company: '', Family: 'Local' }, Platform: 'Desktop', UserAgent: 'Groundhog', Geo: {} };
+        const id = Math.floor(Math.random() * 9_000_000_000) + 1_000_000_000;
+        let payload;
+        switch (event) {
+            case 'delivered':
+                payload = { RecordType: 'Delivery', ...common, Recipient: recipient(email), DeliveredAt: now, Details: 'Simulated by Groundhog' };
+                break;
+            case 'bounced':
+                payload = {
+                    RecordType: 'Bounce', ID: id, Type: 'HardBounce', TypeCode: 1, Name: 'Hard bounce', ...common,
+                    Description: 'The server was unable to deliver your message (ex: unknown user, mailbox not found).',
+                    Details: '550 5.1.1 The email account that you tried to reach does not exist.',
+                    Email: recipient(email), From: email.from?.address ?? '', BouncedAt: now, DumpAvailable: false, Inactive: true, CanActivate: true, Subject: email.subject, Content: '',
+                };
+                break;
+            case 'complained':
+                payload = {
+                    RecordType: 'SpamComplaint', ID: id, Type: 'SpamComplaint', TypeCode: 512, Name: 'Spam complaint', ...common,
+                    Description: '', Details: '', Email: recipient(email), From: email.from?.address ?? '', BouncedAt: now, DumpAvailable: false, Inactive: true, CanActivate: false, Subject: email.subject, Content: '',
+                };
+                break;
+            case 'opened':
+                payload = { RecordType: 'Open', ...common, FirstOpen: true, ...client, ReadSeconds: 5, ReceivedAt: now, Recipient: recipient(email) };
+                break;
+            case 'clicked':
+                payload = { RecordType: 'Click', ...common, ClickLocation: 'HTML', ...client, OriginalLink: ctx.link, ReceivedAt: now, Recipient: recipient(email) };
+                break;
+        }
+        return { eventId: `${EVENT_NAMES[event]} ${id}`, body: JSON.stringify(payload), headers: { 'Content-Type': 'application/json' } };
+    },
+};

package/dist/providers/resend.d.ts

@@ -0,0 +1,8 @@
+import type { HttpResult, RequestContext } from '../http.js';
+import type { Hub, ProviderModule } from './types.js';
+export declare function isResendClient(ctx: RequestContext): boolean;
+export declare function resendSendRoute(ctx: RequestContext, hub: Hub): Promise<HttpResult | void>;
+export declare function resendBatchRoute(ctx: RequestContext, hub: Hub): Promise<HttpResult | void>;
+export declare function resendGetRoute(ctx: RequestContext, hub: Hub): HttpResult;
+/** The Resend API, at `/resend` (and at `/` when the request comes from the Resend SDK). */
+export declare const resend: ProviderModule;

package/dist/providers/resend.js

@@ -0,0 +1,121 @@
+import { newId } from '../mime.js';
+import { svixSignature } from '../signing.js';
+import { fromString, unixSeconds } from './common.js';
+import { groundmailSendFromBody, isResult } from './groundmail.js';
+const EVENT_NAMES = {
+    delivered: 'email.delivered',
+    bounced: 'email.bounced',
+    complained: 'email.complained',
+    opened: 'email.opened',
+    clicked: 'email.clicked',
+};
+function error(status, name, message) {
+    return { status, body: { statusCode: status, name, message } };
+}
+export function isResendClient(ctx) {
+    return ctx.header('user-agent').toLowerCase().startsWith('resend');
+}
+export async function resendSendRoute(ctx, hub) {
+    if (await hub.guard(ctx, resend))
+        return;
+    const result = await groundmailSendFromBody(await ctx.json(), 'resend');
+    if (isResult(result))
+        return result;
+    hub.ingest(result);
+    return { status: 200, body: { id: result.providerMessageId } };
+}
+export async function resendBatchRoute(ctx, hub) {
+    if (await hub.guard(ctx, resend))
+        return;
+    const body = await ctx.json();
+    const items = Array.isArray(body) ? body : [];
+    if (!items.length)
+        return error(422, 'validation_error', 'The batch must contain at least one email.');
+    const caught = [];
+    for (const item of items) {
+        const result = await groundmailSendFromBody(item, 'resend');
+        if (isResult(result))
+            return result;
+        caught.push(result);
+    }
+    for (const email of caught)
+        hub.ingest(email);
+    return { status: 200, body: { data: caught.map((email) => ({ id: email.providerMessageId })) } };
+}
+export function resendGetRoute(ctx, hub) {
+    const email = hub.get(ctx.params.id);
+    if (!email)
+        return error(404, 'not_found', 'Email not found');
+    return {
+        status: 200,
+        body: {
+            object: 'email',
+            id: email.providerMessageId,
+            to: email.to.map((a) => a.address),
+            from: fromString(email),
+            created_at: email.createdAt,
+            subject: email.subject,
+            html: email.html,
+            text: email.text,
+            bcc: email.bcc.map((a) => a.address),
+            cc: email.cc.map((a) => a.address),
+            reply_to: email.replyTo.map((a) => a.address),
+            last_event: 'delivered',
+            scheduled_at: null,
+        },
+    };
+}
+/** The Resend API, at `/resend` (and at `/` when the request comes from the Resend SDK). */
+export const resend = {
+    id: 'resend',
+    eventNames: EVENT_NAMES,
+    register(router, hub) {
+        router.post('/resend/emails', (ctx) => resendSendRoute(ctx, hub));
+        router.post('/resend/emails/batch', (ctx) => resendBatchRoute(ctx, hub));
+        router.get('/resend/emails/:id', (ctx) => resendGetRoute(ctx, hub));
+    },
+    fail(kind) {
+        switch (kind) {
+            case 'rate_limit':
+                return { ...error(429, 'rate_limit_exceeded', 'Too many requests. You can only make 2 requests per second.'), headers: { 'retry-after': '1' } };
+            case 'invalid_recipient':
+                return error(422, 'validation_error', 'Invalid `to` field. The email address needs to follow the `email@example.com` or `Name <email@example.com>` format.');
+            case 'unauthorized':
+                return error(403, 'invalid_api_key', 'API key is invalid');
+            case 'outage':
+                return error(500, 'application_error', 'An unexpected error occurred, please try again later.');
+        }
+    },
+    webhook(event, email, ctx) {
+        const now = new Date();
+        const data = {
+            created_at: email.createdAt,
+            email_id: email.providerMessageId,
+            from: fromString(email),
+            to: email.to.map((a) => a.address),
+            subject: email.subject,
+        };
+        if (event === 'bounced') {
+            data.bounce = { message: 'The recipient’s email address does not exist.', subType: 'General', type: 'Permanent' };
+        }
+        if (event === 'clicked') {
+            data.click = { ipAddress: '127.0.0.1', link: ctx.link, timestamp: now.toISOString(), userAgent: 'Groundhog' };
+        }
+        if (event === 'opened') {
+            data.open = { ipAddress: '127.0.0.1', timestamp: now.toISOString(), userAgent: 'Groundhog' };
+        }
+        const body = JSON.stringify({ type: EVENT_NAMES[event], created_at: now.toISOString(), data });
+        const id = newId('msg');
+        const timestamp = unixSeconds(now);
+        return {
+            eventId: id,
+            body,
+            headers: {
+                'Content-Type': 'application/json',
+                'svix-id': id,
+                'svix-timestamp': String(timestamp),
+                'svix-signature': svixSignature(ctx.secrets.resend, id, timestamp, body),
+            },
+        };
+    },
+};

package/dist/providers/sendgrid.d.ts

@@ -0,0 +1,3 @@
+import type { ProviderModule } from './types.js';
+/** SendGrid's v3 Mail Send, at `/sendgrid/v3/mail/send`. */
+export declare const sendgrid: ProviderModule;