@mohasinac/appkit 3.0.6 → 3.1.1

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

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

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

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

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

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

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

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

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