@mohasinac/appkit 3.0.6 → 3.1.0

package/dist/features/admin/repository/__tests__/notification.repository.test.js

@@ -0,0 +1,356 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { makeMockDb, makeSnap, makeQuerySnap } from "../../../../../tests/helpers/mock-firestore";
+const { db, mockDocRef, mockCollection, mockQuery, mockBatch } = makeMockDb();
+const { mockGetFirestoreCount } = vi.hoisted(() => ({
+    mockGetFirestoreCount: vi.fn().mockResolvedValue(0),
+}));
+vi.mock("../../../../providers/db-firebase/admin", () => ({
+    getAdminDb: () => db,
+}));
+vi.mock("../../../../providers/db-firebase", async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        prepareForFirestore: (d) => d,
+        getFirestoreCount: mockGetFirestoreCount,
+    };
+});
+vi.mock("../../../../contracts/field-ops", () => ({
+    serverTimestamp: () => new Date(),
+    increment: (n) => n,
+    arrayUnion: (...args) => args,
+    arrayRemove: (...args) => args,
+    deleteField: () => null,
+    registerFieldOps: vi.fn(),
+}));
+vi.mock("../../../../errors/normalize", () => ({
+    normalizeError: vi.fn(),
+}));
+vi.mock("../../../../monitoring", () => ({
+    serverLogger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+}));
+import { NotificationRepository } from "../notification.repository";
+const repo = new NotificationRepository();
+function makeNotifDoc(overrides = {}) {
+    return {
+        id: "notif-order-shipped-001",
+        userId: "user-ravi",
+        type: "order_shipped",
+        title: "Your order has shipped!",
+        body: "Order #123 is on its way.",
+        isRead: false,
+        entityId: "order-3-20260627-abc123",
+        entityType: "order",
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        ...overrides,
+    };
+}
+beforeEach(() => {
+    vi.clearAllMocks();
+    mockGetFirestoreCount.mockResolvedValue(0);
+    db.collection.mockReturnValue(mockCollection);
+    mockCollection.doc.mockReturnValue(mockDocRef);
+    mockCollection.where.mockReturnValue(mockQuery);
+    mockQuery.where.mockReturnValue(mockQuery);
+    mockQuery.orderBy.mockReturnValue(mockQuery);
+    mockQuery.limit.mockReturnValue(mockQuery);
+    mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+    mockDocRef.get.mockResolvedValue(makeSnap(makeNotifDoc(), "notif-1"));
+    mockDocRef.set.mockResolvedValue(undefined);
+    mockDocRef.update.mockResolvedValue(undefined);
+    mockDocRef.delete.mockResolvedValue(undefined);
+    db.batch.mockReturnValue(mockBatch);
+});
+// ---------------------------------------------------------------------------
+// create
+// ---------------------------------------------------------------------------
+describe("NotificationRepository.create", () => {
+    it("sets isRead: false on new notifications", async () => {
+        await repo.create({
+            userId: "user-ravi",
+            type: "order_shipped",
+            priority: "normal",
+            title: "Shipped!",
+            message: "Your order shipped.",
+        });
+        const setArg = mockDocRef.set.mock.calls[0][0];
+        expect(setArg.isRead).toBe(false);
+    });
+    it("stores all required fields", async () => {
+        await repo.create({
+            userId: "user-ravi",
+            type: "order_placed",
+            priority: "normal",
+            title: "Order placed",
+            message: "Thanks for your order.",
+        });
+        const setArg = mockDocRef.set.mock.calls[0][0];
+        expect(setArg.userId).toBe("user-ravi");
+        expect(setArg.type).toBe("order_placed");
+        expect(setArg.title).toBe("Order placed");
+    });
+    it("sets createdAt and updatedAt timestamps", async () => {
+        await repo.create({ userId: "user-1", type: "general", priority: "normal", title: "Hi", message: "Hello" });
+        const setArg = mockDocRef.set.mock.calls[0][0];
+        expect(setArg.createdAt).toBeInstanceOf(Date);
+        expect(setArg.updatedAt).toBeInstanceOf(Date);
+    });
+    it("uses collection.doc() with no args (auto-ID)", async () => {
+        await repo.create({ userId: "user-1", type: "general", priority: "normal", title: "T", message: "B" });
+        // doc() is called with no argument for auto-generated IDs
+        expect(mockCollection.doc).toHaveBeenCalledWith();
+    });
+    it("returns the created notification with id", async () => {
+        mockDocRef.id = "notif-auto-123";
+        const result = await repo.create({
+            userId: "user-ravi",
+            type: "bid_won",
+            priority: "normal",
+            title: "You won!",
+            message: "Congratulations.",
+        });
+        expect(result.id).toBe("notif-auto-123");
+        expect(result.isRead).toBe(false);
+    });
+});
+// ---------------------------------------------------------------------------
+// markAsRead
+// ---------------------------------------------------------------------------
+describe("NotificationRepository.markAsRead", () => {
+    it("sets isRead: true on the notification", async () => {
+        await repo.markAsRead("notif-1");
+        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ isRead: true }));
+    });
+    it("sets readAt timestamp", async () => {
+        await repo.markAsRead("notif-1");
+        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ readAt: expect.any(Date) }));
+    });
+    it("sets updatedAt timestamp", async () => {
+        await repo.markAsRead("notif-1");
+        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ updatedAt: expect.any(Date) }));
+    });
+    it("calls doc(id) to target the correct notification", async () => {
+        await repo.markAsRead("notif-abc");
+        expect(mockCollection.doc).toHaveBeenCalledWith("notif-abc");
+    });
+});
+// ---------------------------------------------------------------------------
+// markAllAsRead
+// ---------------------------------------------------------------------------
+describe("NotificationRepository.markAllAsRead", () => {
+    it("queries unread notifications for the user", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        await repo.markAllAsRead("user-ravi");
+        expect(mockCollection.where).toHaveBeenCalledWith(expect.stringContaining("userId"), "==", "user-ravi");
+        expect(mockQuery.where).toHaveBeenCalledWith(expect.stringContaining("isRead"), "==", false);
+    });
+    it("batch-updates all unread notifications to isRead: true", async () => {
+        const notifs = [
+            makeNotifDoc({ id: "n-1", isRead: false }),
+            makeNotifDoc({ id: "n-2", isRead: false }),
+        ];
+        mockQuery.get.mockResolvedValue(makeQuerySnap(notifs.map((n) => ({ id: n.id, data: n }))));
+        await repo.markAllAsRead("user-ravi");
+        expect(mockBatch.update).toHaveBeenCalledTimes(2);
+        const calls = mockBatch.update.mock.calls;
+        expect(calls.every((c) => c[1].isRead === true)).toBe(true);
+        expect(mockBatch.commit).toHaveBeenCalledOnce();
+    });
+    it("returns 0 and does not batch-update when no unread notifications", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        const count = await repo.markAllAsRead("user-ravi");
+        expect(count).toBe(0);
+        expect(mockBatch.update).not.toHaveBeenCalled();
+    });
+    it("returns the count of notifications marked", async () => {
+        const notifs = [
+            makeNotifDoc({ id: "n-1", isRead: false }),
+            makeNotifDoc({ id: "n-2", isRead: false }),
+            makeNotifDoc({ id: "n-3", isRead: false }),
+        ];
+        mockQuery.get.mockResolvedValue(makeQuerySnap(notifs.map((n) => ({ id: n.id, data: n }))));
+        const count = await repo.markAllAsRead("user-ravi");
+        expect(count).toBe(3);
+    });
+});
+// ---------------------------------------------------------------------------
+// getUnreadCount
+// ---------------------------------------------------------------------------
+describe("NotificationRepository.getUnreadCount", () => {
+    it("returns the count of unread notifications for userId", async () => {
+        mockGetFirestoreCount.mockResolvedValue(7);
+        const count = await repo.getUnreadCount("user-ravi");
+        expect(count).toBe(7);
+    });
+    it("returns 0 when no unread notifications", async () => {
+        mockGetFirestoreCount.mockResolvedValue(0);
+        const count = await repo.getUnreadCount("user-ravi");
+        expect(count).toBe(0);
+    });
+    it("returns 0 on error (graceful fallback)", async () => {
+        mockGetFirestoreCount.mockRejectedValue(new Error("Firestore error"));
+        const count = await repo.getUnreadCount("user-ravi");
+        expect(count).toBe(0);
+    });
+    it("queries by userId and isRead == false", async () => {
+        mockGetFirestoreCount.mockResolvedValue(3);
+        await repo.getUnreadCount("user-xyz");
+        expect(mockCollection.where).toHaveBeenCalledWith(expect.stringContaining("userId"), "==", "user-xyz");
+        expect(mockQuery.where).toHaveBeenCalledWith(expect.stringContaining("isRead"), "==", false);
+    });
+});
+// ---------------------------------------------------------------------------
+// deleteAllForUser
+// ---------------------------------------------------------------------------
+describe("NotificationRepository.deleteAllForUser", () => {
+    it("batch-deletes all notifications for the user", async () => {
+        const notifs = [
+            makeNotifDoc({ id: "n-1" }),
+            makeNotifDoc({ id: "n-2" }),
+        ];
+        mockQuery.get.mockResolvedValue(makeQuerySnap(notifs.map((n) => ({ id: n.id, data: n }))));
+        await repo.deleteAllForUser("user-ravi");
+        expect(mockBatch.delete).toHaveBeenCalledTimes(2);
+        expect(mockBatch.commit).toHaveBeenCalledOnce();
+    });
+    it("returns 0 and skips batch when no notifications exist", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        const count = await repo.deleteAllForUser("user-nobody");
+        expect(count).toBe(0);
+        expect(mockBatch.delete).not.toHaveBeenCalled();
+    });
+    it("returns count of deleted notifications", async () => {
+        const notifs = [
+            makeNotifDoc({ id: "n-1" }),
+            makeNotifDoc({ id: "n-2" }),
+            makeNotifDoc({ id: "n-3" }),
+        ];
+        mockQuery.get.mockResolvedValue(makeQuerySnap(notifs.map((n) => ({ id: n.id, data: n }))));
+        const count = await repo.deleteAllForUser("user-ravi");
+        expect(count).toBe(3);
+    });
+});
+// ---------------------------------------------------------------------------
+// delete (single)
+// ---------------------------------------------------------------------------
+describe("NotificationRepository.delete", () => {
+    it("calls doc(id).delete()", async () => {
+        await repo.delete("notif-abc");
+        expect(mockCollection.doc).toHaveBeenCalledWith("notif-abc");
+        expect(mockDocRef.delete).toHaveBeenCalledOnce();
+    });
+});
+// ---------------------------------------------------------------------------
+// getOldReadRefs
+// ---------------------------------------------------------------------------
+describe("NotificationRepository.getOldReadRefs", () => {
+    it("queries isRead == true and createdAt < cutoff date", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        await repo.getOldReadRefs(30);
+        expect(mockCollection.where).toHaveBeenCalledWith(expect.stringContaining("isRead"), "==", true);
+        expect(mockQuery.where).toHaveBeenCalledWith(expect.stringContaining("createdAt"), "<", expect.any(Date));
+    });
+    it("cutoff date is approximately ttlDays ago", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        const before = Date.now();
+        await repo.getOldReadRefs(30);
+        const cutoffArg = mockQuery.where.mock.calls.find((c) => c[0].includes("createdAt"))?.[2];
+        expect(cutoffArg).toBeInstanceOf(Date);
+        const expectedCutoff = before - 30 * 24 * 60 * 60 * 1000;
+        expect(cutoffArg.getTime()).toBeGreaterThanOrEqual(expectedCutoff - 1000);
+        expect(cutoffArg.getTime()).toBeLessThanOrEqual(expectedCutoff + 1000);
+    });
+    it("limits to 500 documents", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        await repo.getOldReadRefs();
+        expect(mockQuery.limit).toHaveBeenCalledWith(500);
+    });
+    it("does NOT include unread notifications (isRead==false docs excluded)", async () => {
+        // The query explicitly filters isRead==true — unread docs are never fetched
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        await repo.getOldReadRefs(30);
+        const whereCalls = mockCollection.where.mock.calls;
+        const isReadFilter = whereCalls.find((c) => c[0].includes("isRead"));
+        expect(isReadFilter?.[1]).toBe("==");
+        expect(isReadFilter?.[2]).toBe(true);
+    });
+    it("returns document refs", async () => {
+        const notif = makeNotifDoc({ id: "notif-old", isRead: true });
+        mockQuery.get.mockResolvedValue(makeQuerySnap([{ id: notif.id, data: notif }]));
+        const refs = await repo.getOldReadRefs(30);
+        expect(refs).toHaveLength(1);
+    });
+});
+// ---------------------------------------------------------------------------
+// createInBatch
+// ---------------------------------------------------------------------------
+describe("NotificationRepository.createInBatch", () => {
+    it("stages notification via batch.create (does not commit)", () => {
+        const mockExternalBatch = {
+            create: vi.fn(),
+            update: vi.fn(),
+            delete: vi.fn(),
+            commit: vi.fn().mockResolvedValue(undefined),
+        };
+        repo.createInBatch(mockExternalBatch, {
+            userId: "user-ravi",
+            type: "order_shipped",
+            priority: "normal",
+            title: "Shipped!",
+            message: "On its way.",
+        });
+        expect(mockExternalBatch.create).toHaveBeenCalledOnce();
+        expect(mockExternalBatch.commit).not.toHaveBeenCalled();
+    });
+    it("sets isRead: false in the batched notification", () => {
+        const mockExternalBatch = { create: vi.fn(), update: vi.fn(), delete: vi.fn(), commit: vi.fn() };
+        repo.createInBatch(mockExternalBatch, {
+            userId: "user-ravi",
+            type: "general",
+            priority: "normal",
+            title: "Hi",
+            message: "Hello",
+        });
+        const createArg = mockExternalBatch.create.mock.calls[0][1];
+        expect(createArg.isRead).toBe(false);
+    });
+    it("returns a document reference synchronously", () => {
+        const mockExternalBatch = { create: vi.fn(), update: vi.fn(), delete: vi.fn(), commit: vi.fn() };
+        const ref = repo.createInBatch(mockExternalBatch, {
+            userId: "user-1",
+            type: "general",
+            priority: "normal",
+            title: "T",
+            message: "B",
+        });
+        expect(ref).toBeDefined();
+        expect(ref.id).toBeDefined();
+    });
+});
+// ---------------------------------------------------------------------------
+// findByUser
+// ---------------------------------------------------------------------------
+describe("NotificationRepository.findByUser", () => {
+    it("returns notifications for the given userId", async () => {
+        const notif = makeNotifDoc({ userId: "user-ravi" });
+        mockQuery.get.mockResolvedValue(makeQuerySnap([{ id: notif.id, data: notif }]));
+        const results = await repo.findByUser("user-ravi");
+        expect(results).toHaveLength(1);
+    });
+    it("orders by createdAt descending (newest first)", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        await repo.findByUser("user-ravi");
+        expect(mockQuery.orderBy).toHaveBeenCalledWith(expect.stringContaining("createdAt"), "desc");
+    });
+    it("applies default limit of 20", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        await repo.findByUser("user-ravi");
+        expect(mockQuery.limit).toHaveBeenCalledWith(20);
+    });
+    it("applies custom limit when provided", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        await repo.findByUser("user-ravi", 5);
+        expect(mockQuery.limit).toHaveBeenCalledWith(5);
+    });
+});

package/dist/features/admin/repository/__tests__/site-settings.repository.test.d.ts

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

package/dist/features/admin/repository/__tests__/site-settings.repository.test.js

@@ -0,0 +1,298 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { makeMockDb, makeSnap } from "../../../../../tests/helpers/mock-firestore";
+const { db, mockDocRef, mockCollection } = makeMockDb();
+const { mockCacheManager, mockDecryptSecret } = vi.hoisted(() => ({
+    mockCacheManager: {
+        get: vi.fn().mockReturnValue(null),
+        set: vi.fn(),
+        delete: vi.fn(),
+    },
+    mockDecryptSecret: vi.fn((v) => v.replace("enc:", "")),
+}));
+vi.mock("../../../../providers/db-firebase/admin", () => ({
+    getAdminDb: () => db,
+}));
+vi.mock("../../../../providers/db-firebase", async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        prepareForFirestore: (d) => d,
+    };
+});
+vi.mock("../../../../core", () => ({
+    cacheManager: mockCacheManager,
+}));
+vi.mock("../../../../security", () => ({
+    encryptSecret: (v) => `enc:${v}`,
+    decryptSecret: mockDecryptSecret,
+    maskSecret: (v) => `${v.slice(0, 4)}***`,
+}));
+vi.mock("../../../../errors/normalize", () => ({
+    normalizeError: vi.fn(),
+}));
+vi.mock("../../../../monitoring", () => ({
+    serverLogger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+}));
+import { SiteSettingsRepository } from "../site-settings.repository";
+// Create a fresh repo per test to avoid shared state from `siteSettingsRepository` singleton
+function makeRepo() {
+    return new SiteSettingsRepository();
+}
+function makeSettingsDoc(overrides = {}) {
+    return {
+        id: "global",
+        siteName: "LetItRip",
+        credentials: {},
+        featureFlags: { useMockPayment: false, useMockShipping: false },
+        features: [],
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        ...overrides,
+    };
+}
+beforeEach(() => {
+    vi.clearAllMocks();
+    mockCacheManager.get.mockReturnValue(null);
+    mockDecryptSecret.mockImplementation((v) => v.replace("enc:", ""));
+    db.collection.mockReturnValue(mockCollection);
+    mockCollection.doc.mockReturnValue(mockDocRef);
+    const settingsDoc = makeSettingsDoc();
+    mockDocRef.get.mockResolvedValue(makeSnap(settingsDoc, "global"));
+    mockDocRef.set.mockResolvedValue(undefined);
+    mockDocRef.update.mockResolvedValue(undefined);
+});
+// ---------------------------------------------------------------------------
+// getSingleton
+// ---------------------------------------------------------------------------
+describe("SiteSettingsRepository.getSingleton", () => {
+    it("returns cached value without hitting Firestore when cache is warm", async () => {
+        const cached = makeSettingsDoc({ siteName: "Cached LetItRip" });
+        mockCacheManager.get.mockReturnValue(cached);
+        const repo = makeRepo();
+        const result = await repo.getSingleton();
+        expect(result.siteName).toBe("Cached LetItRip");
+        expect(mockDocRef.get).not.toHaveBeenCalled();
+    });
+    it("fetches from Firestore when cache is cold (null)", async () => {
+        mockCacheManager.get.mockReturnValue(null);
+        const repo = makeRepo();
+        await repo.getSingleton();
+        expect(mockDocRef.get).toHaveBeenCalledOnce();
+    });
+    it("populates cache after Firestore fetch", async () => {
+        mockCacheManager.get.mockReturnValue(null);
+        const settingsDoc = makeSettingsDoc();
+        mockDocRef.get.mockResolvedValue(makeSnap(settingsDoc, "global"));
+        const repo = makeRepo();
+        await repo.getSingleton();
+        expect(mockCacheManager.set).toHaveBeenCalledWith(expect.stringContaining("site-settings"), expect.anything(), expect.objectContaining({ ttl: expect.any(Number) }));
+    });
+    it("creates default settings when document does not exist", async () => {
+        mockDocRef.get.mockResolvedValue(makeSnap(null));
+        const repo = makeRepo();
+        await repo.getSingleton();
+        expect(mockDocRef.set).toHaveBeenCalledOnce();
+    });
+    it("returns default settings when document does not exist", async () => {
+        mockDocRef.get.mockResolvedValue(makeSnap(null));
+        const repo = makeRepo();
+        const result = await repo.getSingleton();
+        expect(result.id).toBe("global");
+        expect(result.createdAt).toBeInstanceOf(Date);
+    });
+    it("caches the newly-created default settings", async () => {
+        mockDocRef.get.mockResolvedValue(makeSnap(null));
+        const repo = makeRepo();
+        await repo.getSingleton();
+        expect(mockCacheManager.set).toHaveBeenCalledWith(expect.stringContaining("site-settings"), expect.anything(), expect.objectContaining({ ttl: expect.any(Number) }));
+    });
+});
+// ---------------------------------------------------------------------------
+// updateSingleton
+// ---------------------------------------------------------------------------
+describe("SiteSettingsRepository.updateSingleton", () => {
+    it("clears cache before writing", async () => {
+        const repo = makeRepo();
+        await repo.updateSingleton({ branding: { siteName: "New Name" } });
+        expect(mockCacheManager.delete).toHaveBeenCalledWith(expect.stringContaining("site-settings"));
+        // delete happens before the update
+        const deleteCallOrder = mockCacheManager.delete.mock.invocationCallOrder[0];
+        const updateCallOrder = mockDocRef.update.mock.invocationCallOrder[0];
+        expect(deleteCallOrder).toBeLessThan(updateCallOrder);
+    });
+    it("writes updatedAt timestamp", async () => {
+        const repo = makeRepo();
+        await repo.updateSingleton({ branding: { siteName: "New" } });
+        const updateArg = mockDocRef.update.mock.calls[0][0];
+        expect(updateArg.updatedAt).toBeInstanceOf(Date);
+    });
+    it("encrypts credential values before writing", async () => {
+        const settingsDoc = makeSettingsDoc({ credentials: {} });
+        mockDocRef.get.mockResolvedValue(makeSnap(settingsDoc, "global"));
+        const repo = makeRepo();
+        await repo.updateSingleton({
+            credentials: { razorpayKeyId: "rzp_live_abc123" },
+        });
+        const updateArg = mockDocRef.update.mock.calls[0][0];
+        const creds = updateArg.credentials;
+        expect(creds.razorpayKeyId).toBe("enc:rzp_live_abc123");
+    });
+    it("does not overwrite existing credential with empty string", async () => {
+        const settingsDoc = makeSettingsDoc({
+            credentials: { razorpayKeyId: "enc:existing-key" },
+        });
+        mockDocRef.get.mockResolvedValue(makeSnap(settingsDoc, "global"));
+        const repo = makeRepo();
+        await repo.updateSingleton({
+            credentials: { razorpayKeyId: "" },
+        });
+        const updateArg = mockDocRef.update.mock.calls[0][0];
+        const creds = updateArg.credentials;
+        // Empty string → keep existing
+        expect(creds.razorpayKeyId).toBe("enc:existing-key");
+    });
+    it("re-caches the latest settings after update", async () => {
+        const repo = makeRepo();
+        await repo.updateSingleton({ branding: { siteName: "Updated" } });
+        // getSingleton is called after update to get latest — cacheManager.set re-called
+        expect(mockCacheManager.set).toHaveBeenCalled();
+    });
+});
+// ---------------------------------------------------------------------------
+// getDecryptedCredentials
+// ---------------------------------------------------------------------------
+describe("SiteSettingsRepository.getDecryptedCredentials", () => {
+    it("returns decrypted API key values", async () => {
+        const settingsDoc = makeSettingsDoc({
+            credentials: { razorpayKeyId: "enc:rzp_live_abc123" },
+        });
+        mockDocRef.get.mockResolvedValue(makeSnap(settingsDoc, "global"));
+        const repo = makeRepo();
+        const result = await repo.getDecryptedCredentials();
+        expect(result.razorpayKeyId).toBe("rzp_live_abc123");
+    });
+    it("falls back to empty string when decryption fails", async () => {
+        mockDecryptSecret.mockImplementationOnce(() => {
+            throw new Error("auth-tag mismatch");
+        });
+        const settingsDoc = makeSettingsDoc({
+            credentials: { razorpayKeyId: "corrupt-blob" },
+        });
+        mockDocRef.get.mockResolvedValue(makeSnap(settingsDoc, "global"));
+        const repo = makeRepo();
+        const result = await repo.getDecryptedCredentials();
+        expect(result.razorpayKeyId).toBe("");
+    });
+    it("returns empty object when no credentials stored", async () => {
+        const settingsDoc = makeSettingsDoc({ credentials: {} });
+        mockDocRef.get.mockResolvedValue(makeSnap(settingsDoc, "global"));
+        const repo = makeRepo();
+        const result = await repo.getDecryptedCredentials();
+        expect(Object.keys(result)).toHaveLength(0);
+    });
+});
+// ---------------------------------------------------------------------------
+// getCredentialsMasked
+// ---------------------------------------------------------------------------
+describe("SiteSettingsRepository.getCredentialsMasked", () => {
+    it("replaces credential values with masked versions", async () => {
+        const settingsDoc = makeSettingsDoc({
+            credentials: { razorpayKeyId: "enc:rzp_live_abc123" },
+        });
+        mockDocRef.get.mockResolvedValue(makeSnap(settingsDoc, "global"));
+        const repo = makeRepo();
+        const result = await repo.getCredentialsMasked();
+        // maskSecret("rzp_live_abc123") → "rzp_***" per our mock
+        expect(result.razorpayKeyId).toBe("rzp_***");
+    });
+    it("does not expose raw or encrypted credential values", async () => {
+        const settingsDoc = makeSettingsDoc({
+            credentials: { razorpayKeyId: "enc:secret-key" },
+        });
+        mockDocRef.get.mockResolvedValue(makeSnap(settingsDoc, "global"));
+        const repo = makeRepo();
+        const result = await repo.getCredentialsMasked();
+        expect(result.razorpayKeyId).not.toContain("secret-key");
+        expect(result.razorpayKeyId).not.toContain("enc:");
+    });
+    it("empty/falsy credential value → key omitted from masked output", async () => {
+        // getDecryptedCredentials skips falsy values; getCredentialsMasked
+        // only iterates decrypted keys → empty stored credential does not appear in output
+        const settingsDoc = makeSettingsDoc({ credentials: { razorpayKeyId: "" } });
+        mockDocRef.get.mockResolvedValue(makeSnap(settingsDoc, "global"));
+        const repo = makeRepo();
+        const result = await repo.getCredentialsMasked();
+        expect(result).not.toHaveProperty("razorpayKeyId");
+    });
+});
+// ---------------------------------------------------------------------------
+// getFeatures / updateFeatures
+// ---------------------------------------------------------------------------
+describe("SiteSettingsRepository.getFeatures", () => {
+    it("returns the features array from settings", async () => {
+        const features = [{ id: "f-1", name: "Fast Checkout", description: "Quick buy", icon: "zap", enabled: true }];
+        const settingsDoc = makeSettingsDoc({ features });
+        mockDocRef.get.mockResolvedValue(makeSnap(settingsDoc, "global"));
+        const repo = makeRepo();
+        const result = await repo.getFeatures();
+        expect(result).toHaveLength(1);
+        expect(result[0].name).toBe("Fast Checkout");
+    });
+    it("returns empty array when no features stored", async () => {
+        const settingsDoc = makeSettingsDoc({ features: undefined });
+        mockDocRef.get.mockResolvedValue(makeSnap(settingsDoc, "global"));
+        const repo = makeRepo();
+        const result = await repo.getFeatures();
+        expect(result).toEqual([]);
+    });
+});
+describe("SiteSettingsRepository.updateFeatures", () => {
+    it("writes features array to Firestore", async () => {
+        const repo = makeRepo();
+        const features = [{ id: "f-1", name: "F1", description: "D1", icon: "star", enabled: true }];
+        await repo.updateFeatures(features);
+        expect(mockDocRef.update).toHaveBeenCalled();
+        const updateArg = mockDocRef.update.mock.calls[0][0];
+        expect(updateArg.features).toEqual(features);
+    });
+});
+// ---------------------------------------------------------------------------
+// exists
+// ---------------------------------------------------------------------------
+describe("SiteSettingsRepository.exists", () => {
+    it("returns true when singleton document exists", async () => {
+        mockDocRef.get.mockResolvedValue(makeSnap(makeSettingsDoc(), "global"));
+        const repo = makeRepo();
+        const result = await repo.exists();
+        expect(result).toBe(true);
+    });
+    it("returns false when document does not exist", async () => {
+        mockDocRef.get.mockResolvedValue(makeSnap(null));
+        const repo = makeRepo();
+        const result = await repo.exists();
+        expect(result).toBe(false);
+    });
+    it("returns false when Firestore throws", async () => {
+        mockDocRef.get.mockRejectedValue(new Error("Firestore unavailable"));
+        const repo = makeRepo();
+        const result = await repo.exists();
+        expect(result).toBe(false);
+    });
+});
+// ---------------------------------------------------------------------------
+// resetToDefaults
+// ---------------------------------------------------------------------------
+describe("SiteSettingsRepository.resetToDefaults", () => {
+    it("overwrites the singleton with default settings", async () => {
+        const repo = makeRepo();
+        await repo.resetToDefaults();
+        expect(mockDocRef.set).toHaveBeenCalledOnce();
+        const setArg = mockDocRef.set.mock.calls[0][0];
+        expect(setArg.id).toBe("global");
+    });
+    it("caches the reset defaults", async () => {
+        const repo = makeRepo();
+        await repo.resetToDefaults();
+        expect(mockCacheManager.set).toHaveBeenCalledWith(expect.stringContaining("site-settings"), expect.anything(), expect.objectContaining({ ttl: expect.any(Number) }));
+    });
+});

package/dist/features/auctions/repository/__tests__/bid.repository.test.d.ts

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