@mohasinac/appkit 3.8.1 → 3.9.0

package/dist/features/collections/repository/collections.repository.d.ts

@@ -1,8 +0,0 @@
-import type { IRepository } from "../../../contracts";
-import type { CollectionItem } from "../types";
-export declare class CollectionsRepository {
-    private readonly repo;
-    constructor(repo: IRepository<CollectionItem>);
-    findBySlug(slug: string): Promise<CollectionItem | null>;
-    findActive(): Promise<CollectionItem[]>;
-}

package/dist/features/collections/repository/collections.repository.js

@@ -1,16 +0,0 @@
-export class CollectionsRepository {
-    constructor(repo) {
-        this.repo = repo;
-    }
-    async findBySlug(slug) {
-        return this.repo.findById(slug);
-    }
-    async findActive() {
-        const result = await this.repo.findAll({
-            filters: "active==true",
-            sort: "sortOrder",
-            order: "asc",
-        });
-        return result.data;
-    }
-}

package/dist/features/collections/server.d.ts

@@ -1,6 +0,0 @@
-/**
- * @mohasinac/appkit/features/collections/server
- *
- * Server-only entry point for collections repositories.
- */
-export { CollectionsRepository } from "./repository/collections.repository";

package/dist/features/collections/server.js

@@ -1,6 +0,0 @@
-/**
- * @mohasinac/appkit/features/collections/server
- *
- * Server-only entry point for collections repositories.
- */
-export { CollectionsRepository } from "./repository/collections.repository";

package/dist/features/events/repository/__tests__/event.repository.test.d.ts

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

package/dist/features/events/repository/__tests__/event.repository.test.js

@@ -1,299 +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("../../../../security", () => ({
-    encryptPiiFields: (d) => d,
-    decryptPiiFields: (d) => d,
-    EVENT_ENTRY_PII_FIELDS: ["userEmail"],
-}));
-vi.mock("../../../../monitoring", () => ({
-    serverLogger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
-}));
-vi.mock("../../../../errors/normalize", () => ({
-    normalizeError: vi.fn(),
-}));
-import { EventRepository } from "../events.repository";
-import { EventEntryRepository } from "../event-entry.repository";
-const eventRepo = new EventRepository();
-const entryRepo = new EventEntryRepository();
-function makeEventDoc(overrides = {}) {
-    return {
-        id: "event-summer-holo-sale-2026",
-        title: "Summer Holo Sale",
-        type: "sale",
-        status: "active",
-        slug: "summer-holo-sale-2026",
-        startsAt: new Date(Date.now() - 3600000),
-        endsAt: new Date(Date.now() + 3600000),
-        tags: [],
-        stats: { totalEntries: 0, approvedEntries: 0, flaggedEntries: 0 },
-        createdBy: "admin-1",
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        ...overrides,
-    };
-}
-function makeEntryDoc(overrides = {}) {
-    return {
-        id: "entry-abc123",
-        eventId: "event-summer-holo-sale-2026",
-        userId: "user-ravi",
-        userDisplayName: "Ravi Kumar",
-        userEmail: "ravi@test.com",
-        reviewStatus: "pending",
-        submittedAt: new Date(),
-        points: 100,
-        ...overrides,
-    };
-}
-function makeAddRef(data, id = "new-entry-id") {
-    return { id, get: vi.fn().mockResolvedValue(makeSnap(data, 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);
-    mockDocRef.update.mockResolvedValue(undefined);
-});
-// ---------------------------------------------------------------------------
-// EventRepository.incrementTotalEntries
-// ---------------------------------------------------------------------------
-describe("EventRepository.incrementTotalEntries", () => {
-    it("updates stats.totalEntries with an increment op", async () => {
-        await eventRepo.incrementTotalEntries("event-1");
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ "stats.totalEntries": expect.anything() }));
-    });
-    it("calls doc(eventId) before update", async () => {
-        await eventRepo.incrementTotalEntries("event-xyz");
-        expect(mockCollection.doc).toHaveBeenCalledWith("event-xyz");
-    });
-});
-// ---------------------------------------------------------------------------
-// EventRepository.incrementApprovedEntries
-// ---------------------------------------------------------------------------
-describe("EventRepository.incrementApprovedEntries", () => {
-    it("updates stats.approvedEntries with an increment op", async () => {
-        await eventRepo.incrementApprovedEntries("event-1");
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ "stats.approvedEntries": expect.anything() }));
-    });
-});
-// ---------------------------------------------------------------------------
-// EventRepository.changeStatus
-// ---------------------------------------------------------------------------
-describe("EventRepository.changeStatus", () => {
-    it("sets the new status on the event document", async () => {
-        const event = makeEventDoc({ status: "upcoming" });
-        mockDocRef.get.mockResolvedValue(makeSnap(event, "event-1"));
-        await eventRepo.changeStatus("event-1", "active");
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ status: "active" }));
-    });
-    it("sets updatedAt timestamp", async () => {
-        const event = makeEventDoc();
-        mockDocRef.get.mockResolvedValue(makeSnap(event, "event-1"));
-        await eventRepo.changeStatus("event-1", "ended");
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ updatedAt: expect.any(Date) }));
-    });
-});
-// ---------------------------------------------------------------------------
-// EventRepository.createEvent
-// ---------------------------------------------------------------------------
-describe("EventRepository.createEvent", () => {
-    it("sets stats.totalEntries=0, approvedEntries=0, flaggedEntries=0", async () => {
-        const eventData = makeEventDoc();
-        const addRef = makeAddRef(eventData);
-        mockCollection.add.mockResolvedValue(addRef);
-        const result = await eventRepo.createEvent({
-            title: "Summer Holo Sale",
-            type: "sale",
-            status: "upcoming",
-        });
-        expect(result.stats.totalEntries).toBe(0);
-        expect(result.stats.approvedEntries).toBe(0);
-        expect(result.stats.flaggedEntries).toBe(0);
-    });
-    it("generates slug from title when not provided", async () => {
-        const eventData = makeEventDoc({ slug: "summer-holo-sale" });
-        const addRef = makeAddRef(eventData);
-        mockCollection.add.mockResolvedValue(addRef);
-        const result = await eventRepo.createEvent({
-            title: "Summer Holo Sale",
-            type: "sale",
-            status: "upcoming",
-        });
-        expect(result.slug).toBeTruthy();
-    });
-});
-// ---------------------------------------------------------------------------
-// EventEntryRepository.hasUserEntered
-// ---------------------------------------------------------------------------
-describe("EventEntryRepository.hasUserEntered", () => {
-    it("returns true when entry exists for (eventId, userId)", async () => {
-        const entry = makeEntryDoc();
-        mockQuery.get.mockResolvedValue(makeQuerySnap([{ id: entry.id, data: entry }]));
-        const result = await entryRepo.hasUserEntered("event-1", "user-ravi");
-        expect(result).toBe(true);
-    });
-    it("returns false when no entry found", async () => {
-        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
-        const result = await entryRepo.hasUserEntered("event-1", "user-nobody");
-        expect(result).toBe(false);
-    });
-    it("queries by both eventId and userId", async () => {
-        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
-        await entryRepo.hasUserEntered("event-abc", "user-xyz");
-        expect(mockCollection.where).toHaveBeenCalledWith(expect.stringContaining("eventId"), "==", "event-abc");
-        expect(mockQuery.where).toHaveBeenCalledWith(expect.stringContaining("userId"), "==", "user-xyz");
-    });
-});
-// ---------------------------------------------------------------------------
-// EventEntryRepository.countUserEntries
-// ---------------------------------------------------------------------------
-describe("EventEntryRepository.countUserEntries", () => {
-    it("returns 0 when no entries for user", async () => {
-        mockQuery.get.mockResolvedValue({ empty: true, size: 0, docs: [] });
-        const count = await entryRepo.countUserEntries("event-1", "user-1");
-        expect(count).toBe(0);
-    });
-    it("returns correct count when entries exist", async () => {
-        mockQuery.get.mockResolvedValue({ empty: false, size: 3, docs: [] });
-        const count = await entryRepo.countUserEntries("event-1", "user-1");
-        expect(count).toBe(3);
-    });
-});
-// ---------------------------------------------------------------------------
-// EventEntryRepository.getLeaderboard
-// ---------------------------------------------------------------------------
-describe("EventEntryRepository.getLeaderboard", () => {
-    it("sums points per userId from approved entries", async () => {
-        const entries = [
-            makeEntryDoc({ userId: "user-ravi", userDisplayName: "Ravi", points: 100, reviewStatus: "approved" }),
-            makeEntryDoc({ id: "entry-2", userId: "user-ravi", userDisplayName: "Ravi", points: 50, reviewStatus: "approved" }),
-            makeEntryDoc({ id: "entry-3", userId: "user-priya", userDisplayName: "Priya", points: 200, reviewStatus: "approved" }),
-        ];
-        mockQuery.get.mockResolvedValue(makeQuerySnap(entries.map((e) => ({ id: e.id, data: e }))));
-        const board = await entryRepo.getLeaderboard("event-1");
-        expect(board).toHaveLength(2);
-        const ravi = board.find((b) => b.userId === "user-ravi");
-        expect(ravi?.totalPoints).toBe(150);
-    });
-    it("sorts leaderboard descending by totalPoints", async () => {
-        const entries = [
-            makeEntryDoc({ userId: "user-a", userDisplayName: "A", points: 10, reviewStatus: "approved" }),
-            makeEntryDoc({ id: "e2", userId: "user-b", userDisplayName: "B", points: 300, reviewStatus: "approved" }),
-        ];
-        mockQuery.get.mockResolvedValue(makeQuerySnap(entries.map((e) => ({ id: e.id, data: e }))));
-        const board = await entryRepo.getLeaderboard("event-1");
-        expect(board[0].userId).toBe("user-b");
-        expect(board[1].userId).toBe("user-a");
-    });
-    it("assigns correct rank starting at 1", async () => {
-        const entries = [
-            makeEntryDoc({ userId: "user-x", userDisplayName: "X", points: 50, reviewStatus: "approved" }),
-        ];
-        mockQuery.get.mockResolvedValue(makeQuerySnap(entries.map((e) => ({ id: e.id, data: e }))));
-        const board = await entryRepo.getLeaderboard("event-1");
-        expect(board[0].rank).toBe(1);
-    });
-    it("returns empty array when no approved entries", async () => {
-        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
-        const board = await entryRepo.getLeaderboard("event-1");
-        expect(board).toHaveLength(0);
-    });
-    it("applies limit (default 50)", async () => {
-        const entries = Array.from({ length: 60 }, (_, i) => makeEntryDoc({ id: `e-${i}`, userId: `user-${i}`, userDisplayName: `U${i}`, points: 60 - i, reviewStatus: "approved" }));
-        mockQuery.get.mockResolvedValue(makeQuerySnap(entries.map((e) => ({ id: e.id, data: e }))));
-        const board = await entryRepo.getLeaderboard("event-1");
-        expect(board).toHaveLength(50);
-    });
-    it("applies custom limit", async () => {
-        const entries = Array.from({ length: 10 }, (_, i) => makeEntryDoc({ id: `e-${i}`, userId: `user-${i}`, userDisplayName: `U${i}`, points: 10 - i, reviewStatus: "approved" }));
-        mockQuery.get.mockResolvedValue(makeQuerySnap(entries.map((e) => ({ id: e.id, data: e }))));
-        const board = await entryRepo.getLeaderboard("event-1", 3);
-        expect(board).toHaveLength(3);
-    });
-});
-// ---------------------------------------------------------------------------
-// EventEntryRepository.createEntry
-// ---------------------------------------------------------------------------
-describe("EventEntryRepository.createEntry", () => {
-    it("sets submittedAt timestamp on the created entry", async () => {
-        const entry = makeEntryDoc();
-        const addRef = makeAddRef(entry);
-        mockCollection.add.mockResolvedValue(addRef);
-        const result = await entryRepo.createEntry({
-            eventId: "event-1",
-            userId: "user-ravi",
-            userDisplayName: "Ravi Kumar",
-            userEmail: "ravi@test.com",
-        });
-        // submittedAt set in createEntry, visible through the returned doc
-        expect(result.eventId).toBe("event-summer-holo-sale-2026");
-    });
-    it("persists entry to Firestore via add", async () => {
-        const entry = makeEntryDoc();
-        const addRef = makeAddRef(entry);
-        mockCollection.add.mockResolvedValue(addRef);
-        await entryRepo.createEntry({
-            eventId: "event-1",
-            userId: "user-ravi",
-            userDisplayName: "Ravi Kumar",
-            userEmail: "ravi@test.com",
-        });
-        expect(mockCollection.add).toHaveBeenCalledOnce();
-    });
-});
-// ---------------------------------------------------------------------------
-// EventEntryRepository.reviewEntry
-// ---------------------------------------------------------------------------
-describe("EventEntryRepository.reviewEntry", () => {
-    it("sets reviewStatus=approved on the entry", async () => {
-        const entry = makeEntryDoc({ reviewStatus: "approved" });
-        mockDocRef.get.mockResolvedValue(makeSnap(entry, "entry-1"));
-        await entryRepo.reviewEntry("entry-1", "approved", "mod-1");
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ reviewStatus: "approved" }));
-    });
-    it("sets reviewStatus=flagged on the entry", async () => {
-        const entry = makeEntryDoc({ reviewStatus: "flagged" });
-        mockDocRef.get.mockResolvedValue(makeSnap(entry, "entry-1"));
-        await entryRepo.reviewEntry("entry-1", "flagged", "mod-1", "Off topic");
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ reviewStatus: "flagged" }));
-    });
-    it("stores reviewNote when provided", async () => {
-        const entry = makeEntryDoc({ reviewStatus: "flagged" });
-        mockDocRef.get.mockResolvedValue(makeSnap(entry, "entry-1"));
-        await entryRepo.reviewEntry("entry-1", "flagged", "mod-1", "Spam");
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ reviewNote: "Spam" }));
-    });
-    it("stores points when provided", async () => {
-        const entry = makeEntryDoc({ reviewStatus: "approved" });
-        mockDocRef.get.mockResolvedValue(makeSnap(entry, "entry-1"));
-        await entryRepo.reviewEntry("entry-1", "approved", "mod-1", undefined, 250);
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ points: 250 }));
-    });
-    it("sets reviewedBy and reviewedAt", async () => {
-        const entry = makeEntryDoc({ reviewStatus: "approved" });
-        mockDocRef.get.mockResolvedValue(makeSnap(entry, "entry-1"));
-        await entryRepo.reviewEntry("entry-1", "approved", "mod-admin-1");
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({
-            reviewedBy: "mod-admin-1",
-            reviewedAt: expect.any(Date),
-        }));
-    });
-});

package/dist/features/faq/repository/__tests__/faqs.repository.test.d.ts

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

package/dist/features/faq/repository/__tests__/faqs.repository.test.js

@@ -1,311 +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("../../../../errors/normalize", () => ({
-    normalizeError: vi.fn(),
-}));
-import { FirebaseFAQsRepository } from "../faqs.repository";
-const repo = new FirebaseFAQsRepository();
-function makeFaqDoc(overrides = {}) {
-    return {
-        id: "faq-how-does-bidding-work",
-        question: "How does bidding work?",
-        answer: { text: "You place a bid above the current price.", format: "plain" },
-        category: "Auctions",
-        tags: ["bidding", "auctions"],
-        searchTokens: ["how", "does", "bidding", "work"],
-        relatedFAQs: [],
-        seo: { slug: "how-does-bidding-work" },
-        isActive: true,
-        showOnHomepage: false,
-        showInFooter: false,
-        isPinned: false,
-        priority: 0,
-        order: 0,
-        useSiteSettings: false,
-        createdBy: "admin-1",
-        stats: { views: 0, helpful: 0, notHelpful: 0 },
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        ...overrides,
-    };
-}
-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);
-    mockDocRef.update.mockResolvedValue(undefined);
-});
-// ---------------------------------------------------------------------------
-// createWithSlug
-// ---------------------------------------------------------------------------
-describe("FirebaseFAQsRepository.createWithSlug", () => {
-    it("uses seo.slug from input when provided", async () => {
-        const input = {
-            question: "How does bidding work?",
-            answer: { text: "You bid above the current price.", format: "plain" },
-            category: "Auctions",
-            tags: ["bidding"],
-            seo: { slug: "custom-slug" },
-            isActive: true,
-        };
-        const result = await repo.createWithSlug(input);
-        expect(result.seo.slug).toBe("custom-slug");
-    });
-    it("generates seo.slug from question when seo.slug not provided", async () => {
-        const input = {
-            question: "How does bidding work?",
-            answer: { text: "Details here.", format: "plain" },
-            category: "Auctions",
-            tags: [],
-            isActive: true,
-        };
-        const result = await repo.createWithSlug(input);
-        expect(result.seo.slug).toMatch(/bidding/i);
-    });
-    it("builds searchTokens from question, answer, category, and tags", async () => {
-        const input = {
-            question: "What is a reserve price?",
-            answer: { text: "Reserve is the minimum.", format: "plain" },
-            category: "Auctions",
-            tags: ["reserve", "price"],
-            seo: { slug: "what-is-reserve-price" },
-            isActive: true,
-        };
-        const result = await repo.createWithSlug(input);
-        expect(result.searchTokens).toContain("reserve");
-        expect(result.searchTokens).toContain("price");
-        expect(result.searchTokens).toContain("what");
-    });
-    it("sets stats.views=0, stats.helpful=0, stats.notHelpful=0", async () => {
-        const input = {
-            question: "New question?",
-            answer: { text: "Answer.", format: "plain" },
-            category: "General",
-            tags: [],
-            isActive: true,
-        };
-        const result = await repo.createWithSlug(input);
-        expect(result.stats).toEqual({ views: 0, helpful: 0, notHelpful: 0 });
-    });
-    it("persists the FAQ to Firestore", async () => {
-        const input = {
-            question: "Question?",
-            answer: { text: "Answer.", format: "plain" },
-            category: "General",
-            tags: [],
-            seo: { slug: "question" },
-            isActive: true,
-        };
-        await repo.createWithSlug(input);
-        expect(mockDocRef.set).toHaveBeenCalledOnce();
-    });
-    it("searchTokens deduplicated and lowercased", async () => {
-        const input = {
-            question: "What what what?",
-            answer: { text: "Answer.", format: "plain" },
-            category: "General",
-            tags: [],
-            isActive: true,
-        };
-        const result = await repo.createWithSlug(input);
-        const whatCount = result.searchTokens.filter((t) => t === "what").length;
-        expect(whatCount).toBe(1);
-    });
-});
-// ---------------------------------------------------------------------------
-// interpolateVariables
-// ---------------------------------------------------------------------------
-describe("FirebaseFAQsRepository.interpolateVariables", () => {
-    it("replaces {{variable}} placeholders with provided values", async () => {
-        const faq = makeFaqDoc({
-            answer: { text: "Your order {{orderId}} will arrive in {{days}} days.", format: "plain" },
-        });
-        const result = await repo.interpolateVariables(faq, { orderId: "ORD-123", days: 3 });
-        expect(result.answer.interpolated).toBe("Your order ORD-123 will arrive in 3 days.");
-    });
-    it("falls back to faq.variables when runtime variable not provided", async () => {
-        const faq = makeFaqDoc({
-            answer: { text: "Contact us at {{supportEmail}}.", format: "plain" },
-            variables: { supportEmail: "support@letitrip.in" },
-        });
-        const result = await repo.interpolateVariables(faq);
-        expect(result.answer.interpolated).toBe("Contact us at support@letitrip.in.");
-    });
-    it("leaves unknown placeholders as-is", async () => {
-        const faq = makeFaqDoc({
-            answer: { text: "Hello {{unknownVar}}!", format: "plain" },
-        });
-        const result = await repo.interpolateVariables(faq, {});
-        expect(result.answer.interpolated).toBe("Hello {{unknownVar}}!");
-    });
-    it("returns unchanged interpolated when no placeholders present", async () => {
-        const faq = makeFaqDoc({
-            answer: { text: "No variables here.", format: "plain" },
-        });
-        const result = await repo.interpolateVariables(faq, { irrelevant: "x" });
-        expect(result.answer.interpolated).toBe("No variables here.");
-    });
-    it("replaces multiple occurrences of the same placeholder", async () => {
-        const faq = makeFaqDoc({
-            answer: { text: "{{name}} is {{name}}.", format: "plain" },
-        });
-        const result = await repo.interpolateVariables(faq, { name: "LetItRip" });
-        expect(result.answer.interpolated).toBe("LetItRip is LetItRip.");
-    });
-});
-// ---------------------------------------------------------------------------
-// markHelpful
-// ---------------------------------------------------------------------------
-describe("FirebaseFAQsRepository.markHelpful", () => {
-    it("increments stats.helpful on the FAQ document", async () => {
-        await repo.markHelpful("faq-1");
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ "stats.helpful": expect.anything() }));
-    });
-    it("does not modify other stats fields", async () => {
-        await repo.markHelpful("faq-1");
-        const updateArg = mockDocRef.update.mock.calls[0][0];
-        expect(Object.keys(updateArg)).not.toContain("stats.views");
-        expect(Object.keys(updateArg)).not.toContain("stats.notHelpful");
-    });
-});
-// ---------------------------------------------------------------------------
-// markNotHelpful
-// ---------------------------------------------------------------------------
-describe("FirebaseFAQsRepository.markNotHelpful", () => {
-    it("increments stats.notHelpful on the FAQ document", async () => {
-        await repo.markNotHelpful("faq-1");
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ "stats.notHelpful": expect.anything() }));
-    });
-    it("does not modify stats.helpful", async () => {
-        await repo.markNotHelpful("faq-1");
-        const updateArg = mockDocRef.update.mock.calls[0][0];
-        expect(Object.keys(updateArg)).not.toContain("stats.helpful");
-    });
-});
-// ---------------------------------------------------------------------------
-// incrementViews
-// ---------------------------------------------------------------------------
-describe("FirebaseFAQsRepository.incrementViews", () => {
-    it("increments stats.views by 1", async () => {
-        await repo.incrementViews("faq-1");
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ "stats.views": expect.anything() }));
-    });
-    it("sets stats.lastViewed timestamp", async () => {
-        await repo.incrementViews("faq-1");
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ "stats.lastViewed": expect.any(Date) }));
-    });
-});
-// ---------------------------------------------------------------------------
-// getHomepageFAQs
-// ---------------------------------------------------------------------------
-describe("FirebaseFAQsRepository.getHomepageFAQs", () => {
-    it("queries showOnHomepage=true AND isActive=true", async () => {
-        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
-        await repo.getHomepageFAQs();
-        expect(mockCollection.where).toHaveBeenCalledWith(expect.stringContaining("showOnHomepage"), "==", true);
-        expect(mockQuery.where).toHaveBeenCalledWith(expect.stringContaining("isActive"), "==", true);
-    });
-    it("orders results by priority descending", async () => {
-        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
-        await repo.getHomepageFAQs();
-        expect(mockQuery.orderBy).toHaveBeenCalledWith(expect.stringContaining("priority"), "desc");
-    });
-    it("returns matching FAQs", async () => {
-        const faq = makeFaqDoc({ showOnHomepage: true });
-        mockQuery.get.mockResolvedValue(makeQuerySnap([{ id: faq.id, data: faq }]));
-        const results = await repo.getHomepageFAQs();
-        expect(results).toHaveLength(1);
-    });
-});
-// ---------------------------------------------------------------------------
-// searchByTag
-// ---------------------------------------------------------------------------
-describe("FirebaseFAQsRepository.searchByTag", () => {
-    it("filters by array-contains on the tags field", async () => {
-        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
-        await repo.searchByTag("grading");
-        expect(mockCollection.where).toHaveBeenCalledWith(expect.stringContaining("tags"), "array-contains", "grading");
-    });
-    it("also filters isActive=true", async () => {
-        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
-        await repo.searchByTag("returns");
-        expect(mockQuery.where).toHaveBeenCalledWith(expect.stringContaining("isActive"), "==", true);
-    });
-    it("returns matching FAQs", async () => {
-        const faq = makeFaqDoc({ tags: ["grading"] });
-        mockQuery.get.mockResolvedValue(makeQuerySnap([{ id: faq.id, data: faq }]));
-        const results = await repo.searchByTag("grading");
-        expect(results).toHaveLength(1);
-    });
-});
-// ---------------------------------------------------------------------------
-// getPinnedFAQs
-// ---------------------------------------------------------------------------
-describe("FirebaseFAQsRepository.getPinnedFAQs", () => {
-    it("queries isPinned=true AND isActive=true", async () => {
-        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
-        await repo.getPinnedFAQs();
-        expect(mockCollection.where).toHaveBeenCalledWith(expect.stringContaining("isPinned"), "==", true);
-        expect(mockQuery.where).toHaveBeenCalledWith(expect.stringContaining("isActive"), "==", true);
-    });
-    it("orders by order field ascending", async () => {
-        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
-        await repo.getPinnedFAQs();
-        expect(mockQuery.orderBy).toHaveBeenCalledWith(expect.stringContaining("order"), "asc");
-    });
-    it("filters by category when provided", async () => {
-        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
-        await repo.getPinnedFAQs("Shipping");
-        expect(mockQuery.where).toHaveBeenCalledWith(expect.stringContaining("category"), "==", "Shipping");
-    });
-    it("no category filter applied when category not provided", async () => {
-        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
-        await repo.getPinnedFAQs();
-        const whereCalls = mockQuery.where.mock.calls;
-        const categoryFilter = whereCalls.find((c) => c[0].includes("category"));
-        expect(categoryFilter).toBeUndefined();
-    });
-});
-// ---------------------------------------------------------------------------
-// getMostHelpful
-// ---------------------------------------------------------------------------
-describe("FirebaseFAQsRepository.getMostHelpful", () => {
-    it("filters by isActive=true", async () => {
-        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
-        await repo.getMostHelpful();
-        expect(mockCollection.where).toHaveBeenCalledWith(expect.stringContaining("isActive"), "==", true);
-    });
-    it("orders by stats.helpful descending", async () => {
-        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
-        await repo.getMostHelpful();
-        expect(mockQuery.orderBy).toHaveBeenCalledWith("stats.helpful", "desc");
-    });
-    it("applies default limit of 10", async () => {
-        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
-        await repo.getMostHelpful();
-        expect(mockQuery.limit).toHaveBeenCalledWith(10);
-    });
-    it("applies custom limit when provided", async () => {
-        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
-        await repo.getMostHelpful(5);
-        expect(mockQuery.limit).toHaveBeenCalledWith(5);
-    });
-});