@mohasinac/appkit 3.0.6 → 3.1.0

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

@@ -0,0 +1,161 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+vi.mock("../../../../../errors/normalize", () => ({
+    normalizeError: vi.fn(),
+}));
+import { handleUserBanChange } from "../onUserBanChange";
+// ── Helpers ─────────────────────────────────────────────────────────────────
+function makeBatch() {
+    return {
+        set: vi.fn(),
+        update: vi.fn(),
+        delete: vi.fn(),
+        commit: vi.fn().mockResolvedValue(undefined),
+    };
+}
+function makeCtx(batch = makeBatch()) {
+    const mockDoc = vi.fn().mockReturnValue({});
+    const banHistoryCollection = { doc: mockDoc };
+    const userDoc = { collection: vi.fn().mockReturnValue(banHistoryCollection) };
+    const usersCollection = { doc: vi.fn().mockReturnValue(userDoc) };
+    return {
+        db: {
+            collection: vi.fn().mockReturnValue(usersCollection),
+            batch: vi.fn().mockReturnValue(batch),
+        },
+        batch,
+        now: new Date(),
+        logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+    };
+}
+beforeEach(() => {
+    vi.clearAllMocks();
+});
+// ── Tests ────────────────────────────────────────────────────────────────────
+describe("handleUserBanChange — early exit", () => {
+    it("returns immediately when after is null", async () => {
+        const ctx = makeCtx();
+        await handleUserBanChange({ uid: "user-1", before: null, after: null }, ctx);
+        expect(ctx.batch.commit).not.toHaveBeenCalled();
+    });
+    it("returns without writing when no ban changes detected", async () => {
+        // before = active, after = active (same state, no ban)
+        const ctx = makeCtx();
+        await handleUserBanChange({
+            uid: "user-1",
+            before: { isDisabled: false, softBans: [] },
+            after: { isDisabled: false, softBans: [] },
+        }, ctx);
+        expect(ctx.batch.commit).not.toHaveBeenCalled();
+    });
+});
+describe("handleUserBanChange — hard ban applied", () => {
+    it("writes a hard_ban entry when isDisabled transitions false→true", async () => {
+        const batch = makeBatch();
+        const ctx = makeCtx(batch);
+        await handleUserBanChange({
+            uid: "user-1",
+            before: { isDisabled: false },
+            after: { isDisabled: true, hardBanReason: "Violating ToS", hardBannedBy: "admin-1" },
+        }, ctx);
+        expect(batch.set).toHaveBeenCalledWith(expect.any(Object), expect.objectContaining({ type: "hard_ban", reason: "Violating ToS" }));
+        expect(batch.commit).toHaveBeenCalled();
+    });
+    it("stores hardBannedBy as performedBy in the history entry", async () => {
+        const batch = makeBatch();
+        const ctx = makeCtx(batch);
+        await handleUserBanChange({
+            uid: "user-1",
+            before: { isDisabled: false },
+            after: { isDisabled: true, hardBanReason: "Fraud", hardBannedBy: "admin-2" },
+        }, ctx);
+        const call = batch.set.mock.calls[0][1];
+        expect(call.performedBy).toBe("admin-2");
+    });
+    it("does NOT write hard_ban when isDisabled stays true (no transition)", async () => {
+        const batch = makeBatch();
+        const ctx = makeCtx(batch);
+        await handleUserBanChange({
+            uid: "user-1",
+            before: { isDisabled: true },
+            after: { isDisabled: true, hardBanReason: "Fraud" },
+        }, ctx);
+        const hardBanCalls = batch.set.mock.calls.filter((c) => c[1].type === "hard_ban");
+        expect(hardBanCalls).toHaveLength(0);
+    });
+});
+describe("handleUserBanChange — hard ban lifted (unban)", () => {
+    it("writes a hard_unban entry when isDisabled transitions true→false", async () => {
+        const batch = makeBatch();
+        const ctx = makeCtx(batch);
+        await handleUserBanChange({
+            uid: "user-1",
+            before: { isDisabled: true },
+            after: { isDisabled: false },
+        }, ctx);
+        expect(batch.set).toHaveBeenCalledWith(expect.any(Object), expect.objectContaining({ type: "hard_unban" }));
+    });
+});
+describe("handleUserBanChange — soft ban changes", () => {
+    it("writes a soft_ban entry for each newly added soft ban action", async () => {
+        const batch = makeBatch();
+        const ctx = makeCtx(batch);
+        await handleUserBanChange({
+            uid: "user-1",
+            before: { softBans: [] },
+            after: {
+                softBans: [
+                    { action: "place_bids", reason: "Shill bidding", bannedBy: "admin-1" },
+                ],
+            },
+        }, ctx);
+        expect(batch.set).toHaveBeenCalledWith(expect.any(Object), expect.objectContaining({ type: "soft_ban", action: "place_bids" }));
+    });
+    it("writes soft_unban for each removed soft ban", async () => {
+        const batch = makeBatch();
+        const ctx = makeCtx(batch);
+        await handleUserBanChange({
+            uid: "user-1",
+            before: { softBans: [{ action: "place_bids" }] },
+            after: { softBans: [] },
+        }, ctx);
+        expect(batch.set).toHaveBeenCalledWith(expect.any(Object), expect.objectContaining({ type: "soft_unban", action: "place_bids" }));
+    });
+    it("does NOT write entry for soft bans that are unchanged", async () => {
+        const batch = makeBatch();
+        const ctx = makeCtx(batch);
+        await handleUserBanChange({
+            uid: "user-1",
+            before: { softBans: [{ action: "place_bids" }] },
+            after: { softBans: [{ action: "place_bids" }] }, // same ban, no change
+        }, ctx);
+        expect(batch.commit).not.toHaveBeenCalled();
+    });
+    it("handles multiple simultaneous soft ban additions", async () => {
+        const batch = makeBatch();
+        const ctx = makeCtx(batch);
+        await handleUserBanChange({
+            uid: "user-1",
+            before: { softBans: [] },
+            after: {
+                softBans: [
+                    { action: "place_bids" },
+                    { action: "post_reviews" },
+                ],
+            },
+        }, ctx);
+        expect(batch.set).toHaveBeenCalledTimes(2);
+    });
+});
+describe("handleUserBanChange — batch failure", () => {
+    it("batch.commit failure is non-fatal — logs error but does not throw", async () => {
+        const batch = makeBatch();
+        batch.commit.mockRejectedValue(new Error("Firestore error"));
+        const ctx = makeCtx(batch);
+        await expect(handleUserBanChange({
+            uid: "user-1",
+            before: { isDisabled: false },
+            after: { isDisabled: true, hardBanReason: "Test" },
+        }, ctx)).resolves.toBeUndefined();
+        expect(ctx.logger.error).toHaveBeenCalled();
+    });
+});

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

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

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

@@ -0,0 +1,302 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+const { mockGetPending, mockMarkProcessing, mockRecordSuccess, mockRecordFailure, mockFetch, } = vi.hoisted(() => ({
+    mockGetPending: vi.fn(),
+    mockMarkProcessing: vi.fn(),
+    mockRecordSuccess: vi.fn(),
+    mockRecordFailure: vi.fn(),
+    mockFetch: vi.fn(),
+}));
+vi.mock("../../../../../repositories", () => ({
+    payoutRepository: {
+        getPending: mockGetPending,
+        markProcessing: mockMarkProcessing,
+        recordSuccess: mockRecordSuccess,
+        recordFailure: mockRecordFailure,
+    },
+}));
+vi.mock("../../../../../errors/normalize", () => ({
+    normalizeError: vi.fn(),
+}));
+import { runPayoutBatch } from "../payoutBatch";
+// ── Helpers ─────────────────────────────────────────────────────────────────
+function makeCtx(overrides = {}) {
+    return {
+        env: (key) => {
+            const defaults = {
+                RAZORPAY_KEY_ID: "rzp_test_key",
+                RAZORPAY_KEY_SECRET: "secret",
+                RAZORPAY_ACCOUNT_NUMBER: "ACC123",
+                RAZORPAY_API_BASE_URL: "https://api.razorpay.com/v1",
+                APP_BRAND_NAME: "LetItRip",
+            };
+            return defaults[key];
+        },
+        logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() },
+        ...overrides,
+    };
+}
+function makeRef() {
+    return { id: "payout-ref-1" };
+}
+function makePayout(overrides = {}) {
+    return {
+        id: "payout-store-A-001",
+        storeId: "store-A",
+        sellerEmail: "seller@example.com",
+        amount: 1000,
+        netAmount: 1000,
+        currency: "INR",
+        paymentMethod: "upi",
+        upiId: "seller@upi",
+        failureCount: 0,
+        ...overrides,
+    };
+}
+function makeBankPayout(overrides = {}) {
+    return makePayout({
+        paymentMethod: "bank",
+        upiId: undefined,
+        bankAccount: {
+            accountHolderName: "Seller A",
+            ifscCode: "HDFC0000001",
+            accountNumberMasked: "xxxx1234",
+        },
+        ...overrides,
+    });
+}
+function makeEntry(payoutOverrides = {}) {
+    return {
+        ref: makeRef(),
+        data: makePayout(payoutOverrides),
+    };
+}
+function mockRazorpaySuccess(id = "rzp_payout_1", status = "processing") {
+    mockFetch.mockResolvedValue({
+        ok: true,
+        json: async () => ({ id, status }),
+        text: async () => JSON.stringify({ id, status }),
+    });
+}
+function mockRazorpayFailure(statusCode = 500, body = "Internal Server Error") {
+    mockFetch.mockResolvedValue({
+        ok: false,
+        status: statusCode,
+        text: async () => body,
+    });
+}
+beforeEach(() => {
+    vi.clearAllMocks();
+    vi.stubGlobal("fetch", mockFetch);
+    mockMarkProcessing.mockResolvedValue(undefined);
+    mockRecordSuccess.mockResolvedValue(undefined);
+    mockRecordFailure.mockResolvedValue(undefined);
+});
+// ── Tests ────────────────────────────────────────────────────────────────────
+describe("runPayoutBatch — no pending payouts", () => {
+    it("returns early without calling fetch when list is empty", async () => {
+        mockGetPending.mockResolvedValue([]);
+        await runPayoutBatch(makeCtx());
+        expect(mockFetch).not.toHaveBeenCalled();
+    });
+    it("logs 'No pending payouts' when list is empty", async () => {
+        mockGetPending.mockResolvedValue([]);
+        const ctx = makeCtx();
+        await runPayoutBatch(ctx);
+        expect(ctx.logger.info).toHaveBeenCalledWith(expect.stringMatching(/No pending payouts/i));
+    });
+});
+describe("runPayoutBatch — UPI payout", () => {
+    it("marks payout as PROCESSING before dispatching", async () => {
+        const entry = makeEntry();
+        mockGetPending.mockResolvedValue([entry]);
+        mockRazorpaySuccess();
+        await runPayoutBatch(makeCtx());
+        expect(mockMarkProcessing).toHaveBeenCalledWith(entry.ref);
+    });
+    it("builds correct UPI payload (account_type=vpa)", async () => {
+        const entry = makeEntry({ upiId: "seller@okaxis" });
+        mockGetPending.mockResolvedValue([entry]);
+        mockRazorpaySuccess();
+        await runPayoutBatch(makeCtx());
+        const body = JSON.parse(mockFetch.mock.calls[0][1].body);
+        expect(body.fund_account.account_type).toBe("vpa");
+        expect(body.fund_account.vpa.address).toBe("seller@okaxis");
+        expect(body.mode).toBe("UPI");
+    });
+    it("converts amount to paise (multiplies by 100)", async () => {
+        const entry = makeEntry({ amount: 500, netAmount: 500 });
+        mockGetPending.mockResolvedValue([entry]);
+        mockRazorpaySuccess();
+        await runPayoutBatch(makeCtx());
+        const body = JSON.parse(mockFetch.mock.calls[0][1].body);
+        expect(body.amount).toBe(50000);
+    });
+    it("uses netAmount over gross amount when set (after refund deduction)", async () => {
+        const entry = makeEntry({ amount: 1000, netAmount: 800 });
+        mockGetPending.mockResolvedValue([entry]);
+        mockRazorpaySuccess();
+        await runPayoutBatch(makeCtx());
+        const body = JSON.parse(mockFetch.mock.calls[0][1].body);
+        expect(body.amount).toBe(80000); // netAmount 800 * 100
+    });
+    it("sends Authorization: Basic header with base64-encoded credentials", async () => {
+        const entry = makeEntry();
+        mockGetPending.mockResolvedValue([entry]);
+        mockRazorpaySuccess();
+        await runPayoutBatch(makeCtx());
+        const headers = mockFetch.mock.calls[0][1].headers;
+        const expected = "Basic " + Buffer.from("rzp_test_key:secret").toString("base64");
+        expect(headers["Authorization"]).toBe(expected);
+    });
+    it("sets X-Payout-Idempotency header to payout.id", async () => {
+        const entry = makeEntry({ id: "payout-001" });
+        mockGetPending.mockResolvedValue([entry]);
+        mockRazorpaySuccess();
+        await runPayoutBatch(makeCtx());
+        const headers = mockFetch.mock.calls[0][1].headers;
+        expect(headers["X-Payout-Idempotency"]).toBe("payout-001");
+    });
+    it("calls recordSuccess with razorpayId and status on success", async () => {
+        const entry = makeEntry();
+        mockGetPending.mockResolvedValue([entry]);
+        mockRazorpaySuccess("rzp_pout_xyz", "processing");
+        await runPayoutBatch(makeCtx());
+        expect(mockRecordSuccess).toHaveBeenCalledWith(entry.ref, "rzp_pout_xyz", "processing");
+    });
+    it("uses reference_id = payout.id in the request body", async () => {
+        const entry = makeEntry({ id: "payout-store-B-42" });
+        mockGetPending.mockResolvedValue([entry]);
+        mockRazorpaySuccess();
+        await runPayoutBatch(makeCtx());
+        const body = JSON.parse(mockFetch.mock.calls[0][1].body);
+        expect(body.reference_id).toBe("payout-store-B-42");
+    });
+});
+describe("runPayoutBatch — bank payout", () => {
+    it("builds correct bank payload (account_type=bank_account)", async () => {
+        const entry = { ref: makeRef(), data: makeBankPayout() };
+        mockGetPending.mockResolvedValue([entry]);
+        mockRazorpaySuccess();
+        await runPayoutBatch(makeCtx());
+        const body = JSON.parse(mockFetch.mock.calls[0][1].body);
+        expect(body.fund_account.account_type).toBe("bank_account");
+        expect(body.fund_account.bank_account.ifsc).toBe("HDFC0000001");
+        expect(body.mode).toBe("NEFT");
+    });
+    it("bank payout: account_number_masked used in payload", async () => {
+        const entry = { ref: makeRef(), data: makeBankPayout() };
+        mockGetPending.mockResolvedValue([entry]);
+        mockRazorpaySuccess();
+        await runPayoutBatch(makeCtx());
+        const body = JSON.parse(mockFetch.mock.calls[0][1].body);
+        expect(body.fund_account.bank_account.account_number).toBe("xxxx1234");
+    });
+});
+describe("runPayoutBatch — no fund account configured", () => {
+    it("throws and calls recordFailure when paymentMethod is upi but no upiId", async () => {
+        const entry = makeEntry({ paymentMethod: "upi", upiId: undefined });
+        mockGetPending.mockResolvedValue([entry]);
+        await runPayoutBatch(makeCtx());
+        expect(mockFetch).not.toHaveBeenCalled();
+        expect(mockRecordFailure).toHaveBeenCalled();
+    });
+});
+describe("runPayoutBatch — missing Razorpay credentials", () => {
+    it("records failure when RAZORPAY_KEY_ID is missing", async () => {
+        const entry = makeEntry();
+        mockGetPending.mockResolvedValue([entry]);
+        const ctx = makeCtx({ env: (k) => (k === "RAZORPAY_KEY_ID" ? undefined : "value") });
+        await runPayoutBatch(ctx);
+        expect(mockRecordFailure).toHaveBeenCalled();
+        expect(mockFetch).not.toHaveBeenCalled();
+    });
+    it("records failure when RAZORPAY_KEY_SECRET is missing", async () => {
+        const entry = makeEntry();
+        mockGetPending.mockResolvedValue([entry]);
+        const ctx = makeCtx({ env: (k) => (k === "RAZORPAY_KEY_SECRET" ? undefined : "value") });
+        await runPayoutBatch(ctx);
+        expect(mockRecordFailure).toHaveBeenCalled();
+    });
+});
+describe("runPayoutBatch — Razorpay API failure", () => {
+    it("Razorpay returns non-OK → calls recordFailure with incremented failureCount", async () => {
+        const entry = makeEntry({ failureCount: 0 });
+        mockGetPending.mockResolvedValue([entry]);
+        mockRazorpayFailure(500);
+        await runPayoutBatch(makeCtx());
+        expect(mockRecordFailure).toHaveBeenCalledWith(entry.ref, 1, // failureCount incremented from 0 to 1
+        expect.any(String), false);
+    });
+    it("failureCount=1 (2nd attempt) → isFinal = false", async () => {
+        const entry = makeEntry({ failureCount: 1 });
+        mockGetPending.mockResolvedValue([entry]);
+        mockRazorpayFailure();
+        await runPayoutBatch(makeCtx());
+        expect(mockRecordFailure).toHaveBeenCalledWith(entry.ref, 2, expect.any(String), false);
+    });
+    it("failureCount=2 (3rd attempt, MAX_FAILURES) → isFinal = true", async () => {
+        const entry = makeEntry({ failureCount: 2 });
+        mockGetPending.mockResolvedValue([entry]);
+        mockRazorpayFailure();
+        await runPayoutBatch(makeCtx());
+        expect(mockRecordFailure).toHaveBeenCalledWith(entry.ref, 3, expect.any(String), true);
+    });
+    it("final failure → ctx.logger.error called (not just warn)", async () => {
+        const entry = makeEntry({ failureCount: 2 });
+        mockGetPending.mockResolvedValue([entry]);
+        mockRazorpayFailure();
+        const ctx = makeCtx();
+        await runPayoutBatch(ctx);
+        expect(ctx.logger.error).toHaveBeenCalled();
+        expect(ctx.logger.warn).not.toHaveBeenCalled();
+    });
+    it("non-final failure → ctx.logger.warn called (not error)", async () => {
+        const entry = makeEntry({ failureCount: 0 });
+        mockGetPending.mockResolvedValue([entry]);
+        mockRazorpayFailure();
+        const ctx = makeCtx();
+        await runPayoutBatch(ctx);
+        expect(ctx.logger.warn).toHaveBeenCalled();
+        expect(ctx.logger.error).not.toHaveBeenCalled();
+    });
+    it("failure does NOT call recordSuccess", async () => {
+        const entry = makeEntry();
+        mockGetPending.mockResolvedValue([entry]);
+        mockRazorpayFailure();
+        await runPayoutBatch(makeCtx());
+        expect(mockRecordSuccess).not.toHaveBeenCalled();
+    });
+});
+describe("runPayoutBatch — multiple payouts", () => {
+    it("dispatches all payouts independently", async () => {
+        const e1 = makeEntry({ id: "payout-A" });
+        const e2 = makeEntry({ id: "payout-B" });
+        mockGetPending.mockResolvedValue([e1, e2]);
+        mockRazorpaySuccess();
+        await runPayoutBatch(makeCtx());
+        expect(mockMarkProcessing).toHaveBeenCalledTimes(2);
+        expect(mockRecordSuccess).toHaveBeenCalledTimes(2);
+    });
+    it("one payout failure does NOT abort others (Promise.allSettled)", async () => {
+        const e1 = makeEntry({ id: "payout-A", failureCount: 2 });
+        const e2 = makeEntry({ id: "payout-B" });
+        mockGetPending.mockResolvedValue([e1, e2]);
+        // First call fails, second succeeds
+        mockFetch
+            .mockResolvedValueOnce({ ok: false, status: 500, text: async () => "err" })
+            .mockResolvedValueOnce({ ok: true, json: async () => ({ id: "rzp_1", status: "processing" }) });
+        await expect(runPayoutBatch(makeCtx())).resolves.toBeUndefined();
+        expect(mockRecordSuccess).toHaveBeenCalledTimes(1);
+        expect(mockRecordFailure).toHaveBeenCalledTimes(1);
+    });
+    it("logs batch summary with total/succeeded/failed counts", async () => {
+        const e1 = makeEntry({ id: "payout-A" });
+        const e2 = makeEntry({ id: "payout-B" });
+        mockGetPending.mockResolvedValue([e1, e2]);
+        mockRazorpaySuccess();
+        const ctx = makeCtx();
+        await runPayoutBatch(ctx);
+        const summaryCall = ctx.logger.info.mock.calls.find((c) => typeof c[0] === "string" && c[0].toLowerCase().includes("complete"));
+        expect(summaryCall).toBeTruthy();
+    });
+});

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

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