@mohasinac/appkit 3.8.2 → 3.9.1

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

@@ -1,290 +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("../../../../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/auctions/repository/auctions.repository.d.ts

@@ -1,12 +0,0 @@
-import type { IRepository, PagedResult, SieveQuery } from "../../../contracts";
-import type { AuctionItem } from "../types";
-export declare class AuctionsRepository {
-    private readonly repo;
-    constructor(repo: IRepository<AuctionItem>);
-    findAll(query?: SieveQuery): Promise<PagedResult<AuctionItem>>;
-    findById(id: string): Promise<AuctionItem | null>;
-    findBySlug(slug: string): Promise<AuctionItem | null>;
-    findActive(page?: number, perPage?: number): Promise<PagedResult<AuctionItem>>;
-    findByStore(storeSlug: string, page?: number, perPage?: number): Promise<PagedResult<AuctionItem>>;
-    findFeatured(limit?: number): Promise<AuctionItem[]>;
-}

package/dist/features/auctions/repository/auctions.repository.js

@@ -1,42 +0,0 @@
-export class AuctionsRepository {
-    constructor(repo) {
-        this.repo = repo;
-    }
-    async findAll(query) {
-        return this.repo.findAll(query ?? {});
-    }
-    async findById(id) {
-        return this.repo.findById(id);
-    }
-    async findBySlug(slug) {
-        const result = await this.repo.findAll({
-            filters: `slug==${slug},status==published,listingType==auction`,
-            perPage: 1,
-        });
-        return result.data[0] ?? null;
-    }
-    async findActive(page = 1, perPage = 20) {
-        return this.repo.findAll({
-            filters: "status==published,listingType==auction",
-            sort: "auctionEndDate",
-            page,
-            perPage,
-        });
-    }
-    async findByStore(storeSlug, page = 1, perPage = 20) {
-        return this.repo.findAll({
-            filters: `storeSlug==${storeSlug},status==published,listingType==auction`,
-            sort: "auctionEndDate",
-            page,
-            perPage,
-        });
-    }
-    async findFeatured(limit = 6) {
-        const result = await this.repo.findAll({
-            filters: "status==published,listingType==auction,featured==true",
-            sort: "auctionEndDate",
-            perPage: limit,
-        });
-        return result.data;
-    }
-}

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

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

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

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

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