@growth-labs/mailer 0.4.7 → 0.4.9

package/src/index.ts

@@ -105,6 +105,12 @@ export type {
 	TemplateData,
 	TemplateName,
 } from './types.js'
+export type {
+	BroadcastRecipient,
+	SendBroadcastParams,
+	SendBroadcastResult,
+} from './utils/broadcast.js'
+export { sendBroadcast } from './utils/broadcast.js'
 export type { CampaignSchedule, DigestSchedule } from './utils/scheduling.js'
 export {
 	executeCampaignSchedule,

package/src/options.ts

@@ -12,6 +12,11 @@ export const mailerOptionsSchema = z.object({
 
 	// ─── Cloudflare bindings ───
 	d1Binding: z.string().default('SITE_DB'),
+	// D1 binding holding gl_email_sends (the send-record table). Defaults to
+	// d1Binding. Set to the realm mailer DB (e.g. 'MAILER_DB') on sites whose
+	// queue is drained by the central mail-platform Worker, so the consumer's
+	// send-status writeback and the producer's row writes share one DB.
+	sendsD1Binding: z.string().optional(),
 	queueBinding: z.string().default('EMAIL_QUEUE'),
 	senderBinding: z.string().default('EMAIL_SENDER'),
 

package/src/routes/track-click.ts

@@ -33,8 +33,9 @@ export const GET: APIRoute = async (context) => {
 	try {
 		const bindingsEnv = cloudflareEnv as Record<string, unknown>
 		if (bindingsEnv) {
-			const d1 = bindingsEnv[config.d1Binding] as D1Database
-			const schema = await probeMailerSchema(d1, config.d1Binding)
+			const sendsBindingName = config.sendsD1Binding ?? config.d1Binding
+			const d1 = bindingsEnv[sendsBindingName] as D1Database
+			const schema = await probeMailerSchema(d1, sendsBindingName)
 			if (schema.ok) {
 				const db = drizzle(d1)
 				await db

package/src/routes/track-open.ts

@@ -22,8 +22,9 @@ export const GET: APIRoute = async (context) => {
 	try {
 		const bindingsEnv = cloudflareEnv as Record<string, unknown>
 		if (bindingsEnv) {
-			const d1 = bindingsEnv[config.d1Binding] as D1Database
-			const schema = await probeMailerSchema(d1, config.d1Binding)
+			const sendsBindingName = config.sendsD1Binding ?? config.d1Binding
+			const d1 = bindingsEnv[sendsBindingName] as D1Database
+			const schema = await probeMailerSchema(d1, sendsBindingName)
 			if (schema.ok) {
 				const db = drizzle(d1)
 				await db

package/src/routes/unsubscribe.ts

@@ -4,7 +4,6 @@ import type { APIRoute } from 'astro'
 import { drizzle } from 'drizzle-orm/d1'
 import { probeMailerSchema, schemaMissingResponse } from '../_internal/schema-probe.js'
 import { emitMailerAnalyticsEvent } from '../utils/analytics.js'
-import type { MailerEnv } from '../utils/send.js'
 import { sendTransactional } from '../utils/send.js'
 import { getSubscriberById, unsubscribeSubscriber } from '../utils/subscribers.js'
 import { generateToken, verifyToken } from '../utils/tokens.js'
@@ -24,7 +23,6 @@ async function processUnsubscribe(
 	// Resolve bindings
 	const bindingsEnv = cloudflareEnv as Record<string, unknown>
 	const d1 = bindingsEnv[config.d1Binding] as D1Database
-	const queue = bindingsEnv[config.queueBinding] as Queue
 
 	// Schema probe — short-circuit with a Response on miss; both GET and POST
 	// handlers below forward it unchanged.
@@ -32,7 +30,6 @@ async function processUnsubscribe(
 	if (!schema.ok) return { schemaMissing: true as const }
 
 	const db = drizzle(d1)
-	const env: MailerEnv = { DB: d1, QUEUE: queue }
 
 	// Get subscriber
 	const subscriber = await getSubscriberById(db, payload.subscriberId)
@@ -43,8 +40,9 @@ async function processUnsubscribe(
 	// Unsubscribe
 	await unsubscribeSubscriber(db, payload.subscriberId)
 
-	// Send confirmation email
-	await sendTransactional(env, config, {
+	// Send confirmation email — pass the full Worker env so config.d1Binding,
+	// config.queueBinding, and config.sendsD1Binding all resolve correctly.
+	await sendTransactional(bindingsEnv, config, {
 		to: subscriber.email,
 		subscriberId: subscriber.id,
 		subject: `You've been unsubscribed from ${config.senderName}`,

package/src/routes/webhook.ts

@@ -40,6 +40,14 @@ export const POST: APIRoute = async (context) => {
 	}
 	const db = drizzle(d1)
 
+	// Resolve the sends DB (may differ from the subscribers DB when sendsD1Binding is set).
+	const sendsBindingName = config.sendsD1Binding ?? config.d1Binding
+	const sendsD1 = bindingsEnv[sendsBindingName] as D1Database | undefined
+	if (!sendsD1) {
+		return Response.json({ error: 'Sends D1 binding not available' }, { status: 500 })
+	}
+	const sendsDb = drizzle(sendsD1)
+
 	emitMailerAnalyticsEvent(config, bindingsEnv, 'newsletter_webhook_received', {
 		request,
 		context,
@@ -55,7 +63,7 @@ export const POST: APIRoute = async (context) => {
 	switch (body.type) {
 		case 'delivery':
 			if (body.trackingId) {
-				await handleDelivery(db, body.trackingId)
+				await handleDelivery(sendsDb, body.trackingId)
 			}
 			break
 		case 'bounce':

package/src/schema/sends.ts

@@ -5,6 +5,7 @@ export const emailSends = sqliteTable(
 	{
 		id: text('id').primaryKey(),
 		subscriberId: text('subscriber_id').notNull(),
+		siteId: text('site_id'),
 		campaignId: text('campaign_id'),
 		email: text('email').notNull(),
 		subject: text('subject').notNull(),
@@ -26,5 +27,6 @@ export const emailSends = sqliteTable(
 		index('idx_sends_tracking').on(table.trackingId),
 		index('idx_sends_status').on(table.status),
 		index('idx_sends_type_created').on(table.type, table.createdAt),
+		index('idx_sends_site_campaign').on(table.siteId, table.campaignId),
 	],
 )

package/src/types.ts

@@ -39,7 +39,7 @@ export interface SubscriberFilter {
 
 export interface EmailQueueMessage {
 	siteId: string
-	type: 'transactional' | 'campaign' | 'digest'
+	type: 'transactional' | 'campaign' | 'digest' | 'broadcast'
 	recipients: QueueRecipient[]
 	subject: string
 	htmlTemplate: string
@@ -98,7 +98,7 @@ export interface EmailSend {
 	campaignId?: string
 	email: string
 	subject: string
-	type: 'transactional' | 'campaign' | 'digest'
+	type: 'transactional' | 'campaign' | 'digest' | 'broadcast'
 	status: EmailSendStatus
 	sentAt?: string
 	deliveredAt?: string

package/src/utils/broadcast.ts

@@ -0,0 +1,404 @@
+import { and, eq, inArray } from 'drizzle-orm'
+import { drizzle } from 'drizzle-orm/d1'
+import { ulid } from 'ulidx'
+import type { ResolvedMailerOptions } from '../options.js'
+import { emailSends } from '../schema/sends.js'
+import { subscribers } from '../schema/subscribers.js'
+import type { EmailQueueMessage, QueueRecipient, SubscriberStatus } from '../types.js'
+import { sleep } from './providers.js'
+import type { MailerEnv } from './send.js'
+import { generateToken } from './tokens.js'
+import { injectTrackingPixel, rewriteLinksForTracking } from './tracking.js'
+
+type DrizzleDB = ReturnType<typeof drizzle>
+
+/**
+ * Statuses that mean "do not send" — the suppression list. A broadcast skips
+ * every recipient whose `gl_subscribers` row carries one of these. `active` is
+ * the ONLY sendable status; everything else (including `pending`, i.e. an
+ * unconfirmed double-opt-in subscriber) is suppressed so a one-off blast can
+ * never re-permission or re-mail a suppressed address.
+ */
+const SUPPRESSED_STATUSES: ReadonlySet<SubscriberStatus> = new Set<SubscriberStatus>([
+	'unsubscribed',
+	'bounced',
+	'complained',
+	'pending',
+])
+
+// ─── Inputs ───
+
+/**
+ * One recipient of a broadcast. `subscriberId` is optional: when omitted the
+ * subscriber is resolved by `email` against `gl_subscribers` (needed both for
+ * suppression enforcement and for per-recipient unsubscribe/preferences links).
+ * An email with no matching subscriber row is treated as suppressed (we never
+ * blast an address we cannot honour an unsubscribe for).
+ */
+export interface BroadcastRecipient {
+	email: string
+	subscriberId?: string
+}
+
+export interface SendBroadcastParams {
+	/**
+	 * Explicit recipient list. Mutually-resolvable with `segmentName` +
+	 * `resolveRecipients`: segmentation itself is NOT built here (WS5 bead 06 is
+	 * identity-gated) — `sendBroadcast` takes the list, or a resolver callback
+	 * that turns a saved-segment name into the list, from elsewhere.
+	 */
+	recipients?: Array<BroadcastRecipient | string>
+	/**
+	 * Name of a saved segment to blast. Resolved to a recipient list by
+	 * `resolveRecipients` (provided by the caller / a later segmentation bead).
+	 */
+	segmentName?: string
+	/**
+	 * Resolves a saved-segment name to its recipient list. Supplied by the
+	 * caller; broadcast does not implement segmentation.
+	 */
+	resolveRecipients?: (segmentName: string) => Promise<Array<BroadcastRecipient | string>>
+
+	subject: string
+	html: string
+
+	/**
+	 * Idempotency key. A re-run with the same `campaignId` will NOT re-send to
+	 * any recipient that already has a `gl_email_sends` row for this campaign.
+	 * Auto-generated when omitted (a fresh, non-idempotent blast).
+	 */
+	campaignId?: string
+
+	/** When true, resolve + suppress + dedupe and return counts WITHOUT sending. */
+	dryRun?: boolean
+
+	/**
+	 * Max recipients packed into a single queue message. Bounds the message
+	 * payload well under Cloudflare's 128 KiB queue-message limit. Default 100.
+	 */
+	maxRecipientsPerMessage?: number
+
+	/**
+	 * Max queue messages to enqueue per second, to stay under Cloudflare send /
+	 * queue producer rate limits. `0` (default) disables pacing.
+	 */
+	messagesPerSecond?: number
+}
+
+export interface SendBroadcastResult {
+	campaignId: string
+	/** Recipients actually queued (dry-run: would-be-queued). */
+	recipientCount: number
+	/** Recipients skipped because their subscriber row is on the suppression list. */
+	suppressedCount: number
+	/** Recipients skipped because a `gl_email_sends` row already existed (idempotency). */
+	alreadySentCount: number
+	/** Number of queue messages enqueued (0 on dry-run). */
+	batchCount: number
+	dryRun: boolean
+}
+
+interface ResolvedProducerBindings {
+	/** Subscribers DB (gl_subscribers lives here). */
+	db: DrizzleDB
+	/** Sends DB (gl_email_sends lives here). Equals db when sendsD1Binding is unset. */
+	sendsDb: DrizzleDB
+	queue: Queue
+}
+
+function resolveProducerBindings(
+	env: MailerEnv,
+	options: ResolvedMailerOptions,
+): ResolvedProducerBindings {
+	const d1 = env[options.d1Binding] as D1Database | undefined
+	if (!d1) {
+		throw new Error(
+			`[mailer] env.${options.d1Binding} is undefined; ` +
+				'pass d1Binding option to the mailer integration or bind that name in wrangler.toml.',
+		)
+	}
+	const sendsBindingName = options.sendsD1Binding ?? options.d1Binding
+	const sendsD1 = env[sendsBindingName] as D1Database | undefined
+	if (!sendsD1) {
+		throw new Error(
+			`[mailer] env.${sendsBindingName} is undefined; ` +
+				'pass sendsD1Binding option to the mailer integration or bind that name in wrangler.toml.',
+		)
+	}
+	const queue = env[options.queueBinding] as Queue | undefined
+	if (!queue) {
+		throw new Error(
+			`[mailer] env.${options.queueBinding} is undefined; ` +
+				'pass queueBinding option to the mailer integration or bind that name in wrangler.toml.',
+		)
+	}
+	return { db: drizzle(d1), sendsDb: drizzle(sendsD1), queue }
+}
+
+function normalizeRecipient(r: BroadcastRecipient | string): BroadcastRecipient {
+	return typeof r === 'string' ? { email: r } : r
+}
+
+/** A recipient resolved against `gl_subscribers`: sendable, with its id + status. */
+interface ResolvedRecipient {
+	email: string
+	subscriberId: string
+	status: SubscriberStatus
+}
+
+/**
+ * Resolve each requested recipient against `gl_subscribers`:
+ *   - dedupe by email (a list may repeat an address)
+ *   - attach the canonical subscriberId + status
+ *   - drop emails with no subscriber row (cannot honour unsubscribe → suppress)
+ * Returns the resolved sendable-candidate set plus the suppressed count.
+ */
+async function resolveAgainstSubscribers(
+	db: DrizzleDB,
+	requested: BroadcastRecipient[],
+): Promise<{ candidates: ResolvedRecipient[]; suppressedCount: number }> {
+	// Dedupe requested emails (case-insensitive, trimmed) preserving first-seen order.
+	const byEmail = new Map<string, BroadcastRecipient>()
+	for (const r of requested) {
+		const key = r.email.trim().toLowerCase()
+		if (key.length === 0) continue
+		if (!byEmail.has(key)) byEmail.set(key, { ...r, email: r.email.trim() })
+	}
+
+	const emails = [...byEmail.values()].map((r) => r.email)
+	if (emails.length === 0) return { candidates: [], suppressedCount: 0 }
+
+	// Look up subscriber rows for all requested emails.
+	const rows = await db
+		.select({
+			id: subscribers.id,
+			email: subscribers.email,
+			status: subscribers.status,
+		})
+		.from(subscribers)
+		.where(inArray(subscribers.email, emails))
+
+	const rowByEmail = new Map<string, { id: string; status: SubscriberStatus }>()
+	for (const row of rows) {
+		rowByEmail.set((row.email as string).toLowerCase(), {
+			id: row.id as string,
+			status: row.status as SubscriberStatus,
+		})
+	}
+
+	const candidates: ResolvedRecipient[] = []
+	let suppressedCount = 0
+	for (const r of byEmail.values()) {
+		const row = rowByEmail.get(r.email.toLowerCase())
+		// No subscriber row, or a suppressed status → skip. Never send to an
+		// address we cannot honour an unsubscribe for, and never to a
+		// bounced/complained/unsubscribed/pending one.
+		if (!row || SUPPRESSED_STATUSES.has(row.status)) {
+			suppressedCount++
+			continue
+		}
+		candidates.push({ email: r.email, subscriberId: r.subscriberId ?? row.id, status: row.status })
+	}
+
+	return { candidates, suppressedCount }
+}
+
+/**
+ * Of the suppression-cleared candidates, drop any that already have a
+ * `gl_email_sends` row for this campaignId — the idempotency guard that makes a
+ * re-run a no-op for already-processed recipients.
+ */
+async function filterAlreadySent(
+	db: DrizzleDB,
+	campaignId: string,
+	candidates: ResolvedRecipient[],
+): Promise<{ fresh: ResolvedRecipient[]; alreadySentCount: number }> {
+	if (candidates.length === 0) return { fresh: [], alreadySentCount: 0 }
+
+	const candidateEmails = candidates.map((c) => c.email)
+	const existing = await db
+		.select({ email: emailSends.email })
+		.from(emailSends)
+		.where(and(eq(emailSends.campaignId, campaignId), inArray(emailSends.email, candidateEmails)))
+
+	const sentEmails = new Set(existing.map((row) => (row.email as string).toLowerCase()))
+
+	const fresh: ResolvedRecipient[] = []
+	let alreadySentCount = 0
+	for (const c of candidates) {
+		if (sentEmails.has(c.email.toLowerCase())) {
+			alreadySentCount++
+			continue
+		}
+		fresh.push(c)
+	}
+
+	return { fresh, alreadySentCount }
+}
+
+/**
+ * Build the broadcast HTML with the tracking pixel + click-rewrite applied
+ * once (the per-recipient {{TRACKING_ID}} is substituted in the consumer).
+ */
+function prepareBroadcastHtml(html: string, options: ResolvedMailerOptions): string {
+	const trackOpenUrl = `${options.siteUrl}${options.trackOpenPath}`
+	const trackClickUrl = `${options.siteUrl}${options.trackClickPath}`
+	return rewriteLinksForTracking(injectTrackingPixel(html, trackOpenUrl), trackClickUrl)
+}
+
+function chunk<T>(items: T[], size: number): T[][] {
+	const out: T[][] = []
+	for (let i = 0; i < items.length; i += size) {
+		out.push(items.slice(i, i + size))
+	}
+	return out
+}
+
+/**
+ * Send a one-off broadcast blast (Customer.io one-off-blast parity).
+ *
+ * - Takes an explicit recipient list, or a saved-segment name resolved via
+ *   `resolveRecipients` (segmentation is NOT built here — WS5 bead 06).
+ * - Enforces the suppression list: only `active` subscribers are sent;
+ *   unsubscribed / bounced / complained / pending / unknown addresses skip.
+ * - Idempotent on `campaignId`: a re-run never double-sends to a recipient that
+ *   already has a `gl_email_sends` row for the campaign.
+ * - Writes a per-recipient `gl_email_sends` row (`type='broadcast'`, status
+ *   `queued`) before enqueueing.
+ * - Fans out in batches sized for Cloudflare queue/send-rate limits, with
+ *   optional `messagesPerSecond` pacing.
+ * - `dryRun` resolves + suppresses + dedupes and returns the recipient count
+ *   WITHOUT writing rows or enqueueing anything.
+ */
+export async function sendBroadcast(
+	env: MailerEnv,
+	options: ResolvedMailerOptions,
+	params: SendBroadcastParams,
+): Promise<SendBroadcastResult> {
+	const campaignId = params.campaignId ?? ulid()
+	const dryRun = params.dryRun ?? false
+	const maxRecipientsPerMessage = Math.max(
+		1,
+		Math.min(params.maxRecipientsPerMessage ?? options.batchSize, 500),
+	)
+	const messagesPerSecond = params.messagesPerSecond ?? 0
+
+	const { db, sendsDb, queue } = resolveProducerBindings(env, options)
+
+	// 1. Resolve the recipient list — explicit list and/or a resolved segment.
+	const requestedRaw: Array<BroadcastRecipient | string> = [...(params.recipients ?? [])]
+	if (params.segmentName) {
+		if (!params.resolveRecipients) {
+			throw new Error(
+				'[mailer] sendBroadcast: segmentName given without resolveRecipients; ' +
+					'segmentation is resolved by the caller (WS5 bead 06), not by the mailer.',
+			)
+		}
+		const resolved = await params.resolveRecipients(params.segmentName)
+		requestedRaw.push(...resolved)
+	}
+	if (requestedRaw.length === 0) {
+		throw new Error('[mailer] sendBroadcast: no recipients or segmentName provided')
+	}
+	const requested = requestedRaw.map(normalizeRecipient)
+
+	// 2. Suppression enforcement + dedupe — reads gl_subscribers (subscribers db).
+	const { candidates, suppressedCount } = await resolveAgainstSubscribers(db, requested)
+
+	// 3. Idempotency — drop recipients already recorded for this campaign (sends db).
+	const { fresh, alreadySentCount } = await filterAlreadySent(sendsDb, campaignId, candidates)
+
+	// Dry-run: report the counts and stop before any write or enqueue.
+	if (dryRun) {
+		return {
+			campaignId,
+			recipientCount: fresh.length,
+			suppressedCount,
+			alreadySentCount,
+			batchCount: 0,
+			dryRun: true,
+		}
+	}
+
+	if (fresh.length === 0) {
+		return {
+			campaignId,
+			recipientCount: 0,
+			suppressedCount,
+			alreadySentCount,
+			batchCount: 0,
+			dryRun: false,
+		}
+	}
+
+	const html = prepareBroadcastHtml(params.html, options)
+	const now = new Date().toISOString()
+
+	// 4. Per-recipient row write + queue-recipient build.
+	const queueRecipients: QueueRecipient[] = []
+	for (const recipient of fresh) {
+		const trackingId = ulid()
+		const [unsubscribeToken, preferencesToken] = await Promise.all([
+			generateToken(options.signingSecret, {
+				subscriberId: recipient.subscriberId,
+				action: 'unsubscribe',
+			}),
+			generateToken(options.signingSecret, {
+				subscriberId: recipient.subscriberId,
+				action: 'preferences',
+			}),
+		])
+
+		await sendsDb.insert(emailSends).values({
+			id: ulid(),
+			subscriberId: recipient.subscriberId,
+			siteId: options.siteId,
+			campaignId,
+			email: recipient.email,
+			subject: params.subject,
+			type: 'broadcast',
+			status: 'queued',
+			trackingId,
+			createdAt: now,
+		})
+
+		queueRecipients.push({
+			email: recipient.email,
+			subscriberId: recipient.subscriberId,
+			trackingId,
+			unsubscribeToken,
+			preferencesToken,
+		})
+	}
+
+	// 5. Batched fan-out, paced to the configured send rate.
+	const batches = chunk(queueRecipients, maxRecipientsPerMessage)
+	const intervalMs = messagesPerSecond > 0 ? Math.ceil(1000 / messagesPerSecond) : 0
+
+	for (let i = 0; i < batches.length; i++) {
+		const message: EmailQueueMessage = {
+			siteId: options.siteId,
+			type: 'broadcast',
+			recipients: batches[i],
+			subject: params.subject,
+			htmlTemplate: html,
+			from: `${options.senderName} <${options.fromAddress}>`,
+			replyTo: options.replyTo,
+			campaignId,
+		}
+		await queue.send(message)
+
+		if (intervalMs > 0 && i < batches.length - 1) {
+			await sleep(intervalMs)
+		}
+	}
+
+	return {
+		campaignId,
+		recipientCount: fresh.length,
+		suppressedCount,
+		alreadySentCount,
+		batchCount: batches.length,
+		dryRun: false,
+	}
+}

package/src/utils/index.ts

@@ -9,6 +9,12 @@ export {
 	handleDelivery,
 	updateSendStatus,
 } from './bounce.js'
+export type {
+	BroadcastRecipient,
+	SendBroadcastParams,
+	SendBroadcastResult,
+} from './broadcast.js'
+export { sendBroadcast } from './broadcast.js'
 export type { CloudflareEmailSender } from './providers.js'
 export { CloudflareEmailProvider, getProvider, sleep } from './providers.js'
 export type { CampaignSchedule, DigestSchedule } from './scheduling.js'

package/src/utils/send.ts

@@ -30,7 +30,10 @@ type DrizzleDB = ReturnType<typeof drizzle>
 export type MailerEnv = Record<string, unknown>
 
 interface ResolvedProducerBindings {
+	/** Subscribers DB (gl_subscribers lives here). */
 	db: DrizzleDB
+	/** Sends DB (gl_email_sends lives here). Equals db when sendsD1Binding is unset. */
+	sendsDb: DrizzleDB
 	queue: Queue
 }
 
@@ -45,6 +48,14 @@ function resolveProducerBindings(
 				'pass d1Binding option to the mailer integration or bind that name in wrangler.toml.',
 		)
 	}
+	const sendsBindingName = options.sendsD1Binding ?? options.d1Binding
+	const sendsD1 = env[sendsBindingName] as D1Database | undefined
+	if (!sendsD1) {
+		throw new Error(
+			`[mailer] env.${sendsBindingName} is undefined; ` +
+				'pass sendsD1Binding option to the mailer integration or bind that name in wrangler.toml.',
+		)
+	}
 	const queue = env[options.queueBinding] as Queue | undefined
 	if (!queue) {
 		throw new Error(
@@ -52,7 +63,7 @@ function resolveProducerBindings(
 				'pass queueBinding option to the mailer integration or bind that name in wrangler.toml.',
 		)
 	}
-	return { db: drizzle(d1), queue }
+	return { db: drizzle(d1), sendsDb: drizzle(sendsD1), queue }
 }
 
 // ─── sendTransactional ───
@@ -69,7 +80,7 @@ export async function sendTransactional(
 		data?: Record<string, unknown>
 	},
 ): Promise<{ trackingId: string }> {
-	const { db, queue } = resolveProducerBindings(env, options)
+	const { db, sendsDb, queue } = resolveProducerBindings(env, options)
 	const trackingId = ulid()
 	const subscriberId = params.subscriberId ?? ulid()
 
@@ -91,10 +102,11 @@ export async function sendTransactional(
 		throw new Error('Either template or html must be provided')
 	}
 
-	// Record the send
-	await db.insert(emailSends).values({
+	// Record the send (in the sends DB — may differ from the subscribers DB)
+	await sendsDb.insert(emailSends).values({
 		id: ulid(),
 		subscriberId,
+		siteId: options.siteId,
 		email: params.to,
 		subject: params.subject,
 		type: 'transactional',
@@ -132,6 +144,7 @@ export async function sendTransactional(
 async function fanOutToSubscribers(
 	queue: Queue,
 	db: DrizzleDB,
+	sendsDb: DrizzleDB,
 	options: ResolvedMailerOptions,
 	params: {
 		subject: string
@@ -162,9 +175,10 @@ async function fanOutToSubscribers(
 				action: 'preferences',
 			})
 
-			await db.insert(emailSends).values({
+			await sendsDb.insert(emailSends).values({
 				id: ulid(),
 				subscriberId: sub.id,
+				siteId: options.siteId,
 				campaignId: params.campaignId,
 				email: sub.email,
 				subject: params.subject,
@@ -217,7 +231,7 @@ export async function sendCampaign(
 	},
 ): Promise<{ campaignId: string; recipientCount: number }> {
 	const campaignId = params.campaignId ?? ulid()
-	const { db, queue } = resolveProducerBindings(env, options)
+	const { db, sendsDb, queue } = resolveProducerBindings(env, options)
 
 	// Render HTML
 	let html: string
@@ -242,7 +256,7 @@ export async function sendCampaign(
 	html = injectTrackingPixel(html, trackOpenUrl)
 	html = rewriteLinksForTracking(html, trackClickUrl)
 
-	const recipientCount = await fanOutToSubscribers(queue, db, options, {
+	const recipientCount = await fanOutToSubscribers(queue, db, sendsDb, options, {
 		subject: params.subject,
 		html,
 		campaignId,
@@ -267,7 +281,7 @@ export async function sendDigest(
 	},
 ): Promise<{ campaignId: string; recipientCount: number }> {
 	const campaignId = params.campaignId ?? ulid()
-	const { db, queue } = resolveProducerBindings(env, options)
+	const { db, sendsDb, queue } = resolveProducerBindings(env, options)
 
 	// Render digest items then full template
 	const itemsHtml = renderDigestItems(params.items)
@@ -287,7 +301,7 @@ export async function sendDigest(
 	html = injectTrackingPixel(html, trackOpenUrl)
 	html = rewriteLinksForTracking(html, trackClickUrl)
 
-	const recipientCount = await fanOutToSubscribers(queue, db, options, {
+	const recipientCount = await fanOutToSubscribers(queue, db, sendsDb, options, {
 		subject: params.subject,
 		html,
 		campaignId,

package/src/virtual.d.ts

@@ -6,6 +6,7 @@ declare module 'virtual:growth-labs/mailer/config' {
 		fromAddress: string
 		replyTo?: string
 		d1Binding: string
+		sendsD1Binding?: string
 		queueBinding: string
 		senderBinding: string
 		siteConfigLookup?: SiteConfigLookup