@mohasinac/appkit 2.6.3 → 2.6.5

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

@@ -0,0 +1,109 @@
+import { orderRepository, payoutRepository, storeRepository, userRepository, } from "../../../../repositories";
+import { getDefaultCurrency } from "../../../../core/index";
+import { BATCH_LIMIT } from "../handlers/messages";
+const AUTO_PAYOUT_WINDOW_DAYS = 7;
+const PLATFORM_COMMISSION_RATE = 0.05;
+const GATEWAY_FEE_RATE = 0.0236;
+const GST_RATE = 0.18;
+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 async function runAutoPayoutEligibility(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,
+    });
+}

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

@@ -0,0 +1,10 @@
+/**
+ * Core: bundle stock sync (daily 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.
+ */
+import type { JobContext } from "../runtime/types";
+export declare function runBundleStockSync(ctx: JobContext): Promise<void>;

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

@@ -0,0 +1,71 @@
+/**
+ * Core: bundle stock sync (daily 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.
+ */
+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++;
+        }
+        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 async function runBundleStockSync(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,
+    });
+}

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

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

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

@@ -0,0 +1,13 @@
+import { cartRepository } from "../../../../repositories";
+import { CART_TTL_DAYS } from "../handlers/messages";
+import { batchDelete } from "../handlers/_helpers";
+export async function runCartPrune(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 });
+}

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

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

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

@@ -0,0 +1,45 @@
+import { getAdminAuth, getAdminRealtimeDb } from "../../../../providers/db-firebase";
+const AUTH_STALE_MS = 3 * 60 * 1000;
+const PAYMENT_STALE_MS = 15 * 60 * 1000;
+export async function runCleanupRtdbEvents(ctx) {
+    ctx.logger.info("Starting RTDB events cleanup");
+    const rtdb = getAdminRealtimeDb();
+    const auth = getAdminAuth();
+    const now = Date.now();
+    try {
+        const authSnap = await rtdb.ref("auth_events").get();
+        if (authSnap.exists()) {
+            const allEvents = authSnap.val();
+            const staleAuthIds = Object.entries(allEvents)
+                .filter(([, node]) => (node.createdAt ?? 0) < now - AUTH_STALE_MS)
+                .map(([id]) => id);
+            if (staleAuthIds.length > 0) {
+                await Promise.all(staleAuthIds.flatMap((id) => [
+                    rtdb.ref(`auth_events/${id}`).remove(),
+                    auth.deleteUser(`auth_event_${id}`).catch(() => { }),
+                ]));
+                ctx.logger.info("Auth events removed", { count: staleAuthIds.length });
+            }
+        }
+    }
+    catch (authErr) {
+        ctx.logger.error("Auth events cleanup failed (non-fatal)", authErr);
+    }
+    try {
+        const paySnap = await rtdb.ref("payment_events").get();
+        if (paySnap.exists()) {
+            const allPayments = paySnap.val();
+            const stalePayIds = Object.entries(allPayments)
+                .filter(([, node]) => (node.createdAt ?? 0) < now - PAYMENT_STALE_MS)
+                .map(([id]) => id);
+            if (stalePayIds.length > 0) {
+                await Promise.all(stalePayIds.map((id) => rtdb.ref(`payment_events/${id}`).remove()));
+                ctx.logger.info("Payment events removed", { count: stalePayIds.length });
+            }
+        }
+    }
+    catch (payErr) {
+        ctx.logger.error("Payment events cleanup failed (non-fatal)", payErr);
+    }
+    ctx.logger.info("RTDB events cleanup complete");
+}

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

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

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

@@ -0,0 +1,107 @@
+import { categoriesRepository, reviewRepository, storeRepository, } from "../../../../repositories";
+import { ProductStatusValues, PRODUCT_COLLECTION } from "../../../../features/products/schemas/firestore";
+import { QUERY_LIMIT } from "../handlers/messages";
+const STORES_COLLECTION = "stores";
+const ORDERS_COLLECTION = "orders";
+async function reconcileCategories(ctx) {
+    const snap = await ctx.db
+        .collection(PRODUCT_COLLECTION)
+        .where("status", "==", ProductStatusValues.PUBLISHED)
+        .limit(QUERY_LIMIT)
+        .get();
+    ctx.logger.info(`[categories] ${snap.size} published products found`);
+    const leafCounts = {};
+    for (const doc of snap.docs) {
+        const data = doc.data();
+        const catId = data.category;
+        if (!catId)
+            continue;
+        if (!leafCounts[catId])
+            leafCounts[catId] = { productIds: [], auctionIds: [] };
+        if (data.listingType === "auction")
+            leafCounts[catId].auctionIds.push(doc.id);
+        else
+            leafCounts[catId].productIds.push(doc.id);
+    }
+    const ancestorAggregates = {};
+    let leafUpdated = 0;
+    for (const [catId, { productIds, auctionIds }] of Object.entries(leafCounts)) {
+        await categoriesRepository.setMetrics(catId, productIds.length, auctionIds.length, productIds, auctionIds);
+        leafUpdated++;
+        const parentIds = (await categoriesRepository.findById(catId))?.parentIds ?? [];
+        for (const ancestorId of parentIds) {
+            if (!ancestorAggregates[ancestorId]) {
+                ancestorAggregates[ancestorId] = { productDelta: 0, auctionDelta: 0 };
+            }
+            ancestorAggregates[ancestorId].productDelta += productIds.length;
+            ancestorAggregates[ancestorId].auctionDelta += auctionIds.length;
+        }
+    }
+    const ancestorEntries = Object.entries(ancestorAggregates);
+    for (const [ancestorId, { productDelta, auctionDelta }] of ancestorEntries) {
+        await categoriesRepository.setMetrics(ancestorId, productDelta, auctionDelta, [], []);
+    }
+    ctx.logger.info("[categories] reconciliation complete", {
+        leafCategoriesUpdated: leafUpdated,
+        ancestorCategoriesUpdated: ancestorEntries.length,
+    });
+}
+async function reconcileStores(ctx) {
+    const storeIds = await storeRepository.listIds();
+    ctx.logger.info(`[stores] ${storeIds.length} stores found`);
+    let processed = 0;
+    let errors = 0;
+    for (const storeId of storeIds) {
+        try {
+            const storeSnap = await ctx.db.collection(STORES_COLLECTION).doc(storeId).get();
+            if (!storeSnap.exists)
+                continue;
+            const sellerId = storeSnap.data().ownerId;
+            if (!sellerId)
+                continue;
+            const [productsSnap, ordersSnap, reviewStats] = await Promise.all([
+                ctx.db
+                    .collection(PRODUCT_COLLECTION)
+                    .where("sellerId", "==", sellerId)
+                    .where("status", "==", ProductStatusValues.PUBLISHED)
+                    .limit(QUERY_LIMIT)
+                    .get(),
+                ctx.db
+                    .collection(ORDERS_COLLECTION)
+                    .where("sellerId", "==", sellerId)
+                    .where("status", "==", "delivered")
+                    .limit(QUERY_LIMIT)
+                    .get(),
+                reviewRepository.getApprovedRatingAggregateByStore(storeId),
+            ]);
+            await storeRepository.setStats(storeId, productsSnap.size, ordersSnap.size, reviewStats.count, reviewStats.count > 0 ? reviewStats.avgRating : null);
+            processed++;
+        }
+        catch (storeErr) {
+            errors++;
+            ctx.logger.error(`[stores] failed for store ${storeId}`, storeErr);
+        }
+    }
+    ctx.logger.info("[stores] reconciliation complete", {
+        processed,
+        errors,
+        total: storeIds.length,
+    });
+}
+export async function runCountersReconcile(ctx) {
+    ctx.logger.info("Starting counters reconciliation (categories + stores)");
+    try {
+        await reconcileCategories(ctx);
+    }
+    catch (err) {
+        ctx.logger.error("Category reconciliation failed", err);
+    }
+    try {
+        await reconcileStores(ctx);
+    }
+    catch (err) {
+        ctx.logger.error("Store reconciliation failed", err);
+        throw err;
+    }
+    ctx.logger.info("Counters reconciliation complete");
+}

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

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

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

@@ -0,0 +1,13 @@
+import { couponsRepository } from "../../../../repositories";
+export async function runCouponExpiry(ctx) {
+    ctx.logger.info("Starting coupon expiry sweep");
+    const refs = await couponsRepository.getExpiredActiveRefs(ctx.now);
+    if (refs.length === 0) {
+        ctx.logger.info("No expired active coupons found");
+        return;
+    }
+    const batch = ctx.db.batch();
+    refs.forEach((ref) => couponsRepository.deactivateInBatch(batch, ref));
+    await batch.commit();
+    ctx.logger.info("Coupon expiry complete", { deactivated: refs.length });
+}

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

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

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

@@ -0,0 +1,20 @@
+import { sessionRepository, tokenRepository } from "../../../../repositories";
+import { batchDelete } from "../handlers/_helpers";
+export async function runDailyDataCleanup(ctx) {
+    ctx.logger.info("Starting daily data cleanup (sessions + tokens)");
+    const sessionRefs = await sessionRepository.getExpiredRefs(ctx.now);
+    const sessionsDeleted = await batchDelete(ctx, sessionRefs);
+    ctx.logger.info("Session cleanup complete", { deleted: sessionsDeleted });
+    const emailRefs = await tokenRepository.getExpiredEmailVerificationRefs(ctx.now);
+    const emailDeleted = await batchDelete(ctx, emailRefs);
+    const pwRefs = await tokenRepository.getExpiredPasswordResetRefs(ctx.now);
+    const pwDeleted = await batchDelete(ctx, pwRefs);
+    ctx.logger.info("Token cleanup complete", {
+        emailVerificationDeleted: emailDeleted,
+        passwordResetDeleted: pwDeleted,
+    });
+    ctx.logger.info("Daily data cleanup complete", {
+        sessionsDeleted,
+        tokensDeleted: emailDeleted + pwDeleted,
+    });
+}

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

@@ -0,0 +1,44 @@
+/**
+ * Pure job-core functions — no Firebase Functions trigger types, no event
+ * envelope. Call any of these from an API route, server action, script,
+ * Vitest test, or another runtime by passing a `JobContext`.
+ *
+ * The matching `handlers/<name>.ts` wrappers add Firebase Functions trigger
+ * typing (ScheduleHandler / FirestoreTriggerHandler / CallableHandler) and
+ * unwrap the Firestore event envelope — that's the only Firebase-specific
+ * layer. Wire those into `functions/src/index.ts` via `bindToFirebase.*`.
+ */
+export { runCouponExpiry } from "./couponExpiry";
+export { runOfferExpiry } from "./offerExpiry";
+export { runCartPrune } from "./cartPrune";
+export { runNotificationPrune } from "./notificationPrune";
+export { runDailyDataCleanup } from "./dailyDataCleanup";
+export { runCleanupRtdbEvents } from "./cleanupRtdbEvents";
+export { runMediaTmpCleanup } from "./mediaTmpCleanup";
+export { runPendingOrderTimeout } from "./pendingOrderTimeout";
+export { runCountersReconcile } from "./countersReconcile";
+export { runBundleStockSync } from "./bundleStockSync";
+export { runPayoutBatch } from "./payoutBatch";
+export { runAutoPayoutEligibility } from "./autoPayoutEligibility";
+export { runProductStatsSync } from "./productStatsSync";
+export { runPositionsReconcile } from "./positionsReconcile";
+export { runWeeklyPayoutEligibility } from "./weeklyPayoutEligibility";
+export { runAuctionSettlement } from "./auctionSettlement";
+export { runPrizeRevealOpen } from "./prizeRevealOpen";
+export { runPrizeRevealClose } from "./prizeRevealClose";
+export { runPrizeRevealExpiry } from "./prizeRevealExpiry";
+export { runPrizeRevealReminder } from "./prizeRevealReminder";
+export { runPromotions, type PromotionsCallableResult } from "./promotions";
+export { runListingProcessor, supportedListingCollections, type ListingRequestBody, type ListingResponseBody, } from "./listingProcessor";
+export { runStoreAnalytics, type StoreAnalyticsInput, type StoreAnalyticsResult, } from "./storeAnalytics";
+export { runAdminAnalytics, type AdminAnalyticsResult } from "./adminAnalytics";
+export { runTriggerEventRaffle, type TriggerEventRaffleInput, type TriggerEventRaffleResult, } from "./triggerEventRaffle";
+export { runAssignSpinPrize, type AssignSpinPrizeInput, type AssignSpinPrizeResult, } from "./assignSpinPrize";
+export { handleBidPlaced, type HandleBidPlacedInput, type NewBid } from "./onBidPlaced";
+export { handleOrderCreate, type HandleOrderCreateInput, type NewOrder, } from "./onOrderCreate";
+export { handleOrderStatusChange, type HandleOrderStatusChangeInput, type OrderAfter, type OrderBefore, } from "./onOrderStatusChange";
+export { handleProductWrite, type HandleProductWriteInput, type ProductDoc, } from "./onProductWrite";
+export { handleProductStockChange, type HandleProductStockChangeInput, syncBundlesForProduct, syncGroupedListingsForProduct, isAvailable, } from "./onProductStockChange";
+export { handleReviewWrite, type HandleReviewWriteInput } from "./onReviewWrite";
+export { handleCategoryWrite, type HandleCategoryWriteInput, type CategoryDoc, } from "./onCategoryWrite";
+export { handleStoreWrite, type HandleStoreWriteInput, type StoreDoc, } from "./onStoreWrite";

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

@@ -0,0 +1,47 @@
+/**
+ * Pure job-core functions — no Firebase Functions trigger types, no event
+ * envelope. Call any of these from an API route, server action, script,
+ * Vitest test, or another runtime by passing a `JobContext`.
+ *
+ * The matching `handlers/<name>.ts` wrappers add Firebase Functions trigger
+ * typing (ScheduleHandler / FirestoreTriggerHandler / CallableHandler) and
+ * unwrap the Firestore event envelope — that's the only Firebase-specific
+ * layer. Wire those into `functions/src/index.ts` via `bindToFirebase.*`.
+ */
+// Schedule jobs
+export { runCouponExpiry } from "./couponExpiry";
+export { runOfferExpiry } from "./offerExpiry";
+export { runCartPrune } from "./cartPrune";
+export { runNotificationPrune } from "./notificationPrune";
+export { runDailyDataCleanup } from "./dailyDataCleanup";
+export { runCleanupRtdbEvents } from "./cleanupRtdbEvents";
+export { runMediaTmpCleanup } from "./mediaTmpCleanup";
+export { runPendingOrderTimeout } from "./pendingOrderTimeout";
+export { runCountersReconcile } from "./countersReconcile";
+export { runBundleStockSync } from "./bundleStockSync";
+export { runPayoutBatch } from "./payoutBatch";
+export { runAutoPayoutEligibility } from "./autoPayoutEligibility";
+export { runProductStatsSync } from "./productStatsSync";
+export { runPositionsReconcile } from "./positionsReconcile";
+export { runWeeklyPayoutEligibility } from "./weeklyPayoutEligibility";
+export { runAuctionSettlement } from "./auctionSettlement";
+export { runPrizeRevealOpen } from "./prizeRevealOpen";
+export { runPrizeRevealClose } from "./prizeRevealClose";
+export { runPrizeRevealExpiry } from "./prizeRevealExpiry";
+export { runPrizeRevealReminder } from "./prizeRevealReminder";
+// Callables
+export { runPromotions } from "./promotions";
+export { runListingProcessor, supportedListingCollections, } from "./listingProcessor";
+export { runStoreAnalytics, } from "./storeAnalytics";
+export { runAdminAnalytics } from "./adminAnalytics";
+export { runTriggerEventRaffle, } from "./triggerEventRaffle";
+export { runAssignSpinPrize, } from "./assignSpinPrize";
+// Trigger reactors — call with the meaningful payload, no Firestore event needed
+export { handleBidPlaced } from "./onBidPlaced";
+export { handleOrderCreate, } from "./onOrderCreate";
+export { handleOrderStatusChange, } from "./onOrderStatusChange";
+export { handleProductWrite, } from "./onProductWrite";
+export { handleProductStockChange, syncBundlesForProduct, syncGroupedListingsForProduct, isAvailable, } from "./onProductStockChange";
+export { handleReviewWrite } from "./onReviewWrite";
+export { handleCategoryWrite, } from "./onCategoryWrite";
+export { handleStoreWrite, } from "./onStoreWrite";

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

@@ -0,0 +1,30 @@
+/**
+ * Core: server-to-server listing proxy. Every appkit repository routes its
+ * `.list()` through the same Sieve adapter, so adding a new collection is a
+ * one-line addition to `LISTERS`.
+ *
+ * Cursor: opaque base64 over `{ page }`. Callers may use either page-mode
+ * (`p` directly) or infinite-mode (forward `cursor` from previous response).
+ */
+import type { JobContext } from "../runtime/types";
+export interface ListingRequestBody {
+    collection: string;
+    q?: string;
+    f?: string;
+    s?: string;
+    p?: number | string;
+    ps?: number | string;
+    cursor?: string;
+    baseOpts?: Record<string, unknown>;
+}
+export interface ListingResponseBody {
+    items: unknown[];
+    total: number;
+    page: number;
+    pageSize: number;
+    totalPages: number;
+    hasMore: boolean;
+    cursor: string | null;
+}
+export declare function runListingProcessor(body: ListingRequestBody, ctx: JobContext): Promise<ListingResponseBody>;
+export declare const supportedListingCollections: string[];