@mohasinac/appkit 3.8.2 → 3.9.0

package/dist/features/stores/repository/__tests__/store.repository.test.js

@@ -1,261 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { makeMockDb, makeSnap, makeQuerySnap } from "../../../../../tests/helpers/mock-firestore";
-import { DatabaseError } from "../../../../errors";
-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("../../../../security/settings-encryption", () => ({
-    encryptSecret: (v) => `enc:${v}`,
-    decryptSecret: (v) => v.replace(/^enc:/, ""),
-}));
-vi.mock("../../../../errors/normalize", () => ({
-    normalizeError: vi.fn(),
-}));
-import { StoreRepository } from "../store.repository";
-const repo = new StoreRepository();
-function makeStoreDoc(overrides = {}) {
-    return {
-        id: "store-test",
-        storeSlug: "store-test",
-        ownerId: "uid-seller-1",
-        storeName: "Test Store",
-        status: "active",
-        isPublic: true,
-        isVerified: false,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        stats: { totalProducts: 0, itemsSold: 0, totalReviews: 0, averageRating: 0 },
-        ...overrides,
-    };
-}
-function makeCreateInput(overrides = {}) {
-    return {
-        storeSlug: "store-test",
-        ownerId: "uid-seller-1",
-        storeName: "Test Store",
-        status: "pending",
-        isPublic: false,
-        ...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.create.mockResolvedValue(undefined);
-    mockDocRef.set.mockResolvedValue(undefined);
-    mockDocRef.update.mockResolvedValue(undefined);
-    mockDocRef.delete.mockResolvedValue(undefined);
-    db.batch.mockReturnValue(mockBatch);
-});
-// ---------------------------------------------------------------------------
-// create
-// ---------------------------------------------------------------------------
-describe("StoreRepository.create", () => {
-    it("throws when storeSlug equals ownerId", async () => {
-        const input = makeCreateInput({ storeSlug: "uid-same", ownerId: "uid-same" });
-        await expect(repo.create(input)).rejects.toThrow(DatabaseError);
-    });
-    it("creates document using .create() semantics (not .set())", async () => {
-        await repo.create(makeCreateInput());
-        expect(mockDocRef.create).toHaveBeenCalledOnce();
-        expect(mockDocRef.set).not.toHaveBeenCalled();
-    });
-    it("sets document ID to storeSlug", async () => {
-        await repo.create(makeCreateInput({ storeSlug: "store-pokemon-palace" }));
-        expect(mockCollection.doc).toHaveBeenCalledWith("store-pokemon-palace");
-    });
-    it("throws DatabaseError(slug already taken) when .create() fails with gRPC code 6", async () => {
-        const grpcAlreadyExists = Object.assign(new Error("ALREADY_EXISTS"), { code: 6 });
-        mockDocRef.create.mockRejectedValue(grpcAlreadyExists);
-        await expect(repo.create(makeCreateInput({ storeSlug: "store-taken" }))).rejects.toThrow(DatabaseError);
-    });
-    it("re-throws non-ALREADY_EXISTS errors as-is", async () => {
-        const networkErr = new Error("NETWORK_FAILURE");
-        mockDocRef.create.mockRejectedValue(networkErr);
-        await expect(repo.create(makeCreateInput())).rejects.toThrow("NETWORK_FAILURE");
-    });
-    it("returns the store document with id=storeSlug", async () => {
-        const result = await repo.create(makeCreateInput({ storeSlug: "store-abc" }));
-        expect(result.id).toBe("store-abc");
-        expect(result.storeSlug).toBe("store-abc");
-    });
-    it("encrypts whatsappConfig.accessToken before writing", async () => {
-        const input = makeCreateInput({
-            whatsappConfig: { accessToken: "secret-token", phoneNumberId: "ph-1", businessId: "biz-1" },
-        });
-        await repo.create(input);
-        const callArg = mockDocRef.create.mock.calls[0][0];
-        const config = callArg.whatsappConfig;
-        expect(config.accessToken).toBe("enc:secret-token");
-    });
-});
-// ---------------------------------------------------------------------------
-// isSlugAvailable
-// ---------------------------------------------------------------------------
-describe("StoreRepository.isSlugAvailable", () => {
-    it("returns true when no document exists for that slug", async () => {
-        mockDocRef.get.mockResolvedValue(makeSnap(null));
-        const result = await repo.isSlugAvailable("store-new");
-        expect(result).toBe(true);
-    });
-    it("returns false when a document exists for that slug", async () => {
-        const store = makeStoreDoc();
-        mockDocRef.get.mockResolvedValue(makeSnap(store, "store-test"));
-        const result = await repo.isSlugAvailable("store-test");
-        expect(result).toBe(false);
-    });
-});
-// ---------------------------------------------------------------------------
-// findByOwnerId
-// ---------------------------------------------------------------------------
-describe("StoreRepository.findByOwnerId", () => {
-    it("returns store when found", async () => {
-        const store = makeStoreDoc();
-        mockQuery.get.mockResolvedValue(makeQuerySnap([{ id: store.id, data: store }]));
-        const result = await repo.findByOwnerId("uid-seller-1");
-        expect(result).not.toBeNull();
-    });
-    it("queries by ownerId field", async () => {
-        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
-        await repo.findByOwnerId("uid-seller-1");
-        expect(mockCollection.where).toHaveBeenCalledWith("ownerId", "==", "uid-seller-1");
-    });
-    it("returns null when no store matches", async () => {
-        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
-        const result = await repo.findByOwnerId("uid-nobody");
-        expect(result).toBeNull();
-    });
-});
-// ---------------------------------------------------------------------------
-// setStatus
-// ---------------------------------------------------------------------------
-describe("StoreRepository.setStatus", () => {
-    it("status=active → sets isPublic: true", async () => {
-        const store = makeStoreDoc({ status: "pending", isPublic: false });
-        mockDocRef.get.mockResolvedValue(makeSnap(store, "store-test"));
-        await repo.setStatus("store-test", "active");
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ status: "active", isPublic: true }));
-    });
-    it("status=suspended → sets isPublic: false", async () => {
-        const store = makeStoreDoc({ status: "active", isPublic: true });
-        mockDocRef.get.mockResolvedValue(makeSnap(store, "store-test"));
-        await repo.setStatus("store-test", "suspended");
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ status: "suspended", isPublic: false }));
-    });
-    it("status=pending → sets isPublic: false", async () => {
-        const store = makeStoreDoc({ status: "active", isPublic: true });
-        mockDocRef.get.mockResolvedValue(makeSnap(store, "store-test"));
-        await repo.setStatus("store-test", "pending");
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ status: "pending", isPublic: false }));
-    });
-    it("status=rejected → sets isPublic: false", async () => {
-        const store = makeStoreDoc({ status: "active", isPublic: true });
-        mockDocRef.get.mockResolvedValue(makeSnap(store, "store-test"));
-        await repo.setStatus("store-test", "rejected");
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ isPublic: false }));
-    });
-});
-// ---------------------------------------------------------------------------
-// incrementTotalProducts
-// ---------------------------------------------------------------------------
-describe("StoreRepository.incrementTotalProducts", () => {
-    it("calls update with increment on stats.totalProducts", async () => {
-        await repo.incrementTotalProducts("store-1", 1);
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ "stats.totalProducts": expect.anything() }));
-    });
-    it("no-op when storeId is empty string", async () => {
-        await repo.incrementTotalProducts("", 1);
-        expect(mockDocRef.update).not.toHaveBeenCalled();
-    });
-    it("accepts negative delta (decrement)", async () => {
-        await repo.incrementTotalProducts("store-1", -1);
-        expect(mockDocRef.update).toHaveBeenCalledOnce();
-    });
-});
-// ---------------------------------------------------------------------------
-// updateReviewStats
-// ---------------------------------------------------------------------------
-describe("StoreRepository.updateReviewStats", () => {
-    it("updates totalReviews and averageRating on the store doc", async () => {
-        await repo.updateReviewStats("store-1", 10, 4.5);
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({
-            "stats.totalReviews": 10,
-            "stats.averageRating": 4.5,
-        }));
-    });
-    it("no-op when storeId is empty string", async () => {
-        await repo.updateReviewStats("", 10, 4.5);
-        expect(mockDocRef.update).not.toHaveBeenCalled();
-    });
-});
-// ---------------------------------------------------------------------------
-// changeSlug
-// ---------------------------------------------------------------------------
-describe("StoreRepository.changeSlug", () => {
-    it("throws when currentSlug === newSlug", async () => {
-        await expect(repo.changeSlug("store-same", "store-same")).rejects.toThrow(DatabaseError);
-    });
-    it("throws when newSlug is empty", async () => {
-        await expect(repo.changeSlug("store-old", "")).rejects.toThrow(DatabaseError);
-    });
-    it("throws when newSlug contains invalid characters (uppercase)", async () => {
-        await expect(repo.changeSlug("store-old", "Store-BAD")).rejects.toThrow(DatabaseError);
-    });
-    it("throws when current store is not found", async () => {
-        mockDocRef.get.mockResolvedValue(makeSnap(null));
-        await expect(repo.changeSlug("store-ghost", "store-new")).rejects.toThrow(DatabaseError);
-    });
-    it("throws when newSlug is already taken", async () => {
-        const currentStore = makeStoreDoc({ storeSlug: "store-old" });
-        const takenStore = makeStoreDoc({ storeSlug: "store-taken", id: "store-taken" });
-        mockDocRef.get
-            .mockResolvedValueOnce(makeSnap(currentStore, "store-old")) // findById(currentSlug)
-            .mockResolvedValueOnce(makeSnap(takenStore, "store-taken")); // isSlugAvailable check
-        await expect(repo.changeSlug("store-old", "store-taken")).rejects.toThrow(DatabaseError);
-    });
-    it("atomically creates new doc and deletes old doc in one batch", async () => {
-        const currentStore = makeStoreDoc({ storeSlug: "store-old" });
-        mockDocRef.get
-            .mockResolvedValueOnce(makeSnap(currentStore, "store-old")) // findById(currentSlug)
-            .mockResolvedValueOnce(makeSnap(null)); // isSlugAvailable(newSlug) → available
-        await repo.changeSlug("store-old", "store-new");
-        expect(mockBatch.create).toHaveBeenCalledOnce();
-        expect(mockBatch.delete).toHaveBeenCalledOnce();
-        expect(mockBatch.commit).toHaveBeenCalledOnce();
-    });
-    it("returns result with id=newSlug and storeSlug=newSlug", async () => {
-        const currentStore = makeStoreDoc({ storeSlug: "store-old" });
-        mockDocRef.get
-            .mockResolvedValueOnce(makeSnap(currentStore, "store-old"))
-            .mockResolvedValueOnce(makeSnap(null));
-        const result = await repo.changeSlug("store-old", "store-new");
-        expect(result.id).toBe("store-new");
-        expect(result.storeSlug).toBe("store-new");
-    });
-    it("creates new doc at newSlug path, deletes old doc at currentSlug path", async () => {
-        const currentStore = makeStoreDoc({ storeSlug: "store-old" });
-        mockDocRef.get
-            .mockResolvedValueOnce(makeSnap(currentStore, "store-old"))
-            .mockResolvedValueOnce(makeSnap(null));
-        await repo.changeSlug("store-old", "store-new");
-        // doc() was called for newSlug and currentSlug
-        const docCalls = mockCollection.doc.mock.calls.map((c) => c[0]);
-        expect(docCalls).toContain("store-new");
-        expect(docCalls).toContain("store-old");
-    });
-});

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

@@ -1,11 +0,0 @@
-import type { IRepository, PagedResult, SieveQuery } from "../../../contracts";
-import type { StoreListItem } from "../types";
-export declare class StoresRepository {
-    private readonly repo;
-    constructor(repo: IRepository<StoreListItem>);
-    findAll(query?: SieveQuery): Promise<PagedResult<StoreListItem>>;
-    findById(id: string): Promise<StoreListItem | null>;
-    findBySlug(storeSlug: string): Promise<StoreListItem | null>;
-    findActive(page?: number, perPage?: number): Promise<PagedResult<StoreListItem>>;
-    findByCategory(category: string, page?: number, perPage?: number): Promise<PagedResult<StoreListItem>>;
-}

package/dist/features/stores/repository/stores.repository.js

@@ -1,37 +0,0 @@
-import { STORE_FIELDS } from "../../../constants/field-names";
-const { STATUS, IS_PUBLIC, STORE_SLUG, STORE_CATEGORY, STATS_FIELDS } = STORE_FIELDS;
-const { ACTIVE } = STORE_FIELDS.STATUS_VALUES;
-export class StoresRepository {
-    constructor(repo) {
-        this.repo = repo;
-    }
-    async findAll(query) {
-        return this.repo.findAll(query ?? {});
-    }
-    async findById(id) {
-        return this.repo.findById(id);
-    }
-    async findBySlug(storeSlug) {
-        const result = await this.repo.findAll({
-            filters: `${STORE_SLUG}==${storeSlug},${STATUS}==${ACTIVE}`,
-            perPage: 1,
-        });
-        return result.data[0] ?? null;
-    }
-    async findActive(page = 1, perPage = 20) {
-        return this.repo.findAll({
-            filters: `${STATUS}==${ACTIVE},${IS_PUBLIC}==true`,
-            sort: `-${STATS_FIELDS.ITEMS_SOLD}`,
-            page,
-            perPage,
-        });
-    }
-    async findByCategory(category, page = 1, perPage = 20) {
-        return this.repo.findAll({
-            filters: `${STORE_CATEGORY}==${category},${STATUS}==${ACTIVE}`,
-            sort: `-${STATS_FIELDS.AVERAGE_RATING}`,
-            page,
-            perPage,
-        });
-    }
-}

package/dist/features/support/repository/__tests__/support.repository.test.d.ts

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

package/dist/features/support/repository/__tests__/support.repository.test.js

@@ -1,312 +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,
-        firebaseFieldOps: {
-            arrayUnion: (...args) => args,
-            arrayRemove: (...args) => args,
-            increment: (n) => n,
-            serverTimestamp: () => new Date(),
-            delete: () => null,
-        },
-    };
-});
-vi.mock("../../../../errors/normalize", () => ({
-    normalizeError: vi.fn(),
-}));
-vi.mock("../../../../monitoring", () => ({
-    serverLogger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
-}));
-import { SupportRepository } from "../support.repository";
-import { ACTIVE_TICKET_STATUSES } from "../../schemas/firestore";
-const repo = new SupportRepository();
-function makeTicketDoc(overrides = {}) {
-    return {
-        id: "ticket-order-issue-ravi-20260627",
-        userId: "user-ravi",
-        userEmail: "ravi@test.com",
-        userDisplayName: "Ravi Kumar",
-        category: "order_issue",
-        subject: "My order is missing",
-        description: "I placed an order but never received it.",
-        orderId: "order-3-20260601-abc123",
-        status: "open",
-        priority: "normal",
-        messages: [],
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        ...overrides,
-    };
-}
-function makeMessage(overrides = {}) {
-    return {
-        id: "msg-1",
-        authorId: "user-ravi",
-        authorRole: "user",
-        body: "I need help with my order.",
-        createdAt: new Date(),
-        ...overrides,
-    };
-}
-beforeEach(() => {
-    vi.clearAllMocks();
-    db.collection.mockReturnValue(mockCollection);
-    mockCollection.doc.mockReturnValue(mockDocRef);
-    mockCollection.where.mockReturnValue(mockQuery);
-    mockCollection.add = vi.fn().mockResolvedValue({ id: "new-ticket-id", get: vi.fn().mockResolvedValue(makeSnap(makeTicketDoc(), "new-ticket-id")) });
-    mockQuery.where.mockReturnValue(mockQuery);
-    mockQuery.orderBy.mockReturnValue(mockQuery);
-    mockQuery.limit.mockReturnValue(mockQuery);
-    mockQuery.select = vi.fn().mockReturnValue(mockQuery);
-    mockQuery.get.mockResolvedValue(makeQuerySnap([]));
-    mockDocRef.get.mockResolvedValue(makeSnap(makeTicketDoc(), "ticket-1"));
-    mockDocRef.set.mockResolvedValue(undefined);
-    mockDocRef.update.mockResolvedValue(undefined);
-});
-// ---------------------------------------------------------------------------
-// createTicket
-// ---------------------------------------------------------------------------
-describe("SupportRepository.createTicket", () => {
-    it("sets status: open on new tickets", async () => {
-        const input = {
-            userId: "user-ravi",
-            userEmail: "ravi@test.com",
-            userDisplayName: "Ravi Kumar",
-            category: "order_issue",
-            subject: "Missing order",
-            description: "Order never arrived.",
-        };
-        await repo.createTicket(input);
-        // create() calls collection.add (BaseRepository.create uses add for auto-ID)
-        const addArg = mockCollection.add.mock.calls[0][0];
-        expect(addArg.status).toBe("open");
-    });
-    it("sets priority: normal by default", async () => {
-        await repo.createTicket({
-            userId: "user-ravi",
-            userEmail: "ravi@test.com",
-            userDisplayName: "Ravi Kumar",
-            category: "general",
-            subject: "Question",
-            description: "I have a question.",
-        });
-        const addArg = mockCollection.add.mock.calls[0][0];
-        expect(addArg.priority).toBe("normal");
-    });
-    it("initialises messages: [] on new ticket", async () => {
-        await repo.createTicket({
-            userId: "user-ravi",
-            userEmail: "ravi@test.com",
-            userDisplayName: "Ravi Kumar",
-            category: "general",
-            subject: "Question",
-            description: "I have a question.",
-        });
-        const addArg = mockCollection.add.mock.calls[0][0];
-        expect(addArg.messages).toEqual([]);
-    });
-    it("stores orderId when provided", async () => {
-        await repo.createTicket({
-            userId: "user-ravi",
-            userEmail: "ravi@test.com",
-            userDisplayName: "Ravi Kumar",
-            category: "order_issue",
-            subject: "Order missing",
-            description: "My order is gone.",
-            orderId: "order-3-20260601-abc123",
-        });
-        const addArg = mockCollection.add.mock.calls[0][0];
-        expect(addArg.orderId).toBe("order-3-20260601-abc123");
-    });
-    it("sets createdAt and updatedAt timestamps", async () => {
-        await repo.createTicket({
-            userId: "user-ravi",
-            userEmail: "ravi@test.com",
-            userDisplayName: "Ravi Kumar",
-            category: "general",
-            subject: "Q",
-            description: "D",
-        });
-        const addArg = mockCollection.add.mock.calls[0][0];
-        expect(addArg.createdAt).toBeInstanceOf(Date);
-        expect(addArg.updatedAt).toBeInstanceOf(Date);
-    });
-});
-// ---------------------------------------------------------------------------
-// countActiveTickets
-// ---------------------------------------------------------------------------
-describe("SupportRepository.countActiveTickets", () => {
-    it("runs a query per ACTIVE_TICKET_STATUS in parallel", async () => {
-        mockQuery.get.mockResolvedValue({ empty: true, size: 0, docs: [] });
-        await repo.countActiveTickets("user-ravi");
-        // One query per active status
-        expect(mockQuery.get).toHaveBeenCalledTimes(ACTIVE_TICKET_STATUSES.length);
-    });
-    it("returns sum of sizes across all active status queries", async () => {
-        // Each of the 3 queries returns size=2 → total should be 6
-        mockQuery.get.mockResolvedValue({ empty: false, size: 2, docs: [] });
-        const count = await repo.countActiveTickets("user-ravi");
-        expect(count).toBe(ACTIVE_TICKET_STATUSES.length * 2);
-    });
-    it("returns 0 when no active tickets", async () => {
-        mockQuery.get.mockResolvedValue({ empty: true, size: 0, docs: [] });
-        const count = await repo.countActiveTickets("user-nobody");
-        expect(count).toBe(0);
-    });
-    it("queries by userId on each sub-query", async () => {
-        mockQuery.get.mockResolvedValue({ empty: true, size: 0, docs: [] });
-        await repo.countActiveTickets("user-specific");
-        expect(mockCollection.where).toHaveBeenCalledWith(expect.stringContaining("userId"), "==", "user-specific");
-    });
-    it("uses select() stub reads (minimal cost)", async () => {
-        mockQuery.get.mockResolvedValue({ empty: true, size: 0, docs: [] });
-        await repo.countActiveTickets("user-ravi");
-        expect(mockQuery.select).toHaveBeenCalled();
-    });
-});
-// ---------------------------------------------------------------------------
-// getActiveCategoryTicket
-// ---------------------------------------------------------------------------
-describe("SupportRepository.getActiveCategoryTicket", () => {
-    it("returns existing ticket for userId + category with status waiting_on_user", async () => {
-        const ticket = makeTicketDoc({ status: "waiting_on_user", category: "order_issue" });
-        mockQuery.get.mockResolvedValue({
-            empty: false,
-            size: 1,
-            docs: [makeSnap(ticket, ticket.id)],
-        });
-        const result = await repo.getActiveCategoryTicket("user-ravi", "order_issue");
-        expect(result).not.toBeNull();
-        expect(result?.category).toBe("order_issue");
-    });
-    it("returns null when no matching ticket found", async () => {
-        mockQuery.get.mockResolvedValue({ empty: true, size: 0, docs: [] });
-        const result = await repo.getActiveCategoryTicket("user-ravi", "general");
-        expect(result).toBeNull();
-    });
-    it("queries specifically for status == waiting_on_user", async () => {
-        mockQuery.get.mockResolvedValue({ empty: true, size: 0, docs: [] });
-        await repo.getActiveCategoryTicket("user-ravi", "billing_payment");
-        expect(mockQuery.where).toHaveBeenCalledWith(expect.stringContaining("status"), "==", "waiting_on_user");
-    });
-    it("queries by userId and category", async () => {
-        mockQuery.get.mockResolvedValue({ empty: true, size: 0, docs: [] });
-        await repo.getActiveCategoryTicket("user-xyz", "account");
-        expect(mockCollection.where).toHaveBeenCalledWith(expect.stringContaining("userId"), "==", "user-xyz");
-        expect(mockQuery.where).toHaveBeenCalledWith(expect.stringContaining("category"), "==", "account");
-    });
-    it("uses limit(1) to avoid scanning all tickets", async () => {
-        mockQuery.get.mockResolvedValue({ empty: true, size: 0, docs: [] });
-        await repo.getActiveCategoryTicket("user-ravi", "general");
-        expect(mockQuery.limit).toHaveBeenCalledWith(1);
-    });
-});
-// ---------------------------------------------------------------------------
-// addMessage
-// ---------------------------------------------------------------------------
-describe("SupportRepository.addMessage", () => {
-    it("appends message using arrayUnion (does not overwrite messages array)", async () => {
-        const message = makeMessage();
-        await repo.addMessage("ticket-1", message);
-        const updateArg = mockDocRef.update.mock.calls[0][0];
-        // arrayUnion mock returns its arguments as an array
-        expect(updateArg.messages).toBeDefined();
-    });
-    it("updates updatedAt timestamp on message add", async () => {
-        await repo.addMessage("ticket-1", makeMessage());
-        const updateArg = mockDocRef.update.mock.calls[0][0];
-        expect(updateArg.updatedAt).toBeInstanceOf(Date);
-    });
-    it("sets newStatus when provided", async () => {
-        await repo.addMessage("ticket-1", makeMessage(), "in_progress");
-        const updateArg = mockDocRef.update.mock.calls[0][0];
-        expect(updateArg.status).toBe("in_progress");
-    });
-    it("does NOT set status field when newStatus not provided", async () => {
-        await repo.addMessage("ticket-1", makeMessage());
-        const updateArg = mockDocRef.update.mock.calls[0][0];
-        expect(Object.keys(updateArg)).not.toContain("status");
-    });
-    it("calls doc(ticketId).update — not collection.add", async () => {
-        await repo.addMessage("ticket-1", makeMessage());
-        expect(mockCollection.doc).toHaveBeenCalledWith("ticket-1");
-        expect(mockDocRef.update).toHaveBeenCalledOnce();
-    });
-});
-// ---------------------------------------------------------------------------
-// assignTicket
-// ---------------------------------------------------------------------------
-describe("SupportRepository.assignTicket", () => {
-    it("sets assignedTo field", async () => {
-        await repo.assignTicket("ticket-1", "employee-uid-1", "Support Agent");
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ assignedTo: "employee-uid-1" }));
-    });
-    it("sets assignedToName field", async () => {
-        await repo.assignTicket("ticket-1", "emp-1", "Alice Support");
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ assignedToName: "Alice Support" }));
-    });
-    it("sets updatedAt timestamp", async () => {
-        await repo.assignTicket("ticket-1", "emp-1", "Agent");
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ updatedAt: expect.any(Date) }));
-    });
-});
-// ---------------------------------------------------------------------------
-// updateTicketStatus
-// ---------------------------------------------------------------------------
-describe("SupportRepository.updateTicketStatus", () => {
-    it("applies provided status update", async () => {
-        await repo.updateTicketStatus("ticket-1", { status: "resolved" });
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ status: "resolved" }));
-    });
-    it("sets updatedAt on every status change", async () => {
-        await repo.updateTicketStatus("ticket-1", { status: "closed" });
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ updatedAt: expect.any(Date) }));
-    });
-    it("stores resolvedAt when provided", async () => {
-        const resolvedAt = new Date();
-        await repo.updateTicketStatus("ticket-1", { status: "resolved", resolvedAt });
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ resolvedAt }));
-    });
-    it("stores priority update when provided", async () => {
-        await repo.updateTicketStatus("ticket-1", { priority: "high" });
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ priority: "high" }));
-    });
-});
-// ---------------------------------------------------------------------------
-// getActiveOrderTicket
-// ---------------------------------------------------------------------------
-describe("SupportRepository.getActiveOrderTicket", () => {
-    it("returns ticket matching userId + orderId with active status", async () => {
-        const ticket = makeTicketDoc({ status: "open", orderId: "order-1" });
-        mockQuery.get.mockResolvedValue({
-            empty: false,
-            size: 1,
-            docs: [{ id: ticket.id, data: () => ticket }],
-        });
-        const result = await repo.getActiveOrderTicket("user-ravi", "order-1");
-        expect(result).not.toBeNull();
-        expect(result?.orderId).toBe("order-1");
-    });
-    it("returns null when no active order ticket exists", async () => {
-        mockQuery.get.mockResolvedValue({ empty: true, size: 0, docs: [] });
-        const result = await repo.getActiveOrderTicket("user-ravi", "order-nonexistent");
-        expect(result).toBeNull();
-    });
-    it("queries status in ACTIVE_TICKET_STATUSES", async () => {
-        mockQuery.get.mockResolvedValue({ empty: true, size: 0, docs: [] });
-        await repo.getActiveOrderTicket("user-ravi", "order-1");
-        expect(mockQuery.where).toHaveBeenCalledWith(expect.stringContaining("status"), "in", ACTIVE_TICKET_STATUSES);
-    });
-    it("uses limit(1)", async () => {
-        mockQuery.get.mockResolvedValue({ empty: true, size: 0, docs: [] });
-        await repo.getActiveOrderTicket("user-ravi", "order-1");
-        expect(mockQuery.limit).toHaveBeenCalledWith(1);
-    });
-});

package/dist/features/wishlist/repository/__tests__/user-wishlist.repository.test.d.ts

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