@mohasinac/appkit 3.0.4 → 3.1.0

package/dist/features/messages/repository/__tests__/conversations.repository.test.js

@@ -0,0 +1,257 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { makeMockDb } from "../../../../../tests/helpers/mock-firestore";
+const { db, mockDocRef, mockCollection, mockQuery, mockTxn } = makeMockDb();
+vi.mock("../../../../providers/db-firebase", () => ({
+    getAdminDb: () => db,
+}));
+vi.mock("../../../../monitoring", () => ({
+    serverLogger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+}));
+vi.mock("../../../../errors/normalize", () => ({
+    normalizeError: vi.fn(),
+}));
+import { ConversationsRepository } from "../conversations.repository";
+const repo = new ConversationsRepository();
+function makeConvData(overrides = {}) {
+    return {
+        buyerId: "user-ravi",
+        buyerDisplayName: "Ravi Kumar",
+        storeId: "store-pokemon-palace",
+        storeName: "Pokemon Palace",
+        sellerDisplayName: "Misty Singh",
+        productId: "product-charizard",
+        productTitle: "Charizard PSA9",
+        messages: [],
+        lastMessage: "",
+        lastMessageAt: new Date(),
+        unreadBuyer: 0,
+        unreadSeller: 0,
+        status: "active",
+        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.get.mockResolvedValue({ docs: [], empty: true, size: 0 });
+    mockDocRef.get.mockResolvedValue({ exists: false, id: "mock-id", data: () => ({}) });
+    mockDocRef.update.mockResolvedValue(undefined);
+    db.runTransaction.mockImplementation(async (fn) => fn(mockTxn));
+    mockTxn.get.mockResolvedValue({ exists: false, id: "mock-id", data: () => ({}) });
+    mockTxn.set.mockReturnValue(undefined);
+    mockTxn.update.mockReturnValue(undefined);
+});
+// ---------------------------------------------------------------------------
+// findOrCreateByContext
+// ---------------------------------------------------------------------------
+describe("ConversationsRepository.findOrCreateByContext", () => {
+    it("generates stable ID: conv-{buyerId}-{storeId}-{productId}", async () => {
+        const convData = makeConvData();
+        mockTxn.get.mockResolvedValue({ exists: true, id: "conv-user-ravi-store-pokemon-palace-product-charizard", data: () => convData });
+        const result = await repo.findOrCreateByContext({
+            buyerId: "user-ravi",
+            buyerDisplayName: "Ravi Kumar",
+            storeId: "store-pokemon-palace",
+            storeName: "Pokemon Palace",
+            sellerDisplayName: "Misty Singh",
+            productId: "product-charizard",
+        });
+        expect(mockCollection.doc).toHaveBeenCalledWith("conv-user-ravi-store-pokemon-palace-product-charizard");
+        expect(result.buyerId).toBe("user-ravi");
+    });
+    it("uses 'general' productKey when productId is not provided", async () => {
+        const convData = makeConvData({ productId: undefined });
+        mockTxn.get.mockResolvedValue({ exists: true, id: "conv-user-ravi-store-1-general", data: () => convData });
+        await repo.findOrCreateByContext({
+            buyerId: "user-ravi",
+            buyerDisplayName: "Ravi",
+            storeId: "store-1",
+            storeName: "Store 1",
+            sellerDisplayName: "Seller 1",
+        });
+        expect(mockCollection.doc).toHaveBeenCalledWith("conv-user-ravi-store-1-general");
+    });
+    it("returns existing conversation without creating a new one (idempotent)", async () => {
+        const convData = makeConvData();
+        mockTxn.get.mockResolvedValue({ exists: true, id: "conv-abc", data: () => convData });
+        await repo.findOrCreateByContext({
+            buyerId: "user-ravi",
+            buyerDisplayName: "Ravi",
+            storeId: "store-1",
+            storeName: "Store 1",
+            sellerDisplayName: "Seller",
+        });
+        expect(mockTxn.set).not.toHaveBeenCalled();
+    });
+    it("creates a new conversation when one does not exist", async () => {
+        mockTxn.get.mockResolvedValue({ exists: false, id: "conv-new", data: () => ({}) });
+        await repo.findOrCreateByContext({
+            buyerId: "user-new",
+            buyerDisplayName: "New Buyer",
+            storeId: "store-new",
+            storeName: "New Store",
+            sellerDisplayName: "New Seller",
+        });
+        expect(mockTxn.set).toHaveBeenCalledOnce();
+    });
+    it("new conversation starts with messages=[], unreadBuyer=0, unreadSeller=0", async () => {
+        mockTxn.get.mockResolvedValue({ exists: false, id: "conv-new", data: () => ({}) });
+        const result = await repo.findOrCreateByContext({
+            buyerId: "user-new",
+            buyerDisplayName: "New",
+            storeId: "store-new",
+            storeName: "New Store",
+            sellerDisplayName: "Seller",
+        });
+        expect(result.messages).toHaveLength(0);
+        expect(result.unreadBuyer).toBe(0);
+        expect(result.unreadSeller).toBe(0);
+    });
+    it("uses Firestore transaction for atomicity", async () => {
+        mockTxn.get.mockResolvedValue({ exists: false, id: "conv-new", data: () => ({}) });
+        await repo.findOrCreateByContext({
+            buyerId: "user-a",
+            buyerDisplayName: "A",
+            storeId: "store-b",
+            storeName: "B",
+            sellerDisplayName: "Seller",
+        });
+        expect(db.runTransaction).toHaveBeenCalledOnce();
+    });
+});
+// ---------------------------------------------------------------------------
+// appendMessage
+// ---------------------------------------------------------------------------
+describe("ConversationsRepository.appendMessage", () => {
+    it("increments unreadBuyer when seller sends a message", async () => {
+        const convData = makeConvData({ unreadBuyer: 0, unreadSeller: 0 });
+        mockTxn.get.mockResolvedValue({ exists: true, id: "conv-1", data: () => convData });
+        const result = await repo.appendMessage("conv-1", {
+            senderId: "seller-uid",
+            senderRole: "seller",
+            body: "Hello buyer!",
+        });
+        expect(result.unreadBuyer).toBe(1);
+        expect(result.unreadSeller).toBe(0);
+    });
+    it("increments unreadSeller when buyer sends a message", async () => {
+        const convData = makeConvData({ unreadBuyer: 0, unreadSeller: 2 });
+        mockTxn.get.mockResolvedValue({ exists: true, id: "conv-1", data: () => convData });
+        const result = await repo.appendMessage("conv-1", {
+            senderId: "buyer-uid",
+            senderRole: "buyer",
+            body: "Hello seller!",
+        });
+        expect(result.unreadSeller).toBe(3);
+        expect(result.unreadBuyer).toBe(0);
+    });
+    it("appends the new message to the existing messages array", async () => {
+        const existingMsg = {
+            id: "msg-old",
+            senderId: "seller-uid",
+            senderRole: "seller",
+            body: "Previous message",
+            isRead: false,
+            sentAt: new Date(),
+        };
+        const convData = makeConvData({ messages: [existingMsg] });
+        mockTxn.get.mockResolvedValue({ exists: true, id: "conv-1", data: () => convData });
+        const result = await repo.appendMessage("conv-1", {
+            senderId: "buyer-uid",
+            senderRole: "buyer",
+            body: "New message",
+        });
+        expect(result.messages).toHaveLength(2);
+        expect(result.messages[1].body).toBe("New message");
+    });
+    it("sets isRead: false on the new message", async () => {
+        const convData = makeConvData();
+        mockTxn.get.mockResolvedValue({ exists: true, id: "conv-1", data: () => convData });
+        const result = await repo.appendMessage("conv-1", {
+            senderId: "buyer-uid",
+            senderRole: "buyer",
+            body: "Test",
+        });
+        expect(result.messages[0].isRead).toBe(false);
+    });
+    it("updates lastMessage and lastMessageAt", async () => {
+        const convData = makeConvData();
+        mockTxn.get.mockResolvedValue({ exists: true, id: "conv-1", data: () => convData });
+        const result = await repo.appendMessage("conv-1", {
+            senderId: "buyer-uid",
+            senderRole: "buyer",
+            body: "Latest message",
+        });
+        expect(result.lastMessage).toBe("Latest message");
+        expect(result.lastMessageAt).toBeInstanceOf(Date);
+    });
+    it("uses Firestore transaction", async () => {
+        const convData = makeConvData();
+        mockTxn.get.mockResolvedValue({ exists: true, id: "conv-1", data: () => convData });
+        await repo.appendMessage("conv-1", { senderId: "uid", senderRole: "buyer", body: "msg" });
+        expect(db.runTransaction).toHaveBeenCalledOnce();
+        expect(mockTxn.update).toHaveBeenCalledOnce();
+    });
+    it("throws when conversation not found", async () => {
+        mockTxn.get.mockResolvedValue({ exists: false, id: "conv-ghost", data: () => ({}) });
+        await expect(repo.appendMessage("conv-ghost", { senderId: "uid", senderRole: "buyer", body: "msg" })).rejects.toThrow(/not found/i);
+    });
+});
+// ---------------------------------------------------------------------------
+// markRead
+// ---------------------------------------------------------------------------
+describe("ConversationsRepository.markRead", () => {
+    it("zeroes unreadBuyer when role=buyer", async () => {
+        const sellerMsg = { id: "m1", senderId: "seller", senderRole: "seller", body: "Hi", isRead: false, sentAt: new Date() };
+        const convData = makeConvData({ unreadBuyer: 3, unreadSeller: 1, messages: [sellerMsg] });
+        mockTxn.get.mockResolvedValue({ exists: true, id: "conv-1", data: () => convData });
+        await repo.markRead("conv-1", "buyer");
+        const updateArg = mockTxn.update.mock.calls[0][1];
+        expect(updateArg.unreadBuyer).toBe(0);
+    });
+    it("does NOT touch unreadSeller when buyer reads", async () => {
+        const convData = makeConvData({ unreadBuyer: 2, unreadSeller: 5 });
+        mockTxn.get.mockResolvedValue({ exists: true, id: "conv-1", data: () => convData });
+        await repo.markRead("conv-1", "buyer");
+        const updateArg = mockTxn.update.mock.calls[0][1];
+        expect(updateArg).not.toHaveProperty("unreadSeller");
+    });
+    it("zeroes unreadSeller when role=seller", async () => {
+        const buyerMsg = { id: "m1", senderId: "buyer", senderRole: "buyer", body: "Hi", isRead: false, sentAt: new Date() };
+        const convData = makeConvData({ unreadBuyer: 2, unreadSeller: 4, messages: [buyerMsg] });
+        mockTxn.get.mockResolvedValue({ exists: true, id: "conv-1", data: () => convData });
+        await repo.markRead("conv-1", "seller");
+        const updateArg = mockTxn.update.mock.calls[0][1];
+        expect(updateArg.unreadSeller).toBe(0);
+    });
+    it("marks seller-sent messages as isRead=true when buyer reads", async () => {
+        const sellerMsg = { id: "m1", senderId: "seller", senderRole: "seller", body: "Hi", isRead: false, sentAt: new Date() };
+        const convData = makeConvData({ messages: [sellerMsg] });
+        mockTxn.get.mockResolvedValue({ exists: true, id: "conv-1", data: () => convData });
+        await repo.markRead("conv-1", "buyer");
+        const updateArg = mockTxn.update.mock.calls[0][1];
+        const msgs = updateArg.messages;
+        expect(msgs[0].isRead).toBe(true);
+    });
+    it("does NOT mark buyer-sent messages when buyer reads (only marks counterparty)", async () => {
+        const buyerMsg = { id: "m1", senderId: "buyer", senderRole: "buyer", body: "Hi", isRead: false, sentAt: new Date() };
+        const convData = makeConvData({ messages: [buyerMsg] });
+        mockTxn.get.mockResolvedValue({ exists: true, id: "conv-1", data: () => convData });
+        await repo.markRead("conv-1", "buyer");
+        const updateArg = mockTxn.update.mock.calls[0][1];
+        const msgs = updateArg.messages;
+        expect(msgs[0].isRead).toBe(false);
+    });
+    it("uses Firestore transaction", async () => {
+        const convData = makeConvData();
+        mockTxn.get.mockResolvedValue({ exists: true, id: "conv-1", data: () => convData });
+        await repo.markRead("conv-1", "buyer");
+        expect(db.runTransaction).toHaveBeenCalledOnce();
+    });
+});

package/dist/features/messages/schemas/firestore.d.ts

@@ -5,6 +5,7 @@
  * Messages are embedded as an array for seed purposes; production can migrate to
  * a subcollection when the thread exceeds ~200 messages.
  */
+import type { BaseDocument } from "../../../_internal/shared/types/base-document";
 export interface ConversationMessage {
     id: string;
     senderId: string;
@@ -14,8 +15,7 @@ export interface ConversationMessage {
     sentAt: Date;
     attachments?: string[];
 }
-export interface ConversationDocument {
-    id: string;
+export interface ConversationDocument extends BaseDocument {
     buyerId: string;
     buyerDisplayName: string;
     storeId: string;
@@ -29,8 +29,6 @@ export interface ConversationDocument {
     unreadBuyer: number;
     unreadSeller: number;
     status: "active" | "archived" | "blocked";
-    createdAt: Date;
-    updatedAt: Date;
 }
 export declare const CONVERSATIONS_COLLECTION: "conversations";
 export declare const CONVERSATIONS_INDEXED_FIELDS: readonly ["buyerId", "storeId", "productId", "status", "lastMessageAt", "createdAt"];

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

@@ -112,8 +112,8 @@ export declare const conversationFirestoreSchema: 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">;
@@ -145,8 +145,8 @@ export declare const conversationFirestoreSchema: 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">;

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

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

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

@@ -0,0 +1,211 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { makeMockDb, makeSnap, makeQuerySnap } from "../../../../../tests/helpers/mock-firestore";
+const { db, mockDocRef, mockCollection, mockQuery, mockBatch } = makeMockDb();
+vi.mock("../../../../providers/db-firebase", () => ({
+    getAdminDb: () => db,
+    prepareForFirestore: (data) => data,
+    BaseRepository: class {
+        get db() { return db; }
+        constructor(col) { this.collection = col; }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        getCollection() { return db.collection(this.collection); }
+        mapDoc(snap) {
+            return { id: snap.id, ...snap.data() };
+        }
+        async findById(id) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const snap = await db.collection(this.collection).doc(id).get();
+            return snap.exists ? { id: snap.id, ...snap.data() } : null;
+        }
+        async findBy(field, value) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const snap = await db.collection(this.collection).where(field, "==", value).get();
+            return snap.docs.map((d) => ({ id: d.id, ...d.data() }));
+        }
+        async update(id, data) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            await db.collection(this.collection).doc(id).update(data);
+            return { id, ...data };
+        }
+    },
+}));
+vi.mock("../../../../monitoring", () => ({
+    serverLogger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+}));
+vi.mock("../../../../errors/normalize", () => ({
+    normalizeError: vi.fn(),
+}));
+vi.mock("../../../../security", () => ({
+    ORDER_PII_FIELDS: ["shippingAddress.phone", "shippingAddress.fullName"],
+    encryptPiiFields: (data) => data,
+    decryptPiiFields: (data) => data,
+}));
+vi.mock("../../../../contracts/field-ops", () => ({
+    serverTimestamp: () => new Date(),
+}));
+vi.mock("../../schemas", async () => ({
+    ORDER_COLLECTION: "orders",
+    OrderStatusValues: {
+        PENDING: "pending",
+        CONFIRMED: "confirmed",
+        PROCESSING: "processing",
+        SHIPPED: "shipped",
+        DELIVERED: "delivered",
+        CANCELLED: "cancelled",
+        REFUNDED: "refunded",
+    },
+    createOrderId: () => "order-1-20260101-abc123",
+}));
+import { OrderRepository } from "../orders.repository";
+const repo = new OrderRepository();
+beforeEach(() => {
+    vi.clearAllMocks();
+    mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+    mockDocRef.get.mockResolvedValue(makeSnap(null));
+    mockDocRef.update.mockResolvedValue(undefined);
+    mockDocRef.delete.mockResolvedValue(undefined);
+    mockCollection.doc.mockReturnValue(mockDocRef);
+    db.collection.mockReturnValue(mockCollection);
+    db.batch.mockReturnValue(mockBatch);
+});
+describe("OrderRepository.cancelOrder", () => {
+    it("sets status: cancelled", async () => {
+        mockDocRef.update.mockResolvedValue(undefined);
+        await repo.cancelOrder("order-1", "user changed mind");
+        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ status: "cancelled" }));
+    });
+    it("stores cancellation reason", async () => {
+        await repo.cancelOrder("order-1", "payment failed");
+        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ cancellationReason: "payment failed" }));
+    });
+});
+describe("OrderRepository.updateStatus", () => {
+    it("updates status and updatedAt", async () => {
+        await repo.updateStatus("order-1", "shipped");
+        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ status: "shipped", updatedAt: expect.any(Date) }));
+    });
+});
+describe("OrderRepository.hasUserPurchased", () => {
+    it("returns true when confirmed order exists for user + product", async () => {
+        const docs = makeQuerySnap([
+            { id: "o1", data: { userId: "user-1", productId: "product-x", status: "confirmed" } },
+        ]);
+        mockQuery.get.mockResolvedValue(docs);
+        const result = await repo.hasUserPurchased("user-1", "product-x");
+        expect(result).toBe(true);
+    });
+    it("returns true for DELIVERED status", async () => {
+        const docs = makeQuerySnap([
+            { id: "o1", data: { userId: "user-1", productId: "product-x", status: "delivered" } },
+        ]);
+        mockQuery.get.mockResolvedValue(docs);
+        const result = await repo.hasUserPurchased("user-1", "product-x");
+        expect(result).toBe(true);
+    });
+    it("returns false for CANCELLED status", async () => {
+        const docs = makeQuerySnap([
+            { id: "o1", data: { userId: "user-1", productId: "product-x", status: "cancelled" } },
+        ]);
+        mockQuery.get.mockResolvedValue(docs);
+        const result = await repo.hasUserPurchased("user-1", "product-x");
+        expect(result).toBe(false);
+    });
+    it("returns false when no orders exist", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        const result = await repo.hasUserPurchased("user-1", "product-x");
+        expect(result).toBe(false);
+    });
+});
+describe("OrderRepository.countByUserAndProduct", () => {
+    it("returns query size (active statuses)", async () => {
+        mockQuery.get.mockResolvedValue({ ...makeQuerySnap([
+                { id: "o1", data: { status: "pending" } },
+                { id: "o2", data: { status: "delivered" } },
+            ]), size: 2 });
+        const count = await repo.countByUserAndProduct("user-1", "product-x");
+        expect(count).toBe(2);
+    });
+});
+describe("OrderRepository.getTimedOutPending", () => {
+    it("filters by status=pending, paymentStatus=pending, createdAt < cutoff", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        await repo.getTimedOutPending(24);
+        expect(mockQuery.where).toHaveBeenCalledWith("status", "==", "pending");
+        expect(mockQuery.where).toHaveBeenCalledWith("paymentStatus", "==", "pending");
+        expect(mockQuery.where).toHaveBeenCalledWith("createdAt", "<", expect.any(Date));
+    });
+    it("returns docs with id, ref, and data", async () => {
+        const docs = makeQuerySnap([
+            { id: "o-timeout", data: { status: "pending", paymentStatus: "pending" } },
+        ]);
+        // Attach .ref to each doc
+        docs.docs[0].ref = { id: "o-timeout" };
+        mockQuery.get.mockResolvedValue(docs);
+        const result = await repo.getTimedOutPending(24);
+        expect(result[0].id).toBe("o-timeout");
+        expect(result[0].data).toBeDefined();
+    });
+});
+describe("OrderRepository.cancelInBatch", () => {
+    it("stages status: cancelled in caller batch, does NOT commit", () => {
+        const ref = { id: "order-1" };
+        repo.cancelInBatch(mockBatch, ref);
+        expect(mockBatch.update).toHaveBeenCalledWith(ref, expect.objectContaining({ status: "cancelled", cancellationReason: "payment_timeout" }));
+        expect(mockBatch.commit).not.toHaveBeenCalled();
+    });
+});
+describe("OrderRepository.markPayoutRequested", () => {
+    it("stages payoutStatus: requested in caller batch, does NOT commit", () => {
+        const ref = { id: "order-1" };
+        repo.markPayoutRequested(mockBatch, ref, "payout-123");
+        expect(mockBatch.update).toHaveBeenCalledWith(ref, expect.objectContaining({ payoutStatus: "requested", payoutId: "payout-123" }));
+        expect(mockBatch.commit).not.toHaveBeenCalled();
+    });
+});
+describe("OrderRepository.postRefundEvent", () => {
+    it("appends refund event to refunds array, sets contestable: false", async () => {
+        mockDocRef.get.mockResolvedValue(makeSnap({
+            status: "delivered",
+            refunds: [],
+            totalPrice: 10000,
+        }));
+        const event = { type: "partial", amountInPaise: 5000, reason: "damaged", refundedBy: "admin-1", refundedAt: new Date() };
+        await repo.postRefundEvent("order-1", event);
+        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ contestable: false, refunds: [event] }));
+    });
+    it("becomeRefunded=true → sets status: refunded", async () => {
+        mockDocRef.get.mockResolvedValue(makeSnap({ status: "delivered", refunds: [], totalPrice: 10000 }));
+        const event = { type: "full", amountInPaise: 10000, reason: "return", refundedBy: "admin-1", refundedAt: new Date() };
+        await repo.postRefundEvent("order-1", event, true);
+        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ status: "refunded" }));
+    });
+    it("order not found → throws NotFoundError", async () => {
+        mockDocRef.get.mockResolvedValue(makeSnap(null));
+        const { NotFoundError } = await import("../../../../errors");
+        await expect(repo.postRefundEvent("nonexistent", {})).rejects.toBeInstanceOf(NotFoundError);
+    });
+});
+describe("OrderRepository.createFromAuction", () => {
+    it("stages order creation in caller batch with correct fields", () => {
+        mockCollection.doc.mockReturnValue({ ...mockDocRef, id: "new-order-id" });
+        repo.createFromAuction(mockBatch, {
+            productId: "auction-test",
+            productTitle: "Test Auction",
+            userId: "user-1",
+            userName: "Ravi Kumar",
+            userEmail: "ravi@example.com",
+            storeId: "store-1",
+            amount: 10000,
+            currency: "INR",
+            auctionProductId: "auction-test",
+        });
+        expect(mockBatch.create).toHaveBeenCalledWith(expect.anything(), expect.objectContaining({
+            productId: "auction-test",
+            userId: "user-1",
+            storeId: "store-1",
+            totalPrice: 10000,
+            status: "confirmed",
+        }));
+        expect(mockBatch.commit).not.toHaveBeenCalled();
+    });
+});

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

@@ -15,6 +15,11 @@ declare class OrderRepository extends BaseRepository<OrderDocument> {
     findConfirmed(): Promise<OrderDocument[]>;
     findPending(): Promise<OrderDocument[]>;
     updateStatus(orderId: string, status: OrderStatus, additionalData?: Partial<OrderDocument>): Promise<OrderDocument>;
+    assignWorker(orderId: string, workerId: string): Promise<OrderDocument>;
+    unassignWorker(orderId: string): Promise<OrderDocument>;
+    markPicked(orderId: string): Promise<OrderDocument>;
+    markPacked(orderId: string): Promise<OrderDocument>;
+    findFulfillmentQueue(storeId: string): Promise<OrderDocument[]>;
     updatePaymentStatus(orderId: string, paymentStatus: PaymentStatus, paymentId?: string): Promise<OrderDocument>;
     cancelOrder(orderId: string, reason: string, refundAmount?: number): Promise<OrderDocument>;
     findRecentByUser(userId: string): Promise<OrderDocument[]>;

package/dist/features/orders/repository/orders.repository.js

@@ -71,6 +71,32 @@ class OrderRepository extends BaseRepository {
             updatedAt: new Date(),
         });
     }
+    async assignWorker(orderId, workerId) {
+        return this.update(orderId, { assignedWorkerId: workerId, updatedAt: new Date() });
+    }
+    async unassignWorker(orderId) {
+        return this.update(orderId, { assignedWorkerId: undefined, updatedAt: new Date() });
+    }
+    async markPicked(orderId) {
+        const order = await this.findById(orderId);
+        if (!order)
+            throw new NotFoundError(`Order ${orderId} not found`);
+        const nextStatus = order.status === "confirmed" ? "processing" : order.status;
+        return this.update(orderId, { pickedAt: new Date(), status: nextStatus, updatedAt: new Date() });
+    }
+    async markPacked(orderId) {
+        return this.update(orderId, { packedAt: new Date(), updatedAt: new Date() });
+    }
+    async findFulfillmentQueue(storeId) {
+        const snap = await this.db
+            .collection(this.collection)
+            .where(ORDER_FIELDS.STORE_ID, "==", storeId)
+            .where(ORDER_FIELDS.STATUS, "in", ["confirmed", "processing"])
+            .orderBy(ORDER_FIELDS.CREATED_AT, "asc")
+            .limit(200)
+            .get();
+        return snap.docs.map((doc) => this.decryptOrder({ id: doc.id, ...doc.data() }));
+    }
     async updatePaymentStatus(orderId, paymentStatus, paymentId) {
         return this.update(orderId, {
             paymentStatus,

package/dist/features/orders/schemas/firestore.d.ts

@@ -3,6 +3,7 @@
  */
 import type { OrderStatus, PaymentStatus } from "../types";
 import type { OrderType } from "../utils/order-splitter";
+import type { BaseDocument } from "../../../_internal/shared/types/base-document";
 export type ShippingMethod = "custom" | "shiprocket";
 export type RefundType = "full" | "partial";
 export type OrderPayoutStatus = "eligible" | "requested" | "paid";
@@ -99,8 +100,7 @@ export interface AppliedOrderDiscount {
     scope?: "admin" | "seller";
     storeId?: string;
 }
-export interface OrderDocument {
-    id: string;
+export interface OrderDocument extends BaseDocument {
     productId: string;
     productTitle: string;
     userId: string;
@@ -203,11 +203,15 @@ export interface OrderDocument {
         shelf: string;
         bin: string;
     };
-    createdAt: Date;
-    updatedAt: Date;
+    /** UID of the employee or seller assigned to fulfil this order. */
+    assignedWorkerId?: string;
+    /** Timestamp when all items in this order were physically confirmed picked. */
+    pickedAt?: Date;
+    /** Timestamp when the order was packed and ready for courier handoff. */
+    packedAt?: Date;
 }
 export declare const ORDER_COLLECTION: "orders";
-export declare const ORDER_INDEXED_FIELDS: readonly ["userId", "productId", "storeId", "status", "paymentStatus", "payoutStatus", "shippingMethod", "orderDate", "createdAt"];
+export declare const ORDER_INDEXED_FIELDS: readonly ["userId", "productId", "storeId", "status", "paymentStatus", "payoutStatus", "shippingMethod", "orderDate", "createdAt", "assignedWorkerId", "pickedAt", "packedAt"];
 export declare const DEFAULT_ORDER_DATA: Partial<OrderDocument>;
 export declare const ORDER_PUBLIC_FIELDS: readonly ["id", "productId", "productTitle", "quantity", "unitPrice", "totalPrice", "currency", "status", "paymentStatus", "shippingAddress", "trackingNumber", "notes", "orderDate", "shippingDate", "deliveryDate", "createdAt"];
 export declare const ORDER_UPDATABLE_FIELDS: readonly ["notes", "shippingAddress"];

package/dist/features/orders/schemas/firestore.js

@@ -54,6 +54,9 @@ export const ORDER_INDEXED_FIELDS = [
     "shippingMethod",
     "orderDate",
     "createdAt",
+    "assignedWorkerId",
+    "pickedAt",
+    "packedAt",
 ];
 export const DEFAULT_ORDER_DATA = {
     status: "pending",

package/dist/features/payments/repository/__tests__/payout.repository.test.d.ts

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