@mohasinac/appkit 3.8.2 → 3.9.1

package/dist/_internal/server/features/refunds/__tests__/actions.test.js

@@ -1,263 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-// vi.hoisted: these must be declared before vi.mock factories reference them
-const { mockOrderFindById, mockPostRefundEvent, mockPaymentRefund, mockApplyRefundDeduction, mockCodesGet, } = vi.hoisted(() => {
-    const mockCodesQuery = {
-        where: vi.fn(),
-        limit: vi.fn(),
-        get: vi.fn(),
-    };
-    mockCodesQuery.where.mockReturnValue(mockCodesQuery);
-    mockCodesQuery.limit.mockReturnValue(mockCodesQuery);
-    return {
-        mockOrderFindById: vi.fn(),
-        mockPostRefundEvent: vi.fn(),
-        mockPaymentRefund: vi.fn(),
-        mockApplyRefundDeduction: vi.fn(),
-        mockCodesGet: mockCodesQuery.get,
-        _mockCodesQuery: mockCodesQuery,
-    };
-});
-// Mock appkit/server BEFORE other imports to avoid loading broken dist/client.js
-vi.mock("@mohasinac/appkit/server", () => ({
-    wrapAction: async (fn) => {
-        try {
-            const data = await fn();
-            return { ok: true, data };
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            return { ok: false, error: msg };
-        }
-    },
-    isSoftBanned: vi.fn(() => false),
-}));
-vi.mock("../../../../../", () => ({
-    orderRepository: {
-        findById: mockOrderFindById,
-        postRefundEvent: mockPostRefundEvent,
-    },
-}));
-vi.mock("../../../../../contracts/registry", () => ({
-    getProviders: vi.fn(() => ({
-        payment: { refund: mockPaymentRefund },
-    })),
-}));
-// Mock the firebase-admin sub-module that provides getAdminDb
-// Chain: db.collection(PRODUCTS).doc(productId).collection(CODES).where("orderId","==",orderId).limit(1).get()
-vi.mock("../../../../../providers/db-firebase/admin", () => {
-    const mockCodesQuery = { where: vi.fn(), limit: vi.fn(), get: mockCodesGet };
-    mockCodesQuery.where.mockReturnValue(mockCodesQuery);
-    mockCodesQuery.limit.mockReturnValue(mockCodesQuery);
-    const mockCodesCollection = { where: vi.fn() };
-    mockCodesCollection.where.mockReturnValue(mockCodesQuery);
-    const mockDoc = { collection: vi.fn(() => mockCodesCollection) };
-    const mockTopCollection = { doc: vi.fn(() => mockDoc) };
-    const mockDb = { collection: vi.fn(() => mockTopCollection) };
-    return { getAdminDb: () => mockDb, getAdminAuth: vi.fn(), getAdminStorage: vi.fn() };
-});
-vi.mock("../../payouts/actions", () => ({
-    applyRefundDeductionAction: mockApplyRefundDeduction,
-}));
-vi.mock("../../../../../errors/normalize", () => ({ normalizeError: vi.fn() }));
-vi.mock("../../../../../monitoring", () => ({
-    serverLogger: { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() },
-}));
-import { processRefundAction } from "../actions";
-// ─── Helpers ────────────────────────────────────────────────────────────────
-function makeOrder(overrides = {}) {
-    return {
-        id: "order-1",
-        storeId: "store-A",
-        totalPrice: 10000,
-        paymentMethod: "razorpay",
-        paymentId: "pay_abc123",
-        isNonRefundable: false,
-        items: [],
-        ...overrides,
-    };
-}
-function refundInput(overrides = {}) {
-    return {
-        orderId: "order-1",
-        type: "partial",
-        amountInPaise: 5000,
-        reason: "damaged item",
-        confirmIrrevocable: true,
-        refundedBy: "admin-uid",
-        method: "manual",
-        ...overrides,
-    };
-}
-beforeEach(() => {
-    vi.clearAllMocks();
-    mockOrderFindById.mockResolvedValue(makeOrder());
-    mockPostRefundEvent.mockResolvedValue(undefined);
-    mockPaymentRefund.mockResolvedValue({ id: "rfnd_123" });
-    mockApplyRefundDeduction.mockResolvedValue(undefined);
-    mockCodesGet.mockResolvedValue({ empty: true, docs: [] });
-});
-// ─── Tests ──────────────────────────────────────────────────────────────────
-describe("processRefundAction — validation guards", () => {
-    it("order not found → ok: false", async () => {
-        mockOrderFindById.mockResolvedValue(null);
-        const result = await processRefundAction(refundInput());
-        expect(result.ok).toBe(false);
-        expect(result.error).toMatch(/not found/i);
-    });
-    it("amount <= 0 → ok: false (validation)", async () => {
-        const result = await processRefundAction(refundInput({ amountInPaise: 0 }));
-        expect(result.ok).toBe(false);
-    });
-    it("negative amount → ok: false (validation)", async () => {
-        const result = await processRefundAction(refundInput({ amountInPaise: -100 }));
-        expect(result.ok).toBe(false);
-    });
-    it("amount > order.totalPrice → ok: false", async () => {
-        const result = await processRefundAction(refundInput({ amountInPaise: 10001 }));
-        expect(result.ok).toBe(false);
-        expect(result.error).toMatch(/exceeds/i);
-    });
-    it("amount === order.totalPrice → ok: true (full refund, not exceeds)", async () => {
-        const result = await processRefundAction(refundInput({ amountInPaise: 10000 }));
-        expect(result.ok).toBe(true);
-    });
-    it("isNonRefundable: true → ok: false", async () => {
-        mockOrderFindById.mockResolvedValue(makeOrder({ isNonRefundable: true }));
-        const result = await processRefundAction(refundInput());
-        expect(result.ok).toBe(false);
-        expect(result.error).toMatch(/non-refundable/i);
-    });
-});
-describe("processRefundAction — digital code guard", () => {
-    it("digital code already claimed → ok: false", async () => {
-        mockOrderFindById.mockResolvedValue(makeOrder({
-            items: [{ productId: "digital-prod-1", listingType: "digital-code" }],
-        }));
-        mockCodesGet.mockResolvedValue({
-            empty: false,
-            docs: [{ data: () => ({ status: "claimed" }) }],
-        });
-        const result = await processRefundAction(refundInput());
-        expect(result.ok).toBe(false);
-        expect(result.error).toMatch(/digital code|revealed/i);
-    });
-    it("digital code with status 'available' → refund allowed", async () => {
-        mockOrderFindById.mockResolvedValue(makeOrder({
-            items: [{ productId: "digital-prod-1", listingType: "digital-code" }],
-        }));
-        mockCodesGet.mockResolvedValue({
-            empty: false,
-            docs: [{ data: () => ({ status: "available" }) }],
-        });
-        const result = await processRefundAction(refundInput());
-        expect(result.ok).toBe(true);
-    });
-    it("no digital code items → digital code check is skipped", async () => {
-        mockOrderFindById.mockResolvedValue(makeOrder({ items: [] }));
-        const result = await processRefundAction(refundInput());
-        expect(result.ok).toBe(true);
-        expect(mockCodesGet).not.toHaveBeenCalled();
-    });
-    it("digital code collection query returns empty → refund allowed", async () => {
-        mockOrderFindById.mockResolvedValue(makeOrder({
-            items: [{ productId: "digital-prod-1", listingType: "digital-code" }],
-        }));
-        mockCodesGet.mockResolvedValue({ empty: true, docs: [] });
-        const result = await processRefundAction(refundInput());
-        expect(result.ok).toBe(true);
-    });
-});
-describe("processRefundAction — Razorpay path", () => {
-    it("calls payment.refund with correct paymentId and amount", async () => {
-        const result = await processRefundAction(refundInput({
-            method: "razorpay",
-            razorpayPaymentId: "pay_abc123",
-            amountInPaise: 5000,
-        }));
-        expect(result.ok).toBe(true);
-        expect(mockPaymentRefund).toHaveBeenCalledWith("pay_abc123", 5000);
-    });
-    it("Razorpay refund API failure → ok: false, postRefundEvent NOT called", async () => {
-        mockPaymentRefund.mockRejectedValue(new Error("Razorpay API error"));
-        const result = await processRefundAction(refundInput({
-            method: "razorpay",
-            razorpayPaymentId: "pay_abc123",
-        }));
-        expect(result.ok).toBe(false);
-        expect(mockPostRefundEvent).not.toHaveBeenCalled();
-    });
-    it("razorpayRefundId from provider is stored in event", async () => {
-        mockPaymentRefund.mockResolvedValue({ id: "rfnd_xyz789" });
-        await processRefundAction(refundInput({
-            method: "razorpay",
-            razorpayPaymentId: "pay_abc123",
-        }));
-        expect(mockPostRefundEvent).toHaveBeenCalledWith("order-1", expect.objectContaining({ razorpayRefundId: "rfnd_xyz789" }), expect.any(Boolean));
-    });
-});
-describe("processRefundAction — manual path", () => {
-    it("does NOT call payment.refund for manual refunds", async () => {
-        await processRefundAction(refundInput({ method: "manual" }));
-        expect(mockPaymentRefund).not.toHaveBeenCalled();
-    });
-    it("calls postRefundEvent without razorpayRefundId", async () => {
-        await processRefundAction(refundInput({ method: "manual" }));
-        const event = mockPostRefundEvent.mock.calls[0][1];
-        expect(event.razorpayRefundId).toBeUndefined();
-    });
-    it("stores manualTransactionId when provided", async () => {
-        await processRefundAction(refundInput({ method: "manual", manualTransactionId: "TXN123" }));
-        const event = mockPostRefundEvent.mock.calls[0][1];
-        expect(event.manualTransactionId).toBe("TXN123");
-    });
-});
-describe("processRefundAction — success path", () => {
-    it("calls orderRepository.postRefundEvent with correct orderId", async () => {
-        await processRefundAction(refundInput());
-        expect(mockPostRefundEvent).toHaveBeenCalledWith("order-1", expect.any(Object), expect.any(Boolean));
-    });
-    it("partial amount: isFull = false passed to postRefundEvent", async () => {
-        await processRefundAction(refundInput({ amountInPaise: 5000 }));
-        const isFull = mockPostRefundEvent.mock.calls[0][2];
-        expect(isFull).toBe(false);
-    });
-    it("full amount: isFull = true passed to postRefundEvent", async () => {
-        await processRefundAction(refundInput({ amountInPaise: 10000 }));
-        const isFull = mockPostRefundEvent.mock.calls[0][2];
-        expect(isFull).toBe(true);
-    });
-    it("returns ok: true with success: true and a refundId UUID", async () => {
-        const result = await processRefundAction(refundInput());
-        expect(result.ok).toBe(true);
-        const data = result.data;
-        expect(data.success).toBe(true);
-        expect(data.refundId).toMatch(/^[0-9a-f-]{36}$/i);
-    });
-    it("event contains reason, refundedBy, and refundedAt", async () => {
-        await processRefundAction(refundInput({ reason: "broken product", refundedBy: "admin-1" }));
-        const event = mockPostRefundEvent.mock.calls[0][1];
-        expect(event.reason).toBe("broken product");
-        expect(event.refundedBy).toBe("admin-1");
-        expect(event.refundedAt).toBeInstanceOf(Date);
-    });
-});
-describe("processRefundAction — payout deduction", () => {
-    it("triggers applyRefundDeductionAction when order has storeId", async () => {
-        await processRefundAction(refundInput({ amountInPaise: 5000 }));
-        expect(mockApplyRefundDeduction).toHaveBeenCalledWith(expect.objectContaining({
-            storeId: "store-A",
-            orderId: "order-1",
-            refundedAmountInPaise: 5000,
-        }));
-    });
-    it("does NOT call applyRefundDeductionAction when order has no storeId", async () => {
-        mockOrderFindById.mockResolvedValue(makeOrder({ storeId: undefined }));
-        await processRefundAction(refundInput());
-        expect(mockApplyRefundDeduction).not.toHaveBeenCalled();
-    });
-    it("deduction failure does NOT fail the refund (fire-and-forget)", async () => {
-        mockApplyRefundDeduction.mockRejectedValue(new Error("Payout service unavailable"));
-        const result = await processRefundAction(refundInput());
-        expect(result.ok).toBe(true);
-    });
-});

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

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

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

@@ -1,249 +0,0 @@
-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__/couponExpiry.test.d.ts

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

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

@@ -1,65 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-vi.mock("../../../../../repositories", () => ({
-    couponsRepository: {
-        getExpiredActiveRefs: vi.fn(),
-        deactivateInBatch: vi.fn(),
-    },
-}));
-import { runCouponExpiry } from "../couponExpiry";
-import { couponsRepository } from "../../../../../repositories";
-function makeBatch() {
-    return { commit: vi.fn().mockResolvedValue(undefined) };
-}
-function makeCtx(batchOverride) {
-    const batch = batchOverride ?? makeBatch();
-    return {
-        job: "coupon-expiry",
-        db: { batch: vi.fn(() => batch) },
-        logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
-        env: vi.fn(),
-        now: new Date("2026-01-15T12:00:00Z"),
-    };
-}
-beforeEach(() => {
-    vi.clearAllMocks();
-});
-describe("runCouponExpiry", () => {
-    it("returns early and does not commit when no expired coupons", async () => {
-        couponsRepository.getExpiredActiveRefs.mockResolvedValue([]);
-        const ctx = makeCtx();
-        await runCouponExpiry(ctx);
-        expect(ctx.db.batch).not.toHaveBeenCalled();
-    });
-    it("calls getExpiredActiveRefs with ctx.now", async () => {
-        couponsRepository.getExpiredActiveRefs.mockResolvedValue([]);
-        const ctx = makeCtx();
-        await runCouponExpiry(ctx);
-        expect(couponsRepository.getExpiredActiveRefs).toHaveBeenCalledWith(ctx.now);
-    });
-    it("deactivates each expired coupon in the batch", async () => {
-        const refs = [{ id: "coupon-1" }, { id: "coupon-2" }];
-        couponsRepository.getExpiredActiveRefs.mockResolvedValue(refs);
-        const batch = makeBatch();
-        const ctx = makeCtx(batch);
-        await runCouponExpiry(ctx);
-        expect(couponsRepository.deactivateInBatch).toHaveBeenCalledTimes(2);
-        expect(couponsRepository.deactivateInBatch).toHaveBeenCalledWith(batch, refs[0]);
-        expect(couponsRepository.deactivateInBatch).toHaveBeenCalledWith(batch, refs[1]);
-    });
-    it("commits the batch when there are expired coupons", async () => {
-        const refs = [{ id: "coupon-1" }];
-        couponsRepository.getExpiredActiveRefs.mockResolvedValue(refs);
-        const batch = makeBatch();
-        const ctx = makeCtx(batch);
-        await runCouponExpiry(ctx);
-        expect(batch.commit).toHaveBeenCalledOnce();
-    });
-    it("does not deactivate or commit when refs is empty", async () => {
-        couponsRepository.getExpiredActiveRefs.mockResolvedValue([]);
-        const batch = makeBatch();
-        const ctx = makeCtx(batch);
-        await runCouponExpiry(ctx);
-        expect(couponsRepository.deactivateInBatch).not.toHaveBeenCalled();
-        expect(batch.commit).not.toHaveBeenCalled();
-    });
-});

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

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