@mohasinac/appkit 2.6.3 → 2.6.4

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

@@ -0,0 +1,87 @@
+/**
+ * Core: rebuild `position` + `subtreeSize` for every category via
+ * DFS pre-order from the roots. Heals drift left by the trigger's
+ * `positionDirty` flag and any failed real-time updates.
+ */
+import { BATCH_LIMIT } from "../handlers/messages";
+const CATEGORIES = "categories";
+function dfsAssign(nodeId, childMap, counter, result) {
+    const position = counter;
+    counter++;
+    const children = (childMap.get(nodeId) ?? []).sort((a, b) => a.order - b.order);
+    for (const child of children) {
+        counter = dfsAssign(child.id, childMap, counter, result);
+    }
+    const subtreeSize = counter - position;
+    result.set(nodeId, { position, subtreeSize });
+    return counter;
+}
+export async function runPositionsReconcile(ctx) {
+    const snap = await ctx.db.collection(CATEGORIES).get();
+    const nodes = snap.docs.map((doc) => {
+        const d = doc.data();
+        const parentIds = d.parentIds ?? [];
+        return {
+            id: doc.id,
+            parentId: parentIds.length > 0 ? parentIds[parentIds.length - 1] : null,
+            order: d.order ?? 0,
+            position: d.position ?? 0,
+            subtreeSize: d.subtreeSize ?? 1,
+            positionDirty: d.positionDirty ?? false,
+        };
+    });
+    if (nodes.length === 0) {
+        ctx.logger.info("No categories — nothing to reconcile");
+        return;
+    }
+    const childMap = new Map();
+    const roots = [];
+    for (const node of nodes) {
+        if (node.parentId === null) {
+            roots.push(node);
+        }
+        else {
+            const siblings = childMap.get(node.parentId) ?? [];
+            siblings.push(node);
+            childMap.set(node.parentId, siblings);
+        }
+    }
+    const computed = new Map();
+    let counter = 1;
+    for (const root of roots.sort((a, b) => a.order - b.order)) {
+        counter = dfsAssign(root.id, childMap, counter, computed);
+    }
+    const orphans = nodes.filter((n) => !computed.has(n.id));
+    for (const orphan of orphans) {
+        counter = dfsAssign(orphan.id, childMap, counter, computed);
+    }
+    const nodeMap = new Map(nodes.map((n) => [n.id, n]));
+    const toUpdate = [];
+    for (const [id, { position, subtreeSize }] of computed) {
+        const current = nodeMap.get(id);
+        if (!current || current.position !== position || current.subtreeSize !== subtreeSize || current.positionDirty) {
+            toUpdate.push({ id, position, subtreeSize });
+        }
+    }
+    if (toUpdate.length === 0) {
+        ctx.logger.info("Positions already correct", { scanned: nodes.length });
+        return;
+    }
+    for (let i = 0; i < toUpdate.length; i += BATCH_LIMIT) {
+        const batch = ctx.db.batch();
+        for (const { id, position, subtreeSize } of toUpdate.slice(i, i + BATCH_LIMIT)) {
+            batch.update(ctx.db.collection(CATEGORIES).doc(id), {
+                position,
+                subtreeSize,
+                positionDirty: false,
+                updatedAt: new Date(),
+            });
+        }
+        await batch.commit();
+    }
+    ctx.logger.info("Positions reconciled", {
+        scanned: nodes.length,
+        updated: toUpdate.length,
+        orphans: orphans.length,
+    });
+}

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

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

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

@@ -0,0 +1,22 @@
+const PRODUCT_COLLECTION = "products";
+export async function runPrizeRevealClose(ctx) {
+    ctx.logger.info("Prize reveal close sweep starting");
+    const snap = await ctx.db
+        .collection(PRODUCT_COLLECTION)
+        .where("listingType", "==", "prize-draw")
+        .where("prizeRevealStatus", "==", "open")
+        .where("prizeRevealWindowEnd", "<=", ctx.now)
+        .limit(100)
+        .get();
+    if (snap.empty) {
+        ctx.logger.info("No prize draws to close");
+        return;
+    }
+    const batch = ctx.db.batch();
+    snap.docs.forEach((doc) => batch.update(doc.ref, {
+        prizeRevealStatus: "closed",
+        updatedAt: ctx.now,
+    }));
+    await batch.commit();
+    ctx.logger.info("Closed prize draws", { count: snap.size });
+}

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

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

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

@@ -0,0 +1,50 @@
+import { notificationRepository } from "../../../../repositories";
+const ORDER_COLLECTION = "orders";
+export async function runPrizeRevealExpiry(ctx) {
+    ctx.logger.info("Prize reveal expiry sweep starting");
+    const snap = await ctx.db
+        .collection(ORDER_COLLECTION)
+        .where("paymentStatus", "==", "paid")
+        .where("status", "in", ["pending", "confirmed", "processing"])
+        .where("prizeRevealDeadline", "<", ctx.now)
+        .limit(200)
+        .get();
+    if (snap.empty) {
+        ctx.logger.info("No prize-draw orders past deadline");
+        return;
+    }
+    let refunded = 0;
+    for (const doc of snap.docs) {
+        const order = doc.data();
+        if (order.prizeWon)
+            continue;
+        if (!order.prizeDrawProductId)
+            continue;
+        await doc.ref.update({
+            status: "refunded",
+            paymentStatus: "refunded",
+            isNonRefundable: false,
+            prizeRevealExpired: true,
+            updatedAt: ctx.now,
+        });
+        if (order.userId) {
+            try {
+                await notificationRepository.create({
+                    userId: order.userId,
+                    type: "prize_reveal_expired",
+                    priority: "high",
+                    title: "Reveal deadline passed — refunded",
+                    message: `Your entry for "${order.productTitle ?? "the draw"}" expired without a reveal. We've refunded the order.`,
+                    relatedId: doc.id,
+                    relatedType: "order",
+                    actionUrl: `/user/orders/view/${doc.id}`,
+                });
+            }
+            catch (err) {
+                ctx.logger.warn("Reveal-expired notification failed", { err });
+            }
+        }
+        refunded++;
+    }
+    ctx.logger.info("Prize reveal expiry sweep complete", { refunded });
+}

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

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

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

@@ -0,0 +1,56 @@
+import { notificationRepository } from "../../../../repositories";
+const PRODUCT_COLLECTION = "products";
+const ORDER_COLLECTION = "orders";
+export async function runPrizeRevealOpen(ctx) {
+    ctx.logger.info("Prize reveal open sweep starting");
+    const snap = await ctx.db
+        .collection(PRODUCT_COLLECTION)
+        .where("listingType", "==", "prize-draw")
+        .where("prizeRevealStatus", "==", "pending")
+        .where("prizeRevealWindowStart", "<=", ctx.now)
+        .limit(100)
+        .get();
+    if (snap.empty) {
+        ctx.logger.info("No prize draws to open");
+        return;
+    }
+    for (const doc of snap.docs) {
+        const product = doc.data();
+        await doc.ref.update({
+            prizeRevealStatus: "open",
+            updatedAt: ctx.now,
+        });
+        const orders = await ctx.db
+            .collection(ORDER_COLLECTION)
+            .where("prizeDrawProductId", "==", doc.id)
+            .where("paymentStatus", "==", "paid")
+            .where("status", "in", ["pending", "confirmed", "processing"])
+            .get();
+        let notified = 0;
+        for (const orderDoc of orders.docs) {
+            const order = orderDoc.data();
+            if (!order.userId || order.prizeWon)
+                continue;
+            try {
+                await notificationRepository.create({
+                    userId: order.userId,
+                    type: "prize_reveal_ready",
+                    priority: "high",
+                    title: "Your reveal is ready!",
+                    message: `Reveal your prize for "${product.title ?? "draw"}". You have ${product.prizeRevealDeadlineDays ?? 3} days to claim it.`,
+                    relatedId: orderDoc.id,
+                    relatedType: "order",
+                    actionUrl: `/user/orders/view/${orderDoc.id}`,
+                });
+                notified++;
+            }
+            catch (err) {
+                ctx.logger.warn("Reveal-ready notification failed", { err });
+            }
+        }
+        ctx.logger.info("Opened prize draw", {
+            productId: doc.id,
+            buyersNotified: notified,
+        });
+    }
+}

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

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

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

@@ -0,0 +1,38 @@
+import { notificationRepository } from "../../../../repositories";
+const ORDER_COLLECTION = "orders";
+const ONE_DAY_MS = 86400000;
+export async function runPrizeRevealReminder(ctx) {
+    ctx.logger.info("Prize reveal reminder sweep starting");
+    const cutoff = new Date(ctx.now.getTime() + ONE_DAY_MS);
+    const snap = await ctx.db
+        .collection(ORDER_COLLECTION)
+        .where("paymentStatus", "==", "paid")
+        .where("status", "in", ["pending", "confirmed", "processing"])
+        .where("prizeRevealDeadline", "<=", cutoff)
+        .where("prizeRevealDeadline", ">", ctx.now)
+        .limit(500)
+        .get();
+    let notified = 0;
+    for (const doc of snap.docs) {
+        const order = doc.data();
+        if (!order.userId || order.prizeWon || !order.prizeDrawProductId)
+            continue;
+        try {
+            await notificationRepository.create({
+                userId: order.userId,
+                type: "prize_reveal_reminder",
+                priority: "normal",
+                title: "Reveal expires within 24h",
+                message: `Reveal your prize for "${order.productTitle ?? "the draw"}" today — unclaimed reveals are auto-refunded after the deadline.`,
+                relatedId: doc.id,
+                relatedType: "order",
+                actionUrl: `/user/orders/view/${doc.id}`,
+            });
+            notified++;
+        }
+        catch (err) {
+            ctx.logger.warn("Reveal reminder notification failed", { err });
+        }
+    }
+    ctx.logger.info("Prize reveal reminder sweep complete", { notified });
+}

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

@@ -0,0 +1,8 @@
+/**
+ * Core: recompute avgRating + reviewCount on every published product
+ * from approved reviews. Heals drift from partial writes / moderation changes.
+ *
+ * Concurrency capped at 5 to avoid Firestore read-rate spikes.
+ */
+import type { JobContext } from "../runtime/types";
+export declare function runProductStatsSync(ctx: JobContext): Promise<void>;

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

@@ -0,0 +1,36 @@
+/**
+ * Core: recompute avgRating + reviewCount on every published product
+ * from approved reviews. Heals drift from partial writes / moderation changes.
+ *
+ * Concurrency capped at 5 to avoid Firestore read-rate spikes.
+ */
+import { productRepository, reviewRepository } from "../../../../repositories";
+const CONCURRENCY = 5;
+async function syncOne(productId) {
+    const { count, avgRating } = await reviewRepository.getApprovedRatingAggregate(productId);
+    await productRepository.update(productId, { avgRating, reviewCount: count });
+}
+export async function runProductStatsSync(ctx) {
+    ctx.logger.info("Starting product stats sync");
+    const productIds = await productRepository.getPublishedIds();
+    if (productIds.length === 0) {
+        ctx.logger.info("No published products found");
+        return;
+    }
+    ctx.logger.info(`Syncing stats for ${productIds.length} product(s)`);
+    let succeeded = 0;
+    let failed = 0;
+    for (let i = 0; i < productIds.length; i += CONCURRENCY) {
+        const slice = productIds.slice(i, i + CONCURRENCY);
+        const results = await Promise.allSettled(slice.map(syncOne));
+        for (const r of results) {
+            if (r.status === "fulfilled")
+                succeeded++;
+            else {
+                failed++;
+                ctx.logger.error("Failed to sync product stats", r.reason);
+            }
+        }
+    }
+    ctx.logger.info("Product stats sync complete", { succeeded, failed });
+}

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

@@ -0,0 +1,12 @@
+import type { JobContext } from "../runtime/types";
+export interface PromotionsCallableResult {
+    promotedProducts: unknown[];
+    featuredProducts: unknown[];
+    activeCoupons: unknown[];
+}
+/**
+ * Promotions data — promoted + featured products and active coupons.
+ * Wraps the listing query that needs an OR-shaped
+ * (coupon.startDate IS NULL OR <= now) filter Firestore can't express.
+ */
+export declare function runPromotions(_input: void, ctx: JobContext): Promise<PromotionsCallableResult>;

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

@@ -0,0 +1,43 @@
+import { productRepository, couponsRepository } from "../../../../repositories";
+import { ProductStatusValues } from "../../../../features/products/schemas/firestore";
+/**
+ * Promotions data — promoted + featured products and active coupons.
+ * Wraps the listing query that needs an OR-shaped
+ * (coupon.startDate IS NULL OR <= now) filter Firestore can't express.
+ */
+export async function runPromotions(_input, ctx) {
+    ctx.logger.info("Promotions data requested");
+    const now = new Date();
+    const nowIso = now.toISOString();
+    const [promotedResult, featuredResult, activeCouponsResult] = await Promise.all([
+        productRepository.list({
+            filters: `status==${ProductStatusValues.PUBLISHED},isPromoted==true`,
+            sorts: "-createdAt",
+            page: "1",
+            pageSize: "12",
+        }, { status: ProductStatusValues.PUBLISHED }),
+        productRepository.list({
+            filters: `status==${ProductStatusValues.PUBLISHED},featured==true`,
+            sorts: "-createdAt",
+            page: "1",
+            pageSize: "8",
+        }, { status: ProductStatusValues.PUBLISHED }),
+        couponsRepository.list({
+            filters: `validity.isActive==true,validity.endDate>=${nowIso}`,
+            sorts: "validity.endDate",
+            page: "1",
+            pageSize: "50",
+        }),
+    ]);
+    const activeCoupons = activeCouponsResult.items.filter((c) => !c.validity?.startDate || new Date(c.validity.startDate) <= now);
+    ctx.logger.info("Promotions loaded", {
+        promoted: promotedResult.items.length,
+        featured: featuredResult.items.length,
+        coupons: activeCoupons.length,
+    });
+    return {
+        promotedProducts: promotedResult.items,
+        featuredProducts: featuredResult.items,
+        activeCoupons,
+    };
+}

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

@@ -0,0 +1,30 @@
+/**
+ * Core: aggregate seller (store) analytics for the past 6 months. Input:
+ * `{ sellerId }` (the Firebase Auth UID); store slug is resolved server-side
+ * via `storeRepository.findByOwnerId`.
+ */
+import type { JobContext } from "../runtime/types";
+export interface StoreAnalyticsInput {
+    sellerId: string;
+}
+export interface StoreAnalyticsResult {
+    summary: {
+        totalOrders: number;
+        totalRevenue: number;
+        totalProducts: number;
+        publishedProducts: number;
+    };
+    revenueByMonth: Array<{
+        month: string;
+        orders: number;
+        revenue: number;
+    }>;
+    topProducts: Array<{
+        productId: string;
+        title: string;
+        revenue: number;
+        orders: number;
+        mainImage: string;
+    }>;
+}
+export declare function runStoreAnalytics(input: StoreAnalyticsInput, ctx: JobContext): Promise<StoreAnalyticsResult>;

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

@@ -0,0 +1,109 @@
+/**
+ * Core: aggregate seller (store) analytics for the past 6 months. Input:
+ * `{ sellerId }` (the Firebase Auth UID); store slug is resolved server-side
+ * via `storeRepository.findByOwnerId`.
+ */
+import { orderRepository, productRepository, storeRepository, } from "../../../../repositories";
+import { formatMonthYear } from "../../../../utils/date.formatter";
+import { ProductStatusValues } from "../../../../features/products/schemas/firestore";
+class StoreAnalyticsError extends Error {
+    constructor(status, message) {
+        super(message);
+        this.name = "StoreAnalyticsError";
+        this.httpStatus = status;
+    }
+}
+function normalizeDate(raw) {
+    return raw instanceof Date ? raw : new Date(raw);
+}
+async function loadStore6MonthOrders(storeId) {
+    const now = new Date();
+    const isoStart = new Date(now.getFullYear(), now.getMonth() - 5, 1).toISOString();
+    const out = [];
+    let page = 1;
+    let hasMore = true;
+    while (hasMore && page <= 5) {
+        const result = await orderRepository.listAll({
+            filters: `storeId==${storeId},createdAt>=${isoStart}`,
+            sorts: "-createdAt",
+            page: String(page),
+            pageSize: "300",
+        });
+        out.push(...result.items);
+        hasMore = result.hasMore;
+        page += 1;
+    }
+    return out;
+}
+export async function runStoreAnalytics(input, ctx) {
+    const sellerId = input?.sellerId;
+    if (!sellerId || typeof sellerId !== "string") {
+        throw new StoreAnalyticsError(400, "sellerId is required");
+    }
+    ctx.logger.info("Store analytics requested", { sellerId });
+    const store = await storeRepository.findByOwnerId(sellerId);
+    if (!store)
+        throw new StoreAnalyticsError(404, "Store not found for this seller");
+    const storeId = store.id;
+    const [past6, totalProductsResult, publishedProductsResult] = await Promise.all([
+        loadStore6MonthOrders(storeId),
+        productRepository.list({ page: "1", pageSize: "1" }, { storeId }),
+        productRepository.list({
+            filters: `status==${ProductStatusValues.PUBLISHED}`,
+            page: "1",
+            pageSize: "1",
+        }, { storeId, status: ProductStatusValues.PUBLISHED }),
+    ]);
+    const productIds = Array.from(new Set(past6.map((o) => o.productId)));
+    const products = await Promise.all(productIds.map((id) => productRepository.findById(id)));
+    const productMap = new Map(products.filter(Boolean).map((p) => [p.id, p]));
+    const totalOrders = past6.length;
+    const totalRevenue = past6.reduce((sum, o) => sum + (o.totalPrice ?? 0), 0);
+    const now = new Date();
+    const monthMap = new Map();
+    for (let i = 5; 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 past6) {
+        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 past6) {
+        const existing = revenueByProduct.get(order.productId);
+        if (existing) {
+            existing.revenue += order.totalPrice ?? 0;
+            existing.orders += 1;
+        }
+        else {
+            const product = productMap.get(order.productId);
+            revenueByProduct.set(order.productId, {
+                productId: order.productId,
+                title: order.productTitle,
+                revenue: order.totalPrice ?? 0,
+                orders: 1,
+                mainImage: product?.mainImage ?? "",
+            });
+        }
+    }
+    const topProducts = Array.from(revenueByProduct.values())
+        .sort((a, b) => b.revenue - a.revenue)
+        .slice(0, 5);
+    return {
+        summary: {
+            totalOrders,
+            totalRevenue,
+            totalProducts: totalProductsResult.total,
+            publishedProducts: publishedProductsResult.total,
+        },
+        revenueByMonth: Array.from(monthMap.values()),
+        topProducts,
+    };
+}

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

@@ -0,0 +1,19 @@
+/**
+ * Core: select a raffle winner for an event using `crypto.randomInt()`. Pool
+ * logic keys off the event's `raffleType`.
+ */
+import type { JobContext } from "../runtime/types";
+export interface TriggerEventRaffleInput {
+    eventId: string;
+    raffleType?: "top_n_scorers" | "top_n_participants" | "open_raffle";
+    topN?: number;
+}
+export interface TriggerEventRaffleResult {
+    eventId: string;
+    raffleWinnerUserId?: string;
+    raffleWinnerDisplayName?: string;
+    raffleEntryCount: number;
+    alreadyTriggered?: boolean;
+    reason?: string;
+}
+export declare function runTriggerEventRaffle(input: TriggerEventRaffleInput, ctx: JobContext): Promise<TriggerEventRaffleResult>;

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

@@ -0,0 +1,86 @@
+/**
+ * Core: select a raffle winner for an event using `crypto.randomInt()`. Pool
+ * logic keys off the event's `raffleType`.
+ */
+import crypto from "node:crypto";
+const EVENTS_COLLECTION = "events";
+const EVENT_ENTRIES_COLLECTION = "eventEntries";
+export async function runTriggerEventRaffle(input, ctx) {
+    const eventRef = ctx.db.collection(EVENTS_COLLECTION).doc(input.eventId);
+    const eventSnap = await eventRef.get();
+    if (!eventSnap.exists) {
+        return {
+            eventId: input.eventId,
+            raffleEntryCount: 0,
+            reason: "event_not_found",
+        };
+    }
+    const event = eventSnap.data();
+    if (event.raffleWinnerUserId) {
+        return {
+            eventId: input.eventId,
+            raffleEntryCount: 0,
+            alreadyTriggered: true,
+            raffleWinnerUserId: event.raffleWinnerUserId,
+        };
+    }
+    const raffleType = input.raffleType ?? event.raffleType ?? "open_raffle";
+    const topN = input.topN ?? event.raffleTopN ?? 0;
+    const entriesSnap = await ctx.db
+        .collection(EVENT_ENTRIES_COLLECTION)
+        .where("eventId", "==", input.eventId)
+        .where("status", "==", "CONFIRMED")
+        .get();
+    let pool = entriesSnap.docs.map((d) => ({
+        id: d.id,
+        data: d.data(),
+    }));
+    if (raffleType === "top_n_scorers" && topN > 0) {
+        pool = pool
+            .sort((a, b) => (b.data.points ?? 0) - (a.data.points ?? 0))
+            .slice(0, topN);
+    }
+    else if (raffleType === "top_n_participants" && topN > 0) {
+        pool = pool
+            .sort((a, b) => {
+            const aT = a.data.createdAt instanceof Date
+                ? a.data.createdAt.getTime()
+                : (a.data.createdAt?.toDate?.()?.getTime() ?? 0);
+            const bT = b.data.createdAt instanceof Date
+                ? b.data.createdAt.getTime()
+                : (b.data.createdAt?.toDate?.()?.getTime() ?? 0);
+            return aT - bT;
+        })
+            .slice(0, topN);
+    }
+    if (pool.length === 0) {
+        return {
+            eventId: input.eventId,
+            raffleEntryCount: 0,
+            reason: "no_eligible_entries",
+        };
+    }
+    const winnerIdx = crypto.randomInt(0, pool.length);
+    const winner = pool[winnerIdx];
+    await eventRef.update({
+        raffleWinnerUserId: winner.data.userId,
+        raffleWinnerDisplayName: winner.data.userDisplayName ?? "",
+        raffleWinnerEntryId: winner.id,
+        raffleTriggeredAt: ctx.now,
+        raffleEntryCount: entriesSnap.size,
+        raffleGithubFunctionUrl: `${ctx.env("PROOF_OF_FAIRNESS_BASE_URL") ?? ""}/raffles/${input.eventId}.json`,
+        updatedAt: ctx.now,
+    });
+    ctx.logger.info("Event raffle triggered", {
+        eventId: input.eventId,
+        raffleType,
+        poolSize: pool.length,
+        winnerId: winner.id,
+    });
+    return {
+        eventId: input.eventId,
+        raffleWinnerUserId: winner.data.userId,
+        raffleWinnerDisplayName: winner.data.userDisplayName,
+        raffleEntryCount: entriesSnap.size,
+    };
+}

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

@@ -0,0 +1,6 @@
+/**
+ * Core: weekly Saturday sweep — converts delivered Shiprocket orders
+ * with `payoutStatus=eligible` into pending payout documents grouped by seller.
+ */
+import type { JobContext } from "../runtime/types";
+export declare function runWeeklyPayoutEligibility(ctx: JobContext): Promise<void>;