@vex-chat/spire 1.10.3 → 1.11.0

package/src/__tests__/Database.spec.ts

@@ -230,4 +230,128 @@ describe("Database", () => {
             });
         });
     });
+
+    describe("notification subscriptions", () => {
+        it("upserts and filters Expo push subscriptions by event", async () => {
+            expect.assertions(7);
+
+            const provider = new Database(options);
+            await new Promise<void>((resolve, reject) => {
+                provider.once("ready", () => {
+                    void (async () => {
+                        try {
+                            const created =
+                                await provider.saveNotificationSubscription({
+                                    channel: "expo",
+                                    deviceID,
+                                    events: ["mail"],
+                                    platform: "ios",
+                                    token: "ExponentPushToken[test]",
+                                    userID,
+                                });
+                            expect(created.events).toEqual(["mail"]);
+                            expect(created.enabled).toBe(true);
+
+                            const mailSubs =
+                                await provider.retrieveNotificationSubscriptions(
+                                    { deviceID, event: "mail", userID },
+                                );
+                            expect(mailSubs).toHaveLength(1);
+
+                            const deviceSubs =
+                                await provider.retrieveNotificationSubscriptions(
+                                    {
+                                        deviceID,
+                                        event: "deviceRequest",
+                                        userID,
+                                    },
+                                );
+                            expect(deviceSubs).toHaveLength(0);
+
+                            const updated =
+                                await provider.saveNotificationSubscription({
+                                    channel: "expo",
+                                    deviceID,
+                                    events: ["deviceRequest"],
+                                    platform: "ios",
+                                    token: "ExponentPushToken[test]",
+                                    userID,
+                                });
+                            expect(updated.subscriptionID).toBe(
+                                created.subscriptionID,
+                            );
+
+                            const mailSubsAfterUpdate =
+                                await provider.retrieveNotificationSubscriptions(
+                                    { deviceID, event: "mail", userID },
+                                );
+                            expect(mailSubsAfterUpdate).toHaveLength(0);
+
+                            const deviceSubsAfterUpdate =
+                                await provider.retrieveNotificationSubscriptions(
+                                    {
+                                        deviceID,
+                                        event: "deviceRequest",
+                                        userID,
+                                    },
+                                );
+                            expect(deviceSubsAfterUpdate).toHaveLength(1);
+
+                            await provider.close();
+                            resolve();
+                        } catch (e: unknown) {
+                            reject(
+                                e instanceof Error ? e : new Error(String(e)),
+                            );
+                        }
+                    })();
+                });
+            });
+        });
+
+        it("stores one Expo push subscription for concurrent identical saves", async () => {
+            expect.assertions(3);
+
+            const provider = new Database(options);
+            await new Promise<void>((resolve, reject) => {
+                provider.once("ready", () => {
+                    void (async () => {
+                        try {
+                            const input = {
+                                channel: "expo" as const,
+                                deviceID,
+                                events: ["mail"],
+                                platform: "android",
+                                token: "ExponentPushToken[dedupe]",
+                                userID,
+                            };
+                            const [first, second] = await Promise.all([
+                                provider.saveNotificationSubscription(input),
+                                provider.saveNotificationSubscription(input),
+                            ]);
+                            expect(second.subscriptionID).toBe(
+                                first.subscriptionID,
+                            );
+
+                            const mailSubs =
+                                await provider.retrieveNotificationSubscriptions(
+                                    { deviceID, event: "mail", userID },
+                                );
+                            expect(mailSubs).toHaveLength(1);
+                            expect(mailSubs[0]?.subscriptionID).toBe(
+                                first.subscriptionID,
+                            );
+
+                            await provider.close();
+                            resolve();
+                        } catch (e: unknown) {
+                            reject(
+                                e instanceof Error ? e : new Error(String(e)),
+                            );
+                        }
+                    })();
+                });
+            });
+        });
+    });
 });

package/src/__tests__/clientManagerReceipt.spec.ts

@@ -0,0 +1,106 @@
+/**
+ * Copyright (c) 2020-2026 Vex Heavy Industries LLC
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ * Commercial licenses available at vex.wtf
+ */
+
+import type { Device, ReceiptMsg } from "@vex-chat/types";
+
+import { describe, expect, it, vi } from "vitest";
+
+import { ClientManager } from "../ClientManager.ts";
+
+const RECEIPT_NONCE = new Uint8Array([1, 2, 3]);
+
+interface ManagerHarness {
+    authed: boolean;
+    db: { deleteMail: ReturnType<typeof vi.fn> };
+    device: Device | null;
+    failed: boolean;
+    handleReceipt: (msg: ReceiptMsg) => Promise<void>;
+    sendErr: ReturnType<typeof vi.fn>;
+}
+
+function createManagerHarness({
+    authed,
+    deleteMail = vi.fn(),
+    deviceID,
+}: {
+    authed: boolean;
+    deleteMail?: ReturnType<typeof vi.fn>;
+    deviceID: null | string;
+}) {
+    const manager = Object.create(
+        ClientManager.prototype,
+    ) as unknown as ManagerHarness;
+    manager.authed = authed;
+    manager.db = { deleteMail };
+    manager.device =
+        deviceID === null
+            ? null
+            : ({
+                  deviceID,
+              } as Device);
+    manager.failed = false;
+    manager.sendErr = vi.fn();
+    return manager;
+}
+
+function createReceipt(): ReceiptMsg {
+    return {
+        nonce: RECEIPT_NONCE,
+        transmissionID: "00000000-0000-0000-0000-000000000001",
+        type: "receipt",
+    };
+}
+
+describe("ClientManager receipt handling", () => {
+    it("rejects receipts before a device is authenticated", async () => {
+        const deleteMail = vi.fn();
+        const manager = createManagerHarness({
+            authed: false,
+            deleteMail,
+            deviceID: null,
+        });
+
+        await manager.handleReceipt(createReceipt());
+
+        expect(deleteMail).not.toHaveBeenCalled();
+        expect(manager.sendErr).toHaveBeenCalledWith(
+            "00000000-0000-0000-0000-000000000001",
+            "You are not authenticated.",
+        );
+    });
+
+    it("deletes mail receipts for the authenticated device", async () => {
+        const deleteMail = vi.fn();
+        const manager = createManagerHarness({
+            authed: true,
+            deleteMail,
+            deviceID: "device-a",
+        });
+
+        await manager.handleReceipt(createReceipt());
+
+        expect(deleteMail).toHaveBeenCalledWith(RECEIPT_NONCE, "device-a");
+        expect(manager.sendErr).not.toHaveBeenCalled();
+    });
+
+    it("contains receipt deletion failures", async () => {
+        const deleteMail = vi.fn(() =>
+            Promise.reject(new Error("database unavailable")),
+        );
+        const manager = createManagerHarness({
+            authed: true,
+            deleteMail,
+            deviceID: "device-a",
+        });
+
+        await manager.handleReceipt(createReceipt());
+
+        expect(manager.sendErr).toHaveBeenCalledWith(
+            "00000000-0000-0000-0000-000000000001",
+            "Error: database unavailable",
+        );
+    });
+});