@mohasinac/appkit 3.8.2 → 3.9.0

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

@@ -1,260 +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();
-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("../../../../security", () => ({
-    encryptPiiFields: (d) => d,
-    decryptPiiFields: (d) => d,
-    addPiiIndices: (d) => d,
-    piiBlindIndex: (v) => `blind:${v}`,
-    encryptPayoutDetails: (d) => d,
-    decryptPayoutDetails: (d) => d,
-    encryptShippingConfig: (d) => d,
-    decryptShippingConfig: (d) => d,
-    USER_PII_FIELDS: [],
-    TOKEN_PII_FIELDS: [],
-    TOKEN_PII_INDEX_MAP: {},
-}));
-vi.mock("../../../../utils", async (importOriginal) => {
-    const actual = await importOriginal();
-    return { ...actual, resolveDate: (d) => (d instanceof Date ? d : d ? new Date(d) : null) };
-});
-vi.mock("../../../../errors/normalize", () => ({ normalizeError: vi.fn() }));
-vi.mock("../../../../monitoring", () => ({
-    serverLogger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
-}));
-import { EmailVerificationTokenRepository, PasswordResetTokenRepository, } from "../token.repository";
-const emailRepo = new EmailVerificationTokenRepository();
-const passwordRepo = new PasswordResetTokenRepository();
-function makeEmailToken(overrides = {}) {
-    return {
-        id: "token-email-abc123",
-        userId: "user-ravi",
-        token: "secure-random-token",
-        email: "ravi@example.com",
-        expiresAt: new Date(Date.now() + 60 * 60 * 1000), // 1 hour from now
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        ...overrides,
-    };
-}
-function makePasswordResetToken(overrides = {}) {
-    return {
-        id: "pw-token-abc123",
-        userId: "user-ravi",
-        token: "pw-reset-token",
-        email: "ravi@example.com",
-        expiresAt: new Date(Date.now() + 30 * 60 * 1000), // 30 min from now
-        used: false,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        ...overrides,
-    };
-}
-beforeEach(() => {
-    vi.clearAllMocks();
-    db.collection.mockReturnValue(mockCollection);
-    mockCollection.doc.mockReturnValue(mockDocRef);
-    mockCollection.where.mockReturnValue(mockQuery);
-    mockCollection.get = vi.fn().mockResolvedValue(makeQuerySnap([]));
-    mockQuery.where.mockReturnValue(mockQuery);
-    mockQuery.orderBy.mockReturnValue(mockQuery);
-    mockQuery.limit.mockReturnValue(mockQuery);
-    mockQuery.get.mockResolvedValue(makeQuerySnap([]));
-    mockDocRef.get.mockResolvedValue(makeSnap(makeEmailToken(), "token-email-abc123"));
-    mockDocRef.set.mockResolvedValue(undefined);
-    mockDocRef.update.mockResolvedValue(undefined);
-    mockDocRef.delete.mockResolvedValue(undefined);
-    db.batch.mockReturnValue(mockBatch);
-});
-// ---------------------------------------------------------------------------
-// EmailVerificationTokenRepository.findByToken
-// ---------------------------------------------------------------------------
-describe("EmailVerificationTokenRepository.findByToken", () => {
-    it("returns token document when found", async () => {
-        const token = makeEmailToken();
-        mockQuery.get.mockResolvedValue(makeQuerySnap([{ id: token.id, data: token }]));
-        const result = await emailRepo.findByToken("secure-random-token");
-        expect(result).not.toBeNull();
-        expect(result?.token).toBe("secure-random-token");
-    });
-    it("returns null when token does not exist", async () => {
-        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
-        const result = await emailRepo.findByToken("nonexistent-token");
-        expect(result).toBeNull();
-    });
-    it("queries by token field", async () => {
-        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
-        await emailRepo.findByToken("abc");
-        expect(mockCollection.where).toHaveBeenCalledWith("token", "==", "abc");
-    });
-});
-// ---------------------------------------------------------------------------
-// EmailVerificationTokenRepository.isExpired
-// ---------------------------------------------------------------------------
-describe("EmailVerificationTokenRepository.isExpired", () => {
-    it("returns false when expiresAt is in the future", () => {
-        const token = makeEmailToken({ expiresAt: new Date(Date.now() + 60000) });
-        expect(emailRepo.isExpired(token)).toBe(false);
-    });
-    it("returns true when expiresAt is in the past", () => {
-        const token = makeEmailToken({ expiresAt: new Date(Date.now() - 1000) });
-        expect(emailRepo.isExpired(token)).toBe(true);
-    });
-    it("returns true when expiresAt is null/undefined", () => {
-        const token = makeEmailToken({ expiresAt: null });
-        expect(emailRepo.isExpired(token)).toBe(true);
-    });
-});
-// ---------------------------------------------------------------------------
-// EmailVerificationTokenRepository.deleteAllForUser
-// ---------------------------------------------------------------------------
-describe("EmailVerificationTokenRepository.deleteAllForUser", () => {
-    it("deletes all tokens for the user in batch", async () => {
-        const tokens = [
-            makeEmailToken({ id: "t-1" }),
-            makeEmailToken({ id: "t-2" }),
-        ];
-        mockQuery.get.mockResolvedValue(makeQuerySnap(tokens.map((t) => ({ id: t.id, data: t }))));
-        await emailRepo.deleteAllForUser("user-ravi");
-        expect(mockBatch.delete).toHaveBeenCalledTimes(2);
-        expect(mockBatch.commit).toHaveBeenCalledOnce();
-    });
-    it("commits even when no tokens exist for the user", async () => {
-        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
-        await emailRepo.deleteAllForUser("user-no-tokens");
-        expect(mockBatch.delete).not.toHaveBeenCalled();
-        expect(mockBatch.commit).toHaveBeenCalledOnce();
-    });
-});
-// ---------------------------------------------------------------------------
-// EmailVerificationTokenRepository.findByEmail (blind-index lookup)
-// ---------------------------------------------------------------------------
-describe("EmailVerificationTokenRepository.findByEmail", () => {
-    it("first queries emailIndex (blind index), not raw email", async () => {
-        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
-        await emailRepo.findByEmail("ravi@example.com");
-        expect(mockCollection.where).toHaveBeenCalledWith("emailIndex", "==", "blind:ravi@example.com");
-    });
-    it("falls back to plaintext email lookup when index returns empty", async () => {
-        // First call (index) returns empty, second call (email) also empty
-        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
-        await emailRepo.findByEmail("ravi@example.com");
-        // Two where calls — first for emailIndex, second for email
-        expect(mockCollection.where).toHaveBeenCalledTimes(2);
-    });
-    it("does NOT fall back if index returns results", async () => {
-        const token = makeEmailToken();
-        mockQuery.get.mockResolvedValueOnce(makeQuerySnap([{ id: token.id, data: token }]));
-        await emailRepo.findByEmail("ravi@example.com");
-        expect(mockCollection.where).toHaveBeenCalledTimes(1);
-    });
-});
-// ---------------------------------------------------------------------------
-// EmailVerificationTokenRepository.deleteExpired
-// ---------------------------------------------------------------------------
-describe("EmailVerificationTokenRepository.deleteExpired", () => {
-    it("batch-deletes all expired tokens", async () => {
-        const tokens = [makeEmailToken({ id: "t-expired-1" }), makeEmailToken({ id: "t-expired-2" })];
-        mockQuery.get.mockResolvedValue(makeQuerySnap(tokens.map((t) => ({ id: t.id, data: t }))));
-        const count = await emailRepo.deleteExpired();
-        expect(count).toBe(2);
-        expect(mockBatch.delete).toHaveBeenCalledTimes(2);
-        expect(mockBatch.commit).toHaveBeenCalledOnce();
-    });
-    it("queries expiresAt < now", async () => {
-        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
-        await emailRepo.deleteExpired();
-        expect(mockCollection.where).toHaveBeenCalledWith("expiresAt", "<", expect.any(Date));
-    });
-});
-// ---------------------------------------------------------------------------
-// PasswordResetTokenRepository.markAsUsed
-// ---------------------------------------------------------------------------
-describe("PasswordResetTokenRepository.markAsUsed", () => {
-    it("sets used: true on the token", async () => {
-        const token = makePasswordResetToken({ used: false });
-        mockDocRef.get.mockResolvedValue(makeSnap(token, "pw-token-abc123"));
-        await passwordRepo.markAsUsed("pw-token-abc123");
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ used: true }));
-    });
-    it("sets usedAt timestamp", async () => {
-        const token = makePasswordResetToken();
-        mockDocRef.get.mockResolvedValue(makeSnap(token, "pw-token-abc123"));
-        await passwordRepo.markAsUsed("pw-token-abc123");
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ usedAt: expect.any(Date) }));
-    });
-    it("calls doc(tokenId) to target the correct token", async () => {
-        const token = makePasswordResetToken();
-        mockDocRef.get.mockResolvedValue(makeSnap(token, "pw-token-abc123"));
-        await passwordRepo.markAsUsed("pw-token-abc123");
-        expect(mockCollection.doc).toHaveBeenCalledWith("pw-token-abc123");
-    });
-});
-// ---------------------------------------------------------------------------
-// PasswordResetTokenRepository.findUnusedForUser
-// ---------------------------------------------------------------------------
-describe("PasswordResetTokenRepository.findUnusedForUser", () => {
-    it("returns only tokens where used == false for the user", async () => {
-        const unused = makePasswordResetToken({ used: false });
-        mockQuery.get.mockResolvedValue(makeQuerySnap([{ id: unused.id, data: unused }]));
-        const results = await passwordRepo.findUnusedForUser("user-ravi");
-        expect(results).toHaveLength(1);
-    });
-    it("queries userId and used==false filters", async () => {
-        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
-        await passwordRepo.findUnusedForUser("user-ravi");
-        expect(mockCollection.where).toHaveBeenCalledWith("userId", "==", "user-ravi");
-        expect(mockQuery.where).toHaveBeenCalledWith("used", "==", false);
-    });
-    it("returns empty array when all tokens for user are used", async () => {
-        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
-        const results = await passwordRepo.findUnusedForUser("user-ravi");
-        expect(results).toEqual([]);
-    });
-});
-// ---------------------------------------------------------------------------
-// PasswordResetTokenRepository.isExpired
-// ---------------------------------------------------------------------------
-describe("PasswordResetTokenRepository.isExpired", () => {
-    it("returns false when expiresAt is in the future", () => {
-        const token = makePasswordResetToken({ expiresAt: new Date(Date.now() + 60000) });
-        expect(passwordRepo.isExpired(token)).toBe(false);
-    });
-    it("returns true when expiresAt is in the past", () => {
-        const token = makePasswordResetToken({ expiresAt: new Date(Date.now() - 1000) });
-        expect(passwordRepo.isExpired(token)).toBe(true);
-    });
-});
-// ---------------------------------------------------------------------------
-// PasswordResetTokenRepository.findByEmail (blind-index lookup)
-// ---------------------------------------------------------------------------
-describe("PasswordResetTokenRepository.findByEmail", () => {
-    it("queries by HMAC blind index (not plaintext email)", async () => {
-        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
-        await passwordRepo.findByEmail("ravi@example.com");
-        expect(mockCollection.where).toHaveBeenCalledWith("emailIndex", "==", "blind:ravi@example.com");
-    });
-    it("does not expose raw email in the Firestore query field", async () => {
-        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
-        await passwordRepo.findByEmail("ravi@example.com");
-        // First call is index lookup — must NOT use raw email
-        const firstCallArg = mockCollection.where.mock.calls[0][2];
-        expect(firstCallArg).not.toBe("ravi@example.com");
-        expect(firstCallArg).toMatch(/^blind:/);
-    });
-});

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

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

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

@@ -1,140 +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();
-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 findBy(field, value) {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const snap = await db.collection(this.collection).where(field, "==", value).get();
-            return snap.docs.map((d) => ({ id: d.id, ...d.data() }));
-        }
-        async findOneBy(field, value) {
-            const results = await this.findBy(field, value);
-            return results[0] ?? null;
-        }
-        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 findByIdOrFail(id) {
-            const doc = await this.findById(id);
-            if (!doc)
-                throw new Error("Not found");
-            return doc;
-        }
-        async create(data) {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const ref = await db.collection(this.collection).add(data);
-            return { id: ref.id, ...data };
-        }
-    },
-}));
-vi.mock("../../../../monitoring", () => ({
-    serverLogger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
-}));
-vi.mock("../../../../errors/normalize", () => ({
-    normalizeError: vi.fn(),
-}));
-vi.mock("../../../../security", () => ({
-    TOKEN_PII_FIELDS: ["email"],
-    TOKEN_PII_INDEX_MAP: { email: "emailIndex" },
-    encryptPiiFields: (data) => data,
-    decryptPiiFields: (data) => data,
-    addPiiIndices: (data) => data,
-    piiBlindIndex: (v) => `idx:${v}`,
-}));
-vi.mock("../../../../utils", () => ({
-    resolveDate: (d) => (d instanceof Date ? d : d ? new Date(d) : null),
-}));
-import { EmailVerificationTokenRepository, PasswordResetTokenRepository, } from "../token.repository";
-const emailRepo = new EmailVerificationTokenRepository();
-const passwordRepo = new PasswordResetTokenRepository();
-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);
-    mockCollection.add.mockResolvedValue({ id: "token-id-123" });
-    db.collection.mockReturnValue(mockCollection);
-    db.batch.mockReturnValue(mockBatch);
-    mockBatch.commit.mockResolvedValue(undefined);
-});
-describe("EmailVerificationTokenRepository.findByToken", () => {
-    it("token exists → returns document", async () => {
-        const tokenData = { userId: "user-1", email: "a@b.com", expiresAt: new Date(Date.now() + 60000) };
-        mockQuery.get.mockResolvedValue(makeQuerySnap([{ id: "tok-1", data: tokenData }]));
-        const result = await emailRepo.findByToken("some-token");
-        expect(result).not.toBeNull();
-        expect(result?.userId).toBe("user-1");
-    });
-    it("token does not exist → returns null", async () => {
-        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
-        const result = await emailRepo.findByToken("nonexistent-token");
-        expect(result).toBeNull();
-    });
-});
-describe("EmailVerificationTokenRepository.isExpired", () => {
-    it("expiresAt in past → returns true", () => {
-        const pastToken = { id: "t1", userId: "u", email: "a@b.com", expiresAt: new Date(Date.now() - 1000) };
-        expect(emailRepo.isExpired(pastToken)).toBe(true);
-    });
-    it("expiresAt in future → returns false", () => {
-        const futureToken = { id: "t1", userId: "u", email: "a@b.com", expiresAt: new Date(Date.now() + 60000) };
-        expect(emailRepo.isExpired(futureToken)).toBe(false);
-    });
-});
-describe("EmailVerificationTokenRepository.deleteAllForUser", () => {
-    it("batch-deletes all tokens for the user", async () => {
-        mockQuery.get.mockResolvedValue(makeQuerySnap([
-            { id: "tok-1", data: { userId: "user-1" } },
-            { id: "tok-2", data: { userId: "user-1" } },
-        ]));
-        await emailRepo.deleteAllForUser("user-1");
-        expect(mockBatch.commit).toHaveBeenCalledOnce();
-    });
-    it("no tokens for user → still calls commit (empty batch)", async () => {
-        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
-        await emailRepo.deleteAllForUser("user-no-tokens");
-        expect(mockBatch.commit).toHaveBeenCalledOnce();
-    });
-});
-describe("EmailVerificationTokenRepository.findByEmail", () => {
-    it("uses HMAC blind index for lookup (emailIndex field)", async () => {
-        const tokenData = { userId: "u", emailIndex: "idx:a@b.com", expiresAt: new Date() };
-        mockQuery.get.mockResolvedValue(makeQuerySnap([{ id: "tok-1", data: tokenData }]));
-        await emailRepo.findByEmail("a@b.com");
-        expect(mockCollection.where).toHaveBeenCalledWith("emailIndex", "==", "idx:a@b.com");
-    });
-});
-describe("PasswordResetTokenRepository.markAsUsed", () => {
-    it("sets usedAt timestamp and used: true on the document", async () => {
-        mockDocRef.get.mockResolvedValue(makeSnap({ userId: "user-1", token: "tok", used: false }));
-        await passwordRepo.markAsUsed("tok-1");
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ used: true, usedAt: expect.any(Date) }));
-    });
-});
-describe("PasswordResetTokenRepository.findUnusedForUser", () => {
-    it("returns null when all tokens have used: true", async () => {
-        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
-        const result = await passwordRepo.findUnusedForUser("user-1");
-        expect(result).toEqual([]);
-    });
-    it("returns unused tokens (used: false)", async () => {
-        const tokenData = { userId: "user-1", token: "abc", used: false, expiresAt: new Date() };
-        mockQuery.get.mockResolvedValue(makeQuerySnap([{ id: "tok-1", data: tokenData }]));
-        const result = await passwordRepo.findUnusedForUser("user-1");
-        expect(result).toHaveLength(1);
-    });
-});

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

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