@mohasinac/appkit 3.8.2 → 3.9.0

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

@@ -1,163 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-// Mock all repository imports before importing the module under test.
-vi.mock("../../../../../repositories", () => ({
-    productRepository: { list: vi.fn() },
-    blogRepository: { listAll: vi.fn() },
-    eventRepository: { list: vi.fn() },
-    couponsRepository: { list: vi.fn() },
-    storeRepository: { listStores: vi.fn() },
-    categoriesRepository: { list: vi.fn() },
-    bidRepository: { list: vi.fn() },
-    payoutRepository: { list: vi.fn() },
-    orderRepository: { listAll: vi.fn() },
-    reviewRepository: { listAll: vi.fn() },
-    faqsRepository: { list: vi.fn() },
-    notificationRepository: { list: vi.fn() },
-    scammerRepository: { listAll: vi.fn() },
-    productFeaturesRepository: { list: vi.fn() },
-    homepageSectionsRepository: { list: vi.fn() },
-    userRepository: { list: vi.fn() },
-    eventEntryRepository: { listForEvent: vi.fn() },
-    productTemplateRepository: { listByStore: vi.fn() },
-}));
-import { runListingProcessor } from "../listingProcessor";
-import { productRepository, blogRepository, eventRepository, couponsRepository, storeRepository, } from "../../../../../repositories";
-function makeCtx() {
-    return {
-        job: "test",
-        db: {},
-        logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
-        env: vi.fn(),
-        now: new Date(),
-    };
-}
-const EMPTY_RESULT = {
-    items: [],
-    total: 0,
-    page: 1,
-    pageSize: 20,
-    totalPages: 0,
-    hasMore: false,
-};
-beforeEach(() => {
-    vi.clearAllMocks();
-    productRepository.list.mockResolvedValue(EMPTY_RESULT);
-    blogRepository.listAll.mockResolvedValue(EMPTY_RESULT);
-    eventRepository.list.mockResolvedValue(EMPTY_RESULT);
-    couponsRepository.list.mockResolvedValue(EMPTY_RESULT);
-    storeRepository.listStores.mockResolvedValue(EMPTY_RESULT);
-});
-describe("runListingProcessor", () => {
-    it("throws 400 when body is missing collection", async () => {
-        const ctx = makeCtx();
-        await expect(runListingProcessor({}, ctx)).rejects.toMatchObject({ httpStatus: 400, message: "Missing collection" });
-    });
-    it("throws 400 for an unsupported collection name", async () => {
-        const ctx = makeCtx();
-        await expect(runListingProcessor({ collection: "nonexistent" }, ctx)).rejects.toMatchObject({ httpStatus: 400 });
-    });
-    it("calls the correct lister for 'products'", async () => {
-        const ctx = makeCtx();
-        await runListingProcessor({ collection: "products", f: "status==published" }, ctx);
-        expect(productRepository.list).toHaveBeenCalledWith(expect.objectContaining({ filters: "status==published" }), {});
-    });
-    it("calls blogRepository for 'blogPosts'", async () => {
-        const ctx = makeCtx();
-        await runListingProcessor({ collection: "blogPosts" }, ctx);
-        expect(blogRepository.listAll).toHaveBeenCalled();
-    });
-    it("calls eventRepository for 'events'", async () => {
-        const ctx = makeCtx();
-        await runListingProcessor({ collection: "events" }, ctx);
-        expect(eventRepository.list).toHaveBeenCalled();
-    });
-    it("passes filters and sorts to the lister", async () => {
-        const ctx = makeCtx();
-        await runListingProcessor({
-            collection: "products",
-            f: "brand==hasbro",
-            s: "-price",
-        }, ctx);
-        expect(productRepository.list).toHaveBeenCalledWith(expect.objectContaining({ filters: "brand==hasbro", sorts: "-price" }), {});
-    });
-    it("uses default sort when s is absent", async () => {
-        const ctx = makeCtx();
-        await runListingProcessor({ collection: "products" }, ctx);
-        expect(productRepository.list).toHaveBeenCalledWith(expect.objectContaining({ sorts: "-createdAt" }), {});
-    });
-    it("clamps pageSize to MAX_PAGE_SIZE (100)", async () => {
-        const ctx = makeCtx();
-        await runListingProcessor({ collection: "products", ps: 999 }, ctx);
-        expect(productRepository.list).toHaveBeenCalledWith(expect.objectContaining({ pageSize: "100" }), {});
-    });
-    it("uses DEFAULT_PAGE_SIZE when ps is 0", async () => {
-        const ctx = makeCtx();
-        await runListingProcessor({ collection: "products", ps: 0 }, ctx);
-        expect(productRepository.list).toHaveBeenCalledWith(expect.objectContaining({ pageSize: "20" }), {});
-    });
-    it("uses DEFAULT_PAGE_SIZE when ps is negative", async () => {
-        const ctx = makeCtx();
-        await runListingProcessor({ collection: "products", ps: -5 }, ctx);
-        expect(productRepository.list).toHaveBeenCalledWith(expect.objectContaining({ pageSize: "20" }), {});
-    });
-    it("reads page from p param", async () => {
-        const ctx = makeCtx();
-        await runListingProcessor({ collection: "products", p: 3 }, ctx);
-        expect(productRepository.list).toHaveBeenCalledWith(expect.objectContaining({ page: "3" }), {});
-    });
-    it("decodes a valid cursor and uses its page over p", async () => {
-        // Encode page=5 as a cursor
-        const cursor = Buffer.from(JSON.stringify({ page: 5 }), "utf8").toString("base64");
-        const ctx = makeCtx();
-        await runListingProcessor({ collection: "products", cursor, p: 1 }, ctx);
-        expect(productRepository.list).toHaveBeenCalledWith(expect.objectContaining({ page: "5" }), {});
-    });
-    it("falls back to p when cursor is invalid base64 JSON", async () => {
-        const ctx = makeCtx();
-        await runListingProcessor({ collection: "products", cursor: "!!!notbase64!!!", p: 2 }, ctx);
-        expect(productRepository.list).toHaveBeenCalledWith(expect.objectContaining({ page: "2" }), {});
-    });
-    it("encodes the next cursor when hasMore is true", async () => {
-        productRepository.list.mockResolvedValue({
-            ...EMPTY_RESULT,
-            hasMore: true,
-            page: 1,
-        });
-        const ctx = makeCtx();
-        const result = await runListingProcessor({ collection: "products", p: 1 }, ctx);
-        expect(result.cursor).not.toBeNull();
-        // Decode and verify it points to page 2
-        const decoded = JSON.parse(Buffer.from(result.cursor, "base64").toString("utf8"));
-        expect(decoded.page).toBe(2);
-    });
-    it("returns null cursor when hasMore is false", async () => {
-        const ctx = makeCtx();
-        const result = await runListingProcessor({ collection: "products" }, ctx);
-        expect(result.cursor).toBeNull();
-    });
-    it("passes baseOpts to the lister", async () => {
-        const ctx = makeCtx();
-        await runListingProcessor({
-            collection: "products",
-            baseOpts: { storeId: "store-abc" },
-        }, ctx);
-        expect(productRepository.list).toHaveBeenCalledWith(expect.any(Object), { storeId: "store-abc" });
-    });
-    it("calls stores lister with activeOnly=true by default", async () => {
-        const ctx = makeCtx();
-        await runListingProcessor({ collection: "stores" }, ctx);
-        expect(storeRepository.listStores).toHaveBeenCalledWith(expect.any(Object), true);
-    });
-    it("returns the items from the lister result", async () => {
-        const items = [{ id: "p1" }, { id: "p2" }];
-        productRepository.list.mockResolvedValue({
-            ...EMPTY_RESULT,
-            items,
-            total: 2,
-        });
-        const ctx = makeCtx();
-        const result = await runListingProcessor({ collection: "products" }, ctx);
-        expect(result.items).toEqual(items);
-        expect(result.total).toBe(2);
-    });
-});

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

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

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

@@ -1,115 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-vi.mock("../../../../../providers/db-firebase/admin-storage-lite", () => ({
-    getAdminStorageLite: vi.fn(),
-}));
-import { runMediaTmpCleanup } from "../mediaTmpCleanup";
-import { getAdminStorageLite } from "../../../../../providers/db-firebase/admin-storage-lite";
-function makeCtx(envOverrides = {}) {
-    return {
-        job: "media-tmp-cleanup",
-        db: {},
-        logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
-        env: (key) => envOverrides[key],
-        now: new Date("2026-01-15T12:00:00Z"),
-    };
-}
-function makeFile(name, updatedOffset, cutoffBase) {
-    const updated = new Date(cutoffBase.getTime() + updatedOffset).toISOString();
-    return {
-        name,
-        getMetadata: vi.fn().mockResolvedValue([{ updated }]),
-        delete: vi.fn().mockResolvedValue(undefined),
-    };
-}
-function setupBucket(files) {
-    const bucket = {
-        getFiles: vi.fn().mockResolvedValue([files]),
-    };
-    getAdminStorageLite.mockReturnValue({
-        bucket: vi.fn(() => bucket),
-    });
-    return bucket;
-}
-beforeEach(() => {
-    vi.clearAllMocks();
-    delete process.env.FIREBASE_ADMIN_STORAGE_BUCKET;
-    delete process.env.NEXT_PUBLIC_FIREBASE_STORAGE_BUCKET;
-});
-describe("runMediaTmpCleanup", () => {
-    it("does nothing when no files exist under tmp/", async () => {
-        setupBucket([]);
-        const ctx = makeCtx();
-        await runMediaTmpCleanup(ctx);
-        // Should complete without error
-    });
-    it("skips files newer than the TTL cutoff", async () => {
-        // cutoff = now - 24h; file updated 1ms AFTER cutoff → not stale
-        const ctx = makeCtx();
-        const cutoff = new Date(Date.now() - 24 * 60 * 60 * 1000);
-        const newFile = makeFile("tmp/new-file.jpg", 1000, cutoff); // updated after cutoff
-        setupBucket([newFile]);
-        await runMediaTmpCleanup(ctx);
-        expect(newFile.delete).not.toHaveBeenCalled();
-    });
-    it("deletes files older than the TTL cutoff", async () => {
-        const ctx = makeCtx();
-        const cutoff = new Date(Date.now() - 24 * 60 * 60 * 1000);
-        const oldFile = makeFile("tmp/old-file.jpg", -1000, cutoff); // updated before cutoff
-        setupBucket([oldFile]);
-        await runMediaTmpCleanup(ctx);
-        expect(oldFile.delete).toHaveBeenCalledOnce();
-    });
-    it("uses MEDIA_TMP_TTL_HOURS env var to override default TTL", async () => {
-        const ctx = makeCtx({ MEDIA_TMP_TTL_HOURS: "1" });
-        // With 1h TTL, cutoff = now - 1h
-        // A file updated 2h ago should be deleted
-        const cutoff = new Date(Date.now() - 1 * 60 * 60 * 1000);
-        const twoHourOldFile = makeFile("tmp/old.jpg", -60 * 60 * 1000, cutoff);
-        setupBucket([twoHourOldFile]);
-        await runMediaTmpCleanup(ctx);
-        expect(twoHourOldFile.delete).toHaveBeenCalledOnce();
-    });
-    it("swallows 404 errors without logging them as errors", async () => {
-        const ctx = makeCtx();
-        const cutoff = new Date(Date.now() - 24 * 60 * 60 * 1000);
-        const staleFile = makeFile("tmp/gone.jpg", -1000, cutoff);
-        const notFoundErr = Object.assign(new Error("Not found"), { code: 404 });
-        staleFile.delete.mockRejectedValue(notFoundErr);
-        setupBucket([staleFile]);
-        await expect(runMediaTmpCleanup(ctx)).resolves.toBeUndefined();
-        expect(ctx.logger.error).not.toHaveBeenCalledWith("Failed to delete tmp file", expect.anything(), expect.anything());
-    });
-    it("logs a non-404 delete error but continues processing", async () => {
-        const ctx = makeCtx();
-        const cutoff = new Date(Date.now() - 24 * 60 * 60 * 1000);
-        const failFile = makeFile("tmp/fail.jpg", -1000, cutoff);
-        const okFile = makeFile("tmp/ok.jpg", -2000, cutoff);
-        const genericErr = Object.assign(new Error("Permission denied"), { code: 403 });
-        failFile.delete.mockRejectedValue(genericErr);
-        setupBucket([failFile, okFile]);
-        await runMediaTmpCleanup(ctx);
-        expect(ctx.logger.error).toHaveBeenCalledWith("Failed to delete tmp file", genericErr, expect.any(Object));
-        expect(okFile.delete).toHaveBeenCalledOnce();
-    });
-    it("skips files missing updated/timeCreated metadata", async () => {
-        const ctx = makeCtx();
-        const noMetaFile = {
-            name: "tmp/no-meta.jpg",
-            getMetadata: vi.fn().mockResolvedValue([{}]),
-            delete: vi.fn(),
-        };
-        setupBucket([noMetaFile]);
-        await runMediaTmpCleanup(ctx);
-        expect(noMetaFile.delete).not.toHaveBeenCalled();
-    });
-    it("throws when bucket.getFiles itself fails", async () => {
-        const bucket = {
-            getFiles: vi.fn().mockRejectedValue(new Error("Storage unavailable")),
-        };
-        getAdminStorageLite.mockReturnValue({
-            bucket: vi.fn(() => bucket),
-        });
-        const ctx = makeCtx();
-        await expect(runMediaTmpCleanup(ctx)).rejects.toThrow("Storage unavailable");
-    });
-});

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

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

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

@@ -1,201 +0,0 @@
-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

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

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

@@ -1,169 +0,0 @@
-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

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