@mohasinac/appkit 3.0.4 → 3.1.0

package/dist/_internal/server/features/digital-code/adapters.d.ts

@@ -1,21 +1,8 @@
 import type { ProductDocument, ProductDigitalCodeMeta } from "../../../../features/products/schemas/firestore";
-export interface DigitalCodeClientShape {
-    id: string;
-    title: string;
-    description: string;
-    price: number;
-    priceLabel: string;
-    currency: string;
-    mainImage: string | null;
-    images: string[];
-    storeId: string;
-    storeName: string | null;
-    category: string;
-    tags: string[];
+import { type BaseListingClientShape } from "../shared/listing-adapters";
+export interface DigitalCodeClientShape extends BaseListingClientShape {
     /** Delivery method and redemption instructions — codesAvailable intentionally omitted (operational). */
     digitalCode: Pick<ProductDigitalCodeMeta, "codeDeliveryMethod" | "redemptionInstructions"> | null;
-    status: ProductDocument["status"];
-    createdAt: string;
 }
 /** Maps a raw `ProductDocument` to the client-safe digital-code shape. Strips codesAvailable/codePoolSize (operational counters). */
 export declare function toClientDigitalCode(doc: ProductDocument): DigitalCodeClientShape;

package/dist/_internal/server/features/digital-code/adapters.js

@@ -1,29 +1,14 @@
-import { formatCurrency } from "../../../../utils/number.formatter";
+import { mapBaseListingFields } from "../shared/listing-adapters";
 /** Maps a raw `ProductDocument` to the client-safe digital-code shape. Strips codesAvailable/codePoolSize (operational counters). */
 export function toClientDigitalCode(doc) {
     const dc = doc.digitalCode ?? null;
     return {
-        id: doc.id,
-        title: doc.title,
-        description: doc.description,
-        price: doc.price,
-        priceLabel: formatCurrency(doc.price, doc.currency ?? "INR"),
-        currency: doc.currency ?? "INR",
-        mainImage: doc.mainImage || doc.images?.[0] || null,
-        images: doc.images ?? [],
-        storeId: doc.storeId,
-        storeName: doc.storeName ?? null,
-        category: doc.categorySlugs?.[0] ?? doc.category ?? "",
-        tags: doc.tags ?? [],
+        ...mapBaseListingFields(doc),
         digitalCode: dc
             ? {
                 codeDeliveryMethod: dc.codeDeliveryMethod,
                 redemptionInstructions: dc.redemptionInstructions,
             }
             : null,
-        status: doc.status,
-        createdAt: doc.createdAt instanceof Date
-            ? doc.createdAt.toISOString()
-            : String(doc.createdAt),
     };
 }

package/dist/_internal/server/features/digital-code/data.d.ts

@@ -1,6 +1 @@
-import type { ProductDocument } from "../../../../features/products/schemas/firestore";
-export interface DigitalCodeDataOptions {
-    _reserved?: never;
-}
-/** Fetch a single digital-code listing by slug, deduped per RSC render. */
-export declare const getDigitalCodeForDetail: (slug: string, _opts?: DigitalCodeDataOptions) => Promise<ProductDocument | null>;
+export declare const getDigitalCodeForDetail: (slugOrId: string) => Promise<import("../../../..").ProductDocument | null>;

package/dist/_internal/server/features/digital-code/data.js

@@ -1,10 +1,2 @@
-import { cache } from "react";
-import { productRepository } from "../../../../repositories";
-/** Fetch a single digital-code listing by slug, deduped per RSC render. */
-export const getDigitalCodeForDetail = cache(async (slug, _opts) => {
-    void _opts;
-    const product = await productRepository.findByIdOrSlug(slug).catch(() => undefined);
-    if (!product || product.listingType !== "digital-code")
-        return null;
-    return product;
-});
+import { makeGetListingForDetail } from "../shared/listing-data-factory";
+export const getDigitalCodeForDetail = makeGetListingForDetail("digital-code");

package/dist/_internal/server/features/live/adapters.d.ts

@@ -1,21 +1,8 @@
 import type { ProductDocument, ProductLiveItemMeta } from "../../../../features/products/schemas/firestore";
-export interface LiveItemClientShape {
-    id: string;
-    title: string;
-    description: string;
-    price: number;
-    priceLabel: string;
-    currency: string;
-    mainImage: string | null;
-    images: string[];
-    storeId: string;
-    storeName: string | null;
-    category: string;
-    tags: string[];
+import { type BaseListingClientShape } from "../shared/listing-adapters";
+export interface LiveItemClientShape extends BaseListingClientShape {
     /** Live-item meta — vendorVerified is intentionally omitted (admin-only). */
     liveItem: Omit<ProductLiveItemMeta, "vendorVerified"> | null;
-    status: ProductDocument["status"];
-    createdAt: string;
 }
 /** Maps a raw `ProductDocument` to the client-safe live-item shape. Strips vendorVerified (admin-only). */
 export declare function toClientLiveItem(doc: ProductDocument): LiveItemClientShape;

package/dist/_internal/server/features/live/adapters.js

@@ -1,20 +1,9 @@
-import { formatCurrency } from "../../../../utils/number.formatter";
+import { mapBaseListingFields } from "../shared/listing-adapters";
 /** Maps a raw `ProductDocument` to the client-safe live-item shape. Strips vendorVerified (admin-only). */
 export function toClientLiveItem(doc) {
     const li = doc.liveItem ?? null;
     return {
-        id: doc.id,
-        title: doc.title,
-        description: doc.description,
-        price: doc.price,
-        priceLabel: formatCurrency(doc.price, doc.currency ?? "INR"),
-        currency: doc.currency ?? "INR",
-        mainImage: doc.mainImage || doc.images?.[0] || null,
-        images: doc.images ?? [],
-        storeId: doc.storeId,
-        storeName: doc.storeName ?? null,
-        category: doc.categorySlugs?.[0] ?? doc.category ?? "",
-        tags: doc.tags ?? [],
+        ...mapBaseListingFields(doc),
         liveItem: li
             ? {
                 species: li.species,
@@ -26,9 +15,5 @@ export function toClientLiveItem(doc) {
                 cites: li.cites,
             }
             : null,
-        status: doc.status,
-        createdAt: doc.createdAt instanceof Date
-            ? doc.createdAt.toISOString()
-            : String(doc.createdAt),
     };
 }

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

@@ -1,6 +1 @@
-import type { ProductDocument } from "../../../../features/products/schemas/firestore";
-export interface LiveDataOptions {
-    _reserved?: never;
-}
-/** Fetch a single live-item listing by slug, deduped per RSC render. */
-export declare const getLiveItemForDetail: (slug: string, _opts?: LiveDataOptions) => Promise<ProductDocument | null>;
+export declare const getLiveItemForDetail: (slugOrId: string) => Promise<import("../../../..").ProductDocument | null>;

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

@@ -1,10 +1,2 @@
-import { cache } from "react";
-import { productRepository } from "../../../../repositories";
-/** Fetch a single live-item listing by slug, deduped per RSC render. */
-export const getLiveItemForDetail = cache(async (slug, _opts) => {
-    void _opts;
-    const product = await productRepository.findByIdOrSlug(slug).catch(() => undefined);
-    if (!product || product.listingType !== "live")
-        return null;
-    return product;
-});
+import { makeGetListingForDetail } from "../shared/listing-data-factory";
+export const getLiveItemForDetail = makeGetListingForDetail("live");

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

@@ -0,0 +1,43 @@
+import { type ActionResult } from "@mohasinac/appkit/server";
+import type { LotteryConfig } from "../../../../features/lottery/types";
+import type { LotteryEntryDocument } from "../../../../features/lottery/schemas/firestore";
+/**
+ * User-initiated lottery pull.
+ * Atomically:
+ * 1. Validates inputs + limits
+ * 2. Runs weighted slot selection on unclaimed slots
+ * 3. Marks the slot as booked
+ * 4. Creates the LotteryEntryDocument with assignedPrizeSlotNumber set
+ *
+ * Returns the assigned slot number so the user sees their prize immediately.
+ */
+export declare function submitLotteryPullAction(input: unknown): Promise<ActionResult<{
+    userLotteryNumber: number;
+    assignedPrizeSlotNumber: number;
+    slotName: string;
+}>>;
+/**
+ * Admin — flag a lottery entry as fraudulent.
+ * Slot stays booked; use reopenLotterySlotAction to free it.
+ */
+export declare function flagLotteryEntryAction(input: unknown): Promise<ActionResult<LotteryEntryDocument>>;
+/**
+ * Admin — reopen a slot from a flagged entry.
+ * Clears isBooked on the slot so it can be claimed in a future pull.
+ */
+export declare function reopenLotterySlotAction(input: unknown): Promise<ActionResult<void>>;
+/**
+ * Admin — create a new lottery event.
+ * Weights computed server-side; never returned to client.
+ */
+export declare function createLotteryEventAction(data: unknown): Promise<ActionResult<unknown>>;
+/**
+ * Admin — update a lottery event.
+ * Recomputes slot weights after update.
+ */
+export declare function updateLotteryEventAction(id: string, data: unknown): Promise<ActionResult<unknown>>;
+/**
+ * Store owner or Admin — switch a prize-draw product into lottery mode.
+ * Store owners provide prizeSlotPrice but weight is NEVER returned to them.
+ */
+export declare function setProductLotteryModeAction(productId: string, lotteryConfig: LotteryConfig): Promise<ActionResult<void>>;

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

@@ -0,0 +1,243 @@
+"use server";
+import { wrapAction } from "@mohasinac/appkit/server";
+import { getAdminDb } from "../../../../providers/db-firebase";
+import { eventRepository } from "../../../../repositories";
+import { lotteryEntryRepository } from "../../../../features/lottery/repository/lottery-entry.repository";
+import { requireRoleUser } from "../../../../providers/auth-firebase/helpers";
+import { ValidationError } from "../../../shared/errors/index";
+import { submitLotteryPullSchema, flagLotteryEntrySchema, reopenLotterySlotSchema, } from "../../../../features/lottery/schemas/zod";
+import { LotteryError, assignSlotWeights, pickWeightedSlot, } from "../../../../features/lottery/types";
+import { LOTTERY_ENTRIES_COLLECTION } from "../../../../features/lottery/schemas/firestore";
+// ── Helpers ──────────────────────────────────────────────────────────────────
+function isDrawWindowOpen(config) {
+    // Draw window is implicitly open when there are unclaimed slots.
+    // A real implementation would also check if the event status is "active".
+    return config.slots.some((s) => !s.isBooked);
+}
+// ── Public actions ────────────────────────────────────────────────────────────
+/**
+ * User-initiated lottery pull.
+ * Atomically:
+ * 1. Validates inputs + limits
+ * 2. Runs weighted slot selection on unclaimed slots
+ * 3. Marks the slot as booked
+ * 4. Creates the LotteryEntryDocument with assignedPrizeSlotNumber set
+ *
+ * Returns the assigned slot number so the user sees their prize immediately.
+ */
+export async function submitLotteryPullAction(input) {
+    return wrapAction(async () => {
+        // Auth — must be logged in
+        const user = await requireRoleUser(["buyer", "seller", "admin", "moderator", "employee"]);
+        const parsed = submitLotteryPullSchema.safeParse(input);
+        if (!parsed.success) {
+            throw new ValidationError(parsed.error.issues[0]?.message ?? "Invalid lottery pull input");
+        }
+        const data = parsed.data;
+        const sourceId = data.sourceType === "event" ? data.eventId : data.productId;
+        const sourceField = data.sourceType === "event" ? "eventId" : "productId";
+        // Load the event/product to get the lotteryConfig
+        let lotteryConfig;
+        if (data.sourceType === "event") {
+            const event = await eventRepository.findById(sourceId).catch(() => null);
+            if (!event || event.type !== "lottery") {
+                throw new LotteryError("LOTTERY_WINDOW_CLOSED", "Lottery event not found or not of type lottery.");
+            }
+            if (event.status !== "active") {
+                throw new LotteryError("LOTTERY_WINDOW_CLOSED", "This lottery is not currently active.");
+            }
+            if (!event.lotteryConfig) {
+                throw new LotteryError("LOTTERY_WINDOW_CLOSED", "Lottery config not found on event.");
+            }
+            lotteryConfig = event.lotteryConfig;
+        }
+        else {
+            // Product lottery — load via product repository (not implemented here; caller ensures correct source)
+            throw new ValidationError("Product lottery pull must go through the product lottery pull route.");
+        }
+        // Compute weights
+        const weightedSlots = assignSlotWeights(lotteryConfig);
+        // Check draw window
+        if (!isDrawWindowOpen(lotteryConfig)) {
+            throw new LotteryError("LOTTERY_FULL", "All slots have been claimed.");
+        }
+        // Enforce maxPullsPerUser
+        const existingUserPulls = await lotteryEntryRepository.countByUser(sourceId, sourceField, user.uid);
+        if (existingUserPulls >= lotteryConfig.maxPullsPerUser) {
+            throw new LotteryError("USER_LIMIT_REACHED", "You have reached the maximum number of pulls for this lottery.");
+        }
+        // Enforce maxPullsPerTransaction
+        const existingTxPulls = await lotteryEntryRepository.countByTransactionId(sourceId, sourceField, data.transactionId);
+        if (existingTxPulls >= lotteryConfig.maxPullsPerTransaction) {
+            throw new LotteryError("TX_ALREADY_USED", "This transaction ID has already been used the maximum number of times.");
+        }
+        // Atomically: pick slot + create entry + mark slot booked
+        const db = getAdminDb();
+        const sourceDocRef = db.collection("events").doc(sourceId);
+        const { assignedSlot, userLotteryNumber } = await db.runTransaction(async (tx) => {
+            // Re-read lotteryConfig inside transaction for freshness
+            const sourceSnap = await tx.get(sourceDocRef);
+            if (!sourceSnap.exists)
+                throw new LotteryError("LOTTERY_WINDOW_CLOSED", "Lottery source not found.");
+            const freshConfig = sourceSnap.data().lotteryConfig;
+            if (!freshConfig)
+                throw new LotteryError("LOTTERY_WINDOW_CLOSED", "Lottery config missing.");
+            const freshWeighted = assignSlotWeights(freshConfig);
+            const unclaimed = freshWeighted.filter((s) => !s.isBooked);
+            if (unclaimed.length === 0)
+                throw new LotteryError("LOTTERY_FULL", "All slots have been claimed.");
+            // Weighted pick
+            const chosen = pickWeightedSlot(unclaimed);
+            // Compute next userLotteryNumber (count + 1 inside tx via collection size)
+            const countSnap = await db
+                .collection(LOTTERY_ENTRIES_COLLECTION)
+                .where(sourceField, "==", sourceId)
+                .get();
+            const nextNumber = countSnap.size + 1;
+            // Mark slot booked in the source document
+            const updatedSlots = freshConfig.slots.map((s) => s.slotNumber === chosen.slotNumber
+                ? {
+                    ...s,
+                    isBooked: true,
+                    bookedByUserId: user.uid,
+                    bookedByDisplayName: user.displayName ?? user.name ?? undefined,
+                    bookedByUserLotteryNumber: nextNumber,
+                }
+                : s);
+            tx.update(sourceDocRef, {
+                "lotteryConfig.slots": updatedSlots,
+            });
+            return { assignedSlot: chosen, userLotteryNumber: nextNumber };
+        });
+        // Create the entry document outside the transaction (acceptable — slot is already booked)
+        const entryData = {
+            sourceType: data.sourceType,
+            ...(data.sourceType === "event" ? { eventId: sourceId } : { productId: sourceId }),
+            userId: user.uid,
+            userDisplayName: user.displayName ?? user.name ?? undefined,
+            userEmail: user.email ?? undefined,
+            userPhone: data.userPhone,
+            transactionId: data.transactionId,
+            paymentTime: new Date(data.paymentTime),
+            purchasedItemNumber: data.purchasedItemNumber,
+            userLotteryNumber,
+            assignedPrizeSlotNumber: assignedSlot.slotNumber,
+            status: "drawn",
+            isFlagged: false,
+            submittedAt: new Date(),
+            drawnAt: new Date(),
+        };
+        await lotteryEntryRepository.createEntry(entryData);
+        return {
+            userLotteryNumber,
+            assignedPrizeSlotNumber: assignedSlot.slotNumber,
+            slotName: assignedSlot.name,
+        };
+    });
+}
+/**
+ * Admin — flag a lottery entry as fraudulent.
+ * Slot stays booked; use reopenLotterySlotAction to free it.
+ */
+export async function flagLotteryEntryAction(input) {
+    return wrapAction(async () => {
+        await requireRoleUser(["admin", "moderator"]);
+        const parsed = flagLotteryEntrySchema.safeParse(input);
+        if (!parsed.success) {
+            throw new ValidationError(parsed.error.issues[0]?.message ?? "Invalid flag input");
+        }
+        return lotteryEntryRepository.flagEntry(parsed.data.entryId, parsed.data.flagNote, parsed.data.flaggedByUserId);
+    });
+}
+/**
+ * Admin — reopen a slot from a flagged entry.
+ * Clears isBooked on the slot so it can be claimed in a future pull.
+ */
+export async function reopenLotterySlotAction(input) {
+    return wrapAction(async () => {
+        await requireRoleUser(["admin"]);
+        const parsed = reopenLotterySlotSchema.safeParse(input);
+        if (!parsed.success) {
+            throw new ValidationError(parsed.error.issues[0]?.message ?? "Invalid reopen input");
+        }
+        const { sourceType, sourceId, slotNumber } = parsed.data;
+        const db = getAdminDb();
+        const collectionName = sourceType === "event" ? "events" : "products";
+        const docRef = db.collection(collectionName).doc(sourceId);
+        await db.runTransaction(async (tx) => {
+            const snap = await tx.get(docRef);
+            if (!snap.exists)
+                throw new ValidationError("Source document not found.");
+            const config = snap.data().lotteryConfig;
+            if (!config?.slots)
+                throw new ValidationError("Lottery config not found.");
+            const updatedSlots = config.slots.map((s) => s.slotNumber === slotNumber
+                ? {
+                    ...s,
+                    isBooked: false,
+                    bookedByUserId: null,
+                    bookedByDisplayName: null,
+                    bookedByUserLotteryNumber: null,
+                }
+                : s);
+            tx.update(docRef, { "lotteryConfig.slots": updatedSlots });
+        });
+    });
+}
+/**
+ * Admin — create a new lottery event.
+ * Weights computed server-side; never returned to client.
+ */
+export async function createLotteryEventAction(data) {
+    return wrapAction(async () => {
+        const user = await requireRoleUser(["admin", "moderator"]);
+        const rawData = data;
+        const lotteryConfig = rawData.lotteryConfig;
+        if (!lotteryConfig)
+            throw new ValidationError("lotteryConfig is required for lottery events.");
+        // Compute weights server-side
+        const withWeights = assignSlotWeights(lotteryConfig);
+        return eventRepository.createEvent({
+            ...rawData,
+            type: "lottery",
+            lotteryConfig: { ...lotteryConfig, slots: withWeights },
+            createdBy: user.uid,
+            status: rawData.status ?? "draft",
+            stats: { totalEntries: 0, approvedEntries: 0, flaggedEntries: 0 },
+        });
+    });
+}
+/**
+ * Admin — update a lottery event.
+ * Recomputes slot weights after update.
+ */
+export async function updateLotteryEventAction(id, data) {
+    return wrapAction(async () => {
+        await requireRoleUser(["admin", "moderator"]);
+        const rawData = data;
+        const lotteryConfig = rawData.lotteryConfig;
+        if (lotteryConfig) {
+            const withWeights = assignSlotWeights(lotteryConfig);
+            return eventRepository.updateEvent(id, {
+                ...rawData,
+                lotteryConfig: { ...lotteryConfig, slots: withWeights },
+            });
+        }
+        return eventRepository.updateEvent(id, rawData);
+    });
+}
+/**
+ * Store owner or Admin — switch a prize-draw product into lottery mode.
+ * Store owners provide prizeSlotPrice but weight is NEVER returned to them.
+ */
+export async function setProductLotteryModeAction(productId, lotteryConfig) {
+    return wrapAction(async () => {
+        await requireRoleUser(["admin", "moderator", "seller"]);
+        const withWeights = assignSlotWeights(lotteryConfig);
+        const db = getAdminDb();
+        await db.collection("products").doc(productId).update({
+            prizeDrawMode: "lottery",
+            lotteryConfig: { ...lotteryConfig, slots: withWeights },
+        });
+    });
+}

package/dist/_internal/server/features/lottery/adapters.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Lottery adapters — strips server-only fields (priceInPaise, weight)
+ * before any slot/config data leaves the server.
+ */
+import type { LotteryConfig, LotterySlot, ClientLotteryConfig, ClientLotterySlot } from "../../../../features/lottery/types";
+/** Strip priceInPaise and weight from a single slot for client consumption. */
+export declare function toClientLotterySlot(slot: LotterySlot): ClientLotterySlot;
+/** Strip price/weight from the entire config for client consumption. */
+export declare function toClientLotteryConfig(config: LotteryConfig): ClientLotteryConfig;

package/dist/_internal/server/features/lottery/adapters.js

@@ -0,0 +1,21 @@
+/** Strip priceInPaise and weight from a single slot for client consumption. */
+export function toClientLotterySlot(slot) {
+    return {
+        slotNumber: slot.slotNumber,
+        name: slot.name,
+        isBooked: slot.isBooked,
+        bookedByUserLotteryNumber: slot.bookedByUserLotteryNumber,
+        bookedByDisplayName: slot.bookedByDisplayName,
+    };
+}
+/** Strip price/weight from the entire config for client consumption. */
+export function toClientLotteryConfig(config) {
+    return {
+        slots: config.slots.map(toClientLotterySlot),
+        totalSlots: config.totalSlots,
+        pricingMode: config.pricingMode,
+        drawWindowDurationMinutes: config.drawWindowDurationMinutes,
+        maxPullsPerTransaction: config.maxPullsPerTransaction,
+        maxPullsPerUser: config.maxPullsPerUser,
+    };
+}

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

@@ -0,0 +1,20 @@
+import type { SieveModel } from "../../../../providers/db-firebase";
+import type { EventDocument } from "../../../../features/events/schemas/firestore";
+import type { LotteryEntryDocument } from "../../../../features/lottery/schemas/firestore";
+import type { ClientLotteryConfig } from "../../../../features/lottery/types";
+/** Event shape with lottery config stripped of price/weight. */
+export type LotteryEventClient = Omit<EventDocument, "lotteryConfig"> & {
+    lotteryConfig?: ClientLotteryConfig;
+};
+/** Fetch a lottery-type event with price/weight stripped for client use. */
+export declare const getLotteryEventCached: (id: string) => Promise<LotteryEventClient | null>;
+/** List all lottery-type events with price/weight stripped. */
+export declare const listLotteryEvents: (opts?: {
+    status?: string;
+    page?: number;
+    pageSize?: number;
+}) => Promise<LotteryEventClient[]>;
+/** Fetch lottery entries for admin view (includes phone + txId via PII decrypt). */
+export declare function getLotteryEntriesForAdmin(sourceType: "event" | "product", sourceId: string, model: SieveModel): Promise<import("../../../..").FirebaseSieveResult<LotteryEntryDocument>>;
+/** Fetch lottery entries for a specific user (own entries only). */
+export declare function getLotteryEntriesForUser(userId: string, model: SieveModel): Promise<import("../../../..").FirebaseSieveResult<LotteryEntryDocument>>;

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

@@ -0,0 +1,41 @@
+import { cache } from "react";
+import { eventRepository } from "../../../../repositories";
+import { lotteryEntryRepository } from "../../../../features/lottery/repository/lottery-entry.repository";
+import { toClientLotteryConfig } from "./adapters";
+/** Fetch a lottery-type event with price/weight stripped for client use. */
+export const getLotteryEventCached = cache(async (id) => {
+    const event = await eventRepository.findById(id).catch(() => null);
+    if (!event || event.type !== "lottery")
+        return null;
+    return {
+        ...event,
+        lotteryConfig: event.lotteryConfig ? toClientLotteryConfig(event.lotteryConfig) : undefined,
+    };
+});
+/** List all lottery-type events with price/weight stripped. */
+export const listLotteryEvents = cache(async (opts) => {
+    // Build Sieve filter: type==lottery, optionally also status
+    let filters = "type==lottery";
+    if (opts?.status)
+        filters += `,status==${opts.status}`;
+    const result = await eventRepository.list({
+        filters,
+        sorts: "-startsAt",
+        page: opts?.page ?? 1,
+        pageSize: opts?.pageSize ?? 50,
+    });
+    const items = result.items ?? [];
+    return items.map((event) => ({
+        ...event,
+        lotteryConfig: event.lotteryConfig ? toClientLotteryConfig(event.lotteryConfig) : undefined,
+    }));
+});
+/** Fetch lottery entries for admin view (includes phone + txId via PII decrypt). */
+export async function getLotteryEntriesForAdmin(sourceType, sourceId, model) {
+    const field = sourceType === "event" ? "eventId" : "productId";
+    return lotteryEntryRepository.listForSource(sourceId, field, model);
+}
+/** Fetch lottery entries for a specific user (own entries only). */
+export async function getLotteryEntriesForUser(userId, model) {
+    return lotteryEntryRepository.listForUser(userId, model);
+}

package/dist/_internal/server/features/lottery/metadata.d.ts

@@ -0,0 +1,6 @@
+import type { Metadata } from "next";
+import type { LotteryEventClient } from "./data";
+export declare function buildLotteryMetadata(event: LotteryEventClient | null, opts?: {
+    siteName?: string;
+    baseUrl?: string;
+}): Metadata;

package/dist/_internal/server/features/lottery/metadata.js

@@ -0,0 +1,31 @@
+export function buildLotteryMetadata(event, opts) {
+    if (!event) {
+        return {
+            title: "Lottery Not Found",
+            description: "This lottery no longer exists.",
+        };
+    }
+    const siteName = opts?.siteName ?? "the platform";
+    const title = `${event.title} — ${siteName} Lottery`;
+    const description = typeof event.description === "string" && event.description.length > 0
+        ? event.description.slice(0, 155)
+        : `Enter the ${event.title} lottery on ${siteName}.`;
+    const coverUrl = event.coverImage && typeof event.coverImage.url === "string"
+        ? event.coverImage.url
+        : event.coverImageUrl;
+    return {
+        title,
+        description,
+        openGraph: {
+            title,
+            description,
+            ...(coverUrl ? { images: [{ url: coverUrl }] } : {}),
+        },
+        twitter: {
+            card: "summary_large_image",
+            title,
+            description,
+            ...(coverUrl ? { images: [coverUrl] } : {}),
+        },
+    };
+}

package/dist/_internal/server/features/pre-orders/data.d.ts

@@ -1,4 +1,2 @@
-import type { ProductDocument } from "../../../../features/products/schemas/firestore";
-import type { ProductFeatureDocument } from "../../../../features/products/schemas/product-features";
-export declare const getPreOrderForDetail: (slugOrId: string) => Promise<ProductDocument | null>;
-export declare const getProductFeaturesForPreOrder: (storeId: string | null) => Promise<ProductFeatureDocument[]>;
+export declare const getPreOrderForDetail: (slugOrId: string) => Promise<import("../../../..").ProductDocument | null>;
+export declare const getProductFeaturesForPreOrder: (storeId: string | null) => Promise<import("../../../..").ProductFeatureDocument[]>;

package/dist/_internal/server/features/pre-orders/data.js

@@ -1,9 +1,3 @@
-import { cache } from "react";
-import { productRepository } from "../../../../repositories";
-import { loadProductFeaturesForStore } from "../../../../features/products/repository/loadProductFeatures";
-export const getPreOrderForDetail = cache(async (slugOrId) => {
-    return (await productRepository.findByIdOrSlug(slugOrId).catch(() => undefined)) ?? null;
-});
-export const getProductFeaturesForPreOrder = cache(async (storeId) => {
-    return loadProductFeaturesForStore(storeId).catch(() => []);
-});
+import { makeGetListingForDetail, getProductFeaturesForStore } from "../shared/listing-data-factory";
+export const getPreOrderForDetail = makeGetListingForDetail("pre-order");
+export const getProductFeaturesForPreOrder = getProductFeaturesForStore;

package/dist/_internal/server/features/prize-draws/actions.d.ts

@@ -0,0 +1,2 @@
+import { type ActionResult } from "@mohasinac/appkit/server";
+export declare function enterPrizeDrawAction(input: unknown): Promise<ActionResult<unknown>>;

package/dist/_internal/server/features/prize-draws/actions.js

@@ -0,0 +1,22 @@
+"use server";
+import { wrapAction } from "@mohasinac/appkit/server";
+import { productRepository } from "../../../../repositories";
+import { requireRoleUser } from "../../../../providers/auth-firebase/helpers";
+import { assertPrizeDrawOpen } from "./service";
+export async function enterPrizeDrawAction(input) {
+    return wrapAction(async () => {
+        const user = await requireRoleUser(["user", "buyer", "seller", "admin"]);
+        const { prizeDrawId } = input;
+        if (!prizeDrawId)
+            throw new Error("prizeDrawId is required.");
+        const product = await productRepository.findByIdOrSlug(prizeDrawId).catch(() => null);
+        if (!product)
+            throw new Error("Prize draw not found.");
+        assertPrizeDrawOpen(product);
+        // Increment the entry count — server-side only, not exposed to the client adapter.
+        await productRepository.update(prizeDrawId, {
+            prizeCurrentEntries: (product.prizeCurrentEntries ?? 0) + 1,
+        });
+        return { entryRecorded: true, userId: user.uid };
+    });
+}