@mohasinac/appkit 2.6.2 → 2.6.4

package/dist/_internal/server/features/checkout/prize-bundle-gates.js

@@ -1,9 +1,10 @@
 /**
- * Prize-draw + bundle + maxPerUser gates for the checkout pipeline (SB6-C, SB8-A).
+ * maxPerUser gate + prize reveal deadline helper for the checkout pipeline
+ * (SB6-C, SB8-A).
  *
- * Shared helper used by both `createCheckoutOrderAction` (COD/UPI-manual path)
- * and `verifyAndPlaceRazorpayOrderAction` (Razorpay path). Pulled out here so
- * the two transactional flows enforce the same rules.
+ * `enforcePrizePoolCap` was removed in S-SBUNI-RULES (2026-05-13) — the
+ * equivalent check now lives in `prizeDrawRule.preflightChecks` in the rule
+ * registry and is invoked via `runSyncPreflight`.
  */
 import { ValidationError } from "../../../../errors";
 import { orderRepository } from "../../../../repositories";
@@ -80,20 +81,3 @@ export function computePrizeRevealDeadline(product, now = new Date()) {
     const candidate = new Date(base.getTime() + days * dayMs);
     return candidate.getTime() < windowEnd.getTime() ? candidate : windowEnd;
 }
-/**
- * Inside the existing checkout transaction, validate the prize-pool cap for
- * each prize-draw line. Caller must pass the fresh product snapshot read
- * within the transaction (so `prizeCurrentEntries` is up-to-date).
- *
- * Throws ValidationError if any item would overflow the pool.
- */
-export function enforcePrizePoolCap(args) {
-    const { productSnapshot, requestedQuantity } = args;
-    if (productSnapshot.listingType !== "prize-draw")
-        return;
-    const max = productSnapshot.prizeMaxEntries ?? 0;
-    const current = productSnapshot.prizeCurrentEntries ?? 0;
-    if (max > 0 && current + requestedQuantity > max) {
-        throw Object.assign(new ValidationError(`Draw is full for "${productSnapshot.title}". ${current}/${max} entries already in.`), { code: "PRIZE_POOL_FULL", productId: productSnapshot.id });
-    }
-}

package/dist/_internal/server/features/media/contextGuards.js

@@ -29,6 +29,8 @@ export const CONTEXT_LIMITS = {
     BLOG_ADDITIONAL_IMAGE_MAX: 5,
     RICH_TEXT_IMAGE_MAX: 20,
 };
+// Contexts that accept both image and PDF (proof documents).
+const IMAGE_OR_PDF_CONTEXTS = ["shipping-proof", "refund-proof"];
 const PDF_ONLY_CONTEXTS = ["invoice", "payout-doc"];
 const IMAGE_ONLY_CONTEXT_TYPES = new Set([
     "store-logo",
@@ -170,6 +172,7 @@ export function applyMediaContextGuards({ detectedMime, context: ctx, }) {
         };
     }
     const isPdfOnlyContext = (c) => PDF_ONLY_CONTEXTS.includes(c.type);
+    const isImageOrPdfContext = (c) => IMAGE_OR_PDF_CONTEXTS.includes(c.type);
     const ext = MIME_TO_EXT[detectedMime] ?? "bin";
     if (isPdfOnlyContext(ctx)) {
         if (!isPdf) {
@@ -182,11 +185,22 @@ export function applyMediaContextGuards({ detectedMime, context: ctx, }) {
         }
         return { ok: true, filename: generateMediaFilename(ctx), ext };
     }
+    if (isImageOrPdfContext(ctx)) {
+        // shipping-proof and refund-proof accept images or PDFs, not video.
+        if (isVideo) {
+            return {
+                ok: false,
+                status: 400,
+                error: `${ctx.type} must be an image or PDF, not a video`,
+            };
+        }
+        return { ok: true, filename: generateMediaFilename(ctx), ext };
+    }
     if (isPdf) {
         return {
             ok: false,
             status: 400,
-            error: "PDF uploads are only allowed for invoice or payout-doc contexts",
+            error: "PDF uploads are only allowed for invoice, payout-doc, shipping-proof, or refund-proof contexts",
             details: { context: ctx.type, detected: detectedMime },
         };
     }

package/dist/_internal/server/features/payouts/actions.d.ts

@@ -0,0 +1,19 @@
+export type ApplyRefundDeductionInput = {
+    storeId: string;
+    orderId: string;
+    refundId: string;
+    /** Gross refund amount in paise. */
+    refundedAmountInPaise: number;
+    /** Platform fee rate (0–1). Defaults to DEFAULT_PLATFORM_FEE_RATE (0.05). */
+    platformFeeRate?: number;
+    reason: string;
+};
+export type ApplyRefundDeductionResult = {
+    applied: true;
+    payoutId: string;
+    netAmount: number;
+} | {
+    applied: false;
+    reason: string;
+};
+export declare function applyRefundDeductionAction(input: ApplyRefundDeductionInput): Promise<ApplyRefundDeductionResult>;

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

@@ -0,0 +1,38 @@
+"use server";
+/**
+ * applyRefundDeductionAction — deduct a refund from a seller's pending payout.
+ *
+ * Called fire-and-forget after processRefundAction succeeds:
+ *   1. Locate the most recent pending payout for the order's store.
+ *   2. If found and it covers the refunded order, apply the deduction.
+ *   3. If no pending payout exists (already settled), return applied:false —
+ *      the reduced net revenue is automatically reflected in the next payout
+ *      cycle because the order revenue was never re-added.
+ *
+ * deductedAmount = refundedAmount × (1 − platformFeeRate).
+ * The platform keeps its fee share on every refund.
+ */
+import { payoutRepository } from "../../../../repositories";
+import { ValidationError } from "../../../../errors";
+export async function applyRefundDeductionAction(input) {
+    if (input.refundedAmountInPaise <= 0) {
+        throw new ValidationError("Refund amount must be positive");
+    }
+    const feeRate = input.platformFeeRate ?? 0.05;
+    const deductedAmount = Math.round(input.refundedAmountInPaise * (1 - feeRate));
+    const pending = await payoutRepository.findPendingByStore(input.storeId);
+    if (!pending) {
+        return { applied: false, reason: "no_pending_payout" };
+    }
+    if (!pending.orderIds.includes(input.orderId)) {
+        return { applied: false, reason: "order_not_in_payout" };
+    }
+    const updated = await payoutRepository.applyRefundDeduction(pending.id, {
+        orderId: input.orderId,
+        refundId: input.refundId,
+        refundedAmount: input.refundedAmountInPaise,
+        deductedAmount,
+        reason: input.reason,
+    });
+    return { applied: true, payoutId: updated.id, netAmount: updated.netAmount ?? updated.amount };
+}

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

@@ -31,8 +31,7 @@ export async function listSitemapProducts() {
             const rawListingType = data.listingType;
             const listingType = rawListingType === "auction" ||
                 rawListingType === "pre-order" ||
-                rawListingType === "prize-draw" ||
-                rawListingType === "bundle"
+                rawListingType === "prize-draw"
                 ? rawListingType
                 : "standard";
             return {

package/dist/_internal/server/features/raffle/actions.d.ts

@@ -0,0 +1,11 @@
+/**
+ * SB9-H — server actions for triggering an event raffle / assigning a spin
+ * prize from a Next.js API route. Builds an ad-hoc JobContext around
+ * `getAdminDb()` so the same pure runners used by the Firebase Functions
+ * handlers also work in a Vercel lambda (10s cap honoured by raffle pool
+ * size).
+ */
+import { type TriggerEventRaffleInput, type TriggerEventRaffleResult } from "../../jobs/core/triggerEventRaffle";
+import { type AssignSpinPrizeInput, type AssignSpinPrizeResult } from "../../jobs/core/assignSpinPrize";
+export declare function triggerEventRaffleAction(input: TriggerEventRaffleInput): Promise<TriggerEventRaffleResult>;
+export declare function assignSpinPrizeAction(input: AssignSpinPrizeInput): Promise<AssignSpinPrizeResult>;

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

@@ -0,0 +1,31 @@
+/**
+ * SB9-H — server actions for triggering an event raffle / assigning a spin
+ * prize from a Next.js API route. Builds an ad-hoc JobContext around
+ * `getAdminDb()` so the same pure runners used by the Firebase Functions
+ * handlers also work in a Vercel lambda (10s cap honoured by raffle pool
+ * size).
+ */
+"use server";
+import { getAdminDb } from "../../../../providers/db-firebase/admin";
+import { runTriggerEventRaffle, } from "../../jobs/core/triggerEventRaffle";
+import { runAssignSpinPrize, } from "../../jobs/core/assignSpinPrize";
+function buildContext(job) {
+    const logger = {
+        info: (msg, meta) => console.info(`[${job}] ${msg}`, meta ?? {}),
+        warn: (msg, meta) => console.warn(`[${job}] ${msg}`, meta ?? {}),
+        error: (msg, err, meta) => console.error(`[${job}] ${msg}`, err, meta ?? {}),
+    };
+    return {
+        job,
+        db: getAdminDb(),
+        logger,
+        env: (key) => process.env[key],
+        now: new Date(),
+    };
+}
+export async function triggerEventRaffleAction(input) {
+    return runTriggerEventRaffle(input, buildContext("admin.triggerEventRaffle"));
+}
+export async function assignSpinPrizeAction(input) {
+    return runAssignSpinPrize(input, buildContext("user.assignSpinPrize"));
+}

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

@@ -0,0 +1,31 @@
+import type { RefundType } from "../../../../features/orders/schemas";
+export type ProcessRefundInput = {
+    orderId: string;
+    type: RefundType;
+    /** Amount in paise. Must be > 0 and ≤ remaining refundable amount on the order. */
+    amountInPaise: number;
+    reason: string;
+    /** Product/item ids affected (for partial refunds). */
+    itemIds?: string[];
+    /** Required: caller must explicitly confirm this action is irrevocable. */
+    confirmIrrevocable: true;
+    /** uid of the user processing the refund (admin / seller). */
+    refundedBy: string;
+} & ({
+    method: "razorpay";
+    /** Razorpay paymentId from the order (order.paymentId). */
+    razorpayPaymentId: string;
+    manualTransactionId?: never;
+    proofDocumentUrl?: never;
+    proofDocumentMimeType?: never;
+} | {
+    method: "manual";
+    razorpayPaymentId?: never;
+    manualTransactionId?: string;
+    proofDocumentUrl?: string;
+    proofDocumentMimeType?: string;
+});
+export declare function processRefundAction(input: ProcessRefundInput): Promise<{
+    success: true;
+    refundId: string;
+}>;

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

@@ -0,0 +1,77 @@
+"use server";
+/**
+ * processRefundAction — append a refund event to an order.
+ *
+ * Supports two paths:
+ *  - Razorpay: calls the payment provider's `refund()` method, then records
+ *    the razorpayRefundId on the event.
+ *  - Manual: no payment-provider call; records manualTransactionId + optional
+ *    proof document URL.
+ *
+ * Both paths require `confirmIrrevocable: true` from the caller to prevent
+ * accidental use — callers must acknowledge the action is non-reversible.
+ *
+ * Setting `contestable` to false is a side-effect of `orderRepository.postRefundEvent`.
+ */
+import { randomUUID } from "crypto";
+import { getProviders } from "../../../../contracts/registry";
+import { orderRepository } from "../../../..";
+import { NotFoundError, ValidationError } from "../../../../errors";
+import { applyRefundDeductionAction } from "../payouts/actions";
+export async function processRefundAction(input) {
+    const order = await orderRepository.findById(input.orderId);
+    if (!order)
+        throw new NotFoundError(`Order ${input.orderId} not found`);
+    if (input.amountInPaise <= 0)
+        throw new ValidationError("Refund amount must be positive");
+    if (input.amountInPaise > order.totalPrice) {
+        throw new ValidationError("Refund amount exceeds order total");
+    }
+    // Guard: non-refundable orders (prize draws, bundles).
+    if (order.isNonRefundable) {
+        throw new ValidationError("This order is marked non-refundable and cannot be refunded.");
+    }
+    const refundId = randomUUID();
+    const now = new Date();
+    let razorpayRefundId;
+    if (input.method === "razorpay") {
+        const payment = getProviders().payment;
+        if (!payment)
+            throw new ValidationError("Payment provider not configured");
+        const result = await payment.refund(input.razorpayPaymentId, input.amountInPaise);
+        razorpayRefundId = result.id;
+    }
+    const isFull = input.amountInPaise >= order.totalPrice;
+    const event = {
+        refundId,
+        type: input.type,
+        amount: input.amountInPaise,
+        ...(input.itemIds?.length ? { itemIds: input.itemIds } : {}),
+        reason: input.reason,
+        refundedAt: now,
+        refundedBy: input.refundedBy,
+        ...(razorpayRefundId ? { razorpayRefundId } : {}),
+        ...(input.method === "manual" && input.manualTransactionId
+            ? { manualTransactionId: input.manualTransactionId }
+            : {}),
+        ...(input.method === "manual" && input.proofDocumentUrl
+            ? {
+                proofDocumentUrl: input.proofDocumentUrl,
+                proofDocumentMimeType: input.proofDocumentMimeType,
+            }
+            : {}),
+    };
+    await orderRepository.postRefundEvent(input.orderId, event, isFull);
+    // Fire-and-forget: deduct from the store's pending payout if one exists.
+    // Failure here must not roll back the already-posted refund event.
+    if (order.storeId) {
+        applyRefundDeductionAction({
+            storeId: order.storeId,
+            orderId: input.orderId,
+            refundId,
+            refundedAmountInPaise: input.amountInPaise,
+            reason: input.reason,
+        }).catch(() => { });
+    }
+    return { success: true, refundId };
+}

package/dist/_internal/server/jobs/core/adminAnalytics.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Core: aggregate admin analytics. Returns 12-month order totals + monthly
+ * breakdown + top-5 products by revenue.
+ */
+import type { JobContext } from "../runtime/types";
+export interface AdminAnalyticsResult {
+    summary: {
+        totalOrders: number;
+        totalRevenue: number;
+        newOrdersThisMonth: number;
+        revenueThisMonth: number;
+        totalProducts: number;
+        publishedProducts: number;
+    };
+    ordersByMonth: Array<{
+        month: string;
+        orders: number;
+        revenue: number;
+    }>;
+    topProducts: Array<{
+        productId: string;
+        title: string;
+        revenue: number;
+        orders: number;
+        mainImage: string;
+    }>;
+}
+export declare function runAdminAnalytics(_input: void, ctx: JobContext): Promise<AdminAnalyticsResult>;

package/dist/_internal/server/jobs/core/adminAnalytics.js

@@ -0,0 +1,98 @@
+/**
+ * Core: aggregate admin analytics. Returns 12-month order totals + monthly
+ * breakdown + top-5 products by revenue.
+ */
+import { orderRepository, productRepository } from "../../../../repositories";
+import { formatMonthYear } from "../../../../utils/date.formatter";
+import { ProductStatusValues } from "../../../../features/products/schemas/firestore";
+function normalizeDate(raw) {
+    return raw instanceof Date ? raw : new Date(raw);
+}
+async function loadOrdersSince(isoStart, pageCap) {
+    const out = [];
+    let page = 1;
+    let hasMore = true;
+    while (hasMore && page <= pageCap) {
+        const result = await orderRepository.listAll({
+            filters: `createdAt>=${isoStart}`,
+            sorts: "-createdAt",
+            page: String(page),
+            pageSize: "500",
+        });
+        out.push(...result.items);
+        hasMore = result.hasMore;
+        page += 1;
+    }
+    return out;
+}
+export async function runAdminAnalytics(_input, ctx) {
+    ctx.logger.info("Admin analytics requested");
+    const now = new Date();
+    const twelveMonthsAgo = new Date(now.getFullYear() - 1, now.getMonth(), 1).toISOString();
+    const monthStart = new Date(now.getFullYear(), now.getMonth(), 1).toISOString();
+    const [allTimeTotalsResult, past12, thisMonth, totalProductsResult, publishedProductsResult] = await Promise.all([
+        orderRepository.listAll({ page: "1", pageSize: "1" }),
+        loadOrdersSince(twelveMonthsAgo, 10),
+        loadOrdersSince(monthStart, 10),
+        productRepository.list({ page: "1", pageSize: "1" }),
+        productRepository.list({
+            filters: `status==${ProductStatusValues.PUBLISHED}`,
+            page: "1",
+            pageSize: "1",
+        }, { status: ProductStatusValues.PUBLISHED }),
+    ]);
+    const totalRevenue = past12.reduce((sum, o) => sum + (o.totalPrice ?? 0), 0);
+    const newOrdersThisMonth = thisMonth.length;
+    const revenueThisMonth = thisMonth.reduce((sum, o) => sum + (o.totalPrice ?? 0), 0);
+    const monthMap = new Map();
+    for (let i = 11; i >= 0; i--) {
+        const d = new Date(now.getFullYear(), now.getMonth() - i, 1);
+        const key = `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}`;
+        monthMap.set(key, { month: formatMonthYear(d), orders: 0, revenue: 0 });
+    }
+    for (const order of past12) {
+        const d = normalizeDate(order.createdAt);
+        const key = `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}`;
+        const entry = monthMap.get(key);
+        if (entry) {
+            entry.orders += 1;
+            entry.revenue += order.totalPrice ?? 0;
+        }
+    }
+    const revenueByProduct = new Map();
+    for (const order of past12) {
+        const existing = revenueByProduct.get(order.productId);
+        if (existing) {
+            existing.revenue += order.totalPrice ?? 0;
+            existing.orders += 1;
+        }
+        else {
+            revenueByProduct.set(order.productId, {
+                productId: order.productId,
+                title: order.productTitle,
+                revenue: order.totalPrice ?? 0,
+                orders: 1,
+            });
+        }
+    }
+    const topProducts = Array.from(revenueByProduct.values())
+        .sort((a, b) => b.revenue - a.revenue)
+        .slice(0, 5);
+    const topProductDocs = await Promise.all(topProducts.map((p) => productRepository.findById(p.productId)));
+    const topProductsWithImages = topProducts.map((p, i) => ({
+        ...p,
+        mainImage: topProductDocs[i]?.mainImage ?? "",
+    }));
+    return {
+        summary: {
+            totalOrders: allTimeTotalsResult.total,
+            totalRevenue,
+            newOrdersThisMonth,
+            revenueThisMonth,
+            totalProducts: totalProductsResult.total,
+            publishedProducts: publishedProductsResult.total,
+        },
+        ordersByMonth: Array.from(monthMap.values()),
+        topProducts: topProductsWithImages,
+    };
+}

package/dist/_internal/server/jobs/core/assignSpinPrize.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Core: weighted random selection from an event's `spinPrizes` config using
+ * `crypto.randomInt`. Enforces one spin per user.
+ */
+import type { JobContext } from "../runtime/types";
+export interface AssignSpinPrizeInput {
+    eventId: string;
+    userId: string;
+}
+export interface AssignSpinPrizeResult {
+    eventId: string;
+    userId: string;
+    spinPrizeId?: string;
+    spinPrizeTitle?: string;
+    spinPrizeCouponCode?: string;
+    alreadyUsed?: boolean;
+    reason?: string;
+}
+export declare function runAssignSpinPrize(input: AssignSpinPrizeInput, ctx: JobContext): Promise<AssignSpinPrizeResult>;

package/dist/_internal/server/jobs/core/assignSpinPrize.js

@@ -0,0 +1,81 @@
+/**
+ * Core: weighted random selection from an event's `spinPrizes` config using
+ * `crypto.randomInt`. Enforces one spin per user.
+ */
+import crypto from "node:crypto";
+const EVENTS_COLLECTION = "events";
+const EVENT_ENTRIES_COLLECTION = "eventEntries";
+const COUPONS_COLLECTION = "coupons";
+export async function runAssignSpinPrize(input, ctx) {
+    const { eventId, userId } = input;
+    const eventSnap = await ctx.db.collection(EVENTS_COLLECTION).doc(eventId).get();
+    if (!eventSnap.exists) {
+        return { eventId, userId, reason: "event_not_found" };
+    }
+    const event = eventSnap.data();
+    const prizes = Array.isArray(event.spinPrizes) ? event.spinPrizes : [];
+    const totalWeight = prizes.reduce((s, p) => s + (p.weight ?? 0), 0);
+    if (totalWeight <= 0) {
+        return { eventId, userId, reason: "no_prizes_configured" };
+    }
+    const entriesSnap = await ctx.db
+        .collection(EVENT_ENTRIES_COLLECTION)
+        .where("eventId", "==", eventId)
+        .where("userId", "==", userId)
+        .limit(1)
+        .get();
+    if (entriesSnap.empty) {
+        return { eventId, userId, reason: "entry_not_found" };
+    }
+    const entryDoc = entriesSnap.docs[0];
+    const entry = entryDoc.data();
+    if (entry.spinUsed) {
+        return {
+            eventId,
+            userId,
+            spinPrizeId: entry.spinPrizeId,
+            alreadyUsed: true,
+        };
+    }
+    const roll = crypto.randomInt(0, totalWeight);
+    let cumulative = 0;
+    let pick;
+    for (const p of prizes) {
+        cumulative += p.weight ?? 0;
+        if (roll < cumulative) {
+            pick = p;
+            break;
+        }
+    }
+    if (!pick)
+        pick = prizes[prizes.length - 1];
+    let spinPrizeCouponCode;
+    if (pick.couponId) {
+        const coupSnap = await ctx.db
+            .collection(COUPONS_COLLECTION)
+            .doc(pick.couponId)
+            .get();
+        if (coupSnap.exists) {
+            spinPrizeCouponCode = coupSnap.data().code;
+        }
+    }
+    await entryDoc.ref.update({
+        spinUsed: true,
+        spinPrizeId: pick.id,
+        spinWonAt: ctx.now,
+        spinPrizeCouponCode: spinPrizeCouponCode ?? null,
+        updatedAt: ctx.now,
+    });
+    ctx.logger.info("Spin prize assigned", {
+        eventId,
+        userId,
+        spinPrizeId: pick.id,
+    });
+    return {
+        eventId,
+        userId,
+        spinPrizeId: pick.id,
+        spinPrizeTitle: pick.title,
+        spinPrizeCouponCode,
+    };
+}

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

@@ -0,0 +1,2 @@
+import type { JobContext } from "../runtime/types";
+export declare function runAuctionSettlement(ctx: JobContext): Promise<void>;

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

@@ -0,0 +1,70 @@
+import { bidRepository, notificationRepository, orderRepository, productRepository, } from "../../../../repositories";
+import { ProductStatusValues } from "../../../../features/products/schemas/firestore";
+import { AUCTION_MESSAGES } from "../handlers/messages";
+async function settleAuction(ctx, product) {
+    const activeBids = await bidRepository.getActiveByProduct(product.id);
+    const batch = ctx.db.batch();
+    if (activeBids.length === 0) {
+        productRepository.updateStatusInBatch(batch, product.id, ProductStatusValues.OUT_OF_STOCK);
+        await batch.commit();
+        ctx.logger.info(AUCTION_MESSAGES.NO_BIDS_LOG(product.id));
+        return;
+    }
+    const [winnerEntry, ...loserEntries] = activeBids;
+    bidRepository.markWon(batch, winnerEntry.ref);
+    loserEntries.forEach(({ ref }) => bidRepository.markLost(batch, ref));
+    const orderRef = orderRepository.createFromAuction(batch, {
+        productId: product.id,
+        productTitle: product.title,
+        userId: winnerEntry.data.userId,
+        userName: winnerEntry.data.userName,
+        userEmail: winnerEntry.data.userEmail,
+        storeId: product.storeId,
+        amount: winnerEntry.data.bidAmount,
+        currency: winnerEntry.data.currency,
+        auctionProductId: product.id,
+    });
+    productRepository.updateStatusInBatch(batch, product.id, ProductStatusValues.SOLD);
+    notificationRepository.createInBatch(batch, {
+        userId: winnerEntry.data.userId,
+        type: "bid_won",
+        priority: "high",
+        title: AUCTION_MESSAGES.WON_TITLE,
+        message: AUCTION_MESSAGES.WON_MESSAGE(product.title, winnerEntry.data.currency, winnerEntry.data.bidAmount),
+        relatedId: product.id,
+        relatedType: "product",
+    });
+    loserEntries.slice(0, 50).forEach(({ data: bid }) => {
+        notificationRepository.createInBatch(batch, {
+            userId: bid.userId,
+            type: "bid_lost",
+            priority: "normal",
+            title: AUCTION_MESSAGES.LOST_TITLE,
+            message: AUCTION_MESSAGES.LOST_MESSAGE(product.title),
+            relatedId: product.id,
+            relatedType: "product",
+        });
+    });
+    await batch.commit();
+    ctx.logger.info(`Settled auction ${product.id}`, {
+        winner: winnerEntry.data.userId,
+        winningBid: winnerEntry.data.bidAmount,
+        losersCount: loserEntries.length,
+        orderId: orderRef.id,
+    });
+}
+export async function runAuctionSettlement(ctx) {
+    ctx.logger.info("Starting auction settlement sweep");
+    const expired = await productRepository.getExpiredAuctions(ctx.now);
+    if (expired.length === 0) {
+        ctx.logger.info("No expired auctions found");
+        return;
+    }
+    ctx.logger.info(`Found ${expired.length} expired auction(s) to settle`);
+    const results = await Promise.allSettled(expired.map(({ data }) => settleAuction(ctx, data)));
+    const failed = results.filter((r) => r.status === "rejected");
+    if (failed.length > 0) {
+        ctx.logger.error(`${failed.length} auction(s) failed to settle`, failed);
+    }
+    ctx.logger.info(`Settlement complete — ${expired.length - failed.length} succeeded, ${failed.length} failed`);
+}

package/dist/_internal/server/jobs/core/autoPayoutEligibility.d.ts

@@ -0,0 +1,2 @@
+import type { JobContext } from "../runtime/types";
+export declare function runAutoPayoutEligibility(ctx: JobContext): Promise<void>;