@mohasinac/appkit 2.6.3 → 2.6.5

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

@@ -0,0 +1,85 @@
+/**
+ * Core: weekly Saturday sweep — converts delivered Shiprocket orders
+ * with `payoutStatus=eligible` into pending payout documents grouped by seller.
+ */
+import { storeRepository, userRepository, orderRepository, payoutRepository, } from "../../../../repositories";
+import { BATCH_LIMIT } from "../handlers/messages";
+import { getDefaultCurrency } from "../../../../core";
+const PLATFORM_COMMISSION_RATE = 0.05;
+export async function runWeeklyPayoutEligibility(ctx) {
+    ctx.logger.info("Starting weekly payout eligibility sweep");
+    const eligible = await orderRepository.getEligibleShiprocket();
+    if (eligible.length === 0) {
+        ctx.logger.info("No eligible Shiprocket-delivered orders found");
+        return;
+    }
+    ctx.logger.info(`Found ${eligible.length} eligible order(s) — grouping by seller`);
+    const byStore = new Map();
+    for (const entry of eligible) {
+        const storeId = entry.data.storeId;
+        if (!storeId) {
+            ctx.logger.warn(`Order ${entry.id} has no storeId — skipping`);
+            continue;
+        }
+        if (!byStore.has(storeId))
+            byStore.set(storeId, []);
+        byStore.get(storeId).push(entry);
+    }
+    let payoutsCreated = 0;
+    let ordersProcessed = 0;
+    const defaultCurrency = getDefaultCurrency();
+    for (const [storeId, orders] of byStore.entries()) {
+        const store = await storeRepository.findBySlug(storeId);
+        const seller = store ? await userRepository.findById(store.ownerId) : null;
+        if (!store || !seller) {
+            ctx.logger.warn(`Store/seller ${storeId} not found — skipping ${orders.length} order(s)`);
+            continue;
+        }
+        const grossAmount = orders.reduce((sum, o) => sum + (o.data.totalPrice ?? 0), 0);
+        const platformFee = Math.round(grossAmount * PLATFORM_COMMISSION_RATE * 100) / 100;
+        const netAmount = Math.round((grossAmount - platformFee) * 100) / 100;
+        const payoutInput = {
+            storeId,
+            sellerName: (seller.displayName ?? seller.email ?? store.ownerId),
+            sellerEmail: (seller.email ?? ""),
+            orderIds: orders.map((o) => o.id),
+            amount: netAmount,
+            grossAmount,
+            platformFee,
+            platformFeeRate: PLATFORM_COMMISSION_RATE,
+            currency: defaultCurrency,
+            status: "pending",
+            paymentMethod: seller.payoutDetails?.method === "upi" ? "upi" : "bank_transfer",
+            upiId: seller.payoutDetails?.method === "upi" ? seller.payoutDetails.upiId : undefined,
+            bankAccount: seller.payoutDetails?.method === "bank_transfer" && seller.payoutDetails.bankAccount
+                ? {
+                    accountHolderName: seller.payoutDetails.bankAccount.accountHolderName,
+                    accountNumberMasked: seller.payoutDetails.bankAccount.accountNumberMasked,
+                    ifscCode: seller.payoutDetails.bankAccount.ifscCode,
+                    bankName: seller.payoutDetails.bankAccount.bankName,
+                }
+                : undefined,
+            notes: `Automated weekly payout — ${orders.length} Shiprocket delivered order(s)`,
+            requestedAt: new Date(),
+        };
+        const { id: payoutId } = await payoutRepository.create(payoutInput);
+        for (let i = 0; i < orders.length; i += BATCH_LIMIT) {
+            const slice = orders.slice(i, i + BATCH_LIMIT);
+            const batch = ctx.db.batch();
+            for (const entry of slice) {
+                orderRepository.markPayoutRequested(batch, entry.ref, payoutId);
+            }
+            await batch.commit();
+        }
+        payoutsCreated++;
+        ordersProcessed += orders.length;
+        ctx.logger.info(`Payout created for store ${storeId}`, {
+            payoutId,
+            orderCount: orders.length,
+            netAmount,
+            grossAmount,
+            platformFee,
+        });
+    }
+    ctx.logger.info("Weekly payout eligibility sweep complete", { payoutsCreated, ordersProcessed });
+}

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

@@ -1,28 +1,4 @@
-/**
- * HTTPS callable handler: aggregate admin analytics. Returns 12-month order
- * totals + monthly breakdown + top-5 products by revenue.
- */
 import type { CallableHandler } 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;
-    }>;
-}
+import { type AdminAnalyticsResult } from "../core/adminAnalytics";
+export type { AdminAnalyticsResult };
 export declare const adminAnalyticsHandler: CallableHandler<void, AdminAnalyticsResult>;

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

@@ -1,98 +1,2 @@
-/**
- * HTTPS callable handler: 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 const adminAnalyticsHandler = async (_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,
-    };
-};
+import { runAdminAnalytics } from "../core/adminAnalytics";
+export const adminAnalyticsHandler = runAdminAnalytics;

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

@@ -1,24 +1,3 @@
-/**
- * assignSpinPrize — HTTP callable (SB9-E).
- *
- * Weighted random selection from an event's `spinPrizes` config using
- * `crypto.randomInt`. Enforces one spin per user (checks `spinUsed=true` on
- * the user's event entry). Sets `spinPrizeId` + `spinWonAt` on the entry doc.
- * Issues a coupon code if the prize has `spinPrizeCouponId` set.
- */
 import type { CallableHandler } from "../runtime/types";
-interface AssignSpinPrizeInput {
-    eventId: string;
-    userId: string;
-}
-interface AssignSpinPrizeResult {
-    eventId: string;
-    userId: string;
-    spinPrizeId?: string;
-    spinPrizeTitle?: string;
-    spinPrizeCouponCode?: string;
-    alreadyUsed?: boolean;
-    reason?: string;
-}
+import { type AssignSpinPrizeInput, type AssignSpinPrizeResult } from "../core/assignSpinPrize";
 export declare const assignSpinPrizeHandler: CallableHandler<AssignSpinPrizeInput, AssignSpinPrizeResult>;
-export {};

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

@@ -1,86 +1,2 @@
-/**
- * assignSpinPrize — HTTP callable (SB9-E).
- *
- * Weighted random selection from an event's `spinPrizes` config using
- * `crypto.randomInt`. Enforces one spin per user (checks `spinUsed=true` on
- * the user's event entry). Sets `spinPrizeId` + `spinWonAt` on the entry doc.
- * Issues a coupon code if the prize has `spinPrizeCouponId` set.
- */
-import crypto from "node:crypto";
-const EVENTS_COLLECTION = "events";
-const EVENT_ENTRIES_COLLECTION = "eventEntries";
-const COUPONS_COLLECTION = "coupons";
-export const assignSpinPrizeHandler = async (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,
-        };
-    }
-    // Weighted pick: roll a uniform integer in [0, totalWeight) and walk.
-    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,
-    };
-};
+import { runAssignSpinPrize, } from "../core/assignSpinPrize";
+export const assignSpinPrizeHandler = runAssignSpinPrize;

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

@@ -1,70 +1,2 @@
-import { bidRepository, notificationRepository, orderRepository, productRepository, } from "../../../../repositories";
-import { ProductStatusValues } from "../../../../features/products/schemas/firestore";
-import { AUCTION_MESSAGES } from "./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 const auctionSettlementHandler = async (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`);
-};
+import { runAuctionSettlement } from "../core/auctionSettlement";
+export const auctionSettlementHandler = runAuctionSettlement;

package/dist/_internal/server/jobs/handlers/autoPayoutEligibility.js

@@ -1,110 +1,2 @@
-import { orderRepository, payoutRepository, storeRepository, userRepository, } from "../../../../repositories";
-import { getDefaultCurrency } from "../../../../core/index";
-import { BATCH_LIMIT } from "./messages";
-const AUTO_PAYOUT_WINDOW_DAYS = 7;
-const PLATFORM_COMMISSION_RATE = 0.05;
-const GATEWAY_FEE_RATE = 0.0236;
-const GST_RATE = 0.18;
-/** Returns the start of the business day N days ago (10 AM IST = 04:30 UTC). */
-function getBusinessDayCutoff(daysAgo) {
-    const now = new Date();
-    const cutoff = new Date(now);
-    cutoff.setUTCDate(cutoff.getUTCDate() - daysAgo);
-    cutoff.setUTCHours(4, 30, 0, 0);
-    return cutoff;
-}
-export const autoPayoutEligibilityHandler = async (ctx) => {
-    ctx.logger.info("Starting daily auto-payout eligibility sweep", {
-        windowDays: AUTO_PAYOUT_WINDOW_DAYS,
-    });
-    const cutoff = getBusinessDayCutoff(AUTO_PAYOUT_WINDOW_DAYS);
-    const eligible = await orderRepository.getEligibleAutomatic(cutoff);
-    if (eligible.length === 0) {
-        ctx.logger.info("No auto-payout eligible orders found");
-        return;
-    }
-    ctx.logger.info(`Found ${eligible.length} eligible order(s) — grouping by seller`);
-    const byStore = new Map();
-    for (const entry of eligible) {
-        const storeId = entry.data.storeId;
-        if (!storeId) {
-            ctx.logger.warn(`Order ${entry.id} has no storeId — skipping`);
-            continue;
-        }
-        if (!byStore.has(storeId))
-            byStore.set(storeId, []);
-        byStore.get(storeId).push(entry);
-    }
-    let payoutsCreated = 0;
-    let ordersProcessed = 0;
-    for (const [storeId, orders] of byStore.entries()) {
-        const store = await storeRepository.findBySlug(storeId);
-        const seller = store ? await userRepository.findById(store.ownerId) : null;
-        if (!seller) {
-            ctx.logger.warn(`Store/seller ${storeId} not found — skipping ${orders.length} order(s)`, { orderIds: orders.map((o) => o.id) });
-            continue;
-        }
-        const sellerId = store.ownerId;
-        const grossAmount = orders.reduce((sum, o) => sum + (o.data.totalPrice ?? 0), 0);
-        const platformFee = Math.round(grossAmount * PLATFORM_COMMISSION_RATE * 100) / 100;
-        const gatewayFee = Math.round(grossAmount * GATEWAY_FEE_RATE * 100) / 100;
-        const gstAmount = Math.round(platformFee * GST_RATE * 100) / 100;
-        const netAmount = Math.round((grossAmount - platformFee - gatewayFee - gstAmount) * 100) / 100;
-        const payoutInput = {
-            storeId,
-            sellerName: (seller.displayName ?? seller.email ?? sellerId),
-            sellerEmail: (seller.email ?? ""),
-            orderIds: orders.map((o) => o.id),
-            amount: netAmount,
-            grossAmount,
-            platformFee,
-            platformFeeRate: PLATFORM_COMMISSION_RATE,
-            gatewayFee,
-            gatewayFeeRate: GATEWAY_FEE_RATE,
-            gstAmount,
-            gstRate: GST_RATE,
-            isAutomatic: true,
-            currency: getDefaultCurrency(),
-            status: "pending",
-            paymentMethod: seller.payoutDetails?.method === "upi"
-                ? "upi"
-                : "bank_transfer",
-            upiId: seller.payoutDetails?.method === "upi" ? seller.payoutDetails.upiId : undefined,
-            bankAccount: seller.payoutDetails?.method === "bank_transfer" &&
-                seller.payoutDetails.bankAccount
-                ? {
-                    accountHolderName: seller.payoutDetails.bankAccount.accountHolderName,
-                    accountNumberMasked: seller.payoutDetails.bankAccount.accountNumberMasked,
-                    ifscCode: seller.payoutDetails.bankAccount.ifscCode,
-                    bankName: seller.payoutDetails.bankAccount.bankName,
-                }
-                : undefined,
-            notes: `Auto-payout — ${orders.length} delivered order(s) past ${AUTO_PAYOUT_WINDOW_DAYS}-day window`,
-            requestedAt: new Date(),
-        };
-        const { id: payoutId } = await payoutRepository.create(payoutInput);
-        for (let i = 0; i < orders.length; i += BATCH_LIMIT) {
-            const slice = orders.slice(i, i + BATCH_LIMIT);
-            const batch = ctx.db.batch();
-            for (const entry of slice) {
-                orderRepository.markPayoutRequested(batch, entry.ref, payoutId);
-            }
-            await batch.commit();
-        }
-        ctx.logger.info(`Auto-payout created for store ${storeId}`, {
-            payoutId,
-            orderCount: orders.length,
-            grossAmount,
-            platformFee,
-            gatewayFee,
-            gstAmount,
-            netAmount,
-        });
-        payoutsCreated++;
-        ordersProcessed += orders.length;
-    }
-    ctx.logger.info("Daily auto-payout eligibility sweep complete", {
-        payoutsCreated,
-        ordersProcessed,
-    });
-};
+import { runAutoPayoutEligibility } from "../core/autoPayoutEligibility";
+export const autoPayoutEligibilityHandler = runAutoPayoutEligibility;

package/dist/_internal/server/jobs/handlers/bundleStockSync.d.ts

@@ -1,18 +1,2 @@
-/**
- * scheduledBundleStockSync — daily 10am IST safety net.
- *
- * SB-UNI-V: bundles live on the `categories` collection with
- * categoryType:"bundle". Each bundle row owns `bundleProductIds[]` +
- * `bundleStockStatus`. This sweep recomputes `bundleStockStatus` for
- * every active bundle by inspecting its members' product status.
- *
- * Status transitions:
- *   all members published + available   → "in_stock"
- *   ≥1 member unavailable, ≥minActive   → "partial"
- *   ≥1 member unavailable, <minActive   → "out_of_stock"
- *
- * The realtime onProductStockChange Firestore-trigger handles individual
- * writes; this is the cheap nightly safety net for any missed events.
- */
 import type { ScheduleHandler } from "../runtime/types";
 export declare const bundleStockSyncHandler: ScheduleHandler;

package/dist/_internal/server/jobs/handlers/bundleStockSync.js

@@ -1,80 +1,2 @@
-/**
- * scheduledBundleStockSync — daily 10am IST safety net.
- *
- * SB-UNI-V: bundles live on the `categories` collection with
- * categoryType:"bundle". Each bundle row owns `bundleProductIds[]` +
- * `bundleStockStatus`. This sweep recomputes `bundleStockStatus` for
- * every active bundle by inspecting its members' product status.
- *
- * Status transitions:
- *   all members published + available   → "in_stock"
- *   ≥1 member unavailable, ≥minActive   → "partial"
- *   ≥1 member unavailable, <minActive   → "out_of_stock"
- *
- * The realtime onProductStockChange Firestore-trigger handles individual
- * writes; this is the cheap nightly safety net for any missed events.
- */
-const CATEGORIES_COLLECTION = "categories";
-const PRODUCT_COLLECTION = "products";
-const UNAVAILABLE = new Set(["sold", "out_of_stock", "discontinued"]);
-const MIN_ACTIVE_DEFAULT = 1;
-async function computeBundleStockStatus(productIds, minActive, ctx) {
-    if (productIds.length === 0)
-        return "out_of_stock";
-    let unavailable = 0;
-    for (let i = 0; i < productIds.length; i += 30) {
-        const chunk = productIds.slice(i, i + 30);
-        const snap = await ctx.db
-            .collection(PRODUCT_COLLECTION)
-            .where("__name__", "in", chunk)
-            .get();
-        for (const doc of snap.docs) {
-            const status = doc.data().status;
-            if (!status || UNAVAILABLE.has(status))
-                unavailable++;
-        }
-        // Account for missing docs (deleted products).
-        if (snap.size < chunk.length)
-            unavailable += chunk.length - snap.size;
-    }
-    const active = productIds.length - unavailable;
-    if (unavailable === 0)
-        return "in_stock";
-    if (active < minActive)
-        return "out_of_stock";
-    return "partial";
-}
-export const bundleStockSyncHandler = async (ctx) => {
-    ctx.logger.info("Bundle stock sync starting (SB-UNI-V categories)");
-    const snap = await ctx.db
-        .collection(CATEGORIES_COLLECTION)
-        .where("categoryType", "==", "bundle")
-        .where("isActive", "==", true)
-        .limit(500)
-        .get();
-    if (snap.empty) {
-        ctx.logger.info("No active bundle categories to scan");
-        return;
-    }
-    let updated = 0;
-    for (const bundleDoc of snap.docs) {
-        const data = bundleDoc.data();
-        const productIds = data.bundleProductIds ?? [];
-        if (productIds.length === 0)
-            continue;
-        const minActive = data.minActiveMembers ?? MIN_ACTIVE_DEFAULT;
-        const nextStatus = await computeBundleStockStatus(productIds, minActive, ctx);
-        if (nextStatus !== data.bundleStockStatus) {
-            await bundleDoc.ref.update({
-                bundleStockStatus: nextStatus,
-                bundleQueryResolvedAt: ctx.now,
-                updatedAt: ctx.now,
-            });
-            updated++;
-        }
-    }
-    ctx.logger.info("Bundle stock sync complete", {
-        scanned: snap.size,
-        updated,
-    });
-};
+import { runBundleStockSync } from "../core/bundleStockSync";
+export const bundleStockSyncHandler = runBundleStockSync;

package/dist/_internal/server/jobs/handlers/cartPrune.js

@@ -1,13 +1,2 @@
-import { cartRepository } from "../../../../repositories";
-import { CART_TTL_DAYS } from "./messages";
-import { batchDelete } from "./_helpers";
-export const cartPruneHandler = async (ctx) => {
-    ctx.logger.info(`Pruning carts idle for > ${CART_TTL_DAYS} days`);
-    const refs = await cartRepository.getStaleRefs(CART_TTL_DAYS);
-    if (refs.length === 0) {
-        ctx.logger.info("No stale carts found");
-        return;
-    }
-    const deleted = await batchDelete(ctx, refs);
-    ctx.logger.info("Cart prune complete", { deleted });
-};
+import { runCartPrune } from "../core/cartPrune";
+export const cartPruneHandler = runCartPrune;