@mohasinac/appkit 3.8.1 → 3.9.0

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

@@ -1,146 +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", () => ({
-    getAdminDb: () => db,
-    BaseRepository: class {
-        get db() { return db; }
-        constructor(col) { this.collection = col; }
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        getCollection() { return db.collection(this.collection); }
-        mapDoc(snap) {
-            return { id: snap.id, ...snap.data() };
-        }
-        async findById(id) {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const snap = await db.collection(this.collection).doc(id).get();
-            return snap.exists ? { id: snap.id, ...snap.data() } : null;
-        }
-        async update(id, data) {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            return db.collection(this.collection).doc(id).update(data);
-        }
-        async delete(id) {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            return db.collection(this.collection).doc(id).delete();
-        }
-        async createWithId(id, data) {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            await db.collection(this.collection).doc(id).set(data);
-            return { id, ...data };
-        }
-    },
-}));
-vi.mock("../../../../monitoring", () => ({
-    serverLogger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
-}));
-vi.mock("../token-helpers", () => ({
-    generateSessionId: () => "session-id-abc123",
-}));
-vi.mock("../../../../errors/normalize", () => ({
-    normalizeError: vi.fn(),
-}));
-import { SessionRepository } from "../session.repository";
-import { SESSION_EXPIRATION_MS } from "../../schemas";
-const repo = new SessionRepository();
-beforeEach(() => {
-    vi.clearAllMocks();
-    mockQuery.get.mockResolvedValue(makeQuerySnap([]));
-    mockDocRef.get.mockResolvedValue(makeSnap(null));
-    mockDocRef.set.mockResolvedValue(undefined);
-    mockDocRef.update.mockResolvedValue(undefined);
-    mockDocRef.delete.mockResolvedValue(undefined);
-    mockCollection.doc.mockReturnValue(mockDocRef);
-    db.collection.mockReturnValue(mockCollection);
-});
-describe("SessionRepository.createSession", () => {
-    it("sets isActive: true", async () => {
-        await repo.createSession("user-1", {
-            deviceInfo: { browser: "Chrome", os: "Windows", device: "Desktop", ip: "127.0.0.1" },
-            location: { country: "IN" },
-        });
-        expect(mockDocRef.set).toHaveBeenCalledWith(expect.objectContaining({ isActive: true }));
-    });
-    it("expiresAt is now + SESSION_EXPIRATION_MS (within 1s tolerance)", async () => {
-        const before = Date.now();
-        await repo.createSession("user-1", {
-            deviceInfo: { browser: "Chrome", os: "Windows", device: "Desktop", ip: "127.0.0.1" },
-            location: { country: "IN" },
-        });
-        const after = Date.now();
-        const setCall = mockDocRef.set.mock.calls[0][0];
-        const expiresAt = setCall.expiresAt.getTime();
-        expect(expiresAt).toBeGreaterThanOrEqual(before + SESSION_EXPIRATION_MS - 1000);
-        expect(expiresAt).toBeLessThanOrEqual(after + SESSION_EXPIRATION_MS + 1000);
-    });
-    it("stores deviceInfo from input", async () => {
-        await repo.createSession("user-1", {
-            deviceInfo: { browser: "Firefox", os: "macOS", device: "Desktop", ip: "10.0.0.1" },
-            location: { country: "US" },
-        });
-        expect(mockDocRef.set).toHaveBeenCalledWith(expect.objectContaining({ deviceInfo: { browser: "Firefox", os: "macOS", device: "Desktop", ip: "10.0.0.1" } }));
-    });
-});
-describe("SessionRepository.updateActivity", () => {
-    it("updates lastActivity timestamp", async () => {
-        mockDocRef.update.mockResolvedValue(undefined);
-        await repo.updateActivity("session-id");
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ lastActivity: expect.any(Date) }));
-    });
-    it("does NOT throw when Firestore NOT_FOUND (swallowed)", async () => {
-        mockDocRef.update.mockRejectedValue({ code: 5, message: "NOT_FOUND" });
-        await expect(repo.updateActivity("session-id")).resolves.toBeUndefined();
-    });
-});
-describe("SessionRepository.revokeSession", () => {
-    it("sets isActive: false on the targeted session", async () => {
-        await repo.revokeSession("session-id", "admin-uid");
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ isActive: false }));
-    });
-});
-describe("SessionRepository.findActiveByUser", () => {
-    it("queries where isActive == true for the given userId", async () => {
-        const sessions = makeQuerySnap([
-            { id: "s1", data: { userId: "user-1", isActive: true, expiresAt: new Date(Date.now() + 60000), lastActivity: new Date() } },
-        ]);
-        mockQuery.get.mockResolvedValue(sessions);
-        const result = await repo.findActiveByUser("user-1");
-        expect(result).toHaveLength(1);
-        // Verify isActive and userId filters are used
-        expect(mockCollection.where).toHaveBeenCalledWith("userId", "==", "user-1");
-        expect(mockQuery.where).toHaveBeenCalledWith("isActive", "==", true);
-    });
-    it("returns empty array when user has no active sessions", async () => {
-        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
-        const result = await repo.findActiveByUser("user-1");
-        expect(result).toEqual([]);
-    });
-});
-describe("SessionRepository.cleanupExpiredSessions", () => {
-    it("deletes documents returned by expired query, returns count", async () => {
-        const expiredDocs = makeQuerySnap([
-            { id: "s-expired-1", data: { userId: "u", isActive: true } },
-            { id: "s-expired-2", data: { userId: "u", isActive: false } },
-        ]);
-        mockQuery.get.mockResolvedValue(expiredDocs);
-        const count = await repo.cleanupExpiredSessions();
-        expect(count).toBe(2);
-    });
-    it("does not delete non-expired sessions", async () => {
-        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
-        const count = await repo.cleanupExpiredSessions();
-        expect(count).toBe(0);
-        expect(mockDocRef.delete).not.toHaveBeenCalled();
-    });
-});
-describe("SessionRepository.countActiveByUser", () => {
-    it("returns the count of active sessions", async () => {
-        const sessions = makeQuerySnap([
-            { id: "s1", data: { userId: "user-1", isActive: true, expiresAt: new Date(Date.now() + 60000), lastActivity: new Date() } },
-            { id: "s2", data: { userId: "user-1", isActive: true, expiresAt: new Date(Date.now() + 60000), lastActivity: new Date() } },
-        ]);
-        mockQuery.get.mockResolvedValue(sessions);
-        const count = await repo.countActiveByUser("user-1");
-        expect(count).toBe(2);
-    });
-});

package/dist/features/auth/repository/__tests__/sms-counter.repository.test.d.ts

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

package/dist/features/auth/repository/__tests__/sms-counter.repository.test.js

@@ -1,171 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { makeMockDb, makeSnap } from "../../../../../tests/helpers/mock-firestore";
-const { db, mockDocRef, mockCollection, mockTxn } = 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() },
-}));
-import { SmsCounterRepository } from "../sms-counter.repository";
-import { SMS_DAILY_LIMIT } from "../../schemas";
-const repo = new SmsCounterRepository();
-beforeEach(() => {
-    vi.clearAllMocks();
-    db.collection.mockReturnValue(mockCollection);
-    mockCollection.doc.mockReturnValue(mockDocRef);
-    mockTxn.get.mockResolvedValue(makeSnap(null));
-    mockTxn.set.mockReturnValue(undefined);
-    mockTxn.update.mockReturnValue(undefined);
-    db.runTransaction.mockImplementation(async (cb) => cb(mockTxn));
-});
-// ---------------------------------------------------------------------------
-// checkAndIncrement
-// ---------------------------------------------------------------------------
-describe("SmsCounterRepository.checkAndIncrement", () => {
-    it("first call of the day (no doc) → returns { allowed: true, count: 1 }", async () => {
-        mockTxn.get.mockResolvedValue(makeSnap(null));
-        const result = await repo.checkAndIncrement("2026-06-27");
-        expect(result.allowed).toBe(true);
-        expect(result.count).toBe(1);
-    });
-    it("uses Firestore transaction (runTransaction called)", async () => {
-        mockTxn.get.mockResolvedValue(makeSnap(null));
-        await repo.checkAndIncrement("2026-06-27");
-        expect(db.runTransaction).toHaveBeenCalledOnce();
-    });
-    it("increments existing count by 1", async () => {
-        mockTxn.get.mockResolvedValue(makeSnap({ count: 4 }));
-        const result = await repo.checkAndIncrement("2026-06-27");
-        expect(result.count).toBe(5);
-        expect(result.allowed).toBe(true);
-    });
-    it("count at SMS_DAILY_LIMIT - 1 → increments to limit, returns allowed: true", async () => {
-        mockTxn.get.mockResolvedValue(makeSnap({ count: SMS_DAILY_LIMIT - 1 }));
-        const result = await repo.checkAndIncrement("2026-06-27");
-        expect(result.allowed).toBe(true);
-        expect(result.count).toBe(SMS_DAILY_LIMIT);
-    });
-    it("count at SMS_DAILY_LIMIT → returns { allowed: false, count: limit }", async () => {
-        mockTxn.get.mockResolvedValue(makeSnap({ count: SMS_DAILY_LIMIT }));
-        const result = await repo.checkAndIncrement("2026-06-27");
-        expect(result.allowed).toBe(false);
-        expect(result.count).toBe(SMS_DAILY_LIMIT);
-    });
-    it("count exceeds SMS_DAILY_LIMIT → still returns { allowed: false }", async () => {
-        mockTxn.get.mockResolvedValue(makeSnap({ count: SMS_DAILY_LIMIT + 5 }));
-        const result = await repo.checkAndIncrement("2026-06-27");
-        expect(result.allowed).toBe(false);
-    });
-    it("when allowed, calls tx.set with incremented count", async () => {
-        mockTxn.get.mockResolvedValue(makeSnap({ count: 2 }));
-        await repo.checkAndIncrement("2026-06-27");
-        expect(mockTxn.set).toHaveBeenCalledWith(expect.anything(), expect.objectContaining({ count: 3 }), { merge: true });
-    });
-    it("when NOT allowed, does NOT call tx.set", async () => {
-        mockTxn.get.mockResolvedValue(makeSnap({ count: SMS_DAILY_LIMIT }));
-        await repo.checkAndIncrement("2026-06-27");
-        expect(mockTxn.set).not.toHaveBeenCalled();
-    });
-    it("uses dateStr as the document ID (one doc per date)", async () => {
-        mockTxn.get.mockResolvedValue(makeSnap(null));
-        await repo.checkAndIncrement("2026-06-27");
-        expect(mockCollection.doc).toHaveBeenCalledWith("2026-06-27");
-    });
-    it("stores updatedAt timestamp in the tx.set payload", async () => {
-        mockTxn.get.mockResolvedValue(makeSnap(null));
-        await repo.checkAndIncrement("2026-06-27");
-        const setArg = mockTxn.set.mock.calls[0][1];
-        expect(setArg).toHaveProperty("updatedAt");
-    });
-});
-// ---------------------------------------------------------------------------
-// getCount
-// ---------------------------------------------------------------------------
-describe("SmsCounterRepository.getCount", () => {
-    it("returns 0 when no document exists for the date", async () => {
-        mockDocRef.get.mockResolvedValue(makeSnap(null));
-        const count = await repo.getCount("2026-06-27");
-        expect(count).toBe(0);
-    });
-    it("returns the stored count", async () => {
-        mockDocRef.get.mockResolvedValue(makeSnap({ count: 7 }));
-        const count = await repo.getCount("2026-06-27");
-        expect(count).toBe(7);
-    });
-    it("returns 0 if document exists but count field is missing", async () => {
-        mockDocRef.get.mockResolvedValue(makeSnap({}));
-        const count = await repo.getCount("2026-06-27");
-        expect(count).toBe(0);
-    });
-});
-// ---------------------------------------------------------------------------
-// checkAndSetUserCooldown
-// ---------------------------------------------------------------------------
-describe("SmsCounterRepository.checkAndSetUserCooldown", () => {
-    it("first call (no existing cooldown doc) → returns { allowed: true }", async () => {
-        mockTxn.get.mockResolvedValue(makeSnap(null));
-        const result = await repo.checkAndSetUserCooldown("user-ravi");
-        expect(result.allowed).toBe(true);
-        expect(result.retryAfterSeconds).toBe(0);
-    });
-    it("uses Firestore transaction", async () => {
-        mockTxn.get.mockResolvedValue(makeSnap(null));
-        await repo.checkAndSetUserCooldown("user-ravi");
-        expect(db.runTransaction).toHaveBeenCalledOnce();
-    });
-    it("cooldown expired (last request >15 min ago) → returns { allowed: true }", async () => {
-        const sixteenMinutesAgo = new Date(Date.now() - 16 * 60 * 1000);
-        mockTxn.get.mockResolvedValue(makeSnap({ lastRequestedAt: { toDate: () => sixteenMinutesAgo } }));
-        const result = await repo.checkAndSetUserCooldown("user-ravi");
-        expect(result.allowed).toBe(true);
-        expect(result.retryAfterSeconds).toBe(0);
-    });
-    it("within 15 min cooldown → returns { allowed: false, retryAfterSeconds > 0 }", async () => {
-        const twoMinutesAgo = new Date(Date.now() - 2 * 60 * 1000);
-        mockTxn.get.mockResolvedValue(makeSnap({ lastRequestedAt: { toDate: () => twoMinutesAgo } }));
-        const result = await repo.checkAndSetUserCooldown("user-ravi");
-        expect(result.allowed).toBe(false);
-        expect(result.retryAfterSeconds).toBeGreaterThan(0);
-        // 15 min - 2 min = 13 min = 780s (±1s tolerance)
-        expect(result.retryAfterSeconds).toBeGreaterThanOrEqual(778);
-        expect(result.retryAfterSeconds).toBeLessThanOrEqual(780);
-    });
-    it("just within cooldown (1 second in) → retryAfterSeconds ≈ 899", async () => {
-        const oneSecondAgo = new Date(Date.now() - 1000);
-        mockTxn.get.mockResolvedValue(makeSnap({ lastRequestedAt: { toDate: () => oneSecondAgo } }));
-        const result = await repo.checkAndSetUserCooldown("user-ravi");
-        expect(result.allowed).toBe(false);
-        expect(result.retryAfterSeconds).toBeGreaterThanOrEqual(898);
-        expect(result.retryAfterSeconds).toBeLessThanOrEqual(900);
-    });
-    it("document ID is user_cooldown_{userId}", async () => {
-        mockTxn.get.mockResolvedValue(makeSnap(null));
-        await repo.checkAndSetUserCooldown("user-ravi");
-        expect(mockCollection.doc).toHaveBeenCalledWith("user_cooldown_user-ravi");
-    });
-    it("when allowed, calls tx.set with lastRequestedAt timestamp", async () => {
-        mockTxn.get.mockResolvedValue(makeSnap(null));
-        await repo.checkAndSetUserCooldown("user-ravi");
-        expect(mockTxn.set).toHaveBeenCalledWith(expect.anything(), expect.objectContaining({ lastRequestedAt: expect.any(Date) }), { merge: true });
-    });
-    it("when NOT allowed, does NOT call tx.set", async () => {
-        const twoMinutesAgo = new Date(Date.now() - 2 * 60 * 1000);
-        mockTxn.get.mockResolvedValue(makeSnap({ lastRequestedAt: { toDate: () => twoMinutesAgo } }));
-        await repo.checkAndSetUserCooldown("user-ravi");
-        expect(mockTxn.set).not.toHaveBeenCalled();
-    });
-});

package/dist/features/auth/repository/__tests__/sms-counter.test.d.ts

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

package/dist/features/auth/repository/__tests__/sms-counter.test.js

@@ -1,88 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { makeMockDb, makeSnap } from "../../../../../tests/helpers/mock-firestore";
-const { db, mockTxn } = makeMockDb();
-vi.mock("../../../../providers/db-firebase", () => ({
-    getAdminDb: () => db,
-    BaseRepository: class {
-        get db() { return db; }
-        constructor(col) { this.collection = col; }
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        getCollection() { return db.collection(this.collection); }
-    },
-}));
-vi.mock("../../../../monitoring", () => ({
-    serverLogger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
-}));
-import { SmsCounterRepository } from "../sms-counter.repository";
-import { SMS_DAILY_LIMIT } from "../../schemas";
-const repo = new SmsCounterRepository();
-beforeEach(() => {
-    vi.clearAllMocks();
-    db.runTransaction.mockImplementation(async (fn) => fn(mockTxn));
-    mockTxn.set.mockReturnValue(undefined);
-});
-describe("SmsCounterRepository.checkAndIncrement", () => {
-    it("first call of the day → count becomes 1, allowed: true", async () => {
-        mockTxn.get.mockResolvedValue(makeSnap(null));
-        const result = await repo.checkAndIncrement("2026-01-01");
-        expect(result.allowed).toBe(true);
-        expect(result.count).toBe(1);
-    });
-    it("count at LIMIT - 1 → increments, allowed: true", async () => {
-        mockTxn.get.mockResolvedValue(makeSnap({ count: SMS_DAILY_LIMIT - 1, date: "2026-01-01", updatedAt: new Date() }));
-        const result = await repo.checkAndIncrement("2026-01-01");
-        expect(result.allowed).toBe(true);
-        expect(result.count).toBe(SMS_DAILY_LIMIT);
-    });
-    it("count at LIMIT → not allowed, count unchanged", async () => {
-        mockTxn.get.mockResolvedValue(makeSnap({ count: SMS_DAILY_LIMIT, date: "2026-01-01", updatedAt: new Date() }));
-        const result = await repo.checkAndIncrement("2026-01-01");
-        expect(result.allowed).toBe(false);
-        expect(result.count).toBe(SMS_DAILY_LIMIT);
-        expect(mockTxn.set).not.toHaveBeenCalled();
-    });
-    it("uses Firestore transaction (runTransaction called)", async () => {
-        mockTxn.get.mockResolvedValue(makeSnap(null));
-        await repo.checkAndIncrement("2026-01-01");
-        expect(db.runTransaction).toHaveBeenCalledOnce();
-    });
-    it("next UTC day uses different doc ID → starts at 1", async () => {
-        mockTxn.get.mockResolvedValue(makeSnap(null));
-        const result = await repo.checkAndIncrement("2026-01-02");
-        expect(result.allowed).toBe(true);
-        expect(result.count).toBe(1);
-    });
-});
-describe("SmsCounterRepository.checkAndSetUserCooldown", () => {
-    it("first call → allowed: true, sets cooldown doc", async () => {
-        mockTxn.get.mockResolvedValue(makeSnap(null));
-        const result = await repo.checkAndSetUserCooldown("user-1");
-        expect(result.allowed).toBe(true);
-        expect(result.retryAfterSeconds).toBe(0);
-        expect(mockTxn.set).toHaveBeenCalledOnce();
-    });
-    it("called within 15 minutes → allowed: false with retryAfterSeconds", async () => {
-        const recentlyRequested = new Date(Date.now() - 5 * 60 * 1000); // 5 min ago
-        mockTxn.get.mockResolvedValue(makeSnap({
-            lastRequestedAt: { toDate: () => recentlyRequested },
-        }));
-        const result = await repo.checkAndSetUserCooldown("user-1");
-        expect(result.allowed).toBe(false);
-        expect(result.retryAfterSeconds).toBeGreaterThan(0);
-        expect(result.retryAfterSeconds).toBeLessThanOrEqual(10 * 60); // ~10 min remaining
-    });
-    it("called after 15 minutes → allowed: true", async () => {
-        const old = new Date(Date.now() - 20 * 60 * 1000); // 20 min ago
-        mockTxn.get.mockResolvedValue(makeSnap({
-            lastRequestedAt: { toDate: () => old },
-        }));
-        const result = await repo.checkAndSetUserCooldown("user-1");
-        expect(result.allowed).toBe(true);
-        expect(mockTxn.set).toHaveBeenCalledOnce();
-    });
-    it("uses Firestore transaction", async () => {
-        mockTxn.get.mockResolvedValue(makeSnap(null));
-        await repo.checkAndSetUserCooldown("user-1");
-        expect(db.runTransaction).toHaveBeenCalledOnce();
-    });
-});

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

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