@mohasinac/appkit 3.8.2 → 3.9.0

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

@@ -1,356 +0,0 @@
-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

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

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

@@ -1,298 +0,0 @@
-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

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