@mohasinac/appkit 3.0.6 → 3.1.1

package/dist/features/auctions/repository/__tests__/bid.repository.test.js

@@ -0,0 +1,290 @@
+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("../../../../errors/normalize", () => ({
+    normalizeError: vi.fn(),
+}));
+vi.mock("../../../../security", () => ({
+    encryptPiiFields: (d) => d,
+    decryptPiiFields: (d) => d,
+    BID_PII_FIELDS: [],
+}));
+import { BidRepository } from "../bid.repository";
+const repo = new BidRepository();
+function makeBidDoc(overrides = {}) {
+    return {
+        id: "bid-1",
+        productId: "auction-x",
+        bidderId: "user-1",
+        userId: "user-1",
+        userName: "Ravi",
+        userEmail: "ravi@test.com",
+        bidAmount: 5000,
+        status: "active",
+        isWinning: false,
+        bidDate: new Date(),
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        ...overrides,
+    };
+}
+function makeFakeRef(id = "bid-1") {
+    return { id };
+}
+beforeEach(() => {
+    vi.clearAllMocks();
+    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(null));
+    mockDocRef.set.mockResolvedValue(undefined);
+    db.batch.mockReturnValue(mockBatch);
+    mockGetFirestoreCount.mockResolvedValue(0);
+});
+// ---------------------------------------------------------------------------
+// markWon / markLost / markOutbid / markWinning (batch helpers)
+// ---------------------------------------------------------------------------
+describe("BidRepository.markWon", () => {
+    it("stages status=won, isWinning=true in caller batch", () => {
+        const ref = makeFakeRef();
+        repo.markWon(mockBatch, ref);
+        expect(mockBatch.update).toHaveBeenCalledWith(ref, expect.objectContaining({ status: "won", isWinning: true }));
+        expect(mockBatch.commit).not.toHaveBeenCalled();
+    });
+});
+describe("BidRepository.markLost", () => {
+    it("stages status=lost, isWinning=false in caller batch", () => {
+        const ref = makeFakeRef();
+        repo.markLost(mockBatch, ref);
+        expect(mockBatch.update).toHaveBeenCalledWith(ref, expect.objectContaining({ status: "lost", isWinning: false }));
+    });
+});
+describe("BidRepository.markOutbid", () => {
+    it("stages status=outbid, isWinning=false in caller batch", () => {
+        const ref = makeFakeRef();
+        repo.markOutbid(mockBatch, ref);
+        expect(mockBatch.update).toHaveBeenCalledWith(ref, expect.objectContaining({ status: "outbid", isWinning: false }));
+    });
+});
+describe("BidRepository.markWinning", () => {
+    it("stages isWinning=true (does not change status) in caller batch", () => {
+        const ref = makeFakeRef();
+        repo.markWinning(mockBatch, ref);
+        expect(mockBatch.update).toHaveBeenCalledWith(ref, expect.objectContaining({ isWinning: true }));
+    });
+});
+// ---------------------------------------------------------------------------
+// getWinningBid
+// ---------------------------------------------------------------------------
+describe("BidRepository.getWinningBid", () => {
+    it("returns {ref, data} for the winning active bid", async () => {
+        const bid = makeBidDoc({ isWinning: true, status: "active" });
+        const snap = makeSnap(bid, bid.id);
+        mockQuery.get.mockResolvedValue({ ...makeQuerySnap([{ id: bid.id, data: bid }]), docs: [snap], empty: false });
+        const result = await repo.getWinningBid("auction-x");
+        expect(result).not.toBeNull();
+        expect(result.data).toBeDefined();
+    });
+    it("returns null when no winning bid", async () => {
+        mockQuery.get.mockResolvedValue({ ...makeQuerySnap([]), empty: true, docs: [] });
+        const result = await repo.getWinningBid("auction-x");
+        expect(result).toBeNull();
+    });
+    it("queries by isWinning=true AND status=active", async () => {
+        mockQuery.get.mockResolvedValue({ docs: [], empty: true });
+        await repo.getWinningBid("auction-x");
+        expect(mockQuery.where).toHaveBeenCalledWith("isWinning", "==", true);
+        expect(mockQuery.where).toHaveBeenCalledWith("status", "==", "active");
+    });
+});
+// ---------------------------------------------------------------------------
+// findWinningBid
+// ---------------------------------------------------------------------------
+describe("BidRepository.findWinningBid", () => {
+    it("returns BidDocument for winning bid", async () => {
+        const bid = makeBidDoc({ isWinning: true });
+        const snap = makeSnap(bid, bid.id);
+        mockQuery.get.mockResolvedValue({ docs: [snap], empty: false });
+        const result = await repo.findWinningBid("auction-x");
+        expect(result).not.toBeNull();
+    });
+    it("returns null when no winning bid", async () => {
+        mockQuery.get.mockResolvedValue({ docs: [], empty: true });
+        const result = await repo.findWinningBid("auction-x");
+        expect(result).toBeNull();
+    });
+    it("queries by isWinning=true (no status filter unlike getWinningBid)", async () => {
+        mockQuery.get.mockResolvedValue({ docs: [], empty: true });
+        await repo.findWinningBid("auction-x");
+        expect(mockQuery.where).toHaveBeenCalledWith("isWinning", "==", true);
+        // findWinningBid does NOT filter by status — that's the distinction from getWinningBid
+        const statusFilterCalls = mockQuery.where.mock.calls.filter((call) => call[0] === "status");
+        expect(statusFilterCalls).toHaveLength(0);
+    });
+});
+// ---------------------------------------------------------------------------
+// findHighestBid
+// ---------------------------------------------------------------------------
+describe("BidRepository.findHighestBid", () => {
+    it("returns highest bidAmount from active bids", async () => {
+        const bid = makeBidDoc({ bidAmount: 8000, status: "active" });
+        const snap = makeSnap(bid, bid.id);
+        mockQuery.get.mockResolvedValue({ docs: [snap], empty: false });
+        const result = await repo.findHighestBid("auction-x");
+        expect(result).toBe(8000);
+    });
+    it("returns 0 when no bids exist", async () => {
+        mockQuery.get.mockResolvedValue({ docs: [], empty: true });
+        const result = await repo.findHighestBid("auction-x");
+        expect(result).toBe(0);
+    });
+    it("queries by status=active, ordered by bidAmount desc", async () => {
+        mockQuery.get.mockResolvedValue({ docs: [], empty: true });
+        await repo.findHighestBid("auction-x");
+        expect(mockQuery.where).toHaveBeenCalledWith("status", "==", "active");
+        expect(mockQuery.orderBy).toHaveBeenCalledWith("bidAmount", "desc");
+    });
+});
+// ---------------------------------------------------------------------------
+// setWinningBid
+// ---------------------------------------------------------------------------
+describe("BidRepository.setWinningBid", () => {
+    it("sets all other bids for product to outbid", async () => {
+        const bid1 = makeBidDoc({ id: "bid-1", isWinning: false });
+        const bid2 = makeBidDoc({ id: "bid-2", isWinning: false });
+        const snap1 = makeSnap(bid1, "bid-1");
+        const snap2 = makeSnap(bid2, "bid-2");
+        mockQuery.get.mockResolvedValue({ docs: [snap1, snap2], empty: false });
+        await repo.setWinningBid("bid-1", "auction-x");
+        expect(mockBatch.update).toHaveBeenCalledWith(expect.anything(), expect.objectContaining({ status: "outbid" }));
+    });
+    it("sets the winning bid to status=active, isWinning=true", async () => {
+        const bid = makeBidDoc({ id: "bid-winner" });
+        const snap = makeSnap(bid, "bid-winner");
+        mockQuery.get.mockResolvedValue({ docs: [snap], empty: false });
+        await repo.setWinningBid("bid-winner", "auction-x");
+        // The winning bid ref is updated separately with isWinning=true
+        const updateCalls = mockBatch.update.mock.calls;
+        const winningCall = updateCalls.find((c) => c[1].isWinning === true);
+        expect(winningCall).toBeDefined();
+        expect(winningCall[1].status).toBe("active");
+    });
+    it("commits the batch", async () => {
+        mockQuery.get.mockResolvedValue({ docs: [], empty: true });
+        await repo.setWinningBid("bid-1", "auction-x");
+        expect(mockBatch.commit).toHaveBeenCalledOnce();
+    });
+});
+// ---------------------------------------------------------------------------
+// endAuction
+// ---------------------------------------------------------------------------
+describe("BidRepository.endAuction", () => {
+    it("isWinning bid → status=won", async () => {
+        const winBid = makeBidDoc({ id: "bid-win", isWinning: true });
+        const snap = makeSnap(winBid, "bid-win");
+        mockQuery.get.mockResolvedValue({ docs: [snap], empty: false });
+        await repo.endAuction("auction-x");
+        expect(mockBatch.update).toHaveBeenCalledWith(snap.ref, expect.objectContaining({ status: "won" }));
+    });
+    it("non-winning bids → status=lost", async () => {
+        const loseBid = makeBidDoc({ id: "bid-lose", isWinning: false });
+        const snap = makeSnap(loseBid, "bid-lose");
+        mockQuery.get.mockResolvedValue({ docs: [snap], empty: false });
+        await repo.endAuction("auction-x");
+        expect(mockBatch.update).toHaveBeenCalledWith(snap.ref, expect.objectContaining({ status: "lost" }));
+    });
+    it("commits the batch", async () => {
+        mockQuery.get.mockResolvedValue({ docs: [], empty: true });
+        await repo.endAuction("auction-x");
+        expect(mockBatch.commit).toHaveBeenCalledOnce();
+    });
+});
+// ---------------------------------------------------------------------------
+// cancelProductBids
+// ---------------------------------------------------------------------------
+describe("BidRepository.cancelProductBids", () => {
+    it("sets all bids to status=cancelled", async () => {
+        const bid = makeBidDoc({ id: "bid-1" });
+        const snap = makeSnap(bid, "bid-1");
+        mockQuery.get.mockResolvedValue({ docs: [snap], empty: false });
+        await repo.cancelProductBids("auction-x");
+        expect(mockBatch.update).toHaveBeenCalledWith(snap.ref, expect.objectContaining({ status: "cancelled", isWinning: false }));
+    });
+    it("commits the batch", async () => {
+        mockQuery.get.mockResolvedValue({ docs: [], empty: true });
+        await repo.cancelProductBids("auction-x");
+        expect(mockBatch.commit).toHaveBeenCalledOnce();
+    });
+});
+// ---------------------------------------------------------------------------
+// countByProduct / countByUser
+// ---------------------------------------------------------------------------
+describe("BidRepository.countByProduct", () => {
+    it("returns count from getFirestoreCount", async () => {
+        mockGetFirestoreCount.mockResolvedValue(7);
+        const count = await repo.countByProduct("auction-x");
+        expect(count).toBe(7);
+    });
+    it("queries by productId", async () => {
+        await repo.countByProduct("auction-x");
+        expect(mockCollection.where).toHaveBeenCalledWith("productId", "==", "auction-x");
+    });
+});
+describe("BidRepository.countByUser", () => {
+    it("returns count from getFirestoreCount", async () => {
+        mockGetFirestoreCount.mockResolvedValue(3);
+        const count = await repo.countByUser("user-1");
+        expect(count).toBe(3);
+    });
+    it("queries by userId", async () => {
+        await repo.countByUser("user-1");
+        expect(mockCollection.where).toHaveBeenCalledWith("userId", "==", "user-1");
+    });
+});
+// ---------------------------------------------------------------------------
+// findOneByProductAndUser
+// ---------------------------------------------------------------------------
+describe("BidRepository.findOneByProductAndUser", () => {
+    it("returns matching bid", async () => {
+        const bid = makeBidDoc({ productId: "auction-x", userId: "user-1", status: "active" });
+        const snap = makeSnap(bid, bid.id);
+        mockQuery.get.mockResolvedValue({ docs: [snap], empty: false });
+        const result = await repo.findOneByProductAndUser("auction-x", "user-1");
+        expect(result).not.toBeNull();
+    });
+    it("returns null when not found", async () => {
+        mockQuery.get.mockResolvedValue({ docs: [], empty: true });
+        const result = await repo.findOneByProductAndUser("auction-x", "user-2");
+        expect(result).toBeNull();
+    });
+    it("defaults status to 'active'", async () => {
+        mockQuery.get.mockResolvedValue({ docs: [], empty: true });
+        await repo.findOneByProductAndUser("auction-x", "user-1");
+        expect(mockQuery.where).toHaveBeenCalledWith("status", "==", "active");
+    });
+    it("queries by all three conditions: productId, userId, status", async () => {
+        mockQuery.get.mockResolvedValue({ docs: [], empty: true });
+        await repo.findOneByProductAndUser("auction-x", "user-1", "outbid");
+        expect(mockQuery.where).toHaveBeenCalledWith("productId", "==", "auction-x");
+        expect(mockQuery.where).toHaveBeenCalledWith("userId", "==", "user-1");
+        expect(mockQuery.where).toHaveBeenCalledWith("status", "==", "outbid");
+    });
+});

package/dist/features/auth/api/route.d.ts

@@ -17,6 +17,6 @@
  * export { authMeGET as GET } from "@mohasinac/feat-auth";
  * ```
  */
-export declare const authMeGET: (request: Request, context: {
+export declare const authMeGET: (request: Request, context?: {
     params: Promise<Record<string, string>>;
-}) => Promise<Response>;
+} | undefined) => Promise<Response>;

package/dist/features/auth/repository/__tests__/session.repository.test.d.ts

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

package/dist/features/auth/repository/__tests__/session.repository.test.js

@@ -0,0 +1,310 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { makeMockDb, makeSnap, makeQuerySnap } from "../../../../../tests/helpers/mock-firestore";
+const { db, mockDocRef, mockCollection, mockQuery } = makeMockDb();
+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("../../../../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(), debug: vi.fn() },
+}));
+vi.mock("../../token-helpers", () => ({
+    generateSessionId: vi.fn(() => "mock-session-id-abc123"),
+    generateToken: vi.fn(() => "mock-token-xyz"),
+    generateEmailVerificationToken: vi.fn(() => "mock-email-token"),
+    generatePasswordResetToken: vi.fn(() => "mock-pw-reset-token"),
+}));
+import { SessionRepository } from "../session.repository";
+import { SESSION_EXPIRATION_MS } from "../../schemas";
+const repo = new SessionRepository();
+function makeSessionDoc(overrides = {}) {
+    const now = new Date();
+    return {
+        id: "mock-session-id-abc123",
+        userId: "user-ravi",
+        deviceInfo: { browser: "Chrome", os: "Windows", device: "desktop", ip: "*.*.*.1" },
+        location: { country: "IN" },
+        isActive: true,
+        createdAt: now,
+        lastActivity: now,
+        expiresAt: new Date(now.getTime() + SESSION_EXPIRATION_MS),
+        ...overrides,
+    };
+}
+beforeEach(() => {
+    vi.clearAllMocks();
+    db.collection.mockReturnValue(mockCollection);
+    mockCollection.doc.mockReturnValue(mockDocRef);
+    mockCollection.where.mockReturnValue(mockQuery);
+    mockCollection.orderBy = vi.fn().mockReturnValue(mockQuery);
+    mockCollection.get = vi.fn().mockResolvedValue(makeQuerySnap([]));
+    mockQuery.where.mockReturnValue(mockQuery);
+    mockQuery.orderBy.mockReturnValue(mockQuery);
+    mockQuery.limit.mockReturnValue(mockQuery);
+    mockQuery.offset = vi.fn().mockReturnValue(mockQuery);
+    mockQuery.count = vi.fn().mockReturnValue({
+        get: vi.fn().mockResolvedValue({ data: () => ({ count: 0 }) }),
+    });
+    mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+    mockDocRef.get.mockResolvedValue(makeSnap(makeSessionDoc(), "mock-session-id-abc123"));
+    mockDocRef.set.mockResolvedValue(undefined);
+    mockDocRef.update.mockResolvedValue(undefined);
+    mockDocRef.delete.mockResolvedValue(undefined);
+});
+// ---------------------------------------------------------------------------
+// createSession
+// ---------------------------------------------------------------------------
+describe("SessionRepository.createSession", () => {
+    it("sets isActive: true on new session", async () => {
+        await repo.createSession("user-ravi", {
+            deviceInfo: { browser: "Chrome", os: "Windows", device: "desktop", ip: "*.*.*.1" },
+            location: { country: "IN" },
+        });
+        const setArg = mockDocRef.set.mock.calls[0][0];
+        expect(setArg.isActive).toBe(true);
+    });
+    it("sets expiresAt = now + SESSION_EXPIRATION_MS", async () => {
+        const before = Date.now();
+        await repo.createSession("user-ravi", {
+            deviceInfo: { browser: "Chrome", os: "Windows", device: "desktop", ip: "*.*.*.1" },
+            location: { country: "IN" },
+        });
+        const setArg = mockDocRef.set.mock.calls[0][0];
+        const expiresAt = setArg.expiresAt.getTime();
+        const expectedExpiry = before + SESSION_EXPIRATION_MS;
+        expect(expiresAt).toBeGreaterThanOrEqual(expectedExpiry - 100);
+        expect(expiresAt).toBeLessThanOrEqual(expectedExpiry + 1000);
+    });
+    it("stores deviceInfo in the session document", async () => {
+        await repo.createSession("user-ravi", {
+            deviceInfo: { browser: "Safari", os: "iOS", device: "mobile", ip: "*.*.*.2" },
+            location: { country: "IN" },
+        });
+        const setArg = mockDocRef.set.mock.calls[0][0];
+        expect(setArg.deviceInfo.browser).toBe("Safari");
+    });
+    it("uses generated sessionId as document ID", async () => {
+        await repo.createSession("user-ravi", {
+            deviceInfo: { browser: "Chrome", os: "Windows", device: "desktop", ip: "*.*.*.1" },
+            location: { country: "IN" },
+        });
+        expect(mockCollection.doc).toHaveBeenCalledWith("mock-session-id-abc123");
+    });
+    it("stores the userId in the session", async () => {
+        await repo.createSession("user-ravi", {
+            deviceInfo: { browser: "Chrome", os: "Windows", device: "desktop", ip: "*.*.*.1" },
+            location: { country: "IN" },
+        });
+        const setArg = mockDocRef.set.mock.calls[0][0];
+        expect(setArg.userId).toBe("user-ravi");
+    });
+});
+// ---------------------------------------------------------------------------
+// updateActivity
+// ---------------------------------------------------------------------------
+describe("SessionRepository.updateActivity", () => {
+    it("updates lastActivity to current time", async () => {
+        const session = makeSessionDoc();
+        mockDocRef.get.mockResolvedValue(makeSnap(session, "mock-session-id-abc123"));
+        await repo.updateActivity("mock-session-id-abc123");
+        const updateArg = mockDocRef.update.mock.calls[0][0];
+        expect(updateArg.lastActivity).toBeInstanceOf(Date);
+    });
+    it("does NOT throw on NOT_FOUND error (session may have been revoked)", async () => {
+        const notFoundErr = Object.assign(new Error("NOT_FOUND"), { code: 5 });
+        mockDocRef.update.mockRejectedValue(notFoundErr);
+        // update calls super.update which calls docRef.update
+        await expect(repo.updateActivity("revoked-session")).resolves.toBeUndefined();
+    });
+    it("does NOT throw on 'No document to update' error", async () => {
+        const err = new Error("No document to update");
+        mockDocRef.update.mockRejectedValue(err);
+        await expect(repo.updateActivity("deleted-session")).resolves.toBeUndefined();
+    });
+    it("DOES re-throw errors that are not NOT_FOUND", async () => {
+        const permErr = Object.assign(new Error("Permission denied"), { code: 7 });
+        mockDocRef.update.mockRejectedValue(permErr);
+        // BaseRepository.update() wraps in DatabaseError, so the thrown error has DATABASE_ERROR message
+        await expect(repo.updateActivity("session-id")).rejects.toThrow("Failed to update document: session-id");
+    });
+});
+// ---------------------------------------------------------------------------
+// revokeSession
+// ---------------------------------------------------------------------------
+describe("SessionRepository.revokeSession", () => {
+    it("sets isActive: false on the session", async () => {
+        const session = makeSessionDoc();
+        mockDocRef.get.mockResolvedValue(makeSnap(session, "mock-session-id-abc123"));
+        await repo.revokeSession("mock-session-id-abc123", "admin");
+        const updateArg = mockDocRef.update.mock.calls[0][0];
+        expect(updateArg.isActive).toBe(false);
+    });
+    it("stores revokedAt timestamp", async () => {
+        const session = makeSessionDoc();
+        mockDocRef.get.mockResolvedValue(makeSnap(session, "mock-session-id-abc123"));
+        await repo.revokeSession("mock-session-id-abc123", "admin");
+        const updateArg = mockDocRef.update.mock.calls[0][0];
+        expect(updateArg.revokedAt).toBeInstanceOf(Date);
+    });
+    it("stores revokedBy actor", async () => {
+        const session = makeSessionDoc();
+        mockDocRef.get.mockResolvedValue(makeSnap(session, "mock-session-id-abc123"));
+        await repo.revokeSession("mock-session-id-abc123", "user-admin");
+        const updateArg = mockDocRef.update.mock.calls[0][0];
+        expect(updateArg.revokedBy).toBe("user-admin");
+    });
+});
+// ---------------------------------------------------------------------------
+// revokeAllUserSessions
+// ---------------------------------------------------------------------------
+describe("SessionRepository.revokeAllUserSessions", () => {
+    it("revokes all active sessions for the user", async () => {
+        const sessions = [makeSessionDoc({ id: "s-1" }), makeSessionDoc({ id: "s-2" })];
+        // findActiveByUser uses a multi-where + orderBy + get chain
+        mockQuery.get.mockResolvedValue(makeQuerySnap(sessions.map((s) => ({ id: s.id, data: s }))));
+        mockDocRef.get.mockResolvedValue(makeSnap(makeSessionDoc(), "s-1"));
+        const count = await repo.revokeAllUserSessions("user-ravi", "admin");
+        expect(count).toBe(2);
+        expect(mockDocRef.update).toHaveBeenCalledTimes(2);
+    });
+    it("returns 0 when user has no active sessions", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        const count = await repo.revokeAllUserSessions("user-no-sessions", "admin");
+        expect(count).toBe(0);
+        expect(mockDocRef.update).not.toHaveBeenCalled();
+    });
+});
+// ---------------------------------------------------------------------------
+// findActiveByUser
+// ---------------------------------------------------------------------------
+describe("SessionRepository.findActiveByUser", () => {
+    it("queries userId, isActive==true, and expiresAt > now", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        await repo.findActiveByUser("user-ravi");
+        expect(mockCollection.where).toHaveBeenCalledWith("userId", "==", "user-ravi");
+        expect(mockQuery.where).toHaveBeenCalledWith("isActive", "==", true);
+        expect(mockQuery.where).toHaveBeenCalledWith("expiresAt", ">", expect.any(Date));
+    });
+    it("returns only active sessions for the given user", async () => {
+        const session = makeSessionDoc({ isActive: true });
+        mockQuery.get.mockResolvedValue(makeQuerySnap([{ id: session.id, data: session }]));
+        const results = await repo.findActiveByUser("user-ravi");
+        expect(results).toHaveLength(1);
+        expect(results[0].userId).toBe("user-ravi");
+    });
+    it("orders by expiresAt desc", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        await repo.findActiveByUser("user-ravi");
+        expect(mockQuery.orderBy).toHaveBeenCalledWith("expiresAt", "desc");
+    });
+});
+// ---------------------------------------------------------------------------
+// cleanupExpiredSessions
+// ---------------------------------------------------------------------------
+describe("SessionRepository.cleanupExpiredSessions", () => {
+    it("queries sessions where expiresAt <= now", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        await repo.cleanupExpiredSessions();
+        expect(mockCollection.where).toHaveBeenCalledWith("expiresAt", "<=", expect.any(Date));
+    });
+    it("deletes each expired session and returns count", async () => {
+        const expired = [
+            makeSessionDoc({ id: "s-expired-1", isActive: false }),
+            makeSessionDoc({ id: "s-expired-2", isActive: false }),
+        ];
+        mockQuery.get.mockResolvedValue(makeQuerySnap(expired.map((s) => ({ id: s.id, data: s }))));
+        const count = await repo.cleanupExpiredSessions();
+        expect(count).toBe(2);
+        expect(mockDocRef.delete).toHaveBeenCalledTimes(2);
+    });
+    it("returns 0 and deletes nothing when no expired sessions", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        const count = await repo.cleanupExpiredSessions();
+        expect(count).toBe(0);
+        expect(mockDocRef.delete).not.toHaveBeenCalled();
+    });
+    it("limits to 500 documents per cleanup run", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        await repo.cleanupExpiredSessions();
+        expect(mockQuery.limit).toHaveBeenCalledWith(500);
+    });
+});
+// ---------------------------------------------------------------------------
+// countActiveByUser
+// ---------------------------------------------------------------------------
+describe("SessionRepository.countActiveByUser", () => {
+    it("returns count of active sessions for user", async () => {
+        const sessions = [makeSessionDoc(), makeSessionDoc({ id: "s-2" })];
+        mockQuery.get.mockResolvedValue(makeQuerySnap(sessions.map((s) => ({ id: s.id, data: s }))));
+        const count = await repo.countActiveByUser("user-ravi");
+        expect(count).toBe(2);
+    });
+    it("returns 0 when user has no active sessions", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        const count = await repo.countActiveByUser("user-no-sessions");
+        expect(count).toBe(0);
+    });
+});
+// ---------------------------------------------------------------------------
+// findActiveSession
+// ---------------------------------------------------------------------------
+describe("SessionRepository.findActiveSession", () => {
+    it("returns session when it is active and not expired", async () => {
+        const session = makeSessionDoc({ isActive: true, expiresAt: new Date(Date.now() + 60000) });
+        mockDocRef.get.mockResolvedValue(makeSnap(session, "mock-session-id-abc123"));
+        const result = await repo.findActiveSession("mock-session-id-abc123");
+        expect(result).not.toBeNull();
+        expect(result?.userId).toBe("user-ravi");
+    });
+    it("returns null when session is isActive: false", async () => {
+        const session = makeSessionDoc({ isActive: false });
+        mockDocRef.get.mockResolvedValue(makeSnap(session, "s-revoked"));
+        const result = await repo.findActiveSession("s-revoked");
+        expect(result).toBeNull();
+    });
+    it("returns null when session is expired (expiresAt in past)", async () => {
+        const session = makeSessionDoc({ isActive: true, expiresAt: new Date(Date.now() - 1000) });
+        mockDocRef.get.mockResolvedValue(makeSnap(session, "s-expired"));
+        const result = await repo.findActiveSession("s-expired");
+        expect(result).toBeNull();
+    });
+    it("returns null when session does not exist", async () => {
+        mockDocRef.get.mockResolvedValue(makeSnap(null));
+        const result = await repo.findActiveSession("nonexistent");
+        expect(result).toBeNull();
+    });
+});
+// ---------------------------------------------------------------------------
+// getExpiredRefs
+// ---------------------------------------------------------------------------
+describe("SessionRepository.getExpiredRefs", () => {
+    it("queries sessions where expiresAt < now", async () => {
+        const now = new Date();
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        await repo.getExpiredRefs(now);
+        expect(mockCollection.where).toHaveBeenCalledWith("expiresAt", "<", now);
+    });
+    it("limits to 500 documents", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        await repo.getExpiredRefs(new Date());
+        expect(mockQuery.limit).toHaveBeenCalledWith(500);
+    });
+    it("returns document refs from the matching sessions", async () => {
+        const session = makeSessionDoc({ id: "s-expired" });
+        mockQuery.get.mockResolvedValue(makeQuerySnap([{ id: "s-expired", data: session }]));
+        const refs = await repo.getExpiredRefs(new Date());
+        expect(refs).toHaveLength(1);
+    });
+});

package/dist/features/auth/repository/__tests__/session.test.d.ts

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