@mohasinac/appkit 2.4.11 → 2.5.0

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

@@ -0,0 +1,109 @@
+import { categoriesRepository, reviewRepository, storeRepository, } from "../../../../repositories";
+import { ProductStatusValues, PRODUCT_COLLECTION } from "../../../../features/products/schemas/firestore";
+import { QUERY_LIMIT } from "./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) {
+        // SB1-G — split off canonical listingType. Auctions go into auctionIds;
+        // everything else (standard, pre-order, prize-draw, bundle) into productIds.
+        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 const countersReconcileHandler = async (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/handlers/couponExpiry.d.ts

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

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

@@ -0,0 +1,13 @@
+import { couponsRepository } from "../../../../repositories";
+export const couponExpiryHandler = async (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/handlers/dailyDataCleanup.d.ts

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

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

@@ -0,0 +1,20 @@
+import { sessionRepository, tokenRepository } from "../../../../repositories";
+import { batchDelete } from "./_helpers";
+export const dailyDataCleanupHandler = async (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/handlers/index.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Job handlers barrel — pure handler functions ready to be bound by an
+ * adapter (Firebase Functions, local cron, etc.).
+ *
+ * S4 batch 1: promotions, onOrderCreate, onOrderStatusChange,
+ *             auctionSettlement, autoPayoutEligibility, couponExpiry, offerExpiry
+ * S5 batch 2: onReviewWrite, onBidPlaced, cartPrune, notificationPrune,
+ *             dailyDataCleanup, countersReconcile, cleanupRtdbEvents
+ */
+export { couponExpiryHandler } from "./couponExpiry";
+export { offerExpiryHandler } from "./offerExpiry";
+export { cartPruneHandler } from "./cartPrune";
+export { notificationPruneHandler } from "./notificationPrune";
+export { dailyDataCleanupHandler } from "./dailyDataCleanup";
+export { cleanupRtdbEventsHandler } from "./cleanupRtdbEvents";
+export { auctionSettlementHandler } from "./auctionSettlement";
+export { autoPayoutEligibilityHandler } from "./autoPayoutEligibility";
+export { countersReconcileHandler } from "./countersReconcile";
+export { onOrderCreateHandler } from "./onOrderCreate";
+export { onOrderStatusChangeHandler } from "./onOrderStatusChange";
+export { onBidPlacedHandler } from "./onBidPlaced";
+export { onReviewWriteHandler } from "./onReviewWrite";
+export { promotionsHandler, type PromotionsCallableResult } from "./promotions";
+export { mediaTmpCleanupHandler } from "./mediaTmpCleanup";
+export { pendingOrderTimeoutHandler } from "./pendingOrderTimeout";
+export { productStatsSyncHandler } from "./productStatsSync";
+export { positionsReconcileHandler } from "./positionsReconcile";
+export { payoutBatchHandler } from "./payoutBatch";
+export { weeklyPayoutEligibilityHandler } from "./weeklyPayoutEligibility";
+export { onCategoryWriteHandler } from "./onCategoryWrite";
+export { onProductWriteHandler } from "./onProductWrite";
+export { onStoreWriteHandler } from "./onStoreWrite";
+export { adminAnalyticsHandler, type AdminAnalyticsResult } from "./adminAnalytics";
+export { storeAnalyticsHandler, type StoreAnalyticsInput, type StoreAnalyticsResult, } from "./storeAnalytics";
+export { listingProcessorHandler, supportedListingCollections, type ListingRequestBody, type ListingResponseBody, } from "./listingProcessor";

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

@@ -0,0 +1,35 @@
+/**
+ * Job handlers barrel — pure handler functions ready to be bound by an
+ * adapter (Firebase Functions, local cron, etc.).
+ *
+ * S4 batch 1: promotions, onOrderCreate, onOrderStatusChange,
+ *             auctionSettlement, autoPayoutEligibility, couponExpiry, offerExpiry
+ * S5 batch 2: onReviewWrite, onBidPlaced, cartPrune, notificationPrune,
+ *             dailyDataCleanup, countersReconcile, cleanupRtdbEvents
+ */
+export { couponExpiryHandler } from "./couponExpiry";
+export { offerExpiryHandler } from "./offerExpiry";
+export { cartPruneHandler } from "./cartPrune";
+export { notificationPruneHandler } from "./notificationPrune";
+export { dailyDataCleanupHandler } from "./dailyDataCleanup";
+export { cleanupRtdbEventsHandler } from "./cleanupRtdbEvents";
+export { auctionSettlementHandler } from "./auctionSettlement";
+export { autoPayoutEligibilityHandler } from "./autoPayoutEligibility";
+export { countersReconcileHandler } from "./countersReconcile";
+export { onOrderCreateHandler } from "./onOrderCreate";
+export { onOrderStatusChangeHandler } from "./onOrderStatusChange";
+export { onBidPlacedHandler } from "./onBidPlaced";
+export { onReviewWriteHandler } from "./onReviewWrite";
+export { promotionsHandler } from "./promotions";
+export { mediaTmpCleanupHandler } from "./mediaTmpCleanup";
+export { pendingOrderTimeoutHandler } from "./pendingOrderTimeout";
+export { productStatsSyncHandler } from "./productStatsSync";
+export { positionsReconcileHandler } from "./positionsReconcile";
+export { payoutBatchHandler } from "./payoutBatch";
+export { weeklyPayoutEligibilityHandler } from "./weeklyPayoutEligibility";
+export { onCategoryWriteHandler } from "./onCategoryWrite";
+export { onProductWriteHandler } from "./onProductWrite";
+export { onStoreWriteHandler } from "./onStoreWrite";
+export { adminAnalyticsHandler } from "./adminAnalytics";
+export { storeAnalyticsHandler, } from "./storeAnalytics";
+export { listingProcessorHandler, supportedListingCollections, } from "./listingProcessor";

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

@@ -0,0 +1,30 @@
+/**
+ * HTTPS callable handler: 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 { CallableHandler } 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 const listingProcessorHandler: CallableHandler<ListingRequestBody, ListingResponseBody>;
+export declare const supportedListingCollections: string[];

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

@@ -0,0 +1,128 @@
+/**
+ * HTTPS callable handler: 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 { bidRepository, blogRepository, brandsRepository, categoriesRepository, couponsRepository, eventEntryRepository, eventRepository, faqsRepository, homepageSectionsRepository, notificationRepository, orderRepository, payoutRepository, productFeaturesRepository, productRepository, productTemplateRepository, reviewRepository, scammerRepository, storeRepository, sublistingCategoriesRepository, userRepository, } from "../../../../repositories";
+const DEFAULT_SORT = "-createdAt";
+const DEFAULT_PAGE = 1;
+const DEFAULT_PAGE_SIZE = 20;
+const MAX_PAGE_SIZE = 100;
+class ListingError extends Error {
+    constructor(status, message) {
+        super(message);
+        this.name = "ListingError";
+        this.httpStatus = status;
+    }
+}
+function requireOpt(baseOpts, key, collection) {
+    const value = baseOpts[key];
+    if (typeof value !== "string" || value.length === 0) {
+        throw new ListingError(400, `${collection} listing requires baseOpts.${key}`);
+    }
+    return value;
+}
+function getBoolOpt(baseOpts, key, fallback) {
+    const value = baseOpts[key];
+    if (typeof value === "boolean")
+        return value;
+    if (value === "true")
+        return true;
+    if (value === "false")
+        return false;
+    return fallback;
+}
+const LISTERS = {
+    products: (m, o) => productRepository.list(m, o),
+    categories: (m) => categoriesRepository.list(m),
+    brands: (m) => brandsRepository.list(m),
+    orders: (m) => orderRepository.listAll(m),
+    reviews: (m) => reviewRepository.listAll(m),
+    coupons: (m) => couponsRepository.list(m),
+    bids: (m) => bidRepository.list(m),
+    payouts: (m) => payoutRepository.list(m),
+    blogPosts: (m) => blogRepository.listAll(m),
+    events: (m) => eventRepository.list(m),
+    faqs: (m) => faqsRepository.list(m),
+    notifications: (m) => notificationRepository.list(m),
+    scammers: (m) => scammerRepository.listAll(m),
+    sublistingCategories: (m) => sublistingCategoriesRepository.list(m),
+    productFeatures: (m) => productFeaturesRepository.list(m),
+    homepageSections: (m) => homepageSectionsRepository.list(m),
+    users: (m) => userRepository.list(m),
+    stores: (m, o) => storeRepository.listStores(m, getBoolOpt(o, "activeOnly", true)),
+    eventEntries: (m, o) => {
+        const eventId = requireOpt(o, "eventId", "eventEntries");
+        return eventEntryRepository.listForEvent(eventId, m);
+    },
+    productTemplates: (m, o) => {
+        const storeId = requireOpt(o, "storeId", "productTemplates");
+        return productTemplateRepository.listByStore(storeId, m);
+    },
+};
+const SUPPORTED_COLLECTIONS = Object.keys(LISTERS);
+function decodeCursor(cursor) {
+    if (!cursor)
+        return null;
+    try {
+        const json = Buffer.from(cursor, "base64").toString("utf8");
+        const parsed = JSON.parse(json);
+        const page = Number(parsed.page);
+        return Number.isFinite(page) && page > 0 ? page : null;
+    }
+    catch {
+        return null;
+    }
+}
+function encodeCursor(page) {
+    return Buffer.from(JSON.stringify({ page }), "utf8").toString("base64");
+}
+function clampPageSize(raw) {
+    const n = Number(raw);
+    if (!Number.isFinite(n) || n <= 0)
+        return DEFAULT_PAGE_SIZE;
+    return Math.min(Math.floor(n), MAX_PAGE_SIZE);
+}
+function clampPage(raw) {
+    const n = Number(raw);
+    if (!Number.isFinite(n) || n < 1)
+        return DEFAULT_PAGE;
+    return Math.floor(n);
+}
+export const listingProcessorHandler = async (body, ctx) => {
+    if (!body || typeof body.collection !== "string") {
+        throw new ListingError(400, "Missing collection");
+    }
+    const lister = LISTERS[body.collection];
+    if (!lister) {
+        throw new ListingError(400, `Unsupported collection: ${body.collection}. Supported: ${SUPPORTED_COLLECTIONS.join(",")}`);
+    }
+    const cursorPage = decodeCursor(body.cursor);
+    const page = cursorPage ?? clampPage(body.p);
+    const pageSize = clampPageSize(body.ps);
+    const result = await lister({
+        filters: body.f ?? "",
+        sorts: body.s ?? DEFAULT_SORT,
+        page: String(page),
+        pageSize: String(pageSize),
+    }, body.baseOpts ?? {});
+    ctx.logger.info("listing served", {
+        collection: body.collection,
+        page: result.page,
+        pageSize: result.pageSize,
+        total: result.total,
+    });
+    return {
+        items: result.items,
+        total: result.total,
+        page: result.page,
+        pageSize: result.pageSize,
+        totalPages: result.totalPages,
+        hasMore: result.hasMore,
+        cursor: result.hasMore ? encodeCursor(result.page + 1) : null,
+    };
+};
+export const supportedListingCollections = SUPPORTED_COLLECTIONS;

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

@@ -0,0 +1,14 @@
+/**
+ * Job handler: media tmp cleanup.
+ *
+ * Sweeps Firebase Storage for stale objects under the tmp/ prefix. Layer 2 of
+ * the dual-layer scheme — Layer 1 is the form-level onAbort() DELETE call;
+ * this job mops up anything that escaped (crashes, expired sessions).
+ *
+ * Safety invariants:
+ *  - Only touches objects whose name starts with `tmp/`.
+ *  - Only deletes objects older than `ttlHours` (default 24).
+ *  - Idempotent: 404s on delete are swallowed (Layer 1 already removed it).
+ */
+import type { ScheduleHandler } from "../runtime/types";
+export declare const mediaTmpCleanupHandler: ScheduleHandler;

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

@@ -0,0 +1,69 @@
+/**
+ * Job handler: media tmp cleanup.
+ *
+ * Sweeps Firebase Storage for stale objects under the tmp/ prefix. Layer 2 of
+ * the dual-layer scheme — Layer 1 is the form-level onAbort() DELETE call;
+ * this job mops up anything that escaped (crashes, expired sessions).
+ *
+ * Safety invariants:
+ *  - Only touches objects whose name starts with `tmp/`.
+ *  - Only deletes objects older than `ttlHours` (default 24).
+ *  - Idempotent: 404s on delete are swallowed (Layer 1 already removed it).
+ */
+import { getAdminStorageLite } from "../../../../providers/db-firebase/admin-storage-lite";
+const TMP_PREFIX = "tmp/";
+const DEFAULT_TTL_HOURS = 24;
+function getBucket() {
+    const bucketName = process.env.FIREBASE_ADMIN_STORAGE_BUCKET?.trim() ??
+        process.env.NEXT_PUBLIC_FIREBASE_STORAGE_BUCKET?.trim();
+    return bucketName ? getAdminStorageLite().bucket(bucketName) : getAdminStorageLite().bucket();
+}
+export const mediaTmpCleanupHandler = async (ctx) => {
+    const ttlHours = Number(ctx.env("MEDIA_TMP_TTL_HOURS") ?? DEFAULT_TTL_HOURS);
+    const cutoff = new Date(Date.now() - ttlHours * 60 * 60 * 1000);
+    ctx.logger.info("Starting media tmp cleanup", { prefix: TMP_PREFIX, ttlHours });
+    let scanned = 0;
+    let deleted = 0;
+    let skipped = 0;
+    let errors = 0;
+    try {
+        const bucket = getBucket();
+        const [files] = await bucket.getFiles({ prefix: TMP_PREFIX, autoPaginate: true });
+        scanned = files.length;
+        ctx.logger.info("Objects under tmp prefix", { count: scanned });
+        for (const file of files) {
+            try {
+                if (!file.name.startsWith(TMP_PREFIX)) {
+                    skipped++;
+                    continue;
+                }
+                const [metadata] = await file.getMetadata();
+                const updated = metadata.updated ?? metadata.timeCreated;
+                if (!updated) {
+                    skipped++;
+                    continue;
+                }
+                if (new Date(updated) >= cutoff) {
+                    skipped++;
+                    continue;
+                }
+                await file.delete();
+                deleted++;
+            }
+            catch (fileError) {
+                errors++;
+                const code = fileError?.code;
+                if (code === 404) {
+                    // Already deleted by Layer 1 — ignore.
+                    continue;
+                }
+                ctx.logger.error("Failed to delete tmp file", fileError, { name: file.name });
+            }
+        }
+    }
+    catch (err) {
+        ctx.logger.error("Fatal error during media tmp cleanup", err);
+        throw err;
+    }
+    ctx.logger.info("Media tmp cleanup complete", { scanned, deleted, skipped, errors });
+};

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

@@ -0,0 +1,45 @@
+/**
+ * Message templates used by job handlers.
+ *
+ * Lifted verbatim from functions/src/constants/messages.ts so the handlers
+ * can live in appkit without depending on the consumer's functions/ tree.
+ */
+export declare const AUCTION_MESSAGES: {
+    WON_TITLE: string;
+    WON_MESSAGE: (productTitle: string, currency: string, amount: number) => string;
+    LOST_TITLE: string;
+    LOST_MESSAGE: (productTitle: string) => string;
+    NO_BIDS_LOG: (productId: string) => string;
+};
+export declare const BID_MESSAGES: {
+    OUTBID_TITLE: string;
+    OUTBID_MESSAGE: (productTitle: string, currency: string, currentBid: number) => string;
+};
+export declare const ORDER_MESSAGES: {
+    CANCELLED_TITLE: string;
+    CANCELLED_TIMEOUT_MESSAGE: (productTitle: string, hours: number) => string;
+    CONFIRMED_TITLE: string;
+    CONFIRMED_MESSAGE: (productTitle: string) => string;
+    SHIPPED_TITLE: string;
+    SHIPPED_MESSAGE: (productTitle: string, trackingNumber?: string) => string;
+    DELIVERED_TITLE: string;
+    DELIVERED_MESSAGE: (productTitle: string) => string;
+};
+export declare const EMAIL_SUBJECTS: {
+    ORDER_CONFIRMED: (productTitle: string) => string;
+    ORDER_SHIPPED: (productTitle: string) => string;
+    ORDER_DELIVERED: (productTitle: string) => string;
+    ORDER_UPDATE_FALLBACK: (productTitle: string) => string;
+};
+export declare const JOB_ERROR_MESSAGES: {
+    RESEND_KEY_MISSING: string;
+    RESEND_API_ERROR: (status: number, body: string) => string;
+};
+/** Default Cart TTL in days (matches functions/config/constants). */
+export declare const CART_TTL_DAYS = 60;
+/** Default Notification TTL in days (matches functions/config/constants). */
+export declare const NOTIFICATION_TTL_DAYS = 30;
+/** Firestore batch write hard ceiling. */
+export declare const BATCH_LIMIT = 500;
+/** Firestore single-query soft ceiling for reconcile sweeps. */
+export declare const QUERY_LIMIT = 1000;

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

@@ -0,0 +1,45 @@
+/**
+ * Message templates used by job handlers.
+ *
+ * Lifted verbatim from functions/src/constants/messages.ts so the handlers
+ * can live in appkit without depending on the consumer's functions/ tree.
+ */
+export const AUCTION_MESSAGES = {
+    WON_TITLE: "You won the auction! 🎉",
+    WON_MESSAGE: (productTitle, currency, amount) => `Congratulations! You won "${productTitle}" with a bid of ${currency} ${amount}.`,
+    LOST_TITLE: "Auction ended",
+    LOST_MESSAGE: (productTitle) => `The auction for "${productTitle}" has ended. You were outbid.`,
+    NO_BIDS_LOG: (productId) => `Auction ${productId} ended with no bids`,
+};
+export const BID_MESSAGES = {
+    OUTBID_TITLE: "You've been outbid",
+    OUTBID_MESSAGE: (productTitle, currency, currentBid) => `Someone placed a higher bid on "${productTitle}". Current bid: ${currency} ${currentBid}.`,
+};
+export const ORDER_MESSAGES = {
+    CANCELLED_TITLE: "Order cancelled",
+    CANCELLED_TIMEOUT_MESSAGE: (productTitle, hours) => `Your order for "${productTitle}" was cancelled because payment was not received within ${hours} hours.`,
+    CONFIRMED_TITLE: "Order confirmed ✅",
+    CONFIRMED_MESSAGE: (productTitle) => `Your order for "${productTitle}" has been confirmed and is being prepared.`,
+    SHIPPED_TITLE: "Your order has shipped 📦",
+    SHIPPED_MESSAGE: (productTitle, trackingNumber) => `Your order for "${productTitle}" is on its way!${trackingNumber ? ` Tracking: ${trackingNumber}` : ""}`,
+    DELIVERED_TITLE: "Order delivered 🎉",
+    DELIVERED_MESSAGE: (productTitle) => `Your order for "${productTitle}" has been delivered. Enjoy!`,
+};
+export const EMAIL_SUBJECTS = {
+    ORDER_CONFIRMED: (productTitle) => `Order confirmed — ${productTitle}`,
+    ORDER_SHIPPED: (productTitle) => `Your order has shipped — ${productTitle}`,
+    ORDER_DELIVERED: (productTitle) => `Order delivered — ${productTitle}`,
+    ORDER_UPDATE_FALLBACK: (productTitle) => `Order update — ${productTitle}`,
+};
+export const JOB_ERROR_MESSAGES = {
+    RESEND_KEY_MISSING: "RESEND_API_KEY not configured — skipping email",
+    RESEND_API_ERROR: (status, body) => `Resend API error ${status}: ${body}`,
+};
+/** Default Cart TTL in days (matches functions/config/constants). */
+export const CART_TTL_DAYS = 60;
+/** Default Notification TTL in days (matches functions/config/constants). */
+export const NOTIFICATION_TTL_DAYS = 30;
+/** Firestore batch write hard ceiling. */
+export const BATCH_LIMIT = 500;
+/** Firestore single-query soft ceiling for reconcile sweeps. */
+export const QUERY_LIMIT = 1000;

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

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

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

@@ -0,0 +1,13 @@
+import { notificationRepository } from "../../../../repositories";
+import { NOTIFICATION_TTL_DAYS } from "./messages";
+import { batchDelete } from "./_helpers";
+export const notificationPruneHandler = async (ctx) => {
+    ctx.logger.info(`Pruning read notifications older than ${NOTIFICATION_TTL_DAYS} days`);
+    const refs = await notificationRepository.getOldReadRefs(NOTIFICATION_TTL_DAYS);
+    if (refs.length === 0) {
+        ctx.logger.info("No stale read notifications found");
+        return;
+    }
+    const deleted = await batchDelete(ctx, refs);
+    ctx.logger.info("Notification prune complete", { deleted });
+};

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

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

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

@@ -0,0 +1,50 @@
+import { offerRepository, notificationRepository } from "../../../../repositories";
+export const offerExpiryHandler = async (ctx) => {
+    ctx.logger.info("Starting offer expiry sweep");
+    let expiredOffers;
+    try {
+        expiredOffers = await offerRepository.findExpiredActive(ctx.now);
+    }
+    catch (err) {
+        ctx.logger.error("Failed to query expired offers", err);
+        throw err;
+    }
+    if (expiredOffers.length === 0) {
+        ctx.logger.info("No expired offers found");
+        return;
+    }
+    ctx.logger.info(`Found ${expiredOffers.length} expired offer(s) to process`);
+    const expiredIds = [];
+    for (const offer of expiredOffers) {
+        try {
+            expiredIds.push(offer.id);
+            await notificationRepository.create({
+                userId: offer.buyerUid,
+                type: "offer_expired",
+                priority: "normal",
+                title: "Offer expired",
+                message: `Your offer on "${offer.productTitle}" expired without a response.`,
+                relatedId: offer.id,
+                relatedType: "offer",
+            });
+        }
+        catch (err) {
+            ctx.logger.warn(`Failed to process expiry for offer ${offer.id}`, {
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    if (expiredIds.length > 0) {
+        try {
+            await offerRepository.expireMany(expiredIds);
+        }
+        catch (err) {
+            ctx.logger.error("Failed to batch-expire offers", err);
+            throw err;
+        }
+    }
+    ctx.logger.info("Offer expiry complete", {
+        processed: expiredIds.length,
+        skipped: expiredOffers.length - expiredIds.length,
+    });
+};

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

@@ -0,0 +1,12 @@
+import type { FirestoreTriggerHandler } from "../runtime/types";
+interface NewBid {
+    id: string;
+    productId: string;
+    productTitle: string;
+    userId: string;
+    userName: string;
+    bidAmount: number;
+    currency: string;
+}
+export declare const onBidPlacedHandler: FirestoreTriggerHandler<null, NewBid>;
+export {};