@mohasinac/appkit 2.4.11 → 2.5.1

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

@@ -0,0 +1,63 @@
+import { bidRepository, notificationRepository, productRepository, } from "../../../../repositories";
+import { decryptPii } from "../../../../security/index";
+import { getAdminRealtimeDb } from "../../../../providers/db-firebase";
+import { BID_MESSAGES } from "./messages";
+const BIDS_COLLECTION = "bids";
+export const onBidPlacedHandler = async (event, ctx) => {
+    const newBid = event.after;
+    if (!newBid) {
+        ctx.logger.error("No snapshot data", null);
+        return;
+    }
+    newBid.userName = decryptPii(newBid.userName);
+    try {
+        const prevWinning = await bidRepository.getWinningBid(newBid.productId);
+        const batch = ctx.db.batch();
+        const newBidRef = ctx.db.collection(BIDS_COLLECTION).doc(event.params.bidId);
+        bidRepository.markWinning(batch, newBidRef);
+        let outbidUserId = null;
+        if (prevWinning && prevWinning.data.userId !== newBid.userId) {
+            outbidUserId = prevWinning.data.userId;
+            bidRepository.markOutbid(batch, prevWinning.ref);
+            notificationRepository.createInBatch(batch, {
+                userId: outbidUserId,
+                type: "bid_outbid",
+                priority: "high",
+                title: BID_MESSAGES.OUTBID_TITLE,
+                message: BID_MESSAGES.OUTBID_MESSAGE(newBid.productTitle, newBid.currency, newBid.bidAmount),
+                relatedId: newBid.productId,
+                relatedType: "product",
+            });
+        }
+        productRepository.incrementBidCountInBatch(batch, newBid.productId, newBid.bidAmount);
+        await batch.commit();
+        try {
+            if (outbidUserId) {
+                await getAdminRealtimeDb()
+                    .ref(`notifications/${outbidUserId}`)
+                    .push({
+                    type: "bid_outbid",
+                    title: BID_MESSAGES.OUTBID_TITLE,
+                    message: BID_MESSAGES.OUTBID_MESSAGE(newBid.productTitle, newBid.currency, newBid.bidAmount),
+                    timestamp: Date.now(),
+                    read: false,
+                });
+            }
+        }
+        catch (rtdbError) {
+            ctx.logger.error("Realtime DB push failed (non-fatal)", rtdbError);
+        }
+        ctx.logger.info(`Bid placed on ${newBid.productId}`, {
+            bidId: event.params.bidId,
+            amount: newBid.bidAmount,
+            outbidUserId,
+        });
+    }
+    catch (error) {
+        ctx.logger.error("Error handling bid placement", error, {
+            bidId: event.params.bidId,
+            productId: newBid.productId,
+        });
+        throw error;
+    }
+};

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

@@ -0,0 +1,10 @@
+/**
+ * Trigger handler: maintain DFS `position` + `subtreeSize` on every category
+ * write. CREATE → insert into parent's subtree + shift later siblings;
+ * DELETE → shift back; MOVE → mark `positionDirty` so the nightly reconcile
+ * job rebuilds (real-time move would require repositioning an entire subtree).
+ */
+import type { FirestoreTriggerHandler } from "../runtime/types";
+type CategoryDoc = Record<string, unknown>;
+export declare const onCategoryWriteHandler: FirestoreTriggerHandler<CategoryDoc, CategoryDoc>;
+export {};

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

@@ -0,0 +1,136 @@
+/**
+ * Trigger handler: maintain DFS `position` + `subtreeSize` on every category
+ * write. CREATE → insert into parent's subtree + shift later siblings;
+ * DELETE → shift back; MOVE → mark `positionDirty` so the nightly reconcile
+ * job rebuilds (real-time move would require repositioning an entire subtree).
+ */
+import { FieldValue } from "firebase-admin/firestore";
+import { BATCH_LIMIT } from "./messages";
+const CATEGORIES = "categories";
+async function shiftPositions(ctx, threshold, delta, excludeId) {
+    const snap = await ctx.db.collection(CATEGORIES).where("position", ">=", threshold).get();
+    const docs = snap.docs.filter((d) => d.id !== excludeId && d.data().position >= threshold);
+    if (docs.length === 0)
+        return 0;
+    for (let i = 0; i < docs.length; i += BATCH_LIMIT) {
+        const batch = ctx.db.batch();
+        for (const doc of docs.slice(i, i + BATCH_LIMIT)) {
+            batch.update(doc.ref, {
+                position: doc.data().position + delta,
+                updatedAt: new Date(),
+            });
+        }
+        await batch.commit();
+    }
+    return docs.length;
+}
+async function adjustAncestorSubtreeSize(ctx, ancestorIds, delta) {
+    if (ancestorIds.length === 0)
+        return;
+    for (let i = 0; i < ancestorIds.length; i += BATCH_LIMIT) {
+        const batch = ctx.db.batch();
+        for (const id of ancestorIds.slice(i, i + BATCH_LIMIT)) {
+            batch.update(ctx.db.collection(CATEGORIES).doc(id), {
+                subtreeSize: FieldValue.increment(delta),
+                updatedAt: new Date(),
+            });
+        }
+        await batch.commit();
+    }
+}
+async function getMaxPosition(ctx, excludeId) {
+    const snap = await ctx.db
+        .collection(CATEGORIES)
+        .orderBy("position", "desc")
+        .limit(excludeId ? 2 : 1)
+        .get();
+    for (const doc of snap.docs) {
+        if (doc.id === excludeId)
+            continue;
+        return doc.data().position ?? 0;
+    }
+    return 0;
+}
+export const onCategoryWriteHandler = async (event, ctx) => {
+    const categoryId = event.params.categoryId;
+    const before = event.before;
+    const after = event.after;
+    const isCreate = !before && !!after;
+    const isDelete = !!before && !after;
+    const isUpdate = !!before && !!after;
+    try {
+        if (isCreate) {
+            const parentIds = after.parentIds ?? [];
+            const parentId = parentIds.length > 0 ? parentIds[parentIds.length - 1] : null;
+            let insertPosition;
+            if (parentId) {
+                const parentSnap = await ctx.db.collection(CATEGORIES).doc(parentId).get();
+                if (!parentSnap.exists) {
+                    ctx.logger.warn("Parent not found, appending at end", { categoryId, parentId });
+                    insertPosition = (await getMaxPosition(ctx, categoryId)) + 1;
+                }
+                else {
+                    const p = parentSnap.data();
+                    const parentPos = p.position ?? 0;
+                    const parentSize = p.subtreeSize ?? 1;
+                    insertPosition = parentPos + parentSize;
+                }
+            }
+            else {
+                insertPosition = (await getMaxPosition(ctx, categoryId)) + 1;
+            }
+            const shifted = await shiftPositions(ctx, insertPosition, +1, categoryId);
+            await ctx.db.collection(CATEGORIES).doc(categoryId).update({
+                position: insertPosition,
+                subtreeSize: 1,
+                updatedAt: new Date(),
+            });
+            await adjustAncestorSubtreeSize(ctx, parentIds, +1);
+            ctx.logger.info("Category created — position assigned", {
+                categoryId,
+                position: insertPosition,
+                parentId,
+                shifted,
+            });
+        }
+        else if (isDelete) {
+            const deletedPos = before.position ?? 0;
+            const deletedSize = before.subtreeSize ?? 1;
+            const parentIds = before.parentIds ?? [];
+            if (deletedPos === 0) {
+                ctx.logger.warn("Deleted category had no position — skipping shift", { categoryId });
+                return;
+            }
+            const shifted = await shiftPositions(ctx, deletedPos + deletedSize, -deletedSize);
+            await adjustAncestorSubtreeSize(ctx, parentIds, -deletedSize);
+            ctx.logger.info("Category deleted — positions shifted", {
+                categoryId,
+                position: deletedPos,
+                subtreeSize: deletedSize,
+                shifted,
+            });
+        }
+        else if (isUpdate) {
+            const beforeParents = before.parentIds ?? [];
+            const afterParents = after.parentIds ?? [];
+            const beforeParent = beforeParents[beforeParents.length - 1] ?? null;
+            const afterParent = afterParents[afterParents.length - 1] ?? null;
+            if (beforeParent !== afterParent) {
+                await ctx.db
+                    .collection(CATEGORIES)
+                    .doc(categoryId)
+                    .update({ positionDirty: true, updatedAt: new Date() });
+                ctx.logger.warn("Category moved — positionDirty flagged for nightly reconcile", {
+                    categoryId,
+                    fromParent: beforeParent,
+                    toParent: afterParent,
+                });
+            }
+        }
+    }
+    catch (err) {
+        ctx.logger.error("Position update failed (non-fatal — will heal on next reconcile)", err, {
+            categoryId,
+        });
+    }
+};

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

@@ -0,0 +1,14 @@
+import type { FirestoreTriggerHandler } from "../runtime/types";
+interface OrderItem {
+    title?: string;
+    name?: string;
+}
+interface NewOrder {
+    buyerDisplayName?: string;
+    buyerId?: string;
+    items?: OrderItem[];
+    totalAmount?: number;
+    storeId?: string;
+}
+export declare const onOrderCreateHandler: FirestoreTriggerHandler<null, NewOrder>;
+export {};

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

@@ -0,0 +1,83 @@
+import { storeRepository, userRepository } from "../../../../repositories";
+import { decryptPii } from "../../../../security/index";
+import { sendWhatsAppBusinessMessage, buildPurchaseAnnouncementMessage, } from "../../../../features/whatsapp-bot/server";
+async function sendAnnouncement(ctx, toPhone, message, phoneNumberId, accessToken, label, orderId) {
+    try {
+        const sent = await sendWhatsAppBusinessMessage({
+            toPhone,
+            message,
+            phoneNumberId,
+            accessToken,
+        });
+        if (sent) {
+            ctx.logger.info(`Announcement sent to ${label}`, {
+                orderId,
+                toPhone: `...${toPhone.slice(-4)}`,
+            });
+        }
+        else {
+            ctx.logger.error(`Announcement delivery failed for ${label} (non-fatal)`, null, { orderId });
+        }
+    }
+    catch (err) {
+        ctx.logger.error(`Announcement send threw for ${label} (non-fatal)`, err, { orderId });
+    }
+}
+export const onOrderCreateHandler = async (event, ctx) => {
+    const order = event.after;
+    if (!order) {
+        ctx.logger.error("No snapshot data", null);
+        return;
+    }
+    const orderId = event.params.orderId;
+    const phoneNumberId = ctx.env("WHATSAPP_PHONE_NUMBER_ID") ?? "";
+    const accessToken = ctx.env("WHATSAPP_CLOUD_API_TOKEN") ?? "";
+    if (!phoneNumberId || !accessToken) {
+        ctx.logger.info("WhatsApp Cloud API not configured — skipping announcement", { orderId });
+        return;
+    }
+    const items = order.items ?? [];
+    const firstItem = items[0];
+    const firstItemName = firstItem?.title ?? firstItem?.name ?? "an item";
+    const additionalItemCount = Math.max(0, items.length - 1);
+    const buyerName = order.buyerDisplayName ?? "A customer";
+    const message = buildPurchaseAnnouncementMessage({
+        buyerName,
+        firstItemName,
+        additionalItemCount,
+        totalAmount: order.totalAmount ?? 0,
+        orderId,
+    });
+    const adminNumbersRaw = ctx.env("WHATSAPP_ADMIN_NOTIFY_NUMBERS") ?? "";
+    const adminNumbers = adminNumbersRaw
+        .split(",")
+        .map((n) => n.trim().replace(/\D/g, ""))
+        .filter(Boolean);
+    for (const num of adminNumbers) {
+        await sendAnnouncement(ctx, num, message, phoneNumberId, accessToken, "admin", orderId);
+    }
+    const storeId = order.storeId;
+    if (storeId) {
+        try {
+            const store = await storeRepository.findBySlug(storeId);
+            if (store?.ownerId) {
+                const owner = await userRepository.findById(store.ownerId);
+                const encryptedPhone = owner?.phoneNumber;
+                if (encryptedPhone) {
+                    const ownerPhone = decryptPii(encryptedPhone);
+                    if (ownerPhone) {
+                        await sendAnnouncement(ctx, ownerPhone, message, phoneNumberId, accessToken, "store-owner", orderId);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            ctx.logger.error("Store owner lookup failed (non-fatal)", err, { orderId, storeId });
+        }
+    }
+    ctx.logger.info(`Order announcement complete`, {
+        orderId,
+        adminCount: adminNumbers.length,
+        storeId: storeId ?? "unknown",
+    });
+};

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

@@ -0,0 +1,14 @@
+import type { FirestoreTriggerHandler } from "../runtime/types";
+type OrderStatus = "pending" | "confirmed" | "shipped" | "delivered" | "cancelled" | "returned";
+type OrderAfter = {
+    status: OrderStatus;
+    userId: string;
+    userEmail: string;
+    productTitle: string;
+    trackingNumber?: string;
+};
+type OrderBefore = {
+    status: OrderStatus;
+};
+export declare const onOrderStatusChangeHandler: FirestoreTriggerHandler<OrderBefore, OrderAfter>;
+export {};

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

@@ -0,0 +1,141 @@
+import { notificationRepository } from "../../../../repositories";
+import { decryptPii } from "../../../../security/index";
+import { getAdminRealtimeDb } from "../../../../providers/db-firebase";
+import { ORDER_MESSAGES, EMAIL_SUBJECTS, JOB_ERROR_MESSAGES } from "./messages";
+const STATUS_CONFIG = {
+    confirmed: {
+        type: "order_confirmed",
+        title: ORDER_MESSAGES.CONFIRMED_TITLE,
+        message: (o) => ORDER_MESSAGES.CONFIRMED_MESSAGE(o.productTitle),
+        priority: "normal",
+        sendEmail: true,
+    },
+    shipped: {
+        type: "order_shipped",
+        title: ORDER_MESSAGES.SHIPPED_TITLE,
+        message: (o) => ORDER_MESSAGES.SHIPPED_MESSAGE(o.productTitle, o.trackingNumber),
+        priority: "high",
+        sendEmail: true,
+    },
+    delivered: {
+        type: "order_delivered",
+        title: ORDER_MESSAGES.DELIVERED_TITLE,
+        message: (o) => ORDER_MESSAGES.DELIVERED_MESSAGE(o.productTitle),
+        priority: "normal",
+        sendEmail: true,
+    },
+    cancelled: {
+        type: "order_cancelled",
+        title: ORDER_MESSAGES.CANCELLED_TITLE,
+        message: (o) => `Your order for "${o.productTitle}" has been cancelled.`,
+        priority: "normal",
+        sendEmail: false,
+    },
+};
+async function sendResendEmail(params) {
+    const subject = params.status === "confirmed"
+        ? EMAIL_SUBJECTS.ORDER_CONFIRMED(params.productTitle)
+        : params.status === "shipped"
+            ? EMAIL_SUBJECTS.ORDER_SHIPPED(params.productTitle)
+            : params.status === "delivered"
+                ? EMAIL_SUBJECTS.ORDER_DELIVERED(params.productTitle)
+                : EMAIL_SUBJECTS.ORDER_UPDATE_FALLBACK(params.productTitle);
+    const response = await fetch("https://api.resend.com/emails", {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${params.apiKey}`,
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+            from: params.fromAddress,
+            to: [params.to],
+            subject,
+            html: `<p>Hi,</p><p>Your order for <strong>${params.productTitle}</strong> is now <strong>${params.status}</strong>.</p>${params.trackingNumber ? `<p>Tracking number: ${params.trackingNumber}</p>` : ""}<p>Thanks,<br/>${params.brandName} Team</p>`,
+        }),
+    });
+    if (!response.ok) {
+        const body = await response.text();
+        throw new Error(JOB_ERROR_MESSAGES.RESEND_API_ERROR(response.status, body));
+    }
+}
+export const onOrderStatusChangeHandler = async (event, ctx) => {
+    const { before, after } = event;
+    if (!before || !after)
+        return;
+    if (before.status === after.status)
+        return;
+    const orderId = event.params.orderId;
+    const newStatus = after.status;
+    const config = STATUS_CONFIG[newStatus];
+    if (!config) {
+        ctx.logger.info(`No handler for status transition → ${newStatus}`, { orderId });
+        return;
+    }
+    // Decrypt PII that was encrypted at rest
+    const userEmail = decryptPii(after.userEmail);
+    try {
+        const messageText = config.message({
+            productTitle: after.productTitle,
+            trackingNumber: after.trackingNumber,
+        });
+        await notificationRepository.create({
+            userId: after.userId,
+            type: config.type,
+            priority: config.priority,
+            title: config.title,
+            message: messageText,
+            relatedId: orderId,
+            relatedType: "order",
+        });
+        try {
+            await getAdminRealtimeDb().ref(`notifications/${after.userId}`).push({
+                type: config.type,
+                title: config.title,
+                message: messageText,
+                timestamp: Date.now(),
+                read: false,
+            });
+        }
+        catch (rtdbError) {
+            ctx.logger.error("Realtime DB push failed (non-fatal)", rtdbError);
+        }
+        if (config.sendEmail) {
+            const apiKey = ctx.env("RESEND_API_KEY") ?? "";
+            if (!apiKey) {
+                ctx.logger.error(JOB_ERROR_MESSAGES.RESEND_KEY_MISSING, null);
+            }
+            else {
+                try {
+                    const fromAddress = ctx.env("ORDER_EMAIL_FROM") ?? ctx.env("RESEND_FROM_ADDRESS") ?? "";
+                    const brandName = ctx.env("APPKIT_BRAND_NAME") ?? "";
+                    if (!fromAddress || !brandName) {
+                        ctx.logger.error("ORDER_EMAIL_FROM / APPKIT_BRAND_NAME not configured — skipping order status email", null, { orderId });
+                    }
+                    else {
+                        await sendResendEmail({
+                            to: userEmail,
+                            status: newStatus,
+                            orderId,
+                            productTitle: after.productTitle,
+                            trackingNumber: after.trackingNumber,
+                            apiKey,
+                            fromAddress,
+                            brandName,
+                        });
+                    }
+                }
+                catch (emailError) {
+                    ctx.logger.error("Email send failed (non-fatal)", emailError, { orderId });
+                }
+            }
+        }
+        ctx.logger.info(`Order ${orderId} status → ${newStatus}`, {
+            userId: after.userId,
+            emailSent: config.sendEmail,
+        });
+    }
+    catch (error) {
+        ctx.logger.error("Error handling order status change", error, { orderId });
+        throw error;
+    }
+};

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

@@ -0,0 +1,8 @@
+/**
+ * Trigger handler: keep category metrics + store stats in sync when a
+ * product document is written. Only published products count.
+ */
+import type { FirestoreTriggerHandler } from "../runtime/types";
+type ProductDoc = Record<string, unknown>;
+export declare const onProductWriteHandler: FirestoreTriggerHandler<ProductDoc, ProductDoc>;
+export {};

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

@@ -0,0 +1,92 @@
+/**
+ * Trigger handler: keep category metrics + store stats in sync when a
+ * product document is written. Only published products count.
+ */
+import { categoriesRepository, storeRepository } from "../../../../repositories";
+import { ProductStatusValues } from "../../../../features/products/schemas/firestore";
+async function getParentIds(categoryId) {
+    if (!categoryId)
+        return [];
+    return (await categoriesRepository.findById(categoryId))?.parentIds ?? [];
+}
+export const onProductWriteHandler = async (event, ctx) => {
+    const productId = event.params.productId;
+    const before = event.before;
+    const after = event.after;
+    const beforeStatus = before?.status ?? null;
+    const afterStatus = after?.status ?? null;
+    const beforeCategory = before?.category ?? null;
+    const afterCategory = after?.category ?? null;
+    const beforeStoreId = (before?.storeId || before?.sellerId) ?? null;
+    const afterStoreId = (after?.storeId || after?.sellerId) ?? null;
+    // SB1-G — counters drive product-vs-auction split off the canonical
+    // listingType discriminator. Anything not "auction" counts toward products.
+    const isAuction = after?.listingType === "auction";
+    const beforeIsAuction = before?.listingType === "auction";
+    const wasPublished = beforeStatus === ProductStatusValues.PUBLISHED;
+    const isPublished = afterStatus === ProductStatusValues.PUBLISHED;
+    const isDelete = !after;
+    try {
+        if (isDelete && wasPublished && beforeCategory) {
+            const parentIds = await getParentIds(beforeCategory);
+            const batch = ctx.db.batch();
+            categoriesRepository.updateMetricsInBatch(batch, beforeCategory, parentIds, beforeIsAuction ? 0 : -1, beforeIsAuction ? -1 : 0, productId);
+            await batch.commit();
+            if (beforeStoreId)
+                await storeRepository.incrementTotalProducts(beforeStoreId, -1);
+            ctx.logger.info("Decremented counters on hard-delete", {
+                productId,
+                category: beforeCategory,
+                storeId: beforeStoreId,
+            });
+        }
+        else if (!wasPublished && isPublished && afterCategory) {
+            const parentIds = await getParentIds(afterCategory);
+            const batch = ctx.db.batch();
+            categoriesRepository.updateMetricsInBatch(batch, afterCategory, parentIds, isAuction ? 0 : 1, isAuction ? 1 : 0, productId);
+            await batch.commit();
+            if (afterStoreId)
+                await storeRepository.incrementTotalProducts(afterStoreId, 1);
+            ctx.logger.info("Incremented counters on publish", {
+                productId,
+                category: afterCategory,
+                storeId: afterStoreId,
+            });
+        }
+        else if (wasPublished && !isPublished && beforeCategory) {
+            const parentIds = await getParentIds(beforeCategory);
+            const batch = ctx.db.batch();
+            categoriesRepository.updateMetricsInBatch(batch, beforeCategory, parentIds, beforeIsAuction ? 0 : -1, beforeIsAuction ? -1 : 0, productId);
+            await batch.commit();
+            if (beforeStoreId)
+                await storeRepository.incrementTotalProducts(beforeStoreId, -1);
+            ctx.logger.info("Decremented counters on unpublish", {
+                productId,
+                category: beforeCategory,
+                storeId: beforeStoreId,
+            });
+        }
+        else if (wasPublished &&
+            isPublished &&
+            beforeCategory &&
+            afterCategory &&
+            beforeCategory !== afterCategory) {
+            const [beforeParents, afterParents] = await Promise.all([
+                getParentIds(beforeCategory),
+                getParentIds(afterCategory),
+            ]);
+            const batch = ctx.db.batch();
+            categoriesRepository.updateMetricsInBatch(batch, beforeCategory, beforeParents, beforeIsAuction ? 0 : -1, beforeIsAuction ? -1 : 0, productId);
+            categoriesRepository.updateMetricsInBatch(batch, afterCategory, afterParents, isAuction ? 0 : 1, isAuction ? 1 : 0, productId);
+            await batch.commit();
+            ctx.logger.info("Moved product between categories", {
+                productId,
+                from: beforeCategory,
+                to: afterCategory,
+            });
+        }
+    }
+    catch (err) {
+        ctx.logger.error("Counter update failed (non-fatal)", err, { productId });
+    }
+};

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

@@ -0,0 +1,2 @@
+import type { FirestoreTriggerHandler } from "../runtime/types";
+export declare const onReviewWriteHandler: FirestoreTriggerHandler<Record<string, unknown>, Record<string, unknown>>;

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

@@ -0,0 +1,51 @@
+import { reviewRepository, storeRepository } from "../../../../repositories";
+import { ReviewStatusValues } from "../../../../features/reviews/schemas/firestore";
+import { PRODUCT_COLLECTION } from "../../../../features/products/schemas/firestore";
+export const onReviewWriteHandler = async (event, ctx) => {
+    const reviewId = event.params.reviewId;
+    const beforeData = event.before;
+    const afterData = event.after;
+    const beforeStatus = beforeData?.status ?? null;
+    const afterStatus = afterData?.status ?? null;
+    const wasApproved = beforeStatus === ReviewStatusValues.APPROVED;
+    const isApproved = afterStatus === ReviewStatusValues.APPROVED;
+    if (!wasApproved && !isApproved)
+        return;
+    const data = afterData ?? beforeData;
+    if (!data)
+        return;
+    const productId = data.productId ?? null;
+    const storeId = data.storeId ?? null;
+    if (!productId) {
+        ctx.logger.error("Review has no productId — skipping", null, { reviewId });
+        return;
+    }
+    try {
+        const { count, avgRating } = await reviewRepository.getApprovedRatingAggregate(productId);
+        await ctx.db.collection(PRODUCT_COLLECTION).doc(productId).update({
+            avgRating,
+            reviewCount: count,
+            updatedAt: new Date(),
+        });
+        ctx.logger.info("Updated product rating stats", {
+            reviewId,
+            productId,
+            count,
+            avgRating,
+        });
+        if (storeId) {
+            const storeStats = await reviewRepository.getApprovedRatingAggregateByStore(storeId);
+            await storeRepository.updateReviewStats(storeId, storeStats.count, storeStats.avgRating);
+            ctx.logger.info("Updated store review stats", {
+                reviewId,
+                storeId,
+                count: storeStats.count,
+                avgRating: storeStats.avgRating,
+            });
+        }
+    }
+    catch (err) {
+        ctx.logger.error("Failed to update rating stats", err, { reviewId, productId, storeId });
+        throw err;
+    }
+};

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

@@ -0,0 +1,10 @@
+/**
+ * Trigger handler: stores/{id} onWrite — currently a no-op. The previous
+ * implementation synced an external search index that has since been removed.
+ * The handler stays so the binding remains canonical and can be reactivated
+ * without touching the consumer's functions/src/index.ts.
+ */
+import type { FirestoreTriggerHandler } from "../runtime/types";
+type StoreDoc = Record<string, unknown>;
+export declare const onStoreWriteHandler: FirestoreTriggerHandler<StoreDoc, StoreDoc>;
+export {};

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

@@ -0,0 +1,9 @@
+/**
+ * Trigger handler: stores/{id} onWrite — currently a no-op. The previous
+ * implementation synced an external search index that has since been removed.
+ * The handler stays so the binding remains canonical and can be reactivated
+ * without touching the consumer's functions/src/index.ts.
+ */
+export const onStoreWriteHandler = async () => {
+    // Intentionally empty — search provider removed; Firestore queries handle search now.
+};

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

@@ -0,0 +1,11 @@
+/**
+ * Job handler: dispatch pending payouts via Razorpay Payouts API.
+ *
+ * Reads RAZORPAY_KEY_ID / RAZORPAY_KEY_SECRET / RAZORPAY_ACCOUNT_NUMBER from
+ * env (via `ctx.env`). On 3rd consecutive failure the record is marked failed.
+ *
+ * Brand name in the narration is taken from `ctx.env("APP_BRAND_NAME")`
+ * (default empty) so appkit stays consumer-agnostic.
+ */
+import type { ScheduleHandler } from "../runtime/types";
+export declare const payoutBatchHandler: ScheduleHandler;