@mohasinac/appkit 2.6.1 → 2.6.2

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

@@ -33,3 +33,16 @@ export { onStoreWriteHandler } from "./onStoreWrite";
 export { adminAnalyticsHandler } from "./adminAnalytics";
 export { storeAnalyticsHandler, } from "./storeAnalytics";
 export { listingProcessorHandler, supportedListingCollections, } from "./listingProcessor";
+// SB1-L (S7-PrizeDraws) — 7 functions covering prize draws, bundle sync,
+// event raffles, and spin-the-wheel.
+export { prizeRevealOpenHandler } from "./prizeRevealOpen";
+export { prizeRevealCloseHandler } from "./prizeRevealClose";
+export { prizeRevealExpiryHandler } from "./prizeRevealExpiry";
+export { prizeRevealReminderHandler } from "./prizeRevealReminder";
+export { bundleStockSyncHandler } from "./bundleStockSync";
+// SB-UNI-V — Firestore onWrite trigger for product stock changes (recomputes
+// bundleStockStatus on categoryType:"bundle" rows + activeMemberCount on
+// groupedListings).
+export { onProductStockChangeHandler } from "./onProductStockChange";
+export { triggerEventRaffleHandler } from "./triggerEventRaffle";
+export { assignSpinPrizeHandler } from "./assignSpinPrize";

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

@@ -6,7 +6,7 @@
  * 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";
+import { bidRepository, blogRepository, categoriesRepository, couponsRepository, eventEntryRepository, eventRepository, faqsRepository, homepageSectionsRepository, notificationRepository, orderRepository, payoutRepository, productFeaturesRepository, productRepository, productTemplateRepository, reviewRepository, scammerRepository, storeRepository, userRepository, } from "../../../../repositories";
 const DEFAULT_SORT = "-createdAt";
 const DEFAULT_PAGE = 1;
 const DEFAULT_PAGE_SIZE = 20;
@@ -38,7 +38,12 @@ function getBoolOpt(baseOpts, key, fallback) {
 const LISTERS = {
     products: (m, o) => productRepository.list(m, o),
     categories: (m) => categoriesRepository.list(m),
-    brands: (m) => brandsRepository.list(m),
+    brands: (m) => categoriesRepository.list({
+        ...m,
+        filters: m.filters
+            ? `${m.filters},categoryType==brand`
+            : "categoryType==brand",
+    }),
     orders: (m) => orderRepository.listAll(m),
     reviews: (m) => reviewRepository.listAll(m),
     coupons: (m) => couponsRepository.list(m),
@@ -49,7 +54,12 @@ const LISTERS = {
     faqs: (m) => faqsRepository.list(m),
     notifications: (m) => notificationRepository.list(m),
     scammers: (m) => scammerRepository.listAll(m),
-    sublistingCategories: (m) => sublistingCategoriesRepository.list(m),
+    sublistingCategories: (m) => categoriesRepository.list({
+        ...m,
+        filters: m.filters
+            ? `${m.filters},categoryType==sublisting`
+            : "categoryType==sublisting",
+    }),
     productFeatures: (m) => productFeaturesRepository.list(m),
     homepageSections: (m) => homepageSectionsRepository.list(m),
     users: (m) => userRepository.list(m),

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

@@ -0,0 +1,17 @@
+/**
+ * onProductStockChange — SB-UNI-V Firestore onWrite trigger on products.
+ *
+ * Fires when any product document is created / updated / deleted. Looks
+ * up every bundle category (categoryType:"bundle") that lists the product
+ * in `bundleProductIds[]` and recomputes its `bundleStockStatus`. Also
+ * updates every grouped listing that lists the product in `productIds[]`
+ * — bumps `activeMemberCount` and `visibilityStatus`.
+ *
+ * Cheap: each affected bundle/group reads its `bundleProductIds.length`
+ * member products (≤16 typically). Skips entirely when the product's
+ * status didn't transition between "available" and "unavailable".
+ */
+import type { FirestoreTriggerHandler } from "../runtime/types";
+type ProductDoc = Record<string, unknown>;
+export declare const onProductStockChangeHandler: FirestoreTriggerHandler<ProductDoc, ProductDoc>;
+export {};

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

@@ -0,0 +1,136 @@
+/**
+ * onProductStockChange — SB-UNI-V Firestore onWrite trigger on products.
+ *
+ * Fires when any product document is created / updated / deleted. Looks
+ * up every bundle category (categoryType:"bundle") that lists the product
+ * in `bundleProductIds[]` and recomputes its `bundleStockStatus`. Also
+ * updates every grouped listing that lists the product in `productIds[]`
+ * — bumps `activeMemberCount` and `visibilityStatus`.
+ *
+ * Cheap: each affected bundle/group reads its `bundleProductIds.length`
+ * member products (≤16 typically). Skips entirely when the product's
+ * status didn't transition between "available" and "unavailable".
+ */
+const CATEGORIES_COLLECTION = "categories";
+const GROUPED_LISTINGS_COLLECTION = "groupedListings";
+const PRODUCT_COLLECTION = "products";
+const UNAVAILABLE_STATUSES = new Set(["sold", "out_of_stock", "discontinued"]);
+const MIN_ACTIVE_DEFAULT = 2;
+function isAvailable(status) {
+    if (!status)
+        return false;
+    return !UNAVAILABLE_STATUSES.has(status);
+}
+async function recomputeBundleStatus(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 (!isAvailable(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";
+}
+async function syncBundlesForProduct(productId, ctx) {
+    const snap = await ctx.db
+        .collection(CATEGORIES_COLLECTION)
+        .where("categoryType", "==", "bundle")
+        .where("bundleProductIds", "array-contains", productId)
+        .get();
+    let updated = 0;
+    for (const bundleDoc of snap.docs) {
+        const data = bundleDoc.data();
+        const ids = data.bundleProductIds ?? [];
+        const minActive = data.minActiveMembers ?? 1;
+        const next = await recomputeBundleStatus(ids, minActive, ctx);
+        if (next !== data.bundleStockStatus) {
+            await bundleDoc.ref.update({
+                bundleStockStatus: next,
+                bundleQueryResolvedAt: ctx.now,
+                updatedAt: ctx.now,
+            });
+            updated++;
+        }
+    }
+    return updated;
+}
+async function syncGroupedListingsForProduct(productId, ctx) {
+    const snap = await ctx.db
+        .collection(GROUPED_LISTINGS_COLLECTION)
+        .where("productIds", "array-contains", productId)
+        .get();
+    let updated = 0;
+    for (const groupDoc of snap.docs) {
+        const data = groupDoc.data();
+        const productIds = data.productIds ?? [];
+        if (productIds.length === 0)
+            continue;
+        const minActive = data.minActiveMembers ?? MIN_ACTIVE_DEFAULT;
+        let activeCount = 0;
+        for (let i = 0; i < productIds.length; i += 30) {
+            const chunk = productIds.slice(i, i + 30);
+            const productSnap = await ctx.db
+                .collection(PRODUCT_COLLECTION)
+                .where("__name__", "in", chunk)
+                .get();
+            for (const doc of productSnap.docs) {
+                const status = doc.data().status;
+                if (isAvailable(status))
+                    activeCount++;
+            }
+        }
+        const nextVisibility = activeCount >= minActive ? "visible" : "hidden";
+        if (activeCount !== data.activeMemberCount ||
+            nextVisibility !== data.visibilityStatus) {
+            await groupDoc.ref.update({
+                activeMemberCount: activeCount,
+                visibilityStatus: nextVisibility,
+                updatedAt: ctx.now,
+            });
+            updated++;
+        }
+    }
+    return updated;
+}
+export const onProductStockChangeHandler = async (event, ctx) => {
+    const productId = event.params.productId;
+    const before = event.before;
+    const after = event.after;
+    // Only react when the available/unavailable state actually flipped.
+    // Saves Firestore reads on routine writes (price edits, image updates, etc.).
+    const beforeAvailable = isAvailable(before?.status);
+    const afterAvailable = isAvailable(after?.status);
+    const isDelete = !after;
+    const stateFlipped = beforeAvailable !== afterAvailable;
+    if (!isDelete && !stateFlipped) {
+        return;
+    }
+    try {
+        const bundlesUpdated = await syncBundlesForProduct(productId, ctx);
+        const groupsUpdated = await syncGroupedListingsForProduct(productId, ctx);
+        ctx.logger.info("onProductStockChange synced", {
+            productId,
+            bundlesUpdated,
+            groupsUpdated,
+            isDelete,
+        });
+    }
+    catch (err) {
+        ctx.logger.error("onProductStockChange sync failed (non-fatal)", err, { productId });
+    }
+};

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

@@ -2,8 +2,21 @@
  * Trigger handler: keep category metrics + store stats in sync when a
  * product document is written. Only published products count.
  */
-import { categoriesRepository, storeRepository } from "../../../../repositories";
+// SB-UNI-V — bundlesRepository deleted; bundle stock-sync moves to the
+// dedicated `onProductStockChange` Firebase Function handler.
+import { categoriesRepository, storeRepository, } from "../../../../repositories";
 import { ProductStatusValues } from "../../../../features/products/schemas/firestore";
+const UNAVAILABLE_PRODUCT_STATUSES = new Set([
+    ProductStatusValues.SOLD,
+    ProductStatusValues.OUT_OF_STOCK,
+    ProductStatusValues.DISCONTINUED,
+]);
+// SB-UNI-V — `syncBundlesOnUnavailableTransition` deleted. The
+// `onProductStockChange` Firebase Function (registered separately) now
+// observes product writes and recomputes each bundle category's
+// `bundleStockStatus` via `partOfBundleCategoryIds[]` on the product.
+// UNAVAILABLE_PRODUCT_STATUSES retained — referenced by the function.
+void UNAVAILABLE_PRODUCT_STATUSES;
 async function getParentIds(categoryId) {
     if (!categoryId)
         return [];
@@ -89,4 +102,7 @@ export const onProductWriteHandler = async (event, ctx) => {
     catch (err) {
         ctx.logger.error("Counter update failed (non-fatal)", err, { productId });
     }
+    // SB-UNI-V — bundle stock-sync moved to onProductStockChange Function.
+    void before;
+    void after;
 };

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

@@ -0,0 +1,9 @@
+/**
+ * scheduledPrizeRevealClose — every 5 minutes.
+ *
+ * Flips `prizeRevealStatus` from "open" to "closed" on any prize-draw
+ * product whose `prizeRevealWindowEnd` has passed. Pair function to
+ * `prizeRevealOpen`. Orders past the deadline are handled by `prizeRevealExpiry`.
+ */
+import type { ScheduleHandler } from "../runtime/types";
+export declare const prizeRevealCloseHandler: ScheduleHandler;

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

@@ -0,0 +1,29 @@
+/**
+ * scheduledPrizeRevealClose — every 5 minutes.
+ *
+ * Flips `prizeRevealStatus` from "open" to "closed" on any prize-draw
+ * product whose `prizeRevealWindowEnd` has passed. Pair function to
+ * `prizeRevealOpen`. Orders past the deadline are handled by `prizeRevealExpiry`.
+ */
+const PRODUCT_COLLECTION = "products";
+export const prizeRevealCloseHandler = async (ctx) => {
+    ctx.logger.info("Prize reveal close sweep starting");
+    const snap = await ctx.db
+        .collection(PRODUCT_COLLECTION)
+        .where("listingType", "==", "prize-draw")
+        .where("prizeRevealStatus", "==", "open")
+        .where("prizeRevealWindowEnd", "<=", ctx.now)
+        .limit(100)
+        .get();
+    if (snap.empty) {
+        ctx.logger.info("No prize draws to close");
+        return;
+    }
+    const batch = ctx.db.batch();
+    snap.docs.forEach((doc) => batch.update(doc.ref, {
+        prizeRevealStatus: "closed",
+        updatedAt: ctx.now,
+    }));
+    await batch.commit();
+    ctx.logger.info("Closed prize draws", { count: snap.size });
+};

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

@@ -0,0 +1,10 @@
+/**
+ * scheduledPrizeRevealExpiry — every 6 hours (SB8-B).
+ *
+ * Finds paid prize-draw orders where `prizeRevealDeadline < now` AND
+ * `prizeWon` is unset. Marks them as REFUNDED + notifies the buyer. The
+ * actual Razorpay refund is queued — this handler only flips the order
+ * status so the buyer's allowance is freed up immediately.
+ */
+import type { ScheduleHandler } from "../runtime/types";
+export declare const prizeRevealExpiryHandler: ScheduleHandler;

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

@@ -0,0 +1,58 @@
+/**
+ * scheduledPrizeRevealExpiry — every 6 hours (SB8-B).
+ *
+ * Finds paid prize-draw orders where `prizeRevealDeadline < now` AND
+ * `prizeWon` is unset. Marks them as REFUNDED + notifies the buyer. The
+ * actual Razorpay refund is queued — this handler only flips the order
+ * status so the buyer's allowance is freed up immediately.
+ */
+import { notificationRepository } from "../../../../repositories";
+const ORDER_COLLECTION = "orders";
+export const prizeRevealExpiryHandler = async (ctx) => {
+    ctx.logger.info("Prize reveal expiry sweep starting");
+    const snap = await ctx.db
+        .collection(ORDER_COLLECTION)
+        .where("paymentStatus", "==", "paid")
+        .where("status", "in", ["pending", "confirmed", "processing"])
+        .where("prizeRevealDeadline", "<", ctx.now)
+        .limit(200)
+        .get();
+    if (snap.empty) {
+        ctx.logger.info("No prize-draw orders past deadline");
+        return;
+    }
+    let refunded = 0;
+    for (const doc of snap.docs) {
+        const order = doc.data();
+        if (order.prizeWon)
+            continue; // already revealed
+        if (!order.prizeDrawProductId)
+            continue; // not a prize-draw order
+        await doc.ref.update({
+            status: "refunded",
+            paymentStatus: "refunded",
+            isNonRefundable: false,
+            prizeRevealExpired: true,
+            updatedAt: ctx.now,
+        });
+        if (order.userId) {
+            try {
+                await notificationRepository.create({
+                    userId: order.userId,
+                    type: "prize_reveal_expired",
+                    priority: "high",
+                    title: "Reveal deadline passed — refunded",
+                    message: `Your entry for "${order.productTitle ?? "the draw"}" expired without a reveal. We've refunded the order.`,
+                    relatedId: doc.id,
+                    relatedType: "order",
+                    actionUrl: `/user/orders/view/${doc.id}`,
+                });
+            }
+            catch (err) {
+                ctx.logger.warn("Reveal-expired notification failed", { err });
+            }
+        }
+        refunded++;
+    }
+    ctx.logger.info("Prize reveal expiry sweep complete", { refunded });
+};

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

@@ -0,0 +1,10 @@
+/**
+ * scheduledPrizeRevealOpen — every 5 minutes.
+ *
+ * Flips `prizeRevealStatus` from "pending" to "open" on any prize-draw
+ * product whose `prizeRevealWindowStart` has passed. Then (SB8-D) emits an
+ * in-app notification to every buyer with an unrevealed paid order for that
+ * draw: "Your reveal is ready — X reveals waiting. Reveal by [deadline]."
+ */
+import type { ScheduleHandler } from "../runtime/types";
+export declare const prizeRevealOpenHandler: ScheduleHandler;

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

@@ -0,0 +1,65 @@
+/**
+ * scheduledPrizeRevealOpen — every 5 minutes.
+ *
+ * Flips `prizeRevealStatus` from "pending" to "open" on any prize-draw
+ * product whose `prizeRevealWindowStart` has passed. Then (SB8-D) emits an
+ * in-app notification to every buyer with an unrevealed paid order for that
+ * draw: "Your reveal is ready — X reveals waiting. Reveal by [deadline]."
+ */
+import { notificationRepository } from "../../../../repositories";
+const PRODUCT_COLLECTION = "products";
+const ORDER_COLLECTION = "orders";
+export const prizeRevealOpenHandler = async (ctx) => {
+    ctx.logger.info("Prize reveal open sweep starting");
+    const snap = await ctx.db
+        .collection(PRODUCT_COLLECTION)
+        .where("listingType", "==", "prize-draw")
+        .where("prizeRevealStatus", "==", "pending")
+        .where("prizeRevealWindowStart", "<=", ctx.now)
+        .limit(100)
+        .get();
+    if (snap.empty) {
+        ctx.logger.info("No prize draws to open");
+        return;
+    }
+    for (const doc of snap.docs) {
+        const product = doc.data();
+        await doc.ref.update({
+            prizeRevealStatus: "open",
+            updatedAt: ctx.now,
+        });
+        // SB8-D — notify buyers with paid unrevealed orders.
+        const orders = await ctx.db
+            .collection(ORDER_COLLECTION)
+            .where("prizeDrawProductId", "==", doc.id)
+            .where("paymentStatus", "==", "paid")
+            .where("status", "in", ["pending", "confirmed", "processing"])
+            .get();
+        let notified = 0;
+        for (const orderDoc of orders.docs) {
+            const order = orderDoc.data();
+            if (!order.userId || order.prizeWon)
+                continue;
+            try {
+                await notificationRepository.create({
+                    userId: order.userId,
+                    type: "prize_reveal_ready",
+                    priority: "high",
+                    title: "Your reveal is ready!",
+                    message: `Reveal your prize for "${product.title ?? "draw"}". You have ${product.prizeRevealDeadlineDays ?? 3} days to claim it.`,
+                    relatedId: orderDoc.id,
+                    relatedType: "order",
+                    actionUrl: `/user/orders/view/${orderDoc.id}`,
+                });
+                notified++;
+            }
+            catch (err) {
+                ctx.logger.warn("Reveal-ready notification failed", { err });
+            }
+        }
+        ctx.logger.info("Opened prize draw", {
+            productId: doc.id,
+            buyersNotified: notified,
+        });
+    }
+};

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

@@ -0,0 +1,9 @@
+/**
+ * scheduledPrizeRevealReminder — daily 10am IST (SB8-E).
+ *
+ * Notifies users whose prize-draw reveals expire in the next 24 hours and
+ * haven't been claimed yet. Triggered once a day so users get exactly one
+ * nudge before the auto-refund kicks in.
+ */
+import type { ScheduleHandler } from "../runtime/types";
+export declare const prizeRevealReminderHandler: ScheduleHandler;

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

@@ -0,0 +1,45 @@
+/**
+ * scheduledPrizeRevealReminder — daily 10am IST (SB8-E).
+ *
+ * Notifies users whose prize-draw reveals expire in the next 24 hours and
+ * haven't been claimed yet. Triggered once a day so users get exactly one
+ * nudge before the auto-refund kicks in.
+ */
+import { notificationRepository } from "../../../../repositories";
+const ORDER_COLLECTION = "orders";
+const ONE_DAY_MS = 86400000;
+export const prizeRevealReminderHandler = async (ctx) => {
+    ctx.logger.info("Prize reveal reminder sweep starting");
+    const cutoff = new Date(ctx.now.getTime() + ONE_DAY_MS);
+    const snap = await ctx.db
+        .collection(ORDER_COLLECTION)
+        .where("paymentStatus", "==", "paid")
+        .where("status", "in", ["pending", "confirmed", "processing"])
+        .where("prizeRevealDeadline", "<=", cutoff)
+        .where("prizeRevealDeadline", ">", ctx.now)
+        .limit(500)
+        .get();
+    let notified = 0;
+    for (const doc of snap.docs) {
+        const order = doc.data();
+        if (!order.userId || order.prizeWon || !order.prizeDrawProductId)
+            continue;
+        try {
+            await notificationRepository.create({
+                userId: order.userId,
+                type: "prize_reveal_reminder",
+                priority: "normal",
+                title: "Reveal expires within 24h",
+                message: `Reveal your prize for "${order.productTitle ?? "the draw"}" today — unclaimed reveals are auto-refunded after the deadline.`,
+                relatedId: doc.id,
+                relatedType: "order",
+                actionUrl: `/user/orders/view/${doc.id}`,
+            });
+            notified++;
+        }
+        catch (err) {
+            ctx.logger.warn("Reveal reminder notification failed", { err });
+        }
+    }
+    ctx.logger.info("Prize reveal reminder sweep complete", { notified });
+};

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

@@ -0,0 +1,30 @@
+/**
+ * triggerEventRaffle — HTTP callable (SB9-D).
+ *
+ * Selects a raffle winner for an event using `crypto.randomInt()`. Pool logic
+ * keys off the event's `raffleType`:
+ *   - "top_n_scorers"      → sort entries by `points DESC` take top N
+ *   - "top_n_participants" → sort entries by `createdAt ASC` take first N
+ *   - "open_raffle"        → all CONFIRMED entries are eligible
+ *
+ * On success the function stamps the winner fields onto the event doc and
+ * sets the GitHub permalink for proof-of-fairness.
+ */
+import type { CallableHandler } from "../runtime/types";
+interface TriggerEventRaffleInput {
+    eventId: string;
+    /** Optional override; otherwise read from event.raffleType. */
+    raffleType?: "top_n_scorers" | "top_n_participants" | "open_raffle";
+    /** Optional N override; otherwise read from event.raffleTopN. */
+    topN?: number;
+}
+interface TriggerEventRaffleResult {
+    eventId: string;
+    raffleWinnerUserId?: string;
+    raffleWinnerDisplayName?: string;
+    raffleEntryCount: number;
+    alreadyTriggered?: boolean;
+    reason?: string;
+}
+export declare const triggerEventRaffleHandler: CallableHandler<TriggerEventRaffleInput, TriggerEventRaffleResult>;
+export {};

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

@@ -0,0 +1,94 @@
+/**
+ * triggerEventRaffle — HTTP callable (SB9-D).
+ *
+ * Selects a raffle winner for an event using `crypto.randomInt()`. Pool logic
+ * keys off the event's `raffleType`:
+ *   - "top_n_scorers"      → sort entries by `points DESC` take top N
+ *   - "top_n_participants" → sort entries by `createdAt ASC` take first N
+ *   - "open_raffle"        → all CONFIRMED entries are eligible
+ *
+ * On success the function stamps the winner fields onto the event doc and
+ * sets the GitHub permalink for proof-of-fairness.
+ */
+import crypto from "node:crypto";
+const EVENTS_COLLECTION = "events";
+const EVENT_ENTRIES_COLLECTION = "eventEntries";
+export const triggerEventRaffleHandler = async (input, ctx) => {
+    const eventRef = ctx.db.collection(EVENTS_COLLECTION).doc(input.eventId);
+    const eventSnap = await eventRef.get();
+    if (!eventSnap.exists) {
+        return {
+            eventId: input.eventId,
+            raffleEntryCount: 0,
+            reason: "event_not_found",
+        };
+    }
+    const event = eventSnap.data();
+    if (event.raffleWinnerUserId) {
+        return {
+            eventId: input.eventId,
+            raffleEntryCount: 0,
+            alreadyTriggered: true,
+            raffleWinnerUserId: event.raffleWinnerUserId,
+        };
+    }
+    const raffleType = input.raffleType ?? event.raffleType ?? "open_raffle";
+    const topN = input.topN ?? event.raffleTopN ?? 0;
+    const entriesSnap = await ctx.db
+        .collection(EVENT_ENTRIES_COLLECTION)
+        .where("eventId", "==", input.eventId)
+        .where("status", "==", "CONFIRMED")
+        .get();
+    let pool = entriesSnap.docs.map((d) => ({
+        id: d.id,
+        data: d.data(),
+    }));
+    if (raffleType === "top_n_scorers" && topN > 0) {
+        pool = pool
+            .sort((a, b) => (b.data.points ?? 0) - (a.data.points ?? 0))
+            .slice(0, topN);
+    }
+    else if (raffleType === "top_n_participants" && topN > 0) {
+        pool = pool
+            .sort((a, b) => {
+            const aT = a.data.createdAt instanceof Date
+                ? a.data.createdAt.getTime()
+                : (a.data.createdAt?.toDate?.()?.getTime() ?? 0);
+            const bT = b.data.createdAt instanceof Date
+                ? b.data.createdAt.getTime()
+                : (b.data.createdAt?.toDate?.()?.getTime() ?? 0);
+            return aT - bT;
+        })
+            .slice(0, topN);
+    }
+    if (pool.length === 0) {
+        return {
+            eventId: input.eventId,
+            raffleEntryCount: 0,
+            reason: "no_eligible_entries",
+        };
+    }
+    const winnerIdx = crypto.randomInt(0, pool.length);
+    const winner = pool[winnerIdx];
+    await eventRef.update({
+        raffleWinnerUserId: winner.data.userId,
+        raffleWinnerDisplayName: winner.data.userDisplayName ?? "",
+        raffleWinnerEntryId: winner.id,
+        raffleTriggeredAt: ctx.now,
+        raffleEntryCount: entriesSnap.size,
+        raffleGithubFunctionUrl: `${ctx.env("PROOF_OF_FAIRNESS_BASE_URL") ?? ""}/raffles/${input.eventId}.json`,
+        updatedAt: ctx.now,
+    });
+    ctx.logger.info("Event raffle triggered", {
+        eventId: input.eventId,
+        raffleType,
+        poolSize: pool.length,
+        winnerId: winner.id,
+    });
+    return {
+        eventId: input.eventId,
+        raffleWinnerUserId: winner.data.userId,
+        raffleWinnerDisplayName: winner.data.userDisplayName,
+        raffleEntryCount: entriesSnap.size,
+    };
+};

package/dist/_internal/shared/features/brands/schema.d.ts

@@ -28,10 +28,10 @@ export declare const brandInputSchema: z.ZodObject<{
     isActive?: boolean | undefined;
     description?: string | undefined;
     website?: string | undefined;
+    displayOrder?: number | undefined;
     logoURL?: string | undefined;
     bannerURL?: string | undefined;
     founded?: number | undefined;
-    displayOrder?: number | undefined;
 }>;
 export declare const brandUpdateSchema: z.ZodObject<Omit<{
     name: z.ZodOptional<z.ZodString>;
@@ -50,20 +50,20 @@ export declare const brandUpdateSchema: z.ZodObject<Omit<{
     isActive?: boolean | undefined;
     description?: string | undefined;
     website?: string | undefined;
+    displayOrder?: number | undefined;
     logoURL?: string | undefined;
     bannerURL?: string | undefined;
     founded?: number | undefined;
-    displayOrder?: number | undefined;
 }, {
     country?: string | undefined;
     name?: string | undefined;
     isActive?: boolean | undefined;
     description?: string | undefined;
     website?: string | undefined;
+    displayOrder?: number | undefined;
     logoURL?: string | undefined;
     bannerURL?: string | undefined;
     founded?: number | undefined;
-    displayOrder?: number | undefined;
 }>;
 export type BrandInput = z.infer<typeof brandInputSchema>;
 export type BrandUpdate = z.infer<typeof brandUpdateSchema>;