@mohasinac/appkit 2.4.11 → 2.5.1

package/dist/_internal/server/features/sublisting-categories/og.js

@@ -0,0 +1,56 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/** High-level OG renderer — accepts the raw sublisting-category doc from the repository. */
+export function renderSublistingCategoryOg(doc, opts) {
+    const baseName = doc?.name ?? "Sub-listing";
+    const name = doc?.itemCode ? `${baseName} (${doc.itemCode})` : baseName;
+    return renderSublistingCategoryOgImage({
+        name,
+        description: doc?.description?.slice(0, 120) ?? null,
+        productCount: doc?.productCount ?? null,
+        coverImage: doc?.coverImage ?? null,
+    }, opts.siteName);
+}
+export function renderSublistingCategoryOgImage(data, siteName) {
+    const { name, description, productCount, coverImage } = data;
+    const countLabel = productCount !== null && productCount !== undefined && productCount > 0
+        ? `${productCount} listing${productCount !== 1 ? "s" : ""} available`
+        : null;
+    return (_jsxs("div", { style: {
+            display: "flex",
+            width: "100%",
+            height: "100%",
+            background: "#0f172a",
+            fontFamily: "sans-serif",
+            position: "relative",
+            overflow: "hidden",
+        }, children: [coverImage && (_jsx("img", { src: coverImage, alt: "", style: { position: "absolute", inset: 0, width: "100%", height: "100%", objectFit: "cover", opacity: 0.12 } })), _jsx("div", { style: {
+                    position: "absolute",
+                    inset: 0,
+                    background: "linear-gradient(135deg, rgba(15,23,42,0.97) 0%, rgba(15,23,42,0.82) 100%)",
+                } }), _jsxs("div", { style: {
+                    position: "relative",
+                    display: "flex",
+                    width: "100%",
+                    height: "100%",
+                    padding: "60px",
+                    gap: "48px",
+                    alignItems: "center",
+                }, children: [coverImage && (_jsx("img", { src: coverImage, alt: name, style: { width: 300, height: 300, objectFit: "cover", borderRadius: 16, flexShrink: 0 } })), _jsxs("div", { style: { display: "flex", flexDirection: "column", gap: 20, flex: 1 }, children: [_jsxs("div", { style: { fontSize: 16, color: "#f59e0b", fontWeight: 600, letterSpacing: 2, textTransform: "uppercase" }, children: [siteName, " \u00B7 Listings"] }), _jsx("div", { style: {
+                                    fontSize: coverImage ? 48 : 60,
+                                    fontWeight: 700,
+                                    color: "#f1f5f9",
+                                    lineHeight: 1.15,
+                                    display: "-webkit-box",
+                                    WebkitLineClamp: 2,
+                                    WebkitBoxOrient: "vertical",
+                                    overflow: "hidden",
+                                }, children: name }), description && (_jsx("div", { style: {
+                                    fontSize: 24,
+                                    color: "#94a3b8",
+                                    lineHeight: 1.45,
+                                    display: "-webkit-box",
+                                    WebkitLineClamp: 2,
+                                    WebkitBoxOrient: "vertical",
+                                    overflow: "hidden",
+                                }, children: description })), countLabel && (_jsx("div", { style: { fontSize: 20, fontWeight: 600, color: "#f59e0b" }, children: countLabel }))] })] })] }));
+}

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

@@ -0,0 +1,13 @@
+import { type WishlistItem } from "../../../../repositories";
+export declare function addToWishlistAction(productId: string, extras?: {
+    productType?: WishlistItem["productType"];
+    priceAtAdd?: number;
+    productSnapshot?: WishlistItem["productSnapshot"];
+}): Promise<number>;
+export declare function removeFromWishlistAction(productId: string): Promise<void>;
+export declare function mergeGuestWishlistAction(guestItems: Array<{
+    productId: string;
+    productType?: WishlistItem["productType"];
+    priceAtAdd?: number;
+    productSnapshot?: WishlistItem["productSnapshot"];
+}>): Promise<string[]>;

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

@@ -0,0 +1,40 @@
+"use server";
+import { requireRoleUser } from "../../../../providers/auth-firebase/helpers";
+import { wishlistRepository, WishlistFullError, } from "../../../../repositories";
+import { WISHLIST_MAX } from "../../../shared/features/wishlist/config";
+import { WishlistCapError } from "../../../shared/features/wishlist/errors";
+export async function addToWishlistAction(productId, extras) {
+    const user = await requireRoleUser(["buyer", "seller", "admin"]);
+    try {
+        return await wishlistRepository.addItem(user.uid, productId, extras);
+    }
+    catch (err) {
+        if (err instanceof WishlistFullError) {
+            throw new WishlistCapError(err.current, WISHLIST_MAX);
+        }
+        throw err;
+    }
+}
+export async function removeFromWishlistAction(productId) {
+    const user = await requireRoleUser(["buyer", "seller", "admin"]);
+    await wishlistRepository.removeItem(user.uid, productId);
+}
+export async function mergeGuestWishlistAction(guestItems) {
+    const user = await requireRoleUser(["buyer", "seller", "admin"]);
+    const merged = [];
+    for (const item of guestItems) {
+        try {
+            await wishlistRepository.addItem(user.uid, item.productId, {
+                productType: item.productType,
+                priceAtAdd: item.priceAtAdd,
+                productSnapshot: item.productSnapshot,
+            });
+            merged.push(item.productId);
+        }
+        catch (err) {
+            if (err instanceof WishlistFullError)
+                break;
+        }
+    }
+    return merged;
+}

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

@@ -0,0 +1,8 @@
+import { type WishlistItem } from "../../../../repositories";
+export declare const getWishlistForUser: (userId: string) => Promise<{
+    items: WishlistItem[];
+    meta: {
+        total: number;
+    };
+}>;
+export declare const isProductInWishlist: (userId: string, productId: string) => Promise<boolean>;

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

@@ -0,0 +1,9 @@
+import { cache } from "react";
+import { wishlistRepository } from "../../../../repositories";
+export const getWishlistForUser = cache(async (userId) => {
+    const items = await wishlistRepository.getWishlistItems(userId).catch(() => []);
+    return { items, meta: { total: items.length } };
+});
+export const isProductInWishlist = cache(async (userId, productId) => {
+    return wishlistRepository.isInWishlist(userId, productId).catch(() => false);
+});

package/dist/_internal/server/features/wishlist/index.d.ts

@@ -0,0 +1,4 @@
+export { getWishlistForUser, isProductInWishlist } from "./data";
+export { addToWishlistAction, removeFromWishlistAction, mergeGuestWishlistAction, } from "./actions";
+export { WISHLIST_MAX, WISHLIST_GUEST_STORAGE_KEY } from "../../../shared/features/wishlist/config";
+export { WishlistCapError } from "../../../shared/features/wishlist/errors";

package/dist/_internal/server/features/wishlist/index.js

@@ -0,0 +1,4 @@
+export { getWishlistForUser, isProductInWishlist } from "./data";
+export { addToWishlistAction, removeFromWishlistAction, mergeGuestWishlistAction, } from "./actions";
+export { WISHLIST_MAX, WISHLIST_GUEST_STORAGE_KEY } from "../../../shared/features/wishlist/config";
+export { WishlistCapError } from "../../../shared/features/wishlist/errors";

package/dist/_internal/server/index.js

@@ -0,0 +1,4 @@
+"use strict";
+// Server-side internals — populated starting in S2
+// Each migrated feature moves its server surface here
+// Boundary rule: may only import from _internal/shared/, never from _internal/client/

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

@@ -0,0 +1,8 @@
+/**
+ * Shared helpers for job handlers.
+ */
+import { getAdminRealtimeDb } from "../../../../providers/db-firebase";
+import type { JobContext } from "../runtime/types";
+/** Batch-delete document refs, respecting Firestore's 500-write batch limit. */
+export declare function batchDelete(ctx: JobContext, refs: FirebaseFirestore.DocumentReference[]): Promise<number>;
+export { getAdminRealtimeDb };

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

@@ -0,0 +1,19 @@
+/**
+ * Shared helpers for job handlers.
+ */
+import { getAdminRealtimeDb } from "../../../../providers/db-firebase";
+import { BATCH_LIMIT } from "./messages";
+/** Batch-delete document refs, respecting Firestore's 500-write batch limit. */
+export async function batchDelete(ctx, refs) {
+    let deleted = 0;
+    for (let i = 0; i < refs.length; i += BATCH_LIMIT) {
+        const slice = refs.slice(i, i + BATCH_LIMIT);
+        const batch = ctx.db.batch();
+        for (const ref of slice)
+            batch.delete(ref);
+        await batch.commit();
+        deleted += slice.length;
+    }
+    return deleted;
+}
+export { getAdminRealtimeDb };

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

@@ -0,0 +1,28 @@
+/**
+ * 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;
+    }>;
+}
+export declare const adminAnalyticsHandler: CallableHandler<void, AdminAnalyticsResult>;

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

@@ -0,0 +1,98 @@
+/**
+ * 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,
+    };
+};

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

@@ -0,0 +1,2 @@
+import type { ScheduleHandler } from "../runtime/types";
+export declare const auctionSettlementHandler: ScheduleHandler;

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

@@ -0,0 +1,70 @@
+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`);
+};

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

@@ -0,0 +1,2 @@
+import type { ScheduleHandler } from "../runtime/types";
+export declare const autoPayoutEligibilityHandler: ScheduleHandler;

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

@@ -0,0 +1,110 @@
+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,
+    });
+};

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

@@ -0,0 +1,2 @@
+import type { ScheduleHandler } from "../runtime/types";
+export declare const cartPruneHandler: ScheduleHandler;

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

@@ -0,0 +1,13 @@
+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 });
+};

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

@@ -0,0 +1,2 @@
+import type { ScheduleHandler } from "../runtime/types";
+export declare const cleanupRtdbEventsHandler: ScheduleHandler;

package/dist/_internal/server/jobs/handlers/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 const cleanupRtdbEventsHandler = async (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/handlers/countersReconcile.d.ts

@@ -0,0 +1,2 @@
+import type { ScheduleHandler } from "../runtime/types";
+export declare const countersReconcileHandler: ScheduleHandler;