@mohasinac/appkit 3.0.6 → 3.1.1

package/dist/_internal/server/jobs/core/__tests__/auctionSettlement.test.js

@@ -0,0 +1,249 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+const { mockGetExpiredAuctions, mockGetActiveByProduct, mockUpdateStatusInBatch, mockMarkWon, mockMarkLost, mockCreateFromAuction, mockBatchUpdate, mockBatchCommit, mockSendNotification, } = vi.hoisted(() => ({
+    mockGetExpiredAuctions: vi.fn(),
+    mockGetActiveByProduct: vi.fn(),
+    mockUpdateStatusInBatch: vi.fn(),
+    mockMarkWon: vi.fn(),
+    mockMarkLost: vi.fn(),
+    mockCreateFromAuction: vi.fn(),
+    mockBatchUpdate: vi.fn(),
+    mockBatchCommit: vi.fn().mockResolvedValue(undefined),
+    mockSendNotification: vi.fn().mockResolvedValue(undefined),
+}));
+vi.mock("../../../../../repositories", () => ({
+    productRepository: {
+        getExpiredAuctions: mockGetExpiredAuctions,
+        updateStatusInBatch: mockUpdateStatusInBatch,
+    },
+    bidRepository: {
+        getActiveByProduct: mockGetActiveByProduct,
+        markWon: mockMarkWon,
+        markLost: mockMarkLost,
+    },
+    orderRepository: {
+        createFromAuction: mockCreateFromAuction,
+    },
+}));
+vi.mock("../../../../../features/admin/actions/notification-actions", () => ({
+    sendNotification: mockSendNotification,
+}));
+import { runAuctionSettlement } from "../auctionSettlement";
+// ── Helpers ─────────────────────────────────────────────────────────────────
+function makeCtx(overrides = {}) {
+    const mockDoc = vi.fn().mockReturnValue({ id: "products/auction-1" });
+    const mockCollection = vi.fn().mockReturnValue({ doc: mockDoc });
+    const batch = {
+        update: mockBatchUpdate,
+        commit: mockBatchCommit,
+        set: vi.fn(),
+        delete: vi.fn(),
+    };
+    return {
+        db: {
+            collection: mockCollection,
+            batch: vi.fn().mockReturnValue(batch),
+        },
+        now: new Date(),
+        logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+        ...overrides,
+    };
+}
+function makeAuction(overrides = {}) {
+    return {
+        id: "auction-pokemon-charizard",
+        title: "Pokemon Charizard",
+        storeId: "store-A",
+        listingType: "auction",
+        availableQuantity: 1,
+        ...overrides,
+    };
+}
+function makeBid(overrides = {}) {
+    return {
+        ref: { id: "bid-ref-1" },
+        data: {
+            userId: "user-ravi",
+            userName: "Ravi Kumar",
+            userEmail: "ravi@example.com",
+            bidAmount: 25000,
+            currency: "INR",
+            ...overrides,
+        },
+    };
+}
+beforeEach(() => {
+    vi.clearAllMocks();
+    mockBatchCommit.mockResolvedValue(undefined);
+    mockSendNotification.mockResolvedValue(undefined);
+    mockCreateFromAuction.mockReturnValue({ id: "order-1" });
+});
+describe("runAuctionSettlement — no expired auctions", () => {
+    it("returns early when no expired auctions exist", async () => {
+        mockGetExpiredAuctions.mockResolvedValue([]);
+        const ctx = makeCtx();
+        await runAuctionSettlement(ctx);
+        expect(mockGetActiveByProduct).not.toHaveBeenCalled();
+    });
+    it("logs 'No expired auctions found' when list is empty", async () => {
+        mockGetExpiredAuctions.mockResolvedValue([]);
+        const ctx = makeCtx();
+        await runAuctionSettlement(ctx);
+        expect(ctx.logger.info).toHaveBeenCalledWith(expect.stringMatching(/No expired auctions/i));
+    });
+});
+describe("runAuctionSettlement — auction with no bids", () => {
+    it("archives product when no active bids", async () => {
+        const auction = makeAuction();
+        mockGetExpiredAuctions.mockResolvedValue([{ data: auction }]);
+        mockGetActiveByProduct.mockResolvedValue([]);
+        const ctx = makeCtx();
+        await runAuctionSettlement(ctx);
+        expect(mockUpdateStatusInBatch).toHaveBeenCalledWith(expect.any(Object), // batch
+        auction.id, "archived");
+        expect(mockBatchCommit).toHaveBeenCalled();
+    });
+    it("does NOT call createFromAuction when no bids", async () => {
+        mockGetExpiredAuctions.mockResolvedValue([{ data: makeAuction() }]);
+        mockGetActiveByProduct.mockResolvedValue([]);
+        await runAuctionSettlement(makeCtx());
+        expect(mockCreateFromAuction).not.toHaveBeenCalled();
+    });
+    it("does NOT send win/loss notifications when no bids", async () => {
+        mockGetExpiredAuctions.mockResolvedValue([{ data: makeAuction() }]);
+        mockGetActiveByProduct.mockResolvedValue([]);
+        await runAuctionSettlement(makeCtx());
+        expect(mockSendNotification).not.toHaveBeenCalled();
+    });
+});
+describe("runAuctionSettlement — auction with bids", () => {
+    it("marks the highest bid as won", async () => {
+        const winner = makeBid({ bidAmount: 30000 });
+        const loser = makeBid({ bidAmount: 20000, userId: "user-ankit" });
+        mockGetExpiredAuctions.mockResolvedValue([{ data: makeAuction() }]);
+        mockGetActiveByProduct.mockResolvedValue([winner, loser]);
+        await runAuctionSettlement(makeCtx());
+        expect(mockMarkWon).toHaveBeenCalledWith(expect.any(Object), winner.ref);
+    });
+    it("marks all other bids as lost", async () => {
+        const winner = makeBid({ bidAmount: 30000 });
+        const loser1 = makeBid({ userId: "user-ankit", bidAmount: 20000 });
+        const loser2 = makeBid({ userId: "user-priya", bidAmount: 15000 });
+        mockGetExpiredAuctions.mockResolvedValue([{ data: makeAuction() }]);
+        mockGetActiveByProduct.mockResolvedValue([winner, loser1, loser2]);
+        await runAuctionSettlement(makeCtx());
+        expect(mockMarkLost).toHaveBeenCalledTimes(2);
+        expect(mockMarkLost).toHaveBeenCalledWith(expect.any(Object), loser1.ref);
+        expect(mockMarkLost).toHaveBeenCalledWith(expect.any(Object), loser2.ref);
+    });
+    it("creates an order from auction data (winner becomes buyer)", async () => {
+        const winner = makeBid({ bidAmount: 25000, userId: "user-ravi" });
+        const auction = makeAuction({ id: "auction-1", title: "Charizard", storeId: "store-B" });
+        mockGetExpiredAuctions.mockResolvedValue([{ data: auction }]);
+        mockGetActiveByProduct.mockResolvedValue([winner]);
+        await runAuctionSettlement(makeCtx());
+        expect(mockCreateFromAuction).toHaveBeenCalledWith(expect.any(Object), expect.objectContaining({
+            productId: "auction-1",
+            productTitle: "Charizard",
+            userId: "user-ravi",
+            storeId: "store-B",
+            amount: 25000,
+        }));
+    });
+    it("sets isSold=true and availableQuantity=0 on product", async () => {
+        const winner = makeBid();
+        mockGetExpiredAuctions.mockResolvedValue([{ data: makeAuction() }]);
+        mockGetActiveByProduct.mockResolvedValue([winner]);
+        await runAuctionSettlement(makeCtx());
+        expect(mockBatchUpdate).toHaveBeenCalledWith(expect.any(Object), // doc ref
+        expect.objectContaining({ isSold: true, availableQuantity: 0 }));
+    });
+    it("commits the batch before sending notifications", async () => {
+        const winner = makeBid();
+        mockGetExpiredAuctions.mockResolvedValue([{ data: makeAuction() }]);
+        mockGetActiveByProduct.mockResolvedValue([winner]);
+        const callOrder = [];
+        mockBatchCommit.mockImplementation(async () => { callOrder.push("commit"); });
+        mockSendNotification.mockImplementation(async () => { callOrder.push("notify"); });
+        await runAuctionSettlement(makeCtx());
+        const commitIdx = callOrder.indexOf("commit");
+        const notifyIdx = callOrder.indexOf("notify");
+        expect(commitIdx).toBeLessThan(notifyIdx);
+    });
+    it("sends bid_won notification to the winning bidder", async () => {
+        const winner = makeBid({ userId: "user-ravi", bidAmount: 25000, currency: "INR" });
+        mockGetExpiredAuctions.mockResolvedValue([{ data: makeAuction({ title: "Charizard" }) }]);
+        mockGetActiveByProduct.mockResolvedValue([winner]);
+        await runAuctionSettlement(makeCtx());
+        expect(mockSendNotification).toHaveBeenCalledWith(expect.objectContaining({ userId: "user-ravi", type: "bid_won" }));
+    });
+    it("sends bid_lost notification to each losing bidder", async () => {
+        const winner = makeBid({ userId: "user-ravi" });
+        const loser1 = makeBid({ userId: "user-ankit" });
+        const loser2 = makeBid({ userId: "user-priya" });
+        mockGetExpiredAuctions.mockResolvedValue([{ data: makeAuction() }]);
+        mockGetActiveByProduct.mockResolvedValue([winner, loser1, loser2]);
+        await runAuctionSettlement(makeCtx());
+        expect(mockSendNotification).toHaveBeenCalledWith(expect.objectContaining({ userId: "user-ankit", type: "bid_lost" }));
+        expect(mockSendNotification).toHaveBeenCalledWith(expect.objectContaining({ userId: "user-priya", type: "bid_lost" }));
+    });
+    it("notification failure for one loser does NOT abort others (allSettled)", async () => {
+        const winner = makeBid({ userId: "user-ravi" });
+        const loser1 = makeBid({ userId: "user-ankit" });
+        const loser2 = makeBid({ userId: "user-priya" });
+        mockGetExpiredAuctions.mockResolvedValue([{ data: makeAuction() }]);
+        mockGetActiveByProduct.mockResolvedValue([winner, loser1, loser2]);
+        let callCount = 0;
+        mockSendNotification.mockImplementation(async ({ type, userId }) => {
+            callCount++;
+            if (type === "bid_lost" && userId === "user-ankit") {
+                throw new Error("Notification service down");
+            }
+        });
+        // Should not throw
+        await expect(runAuctionSettlement(makeCtx())).resolves.toBeUndefined();
+        // loser2 still got notified
+        expect(callCount).toBeGreaterThanOrEqual(2);
+    });
+});
+describe("runAuctionSettlement — multiple expired auctions", () => {
+    it("settles each auction independently", async () => {
+        const auction1 = makeAuction({ id: "auction-1" });
+        const auction2 = makeAuction({ id: "auction-2" });
+        mockGetExpiredAuctions.mockResolvedValue([
+            { data: auction1 },
+            { data: auction2 },
+        ]);
+        mockGetActiveByProduct.mockResolvedValue([]);
+        await runAuctionSettlement(makeCtx());
+        expect(mockGetActiveByProduct).toHaveBeenCalledTimes(2);
+        expect(mockGetActiveByProduct).toHaveBeenCalledWith("auction-1");
+        expect(mockGetActiveByProduct).toHaveBeenCalledWith("auction-2");
+    });
+    it("one auction error does NOT abort others (allSettled)", async () => {
+        const auction1 = makeAuction({ id: "auction-1" });
+        const auction2 = makeAuction({ id: "auction-2" });
+        mockGetExpiredAuctions.mockResolvedValue([
+            { data: auction1 },
+            { data: auction2 },
+        ]);
+        // auction-1 throws, auction-2 succeeds
+        mockGetActiveByProduct
+            .mockRejectedValueOnce(new Error("Firestore query failed"))
+            .mockResolvedValueOnce([]);
+        await expect(runAuctionSettlement(makeCtx())).resolves.toBeUndefined();
+        // auction-2 was still processed (batch committed)
+        expect(mockBatchCommit).toHaveBeenCalledTimes(1);
+    });
+    it("logs the count of failed settlements when some fail", async () => {
+        mockGetExpiredAuctions.mockResolvedValue([
+            { data: makeAuction({ id: "auction-1" }) },
+            { data: makeAuction({ id: "auction-2" }) },
+        ]);
+        mockGetActiveByProduct
+            .mockRejectedValueOnce(new Error("DB error"))
+            .mockResolvedValueOnce([]);
+        const ctx = makeCtx();
+        await runAuctionSettlement(ctx);
+        expect(ctx.logger.error).toHaveBeenCalledWith(expect.stringMatching(/1 auction\(s\) failed/i), expect.any(Array));
+    });
+});

package/dist/_internal/server/jobs/core/__tests__/onBidPlaced.test.d.ts

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

package/dist/_internal/server/jobs/core/__tests__/onBidPlaced.test.js

@@ -0,0 +1,201 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+const { mockGetWinningBid, mockMarkWinning, mockMarkOutbid, mockIncrementBidCount, mockBatchCommit, mockBatchUpdate, mockSendNotification, mockRtdbPush, mockDecryptPii, } = vi.hoisted(() => ({
+    mockGetWinningBid: vi.fn(),
+    mockMarkWinning: vi.fn(),
+    mockMarkOutbid: vi.fn(),
+    mockIncrementBidCount: vi.fn(),
+    mockBatchCommit: vi.fn().mockResolvedValue(undefined),
+    mockBatchUpdate: vi.fn(),
+    mockSendNotification: vi.fn().mockResolvedValue(undefined),
+    mockRtdbPush: vi.fn().mockResolvedValue(undefined),
+    mockDecryptPii: vi.fn((v) => v),
+}));
+vi.mock("../../../../../repositories", () => ({
+    bidRepository: {
+        getWinningBid: mockGetWinningBid,
+        markWinning: mockMarkWinning,
+        markOutbid: mockMarkOutbid,
+    },
+    productRepository: {
+        incrementBidCountInBatch: mockIncrementBidCount,
+    },
+}));
+vi.mock("../../../../../features/admin/actions/notification-actions", () => ({
+    sendNotification: mockSendNotification,
+}));
+vi.mock("../../../../../providers/db-firebase", () => ({
+    getAdminRealtimeDb: vi.fn(() => ({
+        ref: vi.fn(() => ({ push: mockRtdbPush })),
+    })),
+}));
+vi.mock("../../../../../security/index", () => ({
+    decryptPii: mockDecryptPii,
+}));
+vi.mock("../../../../../errors/normalize", () => ({
+    normalizeError: vi.fn(),
+}));
+import { handleBidPlaced } from "../onBidPlaced";
+// ── Helpers ─────────────────────────────────────────────────────────────────
+function makeCtx() {
+    const batch = {
+        update: mockBatchUpdate,
+        commit: mockBatchCommit,
+        set: vi.fn(),
+        delete: vi.fn(),
+    };
+    return {
+        db: {
+            collection: vi.fn().mockReturnValue({
+                doc: vi.fn().mockReturnValue({ id: "bid-ref-1" }),
+            }),
+            batch: vi.fn().mockReturnValue(batch),
+        },
+        now: new Date(),
+        logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+    };
+}
+function makeInput(overrides = {}) {
+    return {
+        bidId: "bid-charizard-ravi-001",
+        bid: {
+            id: "bid-charizard-ravi-001",
+            productId: "auction-charizard",
+            productTitle: "Pokemon Charizard",
+            userId: "user-ravi",
+            userName: "Ravi Kumar",
+            bidAmount: 25000,
+            currency: "INR",
+            ...overrides,
+        },
+    };
+}
+function makePrevWinning(userId = "user-ankit") {
+    return {
+        ref: { id: "bid-ref-prev" },
+        data: { userId, bidAmount: 20000 },
+    };
+}
+beforeEach(() => {
+    vi.clearAllMocks();
+    mockBatchCommit.mockResolvedValue(undefined);
+    mockSendNotification.mockResolvedValue(undefined);
+    mockRtdbPush.mockResolvedValue(undefined);
+    mockDecryptPii.mockImplementation((v) => v);
+    mockGetWinningBid.mockResolvedValue(null);
+});
+// ── Tests ────────────────────────────────────────────────────────────────────
+describe("handleBidPlaced — marks new bid as winning", () => {
+    it("calls bidRepository.markWinning with new bid ref", async () => {
+        const ctx = makeCtx();
+        await handleBidPlaced(makeInput(), ctx);
+        expect(mockMarkWinning).toHaveBeenCalledWith(expect.any(Object), expect.any(Object));
+    });
+    it("calls productRepository.incrementBidCountInBatch with correct args", async () => {
+        const ctx = makeCtx();
+        await handleBidPlaced(makeInput(), ctx);
+        expect(mockIncrementBidCount).toHaveBeenCalledWith(expect.any(Object), "auction-charizard", 25000, "user-ravi");
+    });
+    it("commits the batch", async () => {
+        const ctx = makeCtx();
+        await handleBidPlaced(makeInput(), ctx);
+        expect(mockBatchCommit).toHaveBeenCalledOnce();
+    });
+});
+describe("handleBidPlaced — first bid (no previous winner)", () => {
+    it("does NOT call markOutbid when no previous winner", async () => {
+        mockGetWinningBid.mockResolvedValue(null);
+        const ctx = makeCtx();
+        await handleBidPlaced(makeInput(), ctx);
+        expect(mockMarkOutbid).not.toHaveBeenCalled();
+    });
+    it("does NOT send outbid notification when no previous winner", async () => {
+        mockGetWinningBid.mockResolvedValue(null);
+        const ctx = makeCtx();
+        await handleBidPlaced(makeInput(), ctx);
+        expect(mockSendNotification).not.toHaveBeenCalled();
+    });
+    it("does NOT push to RTDB when no previous winner", async () => {
+        mockGetWinningBid.mockResolvedValue(null);
+        const ctx = makeCtx();
+        await handleBidPlaced(makeInput(), ctx);
+        expect(mockRtdbPush).not.toHaveBeenCalled();
+    });
+});
+describe("handleBidPlaced — outbid notification", () => {
+    it("marks previous winner as outbid when different user", async () => {
+        mockGetWinningBid.mockResolvedValue(makePrevWinning("user-ankit"));
+        const ctx = makeCtx();
+        await handleBidPlaced(makeInput(), ctx);
+        expect(mockMarkOutbid).toHaveBeenCalledWith(expect.any(Object), expect.any(Object));
+    });
+    it("sends bid_outbid notification to the outbid user", async () => {
+        mockGetWinningBid.mockResolvedValue(makePrevWinning("user-ankit"));
+        const ctx = makeCtx();
+        await handleBidPlaced(makeInput(), ctx);
+        expect(mockSendNotification).toHaveBeenCalledWith(expect.objectContaining({ userId: "user-ankit", type: "bid_outbid" }));
+    });
+    it("pushes outbid event to RTDB for real-time notification", async () => {
+        mockGetWinningBid.mockResolvedValue(makePrevWinning("user-ankit"));
+        const ctx = makeCtx();
+        await handleBidPlaced(makeInput(), ctx);
+        expect(mockRtdbPush).toHaveBeenCalledWith(expect.objectContaining({ type: "bid_outbid" }));
+    });
+    it("outbid notification message includes bid amount and product title", async () => {
+        mockGetWinningBid.mockResolvedValue(makePrevWinning("user-ankit"));
+        const ctx = makeCtx();
+        await handleBidPlaced(makeInput({ productTitle: "Charizard 1st Ed", bidAmount: 30000 }), ctx);
+        const notifCall = mockSendNotification.mock.calls[0][0];
+        expect(notifCall.message).toMatch(/Charizard 1st Ed/);
+    });
+    it("does NOT outbid the same user who placed the new bid", async () => {
+        // Same user re-bids (bidder is already the winner)
+        mockGetWinningBid.mockResolvedValue(makePrevWinning("user-ravi")); // same as input.bid.userId
+        const ctx = makeCtx();
+        await handleBidPlaced(makeInput({ userId: "user-ravi" }), ctx);
+        expect(mockMarkOutbid).not.toHaveBeenCalled();
+        expect(mockSendNotification).not.toHaveBeenCalled();
+    });
+});
+describe("handleBidPlaced — RTDB failure is non-fatal", () => {
+    it("RTDB push failure → logs but does NOT re-throw", async () => {
+        mockGetWinningBid.mockResolvedValue(makePrevWinning("user-ankit"));
+        mockRtdbPush.mockRejectedValue(new Error("RTDB unavailable"));
+        const ctx = makeCtx();
+        await expect(handleBidPlaced(makeInput(), ctx)).resolves.toBeUndefined();
+        expect(ctx.logger.error).toHaveBeenCalledWith(expect.stringMatching(/Realtime DB/i), expect.any(Error));
+    });
+    it("Firestore outbid notification still sent even if RTDB fails", async () => {
+        mockGetWinningBid.mockResolvedValue(makePrevWinning("user-ankit"));
+        mockRtdbPush.mockRejectedValue(new Error("RTDB unavailable"));
+        const ctx = makeCtx();
+        await handleBidPlaced(makeInput(), ctx);
+        // sendNotification (Firestore) should still have been called before RTDB
+        expect(mockSendNotification).toHaveBeenCalledWith(expect.objectContaining({ type: "bid_outbid" }));
+    });
+});
+describe("handleBidPlaced — PII decryption", () => {
+    it("decrypts userName via decryptPii before use", async () => {
+        mockDecryptPii.mockImplementation((v) => `decrypted:${v}`);
+        const ctx = makeCtx();
+        await handleBidPlaced(makeInput({ userName: "encrypted_name" }), ctx);
+        expect(mockDecryptPii).toHaveBeenCalledWith("encrypted_name");
+    });
+});
+describe("handleBidPlaced — error propagation", () => {
+    it("Firestore batch.commit failure → re-throws", async () => {
+        mockBatchCommit.mockRejectedValue(new Error("Firestore unavailable"));
+        const ctx = makeCtx();
+        await expect(handleBidPlaced(makeInput(), ctx)).rejects.toThrow("Firestore unavailable");
+    });
+    it("logs error with bidId and productId before re-throwing", async () => {
+        mockBatchCommit.mockRejectedValue(new Error("Firestore unavailable"));
+        const ctx = makeCtx();
+        try {
+            await handleBidPlaced(makeInput(), ctx);
+        }
+        catch {
+            // expected
+        }
+        expect(ctx.logger.error).toHaveBeenCalledWith(expect.any(String), expect.any(Error), expect.objectContaining({ bidId: "bid-charizard-ravi-001" }));
+    });
+});

package/dist/_internal/server/jobs/core/__tests__/onOrderCreate.test.d.ts

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

package/dist/_internal/server/jobs/core/__tests__/onOrderCreate.test.js

@@ -0,0 +1,169 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+const { mockSendWhatsApp, mockBuildMessage, mockStoreFindBySlug, mockUserFindById, mockDecryptPii, } = vi.hoisted(() => ({
+    mockSendWhatsApp: vi.fn(),
+    mockBuildMessage: vi.fn().mockReturnValue("Purchase announcement message"),
+    mockStoreFindBySlug: vi.fn(),
+    mockUserFindById: vi.fn(),
+    mockDecryptPii: vi.fn((v) => v),
+}));
+vi.mock("../../../../../repositories", () => ({
+    storeRepository: { findBySlug: mockStoreFindBySlug },
+    userRepository: { findById: mockUserFindById },
+}));
+vi.mock("../../../../../features/whatsapp-bot/server", () => ({
+    sendWhatsAppBusinessMessage: mockSendWhatsApp,
+    buildPurchaseAnnouncementMessage: mockBuildMessage,
+}));
+vi.mock("../../../../../security/index", () => ({
+    decryptPii: mockDecryptPii,
+}));
+vi.mock("../../../../../errors/normalize", () => ({
+    normalizeError: vi.fn(),
+}));
+import { handleOrderCreate } from "../onOrderCreate";
+// ── Helpers ─────────────────────────────────────────────────────────────────
+function makeCtx(envOverrides = {}) {
+    const defaults = {
+        WHATSAPP_PHONE_NUMBER_ID: "phone-number-id-123",
+        WHATSAPP_CLOUD_API_TOKEN: "token-abc",
+        WHATSAPP_ADMIN_NOTIFY_NUMBERS: "919876543210",
+        ...envOverrides,
+    };
+    return {
+        env: (key) => defaults[key],
+        logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+    };
+}
+function makeInput(overrides = {}) {
+    return {
+        orderId: "order-1",
+        order: {
+            buyerDisplayName: "Ravi Kumar",
+            buyerId: "user-ravi",
+            items: [{ title: "Pokemon Charizard" }],
+            totalAmount: 25000,
+            storeId: "store-pokemon-palace",
+            ...overrides,
+        },
+    };
+}
+beforeEach(() => {
+    vi.clearAllMocks();
+    mockSendWhatsApp.mockResolvedValue(true);
+    mockBuildMessage.mockReturnValue("Purchase announcement message");
+    mockDecryptPii.mockImplementation((v) => v);
+    mockStoreFindBySlug.mockResolvedValue(null);
+    mockUserFindById.mockResolvedValue(null);
+});
+// ── Tests ────────────────────────────────────────────────────────────────────
+describe("handleOrderCreate — WhatsApp not configured", () => {
+    it("skips when WHATSAPP_PHONE_NUMBER_ID is missing", async () => {
+        const ctx = makeCtx({ WHATSAPP_PHONE_NUMBER_ID: undefined });
+        await handleOrderCreate(makeInput(), ctx);
+        expect(mockSendWhatsApp).not.toHaveBeenCalled();
+    });
+    it("skips when WHATSAPP_CLOUD_API_TOKEN is missing", async () => {
+        const ctx = makeCtx({ WHATSAPP_CLOUD_API_TOKEN: undefined });
+        await handleOrderCreate(makeInput(), ctx);
+        expect(mockSendWhatsApp).not.toHaveBeenCalled();
+    });
+    it("logs that WhatsApp is not configured", async () => {
+        const ctx = makeCtx({ WHATSAPP_PHONE_NUMBER_ID: undefined });
+        await handleOrderCreate(makeInput(), ctx);
+        expect(ctx.logger.info).toHaveBeenCalledWith(expect.stringMatching(/not configured/i), expect.any(Object));
+    });
+});
+describe("handleOrderCreate — admin notification", () => {
+    it("sends announcement to each admin number in WHATSAPP_ADMIN_NOTIFY_NUMBERS", async () => {
+        const ctx = makeCtx({ WHATSAPP_ADMIN_NOTIFY_NUMBERS: "919876543210,918765432109" });
+        await handleOrderCreate(makeInput(), ctx);
+        expect(mockSendWhatsApp).toHaveBeenCalledTimes(2);
+    });
+    it("sends to 0 admin numbers when env var is empty", async () => {
+        const ctx = makeCtx({ WHATSAPP_ADMIN_NOTIFY_NUMBERS: "" });
+        await handleOrderCreate(makeInput(), ctx);
+        // No admin calls, store lookup still happens
+        const waCallArgs = mockSendWhatsApp.mock.calls.map((c) => c[0].toPhone);
+        expect(waCallArgs).toHaveLength(0);
+    });
+    it("strips non-digit chars from admin numbers", async () => {
+        const ctx = makeCtx({ WHATSAPP_ADMIN_NOTIFY_NUMBERS: "+91 987-654-3210" });
+        await handleOrderCreate(makeInput(), ctx);
+        const call = mockSendWhatsApp.mock.calls[0][0];
+        expect(call.toPhone).toBe("919876543210");
+    });
+    it("sends announcement with the built message", async () => {
+        const ctx = makeCtx();
+        mockBuildMessage.mockReturnValue("Custom message content");
+        await handleOrderCreate(makeInput(), ctx);
+        const call = mockSendWhatsApp.mock.calls[0][0];
+        expect(call.message).toBe("Custom message content");
+    });
+    it("one admin send failure is non-fatal, function still completes", async () => {
+        const ctx = makeCtx({ WHATSAPP_ADMIN_NOTIFY_NUMBERS: "91111,91222" });
+        mockSendWhatsApp.mockRejectedValueOnce(new Error("WA error")).mockResolvedValue(true);
+        await expect(handleOrderCreate(makeInput(), ctx)).resolves.toBeUndefined();
+    });
+});
+describe("handleOrderCreate — store owner notification", () => {
+    it("sends to store owner phone when store + owner + phone all exist", async () => {
+        mockStoreFindBySlug.mockResolvedValue({ ownerId: "user-seller-1" });
+        mockUserFindById.mockResolvedValue({ phoneNumber: "encrypted_phone_91999" });
+        mockDecryptPii.mockReturnValue("919999999999");
+        const ctx = makeCtx({ WHATSAPP_ADMIN_NOTIFY_NUMBERS: "" });
+        await handleOrderCreate(makeInput({ storeId: "store-A" }), ctx);
+        expect(mockSendWhatsApp).toHaveBeenCalledWith(expect.objectContaining({ toPhone: "919999999999" }));
+    });
+    it("skips store owner if store not found", async () => {
+        mockStoreFindBySlug.mockResolvedValue(null);
+        const ctx = makeCtx({ WHATSAPP_ADMIN_NOTIFY_NUMBERS: "" });
+        await handleOrderCreate(makeInput({ storeId: "store-nonexistent" }), ctx);
+        expect(mockSendWhatsApp).not.toHaveBeenCalled();
+    });
+    it("skips store owner if owner has no phone number", async () => {
+        mockStoreFindBySlug.mockResolvedValue({ ownerId: "user-seller-1" });
+        mockUserFindById.mockResolvedValue({ phoneNumber: null });
+        const ctx = makeCtx({ WHATSAPP_ADMIN_NOTIFY_NUMBERS: "" });
+        await handleOrderCreate(makeInput({ storeId: "store-A" }), ctx);
+        expect(mockSendWhatsApp).not.toHaveBeenCalled();
+    });
+    it("skips store owner notification when storeId is absent from order", async () => {
+        const ctx = makeCtx({ WHATSAPP_ADMIN_NOTIFY_NUMBERS: "" });
+        await handleOrderCreate(makeInput({ storeId: undefined }), ctx);
+        expect(mockStoreFindBySlug).not.toHaveBeenCalled();
+    });
+    it("store owner lookup failure is non-fatal", async () => {
+        mockStoreFindBySlug.mockRejectedValue(new Error("Firestore error"));
+        const ctx = makeCtx();
+        await expect(handleOrderCreate(makeInput(), ctx)).resolves.toBeUndefined();
+        expect(ctx.logger.error).toHaveBeenCalledWith(expect.stringMatching(/Store owner lookup failed/i), expect.any(Error), expect.any(Object));
+    });
+});
+describe("handleOrderCreate — message content", () => {
+    it("uses buyerDisplayName in announcement", async () => {
+        const ctx = makeCtx();
+        await handleOrderCreate(makeInput({ buyerDisplayName: "Priya Singh" }), ctx);
+        expect(mockBuildMessage).toHaveBeenCalledWith(expect.objectContaining({ buyerName: "Priya Singh" }));
+    });
+    it("uses 'A customer' as fallback when buyerDisplayName is missing", async () => {
+        const ctx = makeCtx();
+        await handleOrderCreate(makeInput({ buyerDisplayName: undefined }), ctx);
+        expect(mockBuildMessage).toHaveBeenCalledWith(expect.objectContaining({ buyerName: "A customer" }));
+    });
+    it("uses first item title as firstItemName", async () => {
+        const ctx = makeCtx();
+        await handleOrderCreate(makeInput({ items: [{ title: "Charizard PSA 9" }] }), ctx);
+        expect(mockBuildMessage).toHaveBeenCalledWith(expect.objectContaining({ firstItemName: "Charizard PSA 9" }));
+    });
+    it("falls back to item.name when title is missing", async () => {
+        const ctx = makeCtx();
+        await handleOrderCreate(makeInput({ items: [{ name: "Blastoise" }] }), ctx);
+        expect(mockBuildMessage).toHaveBeenCalledWith(expect.objectContaining({ firstItemName: "Blastoise" }));
+    });
+    it("additionalItemCount = items.length - 1", async () => {
+        const ctx = makeCtx();
+        const items = [{ title: "A" }, { title: "B" }, { title: "C" }];
+        await handleOrderCreate(makeInput({ items }), ctx);
+        expect(mockBuildMessage).toHaveBeenCalledWith(expect.objectContaining({ additionalItemCount: 2 }));
+    });
+});

package/dist/_internal/server/jobs/core/__tests__/onOrderStatusChange.test.d.ts

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