@wopr-network/platform-core 0.1.0

package/dist/email/drizzle-billing-email-repository.js

@@ -0,0 +1,36 @@
+/**
+ * Billing Email Repository — deduplication record storage for billing emails.
+ *
+ * Implements IBillingEmailRepository using Drizzle ORM.
+ * BillingEmailService depends on this interface, not on PlatformDb directly.
+ */
+import crypto from "node:crypto";
+import { and, eq } from "drizzle-orm";
+import { emailNotifications } from "../db/schema/email-notifications.js";
+// ---------------------------------------------------------------------------
+// Drizzle Implementation
+// ---------------------------------------------------------------------------
+export class DrizzleBillingEmailRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async shouldSend(tenantId, emailType) {
+        const today = new Date().toISOString().split("T")[0];
+        const rows = await this.db
+            .select({ id: emailNotifications.id })
+            .from(emailNotifications)
+            .where(and(eq(emailNotifications.tenantId, tenantId), eq(emailNotifications.emailType, emailType), eq(emailNotifications.sentDate, today)))
+            .limit(1);
+        return rows.length === 0;
+    }
+    async recordSent(tenantId, emailType) {
+        const today = new Date().toISOString().split("T")[0];
+        await this.db.insert(emailNotifications).values({
+            id: crypto.randomUUID(),
+            tenantId,
+            emailType,
+            sentDate: today,
+        });
+    }
+}

package/dist/email/drizzle-billing-email-repository.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/email/drizzle-billing-email-repository.test.js

@@ -0,0 +1,42 @@
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import { createTestDb } from "../test/db.js";
+import { DrizzleBillingEmailRepository } from "./drizzle-billing-email-repository.js";
+describe("DrizzleBillingEmailRepository", () => {
+    let db;
+    let pool;
+    let repo;
+    beforeAll(async () => {
+        const result = await createTestDb();
+        db = result.db;
+        pool = result.pool;
+        repo = new DrizzleBillingEmailRepository(db);
+    });
+    afterAll(async () => {
+        await pool.close();
+    });
+    it("shouldSend returns true when no email sent today", async () => {
+        const result = await repo.shouldSend("tenant-email-1", "low-balance");
+        expect(result).toBe(true);
+    });
+    it("recordSent inserts a dedup record", async () => {
+        await repo.recordSent("tenant-email-1", "low-balance");
+        const result = await repo.shouldSend("tenant-email-1", "low-balance");
+        expect(result).toBe(false);
+    });
+    it("shouldSend returns true for different email type same tenant", async () => {
+        const result = await repo.shouldSend("tenant-email-1", "bot-suspended");
+        expect(result).toBe(true);
+    });
+    it("shouldSend returns true for same email type different tenant", async () => {
+        const result = await repo.shouldSend("tenant-email-2", "low-balance");
+        expect(result).toBe(true);
+    });
+    it("recordSent for different tenant does not affect dedup", async () => {
+        await repo.recordSent("tenant-email-3", "low-balance");
+        const result = await repo.shouldSend("tenant-email-3", "low-balance");
+        expect(result).toBe(false);
+        // original tenant-email-1 dedup still holds
+        const result2 = await repo.shouldSend("tenant-email-1", "low-balance");
+        expect(result2).toBe(false);
+    });
+});

package/dist/email/index.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Email — Transactional email system via Resend.
+ *
+ * Provides:
+ * - EmailClient for sending template-based emails
+ * - 8 email templates (verify, welcome, password-reset, credit-purchase, low-balance, bot-suspended, bot-destruction, data-deleted)
+ * - BillingEmailService for deduplication + billing notifications (WOP-450)
+ * - Email verification flow (token generation, validation)
+ * - requireEmailVerified middleware for gating actions
+ */
+export type { BillingEmailServiceConfig, BillingEmailType } from "./billing-emails.js";
+export { BillingEmailService } from "./billing-emails.js";
+export type { EmailClientConfig, EmailSendResult, SendTemplateEmailOpts } from "./client.js";
+export { EmailClient, getEmailClient, resetEmailClient, setEmailClient } from "./client.js";
+export type { IBillingEmailRepository } from "./drizzle-billing-email-repository.js";
+export { DrizzleBillingEmailRepository } from "./drizzle-billing-email-repository.js";
+export type { INotificationPreferencesRepository } from "./notification-preferences-store.js";
+export { DrizzleNotificationPreferencesStore } from "./notification-preferences-store.js";
+export type { INotificationQueueRepository } from "./notification-queue-store.js";
+export { DrizzleNotificationQueueStore } from "./notification-queue-store.js";
+export type { NotificationPrefs, NotificationStatus, QueuedNotification, NotificationEmailType, NotificationInput, NotificationRow, } from "./notification-repository-types.js";
+export { NotificationService } from "./notification-service.js";
+export type { TemplateName as NotificationTemplateName } from "./notification-templates.js";
+export { renderNotificationTemplate } from "./notification-templates.js";
+export { NotificationWorker } from "./notification-worker.js";
+export type { IEmailVerifier } from "./require-verified.js";
+export { requireEmailVerified } from "./require-verified.js";
+export type { EmailOptions } from "./resend-adapter.js";
+export { escapeHtml, passwordResetTemplate, passwordResetText, sendEmail } from "./resend-adapter.js";
+export type { TemplateName, TemplateResult } from "./templates.js";
+export { botDestructionTemplate, botSuspendedTemplate, creditPurchaseTemplate, dataDeletedTemplate, lowBalanceTemplate, passwordResetEmailTemplate, verifyEmailTemplate, welcomeTemplate, } from "./templates.js";
+export type { VerificationToken } from "./verification.js";
+export { generateVerificationToken, getUserEmail, initVerificationSchema, isEmailVerified, PgEmailVerifier, verifyToken, } from "./verification.js";

package/dist/email/index.js

@@ -0,0 +1,22 @@
+/**
+ * Email — Transactional email system via Resend.
+ *
+ * Provides:
+ * - EmailClient for sending template-based emails
+ * - 8 email templates (verify, welcome, password-reset, credit-purchase, low-balance, bot-suspended, bot-destruction, data-deleted)
+ * - BillingEmailService for deduplication + billing notifications (WOP-450)
+ * - Email verification flow (token generation, validation)
+ * - requireEmailVerified middleware for gating actions
+ */
+export { BillingEmailService } from "./billing-emails.js";
+export { EmailClient, getEmailClient, resetEmailClient, setEmailClient } from "./client.js";
+export { DrizzleBillingEmailRepository } from "./drizzle-billing-email-repository.js";
+export { DrizzleNotificationPreferencesStore } from "./notification-preferences-store.js";
+export { DrizzleNotificationQueueStore } from "./notification-queue-store.js";
+export { NotificationService } from "./notification-service.js";
+export { renderNotificationTemplate } from "./notification-templates.js";
+export { NotificationWorker } from "./notification-worker.js";
+export { requireEmailVerified } from "./require-verified.js";
+export { escapeHtml, passwordResetTemplate, passwordResetText, sendEmail } from "./resend-adapter.js";
+export { botDestructionTemplate, botSuspendedTemplate, creditPurchaseTemplate, dataDeletedTemplate, lowBalanceTemplate, passwordResetEmailTemplate, verifyEmailTemplate, welcomeTemplate, } from "./templates.js";
+export { generateVerificationToken, getUserEmail, initVerificationSchema, isEmailVerified, PgEmailVerifier, verifyToken, } from "./verification.js";

package/dist/email/notification-preferences-store.d.ts

@@ -0,0 +1,12 @@
+import type { PlatformDb } from "../db/index.js";
+import type { INotificationPreferencesRepository, NotificationPrefs } from "./notification-repository-types.js";
+export type { NotificationPrefs } from "./notification-repository-types.js";
+export type { INotificationPreferencesRepository };
+export declare class DrizzleNotificationPreferencesStore implements INotificationPreferencesRepository {
+    private readonly db;
+    constructor(db: PlatformDb);
+    /** Get preferences for a tenant. Returns defaults if no row exists. */
+    get(tenantId: string): Promise<NotificationPrefs>;
+    /** Update preferences for a tenant. Upserts — creates row if missing. */
+    update(tenantId: string, prefs: Partial<NotificationPrefs>): Promise<void>;
+}

package/dist/email/notification-preferences-store.js

@@ -0,0 +1,82 @@
+import { eq } from "drizzle-orm";
+import { notificationPreferences } from "../db/schema/notification-preferences.js";
+// ---------------------------------------------------------------------------
+// Drizzle Implementation
+// ---------------------------------------------------------------------------
+const DEFAULTS = {
+    billing_low_balance: true,
+    billing_receipts: true,
+    billing_auto_topup: true,
+    agent_channel_disconnect: true,
+    agent_status_changes: false,
+    account_role_changes: true,
+    account_team_invites: true,
+};
+export class DrizzleNotificationPreferencesStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    /** Get preferences for a tenant. Returns defaults if no row exists. */
+    async get(tenantId) {
+        const rows = await this.db
+            .select()
+            .from(notificationPreferences)
+            .where(eq(notificationPreferences.tenantId, tenantId));
+        const row = rows[0];
+        if (!row)
+            return { ...DEFAULTS };
+        return {
+            billing_low_balance: row.billingLowBalance,
+            billing_receipts: row.billingReceipts,
+            billing_auto_topup: row.billingAutoTopup,
+            agent_channel_disconnect: row.agentChannelDisconnect,
+            agent_status_changes: row.agentStatusChanges,
+            account_role_changes: row.accountRoleChanges,
+            account_team_invites: row.accountTeamInvites,
+        };
+    }
+    /** Update preferences for a tenant. Upserts — creates row if missing. */
+    async update(tenantId, prefs) {
+        const values = { tenantId, updatedAt: Math.floor(Date.now() / 1000) };
+        if (prefs.billing_low_balance !== undefined)
+            values.billingLowBalance = prefs.billing_low_balance;
+        if (prefs.billing_receipts !== undefined)
+            values.billingReceipts = prefs.billing_receipts;
+        if (prefs.billing_auto_topup !== undefined)
+            values.billingAutoTopup = prefs.billing_auto_topup;
+        if (prefs.agent_channel_disconnect !== undefined)
+            values.agentChannelDisconnect = prefs.agent_channel_disconnect;
+        if (prefs.agent_status_changes !== undefined)
+            values.agentStatusChanges = prefs.agent_status_changes;
+        if (prefs.account_role_changes !== undefined)
+            values.accountRoleChanges = prefs.account_role_changes;
+        if (prefs.account_team_invites !== undefined)
+            values.accountTeamInvites = prefs.account_team_invites;
+        // Get existing row to merge with defaults
+        const existing = await this.db
+            .select()
+            .from(notificationPreferences)
+            .where(eq(notificationPreferences.tenantId, tenantId));
+        if (existing.length > 0) {
+            // Only update the set fields
+            await this.db.update(notificationPreferences).set(values).where(eq(notificationPreferences.tenantId, tenantId));
+        }
+        else {
+            // Insert with defaults for unspecified fields
+            const insertValues = {
+                tenantId,
+                billingLowBalance: DEFAULTS.billing_low_balance,
+                billingReceipts: DEFAULTS.billing_receipts,
+                billingAutoTopup: DEFAULTS.billing_auto_topup,
+                agentChannelDisconnect: DEFAULTS.agent_channel_disconnect,
+                agentStatusChanges: DEFAULTS.agent_status_changes,
+                accountRoleChanges: DEFAULTS.account_role_changes,
+                accountTeamInvites: DEFAULTS.account_team_invites,
+                updatedAt: Math.floor(Date.now() / 1000),
+                ...values,
+            };
+            await this.db.insert(notificationPreferences).values(insertValues);
+        }
+    }
+}

package/dist/email/notification-preferences-store.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/email/notification-preferences-store.test.js

@@ -0,0 +1,86 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from "vitest";
+import { beginTestTransaction, createTestDb, endTestTransaction, rollbackTestTransaction } from "../test/db.js";
+import { DrizzleNotificationPreferencesStore } from "./notification-preferences-store.js";
+describe("DrizzleNotificationPreferencesStore", () => {
+    let db;
+    let pool;
+    let store;
+    beforeAll(async () => {
+        ({ db, pool } = await createTestDb());
+        await beginTestTransaction(pool);
+    });
+    afterAll(async () => {
+        await endTestTransaction(pool);
+        await pool.close();
+    });
+    beforeEach(async () => {
+        await rollbackTestTransaction(pool);
+        store = new DrizzleNotificationPreferencesStore(db);
+    });
+    describe("get", () => {
+        it("returns defaults when no row exists", async () => {
+            const prefs = await store.get("tenant-1");
+            expect(prefs).toEqual({
+                billing_low_balance: true,
+                billing_receipts: true,
+                billing_auto_topup: true,
+                agent_channel_disconnect: true,
+                agent_status_changes: false,
+                account_role_changes: true,
+                account_team_invites: true,
+            });
+        });
+        it("returns stored values when row exists", async () => {
+            await store.update("tenant-1", { billing_low_balance: false, agent_status_changes: true });
+            const prefs = await store.get("tenant-1");
+            expect(prefs.billing_low_balance).toBe(false);
+            expect(prefs.agent_status_changes).toBe(true);
+        });
+        it("maps integer 1 to true and 0 to false", async () => {
+            await store.update("tenant-1", { billing_low_balance: true });
+            const prefs = await store.get("tenant-1");
+            expect(typeof prefs.billing_low_balance).toBe("boolean");
+            expect(prefs.billing_low_balance).toBe(true);
+        });
+    });
+    describe("update", () => {
+        it("creates row on first call (upsert)", async () => {
+            await store.update("tenant-1", { billing_low_balance: false });
+            const prefs = await store.get("tenant-1");
+            expect(prefs.billing_low_balance).toBe(false);
+        });
+        it("merges partial updates without touching unspecified fields", async () => {
+            await store.update("tenant-1", { billing_low_balance: false });
+            await store.update("tenant-1", { billing_receipts: false });
+            const prefs = await store.get("tenant-1");
+            expect(prefs.billing_low_balance).toBe(false);
+            expect(prefs.billing_receipts).toBe(false);
+            expect(prefs.billing_auto_topup).toBe(true); // default unchanged
+        });
+        it("allows setting all preferences at once", async () => {
+            await store.update("tenant-1", {
+                billing_low_balance: false,
+                billing_receipts: false,
+                billing_auto_topup: false,
+                agent_channel_disconnect: false,
+                agent_status_changes: true,
+                account_role_changes: false,
+                account_team_invites: false,
+            });
+            const prefs = await store.get("tenant-1");
+            expect(prefs.billing_low_balance).toBe(false);
+            expect(prefs.billing_receipts).toBe(false);
+            expect(prefs.billing_auto_topup).toBe(false);
+            expect(prefs.agent_channel_disconnect).toBe(false);
+            expect(prefs.agent_status_changes).toBe(true);
+            expect(prefs.account_role_changes).toBe(false);
+            expect(prefs.account_team_invites).toBe(false);
+        });
+        it("second call updates existing row", async () => {
+            await store.update("tenant-1", { billing_low_balance: false });
+            await store.update("tenant-1", { billing_low_balance: true });
+            const prefs = await store.get("tenant-1");
+            expect(prefs.billing_low_balance).toBe(true);
+        });
+    });
+});

package/dist/email/notification-queue-store.d.ts

@@ -0,0 +1,25 @@
+import type { PlatformDb } from "../db/index.js";
+import type { INotificationQueueRepository, NotificationStatus, QueuedNotification } from "./notification-repository-types.js";
+export type { NotificationStatus, QueuedNotification } from "./notification-repository-types.js";
+export type { INotificationQueueRepository };
+export declare class DrizzleNotificationQueueStore implements INotificationQueueRepository {
+    private readonly db;
+    constructor(db: PlatformDb);
+    /** Enqueue a notification for async delivery. Returns the new row ID. */
+    enqueue(tenantId: string, template: string, data: Record<string, unknown>): Promise<string>;
+    /** Fetch up to `limit` notifications ready to send. */
+    fetchPending(limit?: number): Promise<QueuedNotification[]>;
+    /** Mark a notification as sent. */
+    markSent(id: string): Promise<void>;
+    /** Mark a notification as failed with exponential backoff retry. */
+    markFailed(id: string, attempts: number): Promise<void>;
+    /** List notifications for a tenant (for admin view). Paginated. */
+    listForTenant(tenantId: string, opts?: {
+        limit?: number;
+        offset?: number;
+        status?: NotificationStatus;
+    }): Promise<{
+        entries: QueuedNotification[];
+        total: number;
+    }>;
+}

package/dist/email/notification-queue-store.js

@@ -0,0 +1,97 @@
+import crypto from "node:crypto";
+import { and, desc, eq, lte, or, sql } from "drizzle-orm";
+import { notificationQueue } from "../db/schema/notification-queue.js";
+// ---------------------------------------------------------------------------
+// Drizzle Implementation
+// ---------------------------------------------------------------------------
+export class DrizzleNotificationQueueStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    /** Enqueue a notification for async delivery. Returns the new row ID. */
+    async enqueue(tenantId, template, data) {
+        const id = crypto.randomUUID();
+        const recipientEmail = data.email ?? "";
+        await this.db.insert(notificationQueue).values({
+            id,
+            tenantId,
+            emailType: template,
+            recipientEmail,
+            payload: JSON.stringify(data),
+            status: "pending",
+            attempts: 0,
+        });
+        return id;
+    }
+    /** Fetch up to `limit` notifications ready to send. */
+    async fetchPending(limit = 10) {
+        const now = Date.now();
+        const rows = await this.db
+            .select()
+            .from(notificationQueue)
+            .where(and(eq(notificationQueue.status, "pending"), or(sql `${notificationQueue.retryAfter} IS NULL`, lte(notificationQueue.retryAfter, now))))
+            .limit(limit);
+        return rows.map((r) => ({
+            id: r.id,
+            tenantId: r.tenantId,
+            template: r.emailType,
+            data: r.payload,
+            status: r.status,
+            attempts: r.attempts,
+            retryAfter: r.retryAfter ?? null,
+            sentAt: r.sentAt ?? null,
+            createdAt: r.createdAt,
+        }));
+    }
+    /** Mark a notification as sent. */
+    async markSent(id) {
+        await this.db
+            .update(notificationQueue)
+            .set({ status: "sent", sentAt: Date.now() })
+            .where(eq(notificationQueue.id, id));
+    }
+    /** Mark a notification as failed with exponential backoff retry. */
+    async markFailed(id, attempts) {
+        const maxAttempts = 5;
+        const isPermanentFail = attempts >= maxAttempts;
+        const backoffMs = Math.min(60_000 * 2 ** attempts, 3_600_000); // max 1 hour
+        await this.db
+            .update(notificationQueue)
+            .set({
+            status: isPermanentFail ? "failed" : "pending",
+            attempts,
+            retryAfter: isPermanentFail ? null : Date.now() + backoffMs,
+        })
+            .where(eq(notificationQueue.id, id));
+    }
+    /** List notifications for a tenant (for admin view). Paginated. */
+    async listForTenant(tenantId, opts = {}) {
+        const conditions = [eq(notificationQueue.tenantId, tenantId)];
+        if (opts.status) {
+            conditions.push(eq(notificationQueue.status, opts.status));
+        }
+        const whereClause = conditions.length === 1 ? conditions[0] : and(...conditions);
+        const totalRows = await this.db.select({ count: sql `count(*)` }).from(notificationQueue).where(whereClause);
+        const total = totalRows[0]?.count ?? 0;
+        const rows = await this.db
+            .select()
+            .from(notificationQueue)
+            .where(whereClause)
+            .orderBy(desc(notificationQueue.createdAt))
+            .limit(opts.limit ?? 50)
+            .offset(opts.offset ?? 0);
+        const entries = rows.map((r) => ({
+            id: r.id,
+            tenantId: r.tenantId,
+            template: r.emailType,
+            data: r.payload,
+            status: r.status,
+            attempts: r.attempts,
+            retryAfter: r.retryAfter ?? null,
+            sentAt: r.sentAt ?? null,
+            createdAt: r.createdAt,
+        }));
+        return { entries, total };
+    }
+}

package/dist/email/notification-queue-store.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/email/notification-queue-store.test.js

@@ -0,0 +1,177 @@
+import { eq } from "drizzle-orm";
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from "vitest";
+import { notificationQueue } from "../db/schema/notification-queue.js";
+import { beginTestTransaction, createTestDb, endTestTransaction, rollbackTestTransaction } from "../test/db.js";
+import { DrizzleNotificationQueueStore } from "./notification-queue-store.js";
+describe("DrizzleNotificationQueueStore", () => {
+    let db;
+    let pool;
+    let store;
+    beforeAll(async () => {
+        ({ db, pool } = await createTestDb());
+        await beginTestTransaction(pool);
+    });
+    afterAll(async () => {
+        await endTestTransaction(pool);
+        await pool.close();
+    });
+    beforeEach(async () => {
+        await rollbackTestTransaction(pool);
+        store = new DrizzleNotificationQueueStore(db);
+    });
+    describe("enqueue", () => {
+        it("creates a pending notification row", async () => {
+            const id = await store.enqueue("tenant-1", "low-balance", { email: "user@example.com" });
+            expect(id).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/);
+            const rows = await db.select().from(notificationQueue);
+            expect(rows).toHaveLength(1);
+            expect(rows[0].id).toBe(id);
+            expect(rows[0].tenantId).toBe("tenant-1");
+            // emailType stores the template name
+            expect(rows[0].emailType).toBe("low-balance");
+            expect(rows[0].status).toBe("pending");
+            expect(rows[0].attempts).toBe(0);
+        });
+        it("serializes data as JSON payload", async () => {
+            await store.enqueue("tenant-1", "low-balance", { email: "a@b.com", amount: 42 });
+            const rows = await db.select().from(notificationQueue);
+            expect(JSON.parse(rows[0].payload)).toEqual({ email: "a@b.com", amount: 42 });
+        });
+        it("returns a unique ID each call", async () => {
+            const id1 = await store.enqueue("tenant-1", "low-balance", {});
+            const id2 = await store.enqueue("tenant-1", "low-balance", {});
+            expect(id1).not.toBe(id2);
+        });
+        it("exposes template via QueuedNotification interface", async () => {
+            await store.enqueue("tenant-1", "low-balance", { email: "a@b.com" });
+            const pending = await store.fetchPending(10);
+            expect(pending[0].template).toBe("low-balance");
+        });
+        it("exposes data via QueuedNotification interface", async () => {
+            await store.enqueue("tenant-1", "low-balance", { email: "a@b.com", amount: 42 });
+            const pending = await store.fetchPending(10);
+            expect(JSON.parse(pending[0].data)).toEqual({ email: "a@b.com", amount: 42 });
+        });
+    });
+    describe("fetchPending", () => {
+        it("returns pending notifications", async () => {
+            await store.enqueue("tenant-1", "low-balance", { email: "a@b.com" });
+            const pending = await store.fetchPending(10);
+            expect(pending).toHaveLength(1);
+            expect(pending[0].template).toBe("low-balance");
+        });
+        it("does not return sent notifications", async () => {
+            const id = await store.enqueue("tenant-1", "low-balance", { email: "a@b.com" });
+            await store.markSent(id);
+            const pending = await store.fetchPending(10);
+            expect(pending).toHaveLength(0);
+        });
+        it("does not return permanently failed notifications", async () => {
+            const id = await store.enqueue("tenant-1", "low-balance", { email: "a@b.com" });
+            // 5 attempts = permanently failed
+            await store.markFailed(id, 5);
+            const pending = await store.fetchPending(10);
+            expect(pending).toHaveLength(0);
+        });
+        it("respects limit parameter", async () => {
+            await store.enqueue("tenant-1", "low-balance", {});
+            await store.enqueue("tenant-1", "low-balance", {});
+            await store.enqueue("tenant-1", "low-balance", {});
+            const pending = await store.fetchPending(2);
+            expect(pending).toHaveLength(2);
+        });
+    });
+    describe("markSent", () => {
+        it("transitions status to sent and sets sentAt", async () => {
+            const id = await store.enqueue("tenant-1", "low-balance", {});
+            const before = Date.now();
+            await store.markSent(id);
+            const after = Date.now();
+            const rows = await db.select().from(notificationQueue);
+            expect(rows[0].status).toBe("sent");
+            expect(rows[0].sentAt).toBeGreaterThanOrEqual(before);
+            expect(rows[0].sentAt).toBeLessThanOrEqual(after);
+        });
+    });
+    describe("markFailed", () => {
+        it("increments attempts and applies exponential backoff for first failure", async () => {
+            const id = await store.enqueue("tenant-1", "low-balance", {});
+            const before = Date.now();
+            await store.markFailed(id, 1);
+            const after = Date.now();
+            const rows = await db.select().from(notificationQueue);
+            expect(rows[0].attempts).toBe(1);
+            // 1st attempt: 60s * 2^1 = 120s backoff
+            const expectedBackoff = 60_000 * 2 ** 1;
+            expect(rows[0].retryAfter).toBeGreaterThanOrEqual(before + expectedBackoff - 100);
+            expect(rows[0].retryAfter).toBeLessThanOrEqual(after + expectedBackoff + 100);
+        });
+        it("caps backoff at 1 hour", async () => {
+            const id = await store.enqueue("tenant-1", "low-balance", {});
+            await store.markFailed(id, 4);
+            const rows = await db.select().from(notificationQueue);
+            // backoff = 60_000 * 2^4 = 960_000ms > 3_600_000ms cap
+            const maxBackoff = 3_600_000;
+            expect(rows[0].retryAfter).toBeLessThanOrEqual(Date.now() + maxBackoff + 1000);
+        });
+        it("permanently fails after 5 attempts", async () => {
+            const id = await store.enqueue("tenant-1", "low-balance", {});
+            await store.markFailed(id, 5);
+            const rows = await db.select().from(notificationQueue);
+            expect(rows[0].status).toBe("failed");
+            expect(rows[0].attempts).toBe(5);
+        });
+        it("keeps status as pending with retry for attempts below 5", async () => {
+            const id = await store.enqueue("tenant-1", "low-balance", {});
+            await store.markFailed(id, 3);
+            const rows = await db.select().from(notificationQueue);
+            expect(rows[0].status).toBe("pending");
+        });
+    });
+    describe("listForTenant", () => {
+        it("returns notifications for the given tenant", async () => {
+            await store.enqueue("tenant-1", "low-balance", {});
+            await store.enqueue("tenant-2", "low-balance", {});
+            await store.enqueue("tenant-1", "welcome", {});
+            const result = await store.listForTenant("tenant-1");
+            expect(result.entries).toHaveLength(2);
+            expect(result.total).toBe(2);
+        });
+        it("returns most recent first (ordered by createdAt desc)", async () => {
+            const id1 = await store.enqueue("tenant-1", "template-a", {});
+            const id2 = await store.enqueue("tenant-1", "template-b", {});
+            // Force distinct timestamps so ordering is deterministic
+            await db.update(notificationQueue).set({ createdAt: 1000 }).where(eq(notificationQueue.id, id1));
+            await db.update(notificationQueue).set({ createdAt: 2000 }).where(eq(notificationQueue.id, id2));
+            const result = await store.listForTenant("tenant-1");
+            // Most recent (id2, createdAt=2000) should be first
+            expect(result.entries[0].id).toBe(id2);
+            expect(result.entries[1].id).toBe(id1);
+        });
+        it("paginates results", async () => {
+            await store.enqueue("tenant-1", "template-a", {});
+            await store.enqueue("tenant-1", "template-b", {});
+            await store.enqueue("tenant-1", "template-c", {});
+            const page1 = await store.listForTenant("tenant-1", { limit: 2, offset: 0 });
+            expect(page1.entries).toHaveLength(2);
+            expect(page1.total).toBe(3);
+            const page2 = await store.listForTenant("tenant-1", { limit: 2, offset: 2 });
+            expect(page2.entries).toHaveLength(1);
+        });
+        it("filters by status", async () => {
+            const id = await store.enqueue("tenant-1", "low-balance", {});
+            await store.enqueue("tenant-1", "welcome", {});
+            await store.markSent(id);
+            const sent = await store.listForTenant("tenant-1", { status: "sent" });
+            expect(sent.entries).toHaveLength(1);
+            expect(sent.entries[0].status).toBe("sent");
+            const pending = await store.listForTenant("tenant-1", { status: "pending" });
+            expect(pending.entries).toHaveLength(1);
+        });
+        it("returns empty for unknown tenant", async () => {
+            const result = await store.listForTenant("nonexistent");
+            expect(result.entries).toHaveLength(0);
+            expect(result.total).toBe(0);
+        });
+    });
+});