@mohasinac/appkit 3.0.6 → 3.1.1

package/dist/_internal/server/features/lottery/actions.js

@@ -0,0 +1,243 @@
+"use server";
+import { wrapAction } from "@mohasinac/appkit/server";
+import { getAdminDb } from "../../../../providers/db-firebase";
+import { eventRepository } from "../../../../repositories";
+import { lotteryEntryRepository } from "../../../../features/lottery/repository/lottery-entry.repository";
+import { requireRoleUser } from "../../../../providers/auth-firebase/helpers";
+import { ValidationError } from "../../../shared/errors/index";
+import { submitLotteryPullSchema, flagLotteryEntrySchema, reopenLotterySlotSchema, } from "../../../../features/lottery/schemas/zod";
+import { LotteryError, assignSlotWeights, pickWeightedSlot, } from "../../../../features/lottery/types";
+import { LOTTERY_ENTRIES_COLLECTION } from "../../../../features/lottery/schemas/firestore";
+// ── Helpers ──────────────────────────────────────────────────────────────────
+function isDrawWindowOpen(config) {
+    // Draw window is implicitly open when there are unclaimed slots.
+    // A real implementation would also check if the event status is "active".
+    return config.slots.some((s) => !s.isBooked);
+}
+// ── Public actions ────────────────────────────────────────────────────────────
+/**
+ * User-initiated lottery pull.
+ * Atomically:
+ * 1. Validates inputs + limits
+ * 2. Runs weighted slot selection on unclaimed slots
+ * 3. Marks the slot as booked
+ * 4. Creates the LotteryEntryDocument with assignedPrizeSlotNumber set
+ *
+ * Returns the assigned slot number so the user sees their prize immediately.
+ */
+export async function submitLotteryPullAction(input) {
+    return wrapAction(async () => {
+        // Auth — must be logged in
+        const user = await requireRoleUser(["buyer", "seller", "admin", "moderator", "employee"]);
+        const parsed = submitLotteryPullSchema.safeParse(input);
+        if (!parsed.success) {
+            throw new ValidationError(parsed.error.issues[0]?.message ?? "Invalid lottery pull input");
+        }
+        const data = parsed.data;
+        const sourceId = data.sourceType === "event" ? data.eventId : data.productId;
+        const sourceField = data.sourceType === "event" ? "eventId" : "productId";
+        // Load the event/product to get the lotteryConfig
+        let lotteryConfig;
+        if (data.sourceType === "event") {
+            const event = await eventRepository.findById(sourceId).catch(() => null);
+            if (!event || event.type !== "lottery") {
+                throw new LotteryError("LOTTERY_WINDOW_CLOSED", "Lottery event not found or not of type lottery.");
+            }
+            if (event.status !== "active") {
+                throw new LotteryError("LOTTERY_WINDOW_CLOSED", "This lottery is not currently active.");
+            }
+            if (!event.lotteryConfig) {
+                throw new LotteryError("LOTTERY_WINDOW_CLOSED", "Lottery config not found on event.");
+            }
+            lotteryConfig = event.lotteryConfig;
+        }
+        else {
+            // Product lottery — load via product repository (not implemented here; caller ensures correct source)
+            throw new ValidationError("Product lottery pull must go through the product lottery pull route.");
+        }
+        // Compute weights
+        const weightedSlots = assignSlotWeights(lotteryConfig);
+        // Check draw window
+        if (!isDrawWindowOpen(lotteryConfig)) {
+            throw new LotteryError("LOTTERY_FULL", "All slots have been claimed.");
+        }
+        // Enforce maxPullsPerUser
+        const existingUserPulls = await lotteryEntryRepository.countByUser(sourceId, sourceField, user.uid);
+        if (existingUserPulls >= lotteryConfig.maxPullsPerUser) {
+            throw new LotteryError("USER_LIMIT_REACHED", "You have reached the maximum number of pulls for this lottery.");
+        }
+        // Enforce maxPullsPerTransaction
+        const existingTxPulls = await lotteryEntryRepository.countByTransactionId(sourceId, sourceField, data.transactionId);
+        if (existingTxPulls >= lotteryConfig.maxPullsPerTransaction) {
+            throw new LotteryError("TX_ALREADY_USED", "This transaction ID has already been used the maximum number of times.");
+        }
+        // Atomically: pick slot + create entry + mark slot booked
+        const db = getAdminDb();
+        const sourceDocRef = db.collection("events").doc(sourceId);
+        const { assignedSlot, userLotteryNumber } = await db.runTransaction(async (tx) => {
+            // Re-read lotteryConfig inside transaction for freshness
+            const sourceSnap = await tx.get(sourceDocRef);
+            if (!sourceSnap.exists)
+                throw new LotteryError("LOTTERY_WINDOW_CLOSED", "Lottery source not found.");
+            const freshConfig = sourceSnap.data().lotteryConfig;
+            if (!freshConfig)
+                throw new LotteryError("LOTTERY_WINDOW_CLOSED", "Lottery config missing.");
+            const freshWeighted = assignSlotWeights(freshConfig);
+            const unclaimed = freshWeighted.filter((s) => !s.isBooked);
+            if (unclaimed.length === 0)
+                throw new LotteryError("LOTTERY_FULL", "All slots have been claimed.");
+            // Weighted pick
+            const chosen = pickWeightedSlot(unclaimed);
+            // Compute next userLotteryNumber (count + 1 inside tx via collection size)
+            const countSnap = await db
+                .collection(LOTTERY_ENTRIES_COLLECTION)
+                .where(sourceField, "==", sourceId)
+                .get();
+            const nextNumber = countSnap.size + 1;
+            // Mark slot booked in the source document
+            const updatedSlots = freshConfig.slots.map((s) => s.slotNumber === chosen.slotNumber
+                ? {
+                    ...s,
+                    isBooked: true,
+                    bookedByUserId: user.uid,
+                    bookedByDisplayName: user.displayName ?? user.name ?? undefined,
+                    bookedByUserLotteryNumber: nextNumber,
+                }
+                : s);
+            tx.update(sourceDocRef, {
+                "lotteryConfig.slots": updatedSlots,
+            });
+            return { assignedSlot: chosen, userLotteryNumber: nextNumber };
+        });
+        // Create the entry document outside the transaction (acceptable — slot is already booked)
+        const entryData = {
+            sourceType: data.sourceType,
+            ...(data.sourceType === "event" ? { eventId: sourceId } : { productId: sourceId }),
+            userId: user.uid,
+            userDisplayName: user.displayName ?? user.name ?? undefined,
+            userEmail: user.email ?? undefined,
+            userPhone: data.userPhone,
+            transactionId: data.transactionId,
+            paymentTime: new Date(data.paymentTime),
+            purchasedItemNumber: data.purchasedItemNumber,
+            userLotteryNumber,
+            assignedPrizeSlotNumber: assignedSlot.slotNumber,
+            status: "drawn",
+            isFlagged: false,
+            submittedAt: new Date(),
+            drawnAt: new Date(),
+        };
+        await lotteryEntryRepository.createEntry(entryData);
+        return {
+            userLotteryNumber,
+            assignedPrizeSlotNumber: assignedSlot.slotNumber,
+            slotName: assignedSlot.name,
+        };
+    });
+}
+/**
+ * Admin — flag a lottery entry as fraudulent.
+ * Slot stays booked; use reopenLotterySlotAction to free it.
+ */
+export async function flagLotteryEntryAction(input) {
+    return wrapAction(async () => {
+        await requireRoleUser(["admin", "moderator"]);
+        const parsed = flagLotteryEntrySchema.safeParse(input);
+        if (!parsed.success) {
+            throw new ValidationError(parsed.error.issues[0]?.message ?? "Invalid flag input");
+        }
+        return lotteryEntryRepository.flagEntry(parsed.data.entryId, parsed.data.flagNote, parsed.data.flaggedByUserId);
+    });
+}
+/**
+ * Admin — reopen a slot from a flagged entry.
+ * Clears isBooked on the slot so it can be claimed in a future pull.
+ */
+export async function reopenLotterySlotAction(input) {
+    return wrapAction(async () => {
+        await requireRoleUser(["admin"]);
+        const parsed = reopenLotterySlotSchema.safeParse(input);
+        if (!parsed.success) {
+            throw new ValidationError(parsed.error.issues[0]?.message ?? "Invalid reopen input");
+        }
+        const { sourceType, sourceId, slotNumber } = parsed.data;
+        const db = getAdminDb();
+        const collectionName = sourceType === "event" ? "events" : "products";
+        const docRef = db.collection(collectionName).doc(sourceId);
+        await db.runTransaction(async (tx) => {
+            const snap = await tx.get(docRef);
+            if (!snap.exists)
+                throw new ValidationError("Source document not found.");
+            const config = snap.data().lotteryConfig;
+            if (!config?.slots)
+                throw new ValidationError("Lottery config not found.");
+            const updatedSlots = config.slots.map((s) => s.slotNumber === slotNumber
+                ? {
+                    ...s,
+                    isBooked: false,
+                    bookedByUserId: null,
+                    bookedByDisplayName: null,
+                    bookedByUserLotteryNumber: null,
+                }
+                : s);
+            tx.update(docRef, { "lotteryConfig.slots": updatedSlots });
+        });
+    });
+}
+/**
+ * Admin — create a new lottery event.
+ * Weights computed server-side; never returned to client.
+ */
+export async function createLotteryEventAction(data) {
+    return wrapAction(async () => {
+        const user = await requireRoleUser(["admin", "moderator"]);
+        const rawData = data;
+        const lotteryConfig = rawData.lotteryConfig;
+        if (!lotteryConfig)
+            throw new ValidationError("lotteryConfig is required for lottery events.");
+        // Compute weights server-side
+        const withWeights = assignSlotWeights(lotteryConfig);
+        return eventRepository.createEvent({
+            ...rawData,
+            type: "lottery",
+            lotteryConfig: { ...lotteryConfig, slots: withWeights },
+            createdBy: user.uid,
+            status: rawData.status ?? "draft",
+            stats: { totalEntries: 0, approvedEntries: 0, flaggedEntries: 0 },
+        });
+    });
+}
+/**
+ * Admin — update a lottery event.
+ * Recomputes slot weights after update.
+ */
+export async function updateLotteryEventAction(id, data) {
+    return wrapAction(async () => {
+        await requireRoleUser(["admin", "moderator"]);
+        const rawData = data;
+        const lotteryConfig = rawData.lotteryConfig;
+        if (lotteryConfig) {
+            const withWeights = assignSlotWeights(lotteryConfig);
+            return eventRepository.updateEvent(id, {
+                ...rawData,
+                lotteryConfig: { ...lotteryConfig, slots: withWeights },
+            });
+        }
+        return eventRepository.updateEvent(id, rawData);
+    });
+}
+/**
+ * Store owner or Admin — switch a prize-draw product into lottery mode.
+ * Store owners provide prizeSlotPrice but weight is NEVER returned to them.
+ */
+export async function setProductLotteryModeAction(productId, lotteryConfig) {
+    return wrapAction(async () => {
+        await requireRoleUser(["admin", "moderator", "seller"]);
+        const withWeights = assignSlotWeights(lotteryConfig);
+        const db = getAdminDb();
+        await db.collection("products").doc(productId).update({
+            prizeDrawMode: "lottery",
+            lotteryConfig: { ...lotteryConfig, slots: withWeights },
+        });
+    });
+}

package/dist/_internal/server/features/lottery/adapters.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Lottery adapters — strips server-only fields (priceInPaise, weight)
+ * before any slot/config data leaves the server.
+ */
+import type { LotteryConfig, LotterySlot, ClientLotteryConfig, ClientLotterySlot } from "../../../../features/lottery/types";
+/** Strip priceInPaise and weight from a single slot for client consumption. */
+export declare function toClientLotterySlot(slot: LotterySlot): ClientLotterySlot;
+/** Strip price/weight from the entire config for client consumption. */
+export declare function toClientLotteryConfig(config: LotteryConfig): ClientLotteryConfig;

package/dist/_internal/server/features/lottery/adapters.js

@@ -0,0 +1,21 @@
+/** Strip priceInPaise and weight from a single slot for client consumption. */
+export function toClientLotterySlot(slot) {
+    return {
+        slotNumber: slot.slotNumber,
+        name: slot.name,
+        isBooked: slot.isBooked,
+        bookedByUserLotteryNumber: slot.bookedByUserLotteryNumber,
+        bookedByDisplayName: slot.bookedByDisplayName,
+    };
+}
+/** Strip price/weight from the entire config for client consumption. */
+export function toClientLotteryConfig(config) {
+    return {
+        slots: config.slots.map(toClientLotterySlot),
+        totalSlots: config.totalSlots,
+        pricingMode: config.pricingMode,
+        drawWindowDurationMinutes: config.drawWindowDurationMinutes,
+        maxPullsPerTransaction: config.maxPullsPerTransaction,
+        maxPullsPerUser: config.maxPullsPerUser,
+    };
+}

package/dist/_internal/server/features/lottery/data.d.ts

@@ -0,0 +1,20 @@
+import type { SieveModel } from "../../../../providers/db-firebase";
+import type { EventDocument } from "../../../../features/events/schemas/firestore";
+import type { LotteryEntryDocument } from "../../../../features/lottery/schemas/firestore";
+import type { ClientLotteryConfig } from "../../../../features/lottery/types";
+/** Event shape with lottery config stripped of price/weight. */
+export type LotteryEventClient = Omit<EventDocument, "lotteryConfig"> & {
+    lotteryConfig?: ClientLotteryConfig;
+};
+/** Fetch a lottery-type event with price/weight stripped for client use. */
+export declare const getLotteryEventCached: (id: string) => Promise<LotteryEventClient | null>;
+/** List all lottery-type events with price/weight stripped. */
+export declare const listLotteryEvents: (opts?: {
+    status?: string;
+    page?: number;
+    pageSize?: number;
+}) => Promise<LotteryEventClient[]>;
+/** Fetch lottery entries for admin view (includes phone + txId via PII decrypt). */
+export declare function getLotteryEntriesForAdmin(sourceType: "event" | "product", sourceId: string, model: SieveModel): Promise<import("../../../..").FirebaseSieveResult<LotteryEntryDocument>>;
+/** Fetch lottery entries for a specific user (own entries only). */
+export declare function getLotteryEntriesForUser(userId: string, model: SieveModel): Promise<import("../../../..").FirebaseSieveResult<LotteryEntryDocument>>;

package/dist/_internal/server/features/lottery/data.js

@@ -0,0 +1,41 @@
+import { cache } from "react";
+import { eventRepository } from "../../../../repositories";
+import { lotteryEntryRepository } from "../../../../features/lottery/repository/lottery-entry.repository";
+import { toClientLotteryConfig } from "./adapters";
+/** Fetch a lottery-type event with price/weight stripped for client use. */
+export const getLotteryEventCached = cache(async (id) => {
+    const event = await eventRepository.findById(id).catch(() => null);
+    if (!event || event.type !== "lottery")
+        return null;
+    return {
+        ...event,
+        lotteryConfig: event.lotteryConfig ? toClientLotteryConfig(event.lotteryConfig) : undefined,
+    };
+});
+/** List all lottery-type events with price/weight stripped. */
+export const listLotteryEvents = cache(async (opts) => {
+    // Build Sieve filter: type==lottery, optionally also status
+    let filters = "type==lottery";
+    if (opts?.status)
+        filters += `,status==${opts.status}`;
+    const result = await eventRepository.list({
+        filters,
+        sorts: "-startsAt",
+        page: opts?.page ?? 1,
+        pageSize: opts?.pageSize ?? 50,
+    });
+    const items = result.items ?? [];
+    return items.map((event) => ({
+        ...event,
+        lotteryConfig: event.lotteryConfig ? toClientLotteryConfig(event.lotteryConfig) : undefined,
+    }));
+});
+/** Fetch lottery entries for admin view (includes phone + txId via PII decrypt). */
+export async function getLotteryEntriesForAdmin(sourceType, sourceId, model) {
+    const field = sourceType === "event" ? "eventId" : "productId";
+    return lotteryEntryRepository.listForSource(sourceId, field, model);
+}
+/** Fetch lottery entries for a specific user (own entries only). */
+export async function getLotteryEntriesForUser(userId, model) {
+    return lotteryEntryRepository.listForUser(userId, model);
+}

package/dist/_internal/server/features/lottery/metadata.d.ts

@@ -0,0 +1,6 @@
+import type { Metadata } from "next";
+import type { LotteryEventClient } from "./data";
+export declare function buildLotteryMetadata(event: LotteryEventClient | null, opts?: {
+    siteName?: string;
+    baseUrl?: string;
+}): Metadata;

package/dist/_internal/server/features/lottery/metadata.js

@@ -0,0 +1,31 @@
+export function buildLotteryMetadata(event, opts) {
+    if (!event) {
+        return {
+            title: "Lottery Not Found",
+            description: "This lottery no longer exists.",
+        };
+    }
+    const siteName = opts?.siteName ?? "the platform";
+    const title = `${event.title} — ${siteName} Lottery`;
+    const description = typeof event.description === "string" && event.description.length > 0
+        ? event.description.slice(0, 155)
+        : `Enter the ${event.title} lottery on ${siteName}.`;
+    const coverUrl = event.coverImage && typeof event.coverImage.url === "string"
+        ? event.coverImage.url
+        : event.coverImageUrl;
+    return {
+        title,
+        description,
+        openGraph: {
+            title,
+            description,
+            ...(coverUrl ? { images: [{ url: coverUrl }] } : {}),
+        },
+        twitter: {
+            card: "summary_large_image",
+            title,
+            description,
+            ...(coverUrl ? { images: [coverUrl] } : {}),
+        },
+    };
+}

package/dist/_internal/server/features/refunds/__tests__/actions.test.d.ts

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

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

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

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