@mohasinac/appkit 3.0.4 → 3.1.0

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

@@ -0,0 +1,261 @@
+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/schemas/firestore.d.ts

@@ -5,6 +5,7 @@
  * and helpers for the stores feature.
  */
 import type { StoreCapability } from "../../auth/permissions/constants";
+import type { BaseDocument } from "../../../_internal/shared/types/base-document";
 export type ShippingProviderType = "shiprocket" | "self-courier" | "store-pickup" | "custom";
 export interface ShippingProviderConfig {
     /** Stable slug — never changes after creation. */
@@ -46,8 +47,7 @@ export declare const StoreStatusValues: {
     readonly REJECTED: "rejected";
 };
 export type StoreStatus = (typeof StoreStatusValues)[keyof typeof StoreStatusValues];
-export interface StoreDocument {
-    id: string;
+export interface StoreDocument extends BaseDocument {
     storeSlug: string;
     ownerId: string;
     storeName: string;
@@ -123,8 +123,6 @@ export interface StoreDocument {
         /** When the seller first connected their account */
         connectedAt?: Date;
     };
-    createdAt: Date;
-    updatedAt: Date;
 }
 export type { StoreCapability } from "../../auth/permissions/constants";
 export declare const STORE_COLLECTION: "stores";

package/dist/features/stores/schemas/index.d.ts

@@ -405,8 +405,8 @@ export declare const storeFirestoreSchema: z.ZodObject<{
     createdAt: string | Date | z.objectOutputType<{
         toDate: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodDate>;
     }, z.ZodTypeAny, "passthrough">;
-    id: string;
     storeName: string;
+    id: string;
     updatedAt: string | Date | z.objectOutputType<{
         toDate: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodDate>;
     }, z.ZodTypeAny, "passthrough">;
@@ -489,8 +489,8 @@ export declare const storeFirestoreSchema: z.ZodObject<{
     createdAt: string | Date | z.objectInputType<{
         toDate: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodDate>;
     }, z.ZodTypeAny, "passthrough">;
-    id: string;
     storeName: string;
+    id: string;
     updatedAt: string | Date | z.objectInputType<{
         toDate: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodDate>;
     }, z.ZodTypeAny, "passthrough">;
@@ -603,8 +603,8 @@ export declare const storeListItemSchema: z.ZodObject<{
     createdAt: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     status: string;
-    id: string;
     storeName: string;
+    id: string;
     isPublic: boolean;
     storeSlug: string;
     ownerId: string;
@@ -619,8 +619,8 @@ export declare const storeListItemSchema: z.ZodObject<{
     averageRating?: number | undefined;
 }, {
     status: string;
-    id: string;
     storeName: string;
+    id: string;
     isPublic: boolean;
     storeSlug: string;
     ownerId: string;

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

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

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

@@ -0,0 +1,312 @@
+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/support/schemas/firestore.d.ts

@@ -14,6 +14,7 @@
  *  - No creation if user has create_support_tickets soft ban
  *  - No new ticket in the same category while existing one is waiting_on_user
  */
+import type { BaseDocument } from "../../../_internal/shared/types/base-document";
 export declare const TicketCategoryValues: {
     readonly ORDER_ISSUE: "order_issue";
     readonly BILLING_PAYMENT: "billing_payment";
@@ -70,8 +71,7 @@ export interface TicketRelatedParties {
     productId?: string;
     bidId?: string;
 }
-export interface SupportTicketDocument {
-    id: string;
+export interface SupportTicketDocument extends BaseDocument {
     userId: string;
     /** Denormalized — for admin table display. */
     userEmail: string;
@@ -103,8 +103,6 @@ export interface SupportTicketDocument {
     messages: TicketMessage[];
     resolvedAt?: Date;
     closedAt?: Date;
-    createdAt: Date;
-    updatedAt: Date;
 }
 export type SupportTicketCreateInput = Pick<SupportTicketDocument, "userId" | "userEmail" | "userDisplayName" | "category" | "subject" | "description" | "orderId">;
 export type SupportTicketUpdateInput = Partial<Pick<SupportTicketDocument, "status" | "priority" | "assignedTo" | "assignedToName" | "internalNotes" | "resolvedAt" | "closedAt" | "relatedParties">>;