@mohasinac/appkit 2.4.10 → 2.5.0

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

@@ -0,0 +1,327 @@
+/**
+ * Checkout server actions (appkit).
+ *
+ * Lifted from src/app/api/checkout/route.ts so any consumer (REST handler,
+ * server component form, RSC action) can place orders by calling these
+ * directly. The consumer is responsible for auth/rate-limit/Next-specific
+ * concerns; the action only does transactional order placement.
+ */
+import { ApiError, ValidationError, NotFoundError, ERROR_MESSAGES } from "../../../../errors";
+import { serverLogger } from "../../../../monitoring";
+import { unitOfWork, siteSettingsRepository, userRepository, storeRepository, couponsRepository, } from "../../../../repositories";
+import { failedCheckoutRepository } from "../../../../features/checkout/repository/failed-checkout.repository";
+import { sendOrderConfirmationEmail } from "../../../../features/contact/server";
+import { splitCartIntoOrderGroups } from "../../../../features/orders/index";
+import { resolveDate } from "../../../../utils";
+import { getAdminDb } from "../../../../providers/db-firebase";
+import { PRODUCT_COLLECTION, ProductStatusValues } from "../../../../features/products/schemas/firestore";
+import { CART_COLLECTION } from "../../../../features/cart/schemas/index";
+import { consentOtpRef, consentOtpRateLimitRef, CONSENT_OTP_MAX_BYPASS_CREDITS, } from "../../../../features/auth/server";
+import { OrderStatusValues, PaymentStatusValues } from "../../../../features/orders/schemas/index";
+import { getDefaultCurrency } from "../../../../core/index";
+import { CHECKOUT_DEFAULT_COMMISSIONS } from "../../../shared/features/checkout/config";
+import { formatShippingAddress } from "./data";
+/**
+ * Place order(s) from the user's cart in a single Firestore transaction.
+ *
+ * Mirrors the existing /api/checkout route handler. Consumers should perform
+ * auth + rate-limiting before calling this and supply the resolved user fields.
+ */
+export async function createCheckoutOrderAction(input) {
+    const { userId: uid, userName, userEmail, addressId, paymentMethod, notes, excludedProductIds = [], } = input;
+    const siteSettings = await siteSettingsRepository.getSingleton();
+    const commissions = siteSettings?.commissions ?? CHECKOUT_DEFAULT_COMMISSIONS;
+    const cart = await unitOfWork.carts.getOrCreate(uid);
+    if (!cart.items || cart.items.length === 0) {
+        throw new ValidationError(ERROR_MESSAGES.CHECKOUT.CART_EMPTY);
+    }
+    const excludedSet = new Set(excludedProductIds);
+    const selectedSet = cart.selectedItemIds?.length
+        ? new Set(cart.selectedItemIds)
+        : null;
+    const cartItems = cart.items.filter((item) => !excludedSet.has(item.productId) &&
+        (!selectedSet || selectedSet.has(item.itemId)));
+    if (cartItems.length === 0) {
+        throw new ValidationError(ERROR_MESSAGES.CHECKOUT.CART_EMPTY);
+    }
+    const address = await unitOfWork.addresses.findById(uid, addressId);
+    if (!address) {
+        failedCheckoutRepository
+            .logCheckout(uid, "address_not_found", "Address not found", { addressId, paymentMethod })
+            .catch(() => { });
+        throw new NotFoundError(ERROR_MESSAGES.CHECKOUT.ADDRESS_REQUIRED);
+    }
+    const shippingAddress = formatShippingAddress(address);
+    const db = getAdminDb();
+    const otpRef = consentOtpRef(db, uid, addressId);
+    let stockResult;
+    try {
+        stockResult = await db.runTransaction(async (tx) => {
+            const otpSnap = await tx.get(otpRef);
+            const otpData = otpSnap.exists
+                ? otpSnap.data()
+                : null;
+            const isConsentValid = otpData?.verified === true &&
+                otpData.expiresAt &&
+                (resolveDate(otpData.expiresAt)?.getTime() ?? 0) > Date.now();
+            if (!isConsentValid) {
+                const reason = !otpData ? "otp_not_verified" : "consent_expired";
+                throw Object.assign(new ApiError(403, "Order verification required. Please complete OTP verification before placing this order."), { _failReason: reason });
+            }
+            const emailOtpUsed = otpData.verifiedVia !== "sms";
+            const productRefs = cartItems.map((item) => db.collection(PRODUCT_COLLECTION).doc(item.productId));
+            const productDocs = await Promise.all(productRefs.map((ref) => tx.get(ref)));
+            const availableItems = [];
+            const unavailableItems = [];
+            for (let i = 0; i < cartItems.length; i++) {
+                const item = cartItems[i];
+                const doc = productDocs[i];
+                const productData = doc.exists ? doc.data() : null;
+                if (!productData ||
+                    productData.status !== ProductStatusValues.PUBLISHED ||
+                    productData.availableQuantity < item.quantity) {
+                    unavailableItems.push({
+                        productId: item.productId,
+                        productTitle: item.productTitle,
+                        requestedQty: item.quantity,
+                        availableQty: productData?.availableQuantity ?? 0,
+                    });
+                }
+                else {
+                    tx.update(productRefs[i], {
+                        availableQuantity: productData.availableQuantity - item.quantity,
+                        updatedAt: new Date(),
+                    });
+                    availableItems.push({ item, product: productData });
+                }
+            }
+            if (availableItems.length > 0) {
+                const orderedProductIds = new Set(availableItems.map((a) => a.item.productId));
+                const remainingCartItems = cart.items.filter((ci) => !orderedProductIds.has(ci.productId));
+                const cartRef = db.collection(CART_COLLECTION).doc(uid);
+                tx.set(cartRef, {
+                    items: remainingCartItems,
+                    appliedCoupons: [],
+                    selectedItemIds: null,
+                    updatedAt: new Date(),
+                }, { merge: true });
+                tx.delete(otpRef);
+            }
+            return { available: availableItems, unavailable: unavailableItems, emailOtpUsed };
+        });
+    }
+    catch (err) {
+        const reason = err?._failReason === "consent_expired"
+            ? "consent_expired"
+            : err?._failReason === "otp_not_verified"
+                ? "otp_not_verified"
+                : "unknown";
+        failedCheckoutRepository
+            .logCheckout(uid, reason, err instanceof Error ? err.message : String(err), {
+            addressId,
+            paymentMethod,
+        })
+            .catch(() => { });
+        throw err;
+    }
+    const { available, unavailable, emailOtpUsed } = stockResult;
+    if (available.length === 0) {
+        failedCheckoutRepository
+            .logCheckout(uid, "stock_failed", "All items out of stock", {
+            addressId,
+            paymentMethod,
+            cartItemCount: cartItems.length,
+        })
+            .catch(() => { });
+        throw new ValidationError(ERROR_MESSAGES.CHECKOUT.INSUFFICIENT_STOCK);
+    }
+    const appliedCoupons = cart.appliedCoupons ?? [];
+    const orderGroups = splitCartIntoOrderGroups(available);
+    const orderIds = [];
+    let total = 0;
+    const emailsToSend = [];
+    const cartSubtotal = orderGroups.reduce((s, { items: g }) => s + g.reduce((gs, { item }) => gs + item.price * item.quantity, 0), 0);
+    const couponUsageAccumulator = new Map();
+    for (const { items: group, orderType } of orderGroups) {
+        const firstItem = group[0].item;
+        const groupTotal = group.reduce((sum, { item }) => sum + item.price * item.quantity, 0);
+        total += groupTotal;
+        const orderItems = group.map(({ item }) => ({
+            productId: item.productId,
+            productTitle: item.productTitle,
+            quantity: item.quantity,
+            unitPrice: item.price,
+            totalPrice: item.price * item.quantity,
+        }));
+        const totalQuantity = group.reduce((sum, { item }) => sum + item.quantity, 0);
+        let shippingFee = 0;
+        const storeId = firstItem.storeId;
+        if (storeId) {
+            const store = await storeRepository.findById(storeId);
+            const storeOwnerId = store?.ownerId;
+            if (storeOwnerId) {
+                const sellerUser = await userRepository.findById(storeOwnerId);
+                const shippingConfig = sellerUser?.shippingConfig;
+                if (shippingConfig?.isConfigured) {
+                    if (shippingConfig.method === "custom") {
+                        shippingFee = shippingConfig.customShippingPrice ?? 0;
+                    }
+                    else if (shippingConfig.method === "shiprocket") {
+                        const percentFee = groupTotal * (commissions.platformShippingPercent / 100);
+                        shippingFee = Math.max(percentFee, commissions.platformShippingFixedMin);
+                    }
+                }
+            }
+        }
+        const isCodLike = paymentMethod === "cod" || paymentMethod === "upi_manual";
+        const depositAmount = isCodLike
+            ? Math.round(groupTotal * (commissions.codDepositPercent / 100) * 100) / 100
+            : undefined;
+        const codRemainingAmount = isCodLike
+            ? Math.round((groupTotal - (depositAmount ?? 0)) * 100) / 100
+            : undefined;
+        let couponDiscount = 0;
+        const appliedDiscounts = [];
+        const groupCouponCodes = new Set();
+        for (const coupon of appliedCoupons) {
+            let couponGroupDiscount = 0;
+            const isSellerScoped = coupon.scope === "seller" && coupon.storeId;
+            if (isSellerScoped) {
+                if (coupon.storeId !== firstItem.storeId)
+                    continue;
+                if (coupon.applicableItemIds?.length) {
+                    const eligibleTotal = group
+                        .filter(({ item }) => coupon.applicableItemIds.includes(item.itemId))
+                        .reduce((s, { item }) => s + item.price * item.quantity, 0);
+                    couponGroupDiscount =
+                        eligibleTotal > 0
+                            ? Math.min(Math.round((eligibleTotal / groupTotal) * coupon.discountAmount * 100) / 100, eligibleTotal)
+                            : 0;
+                }
+                else {
+                    couponGroupDiscount = Math.min(coupon.discountAmount, groupTotal);
+                }
+            }
+            else {
+                if (cartSubtotal > 0) {
+                    couponGroupDiscount = Math.min(Math.round((groupTotal / cartSubtotal) * coupon.discountAmount * 100) / 100, groupTotal);
+                }
+            }
+            if (couponGroupDiscount > 0) {
+                couponDiscount += couponGroupDiscount;
+                appliedDiscounts.push({
+                    code: coupon.code,
+                    couponId: coupon.couponId,
+                    type: "coupon",
+                    discountAmount: couponGroupDiscount,
+                    scope: coupon.scope,
+                    storeId: coupon.storeId,
+                });
+                if (coupon.couponId) {
+                    const entry = couponUsageAccumulator.get(coupon.code) ?? {
+                        couponId: coupon.couponId,
+                        code: coupon.code,
+                        orderIds: [],
+                        totalDiscount: 0,
+                    };
+                    entry.totalDiscount += couponGroupDiscount;
+                    couponUsageAccumulator.set(coupon.code, entry);
+                    groupCouponCodes.add(coupon.code);
+                }
+            }
+        }
+        couponDiscount = Math.min(couponDiscount, groupTotal);
+        const orderTotal = Math.max(0, groupTotal - couponDiscount) + shippingFee;
+        const imageUrls = [
+            ...new Set(group
+                .map(({ product }) => product.mainImage)
+                .filter((url) => typeof url === "string" && url.length > 0)),
+        ];
+        const order = await unitOfWork.orders.create({
+            productId: firstItem.productId,
+            productTitle: firstItem.productTitle,
+            userId: uid,
+            userName,
+            userEmail,
+            quantity: totalQuantity,
+            unitPrice: firstItem.price,
+            totalPrice: orderTotal,
+            currency: firstItem.currency ?? getDefaultCurrency(),
+            storeId: firstItem.storeId || undefined,
+            storeName: firstItem.storeName || undefined,
+            items: orderItems,
+            orderType,
+            offerId: firstItem.offerId ?? undefined,
+            status: OrderStatusValues.PENDING,
+            paymentStatus: PaymentStatusValues.PENDING,
+            paymentMethod,
+            shippingAddress,
+            notes,
+            shippingFee: shippingFee > 0 ? shippingFee : undefined,
+            depositAmount,
+            codRemainingAmount,
+            couponCode: appliedDiscounts[0]?.code,
+            couponDiscount: couponDiscount > 0 ? couponDiscount : undefined,
+            appliedDiscounts: appliedDiscounts.length > 0 ? appliedDiscounts : undefined,
+            imageUrls: imageUrls.length > 0 ? imageUrls : undefined,
+        });
+        orderIds.push(order.id);
+        for (const code of groupCouponCodes) {
+            const entry = couponUsageAccumulator.get(code);
+            if (entry)
+                entry.orderIds.push(order.id);
+        }
+        if (userEmail) {
+            emailsToSend.push({
+                to: userEmail,
+                userName,
+                orderId: order.id,
+                productTitle: orderItems.length > 1 ? `${orderItems.length} items` : firstItem.productTitle,
+                quantity: totalQuantity,
+                totalPrice: orderTotal,
+                currency: firstItem.currency ?? getDefaultCurrency(),
+                shippingAddress,
+                paymentMethod,
+                items: orderItems,
+            });
+        }
+    }
+    if (couponUsageAccumulator.size > 0) {
+        Promise.all([...couponUsageAccumulator.values()].map(({ couponId, code, orderIds: ids, totalDiscount }) => couponsRepository.applyCoupon(couponId, code, uid, ids, totalDiscount))).catch((err) => serverLogger.error("Failed to record coupon usage:", err));
+    }
+    if (emailOtpUsed && unavailable.length > 0) {
+        const metaRef = consentOtpRateLimitRef(db, uid);
+        metaRef
+            .get()
+            .then((snap) => {
+            const cur = snap.exists ? (snap.data()?.bypassCredits ?? 0) : 0;
+            return metaRef.set({ bypassCredits: Math.min(cur + 1, CONSENT_OTP_MAX_BYPASS_CREDITS) }, { merge: true });
+        })
+            .catch((err) => serverLogger.warn("Failed to grant consent OTP bypass credit", { err }));
+    }
+    if (emailsToSend.length > 0) {
+        Promise.all(emailsToSend.map((e) => sendOrderConfirmationEmail(e))).catch((err) => serverLogger.error("Order confirmation email error:", err));
+    }
+    serverLogger.info(`createCheckoutOrderAction: ${orderIds.length} order(s) placed for uid=${uid}` +
+        (unavailable.length > 0 ? ` (${unavailable.length} item(s) unavailable)` : ""));
+    return {
+        orderIds,
+        total,
+        itemCount: orderIds.length,
+        ...(unavailable.length > 0 ? { unavailableItems: unavailable } : {}),
+    };
+}
+/**
+ * Mark an order as paid after a payment provider verifies the transaction.
+ * Consumers call this from /api/payment/verify or a payment webhook.
+ */
+export async function attachPaymentAction(input) {
+    const { orderId, paymentId, paidAmount } = input;
+    await unitOfWork.orders.update(orderId, {
+        paymentStatus: PaymentStatusValues.PAID,
+        paymentId,
+        paidAmount,
+        status: OrderStatusValues.PROCESSING,
+        updatedAt: new Date(),
+    });
+}

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

@@ -0,0 +1,13 @@
+import type { AddressDocument } from "../../../../features/account/schemas/index";
+export declare function formatShippingAddress(a: AddressDocument): string;
+export interface CheckoutOrderResult {
+    orderIds: string[];
+    total: number;
+    itemCount: number;
+    unavailableItems?: {
+        productId: string;
+        productTitle: string;
+        requestedQty: number;
+        availableQty: number;
+    }[];
+}

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

@@ -0,0 +1,13 @@
+export function formatShippingAddress(a) {
+    const parts = [
+        a.fullName,
+        a.addressLine1,
+        a.addressLine2,
+        a.landmark,
+        a.city,
+        a.state,
+        a.postalCode,
+        a.country,
+    ].filter(Boolean);
+    return parts.join(", ");
+}

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

@@ -0,0 +1,3 @@
+export { createCheckoutOrderAction, attachPaymentAction, type CreateCheckoutOrderInput, } from "./actions";
+export { formatShippingAddress, type CheckoutOrderResult, } from "./data";
+export { CHECKOUT_DEFAULT_COMMISSIONS, CHECKOUT_PAYMENT_METHODS, type CheckoutPaymentMethod, } from "../../../shared/features/checkout/config";

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

@@ -0,0 +1,3 @@
+export { createCheckoutOrderAction, attachPaymentAction, } from "./actions";
+export { formatShippingAddress, } from "./data";
+export { CHECKOUT_DEFAULT_COMMISSIONS, CHECKOUT_PAYMENT_METHODS, } from "../../../shared/features/checkout/config";

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

@@ -0,0 +1,4 @@
+export declare function createEventAction(input: unknown): Promise<import("../../../..").EventDocument>;
+export declare function updateEventAction(eventId: string, input: unknown): Promise<import("../../../..").EventDocument>;
+export declare function registerForEventAction(input: unknown): Promise<import("../../../..").EventEntryDocument>;
+export declare function cancelEventRegistrationAction(entryId: string): Promise<void>;

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

@@ -0,0 +1,60 @@
+"use server";
+import { eventRepository, eventEntryRepository } from "../../../../repositories";
+import { requireRoleUser } from "../../../../providers/auth-firebase/helpers";
+import { eventInputSchema, eventUpdateSchema, registerForEventSchema } from "../../../shared/features/events/schema";
+import { assertEventActive } from "./service";
+import { AlreadyRegisteredError, EventNotFoundError } from "../../../shared/features/events/errors";
+import { ValidationError } from "../../../shared/errors/index";
+export async function createEventAction(input) {
+    const user = await requireRoleUser(["admin", "moderator"]);
+    const parsed = eventInputSchema.safeParse(input);
+    if (!parsed.success)
+        throw new ValidationError(parsed.error.errors[0]?.message ?? "Invalid event input");
+    return eventRepository.createEvent({
+        ...parsed.data,
+        createdBy: user.uid,
+        status: "draft",
+        stats: { totalEntries: 0, approvedEntries: 0, flaggedEntries: 0 },
+    });
+}
+export async function updateEventAction(eventId, input) {
+    await requireRoleUser(["admin", "moderator"]);
+    const event = await eventRepository.findById(eventId).catch(() => null);
+    if (!event)
+        throw new EventNotFoundError(eventId);
+    const parsed = eventUpdateSchema.safeParse(input);
+    if (!parsed.success)
+        throw new ValidationError(parsed.error.errors[0]?.message ?? "Invalid event input");
+    return eventRepository.updateEvent(eventId, parsed.data);
+}
+export async function registerForEventAction(input) {
+    const user = await requireRoleUser(["buyer", "seller", "admin"]);
+    const parsed = registerForEventSchema.safeParse(input);
+    if (!parsed.success)
+        throw new ValidationError(parsed.error.errors[0]?.message ?? "Invalid registration input");
+    const { eventId } = parsed.data;
+    await assertEventActive(eventId);
+    // Check if already registered
+    const alreadyRegistered = await eventEntryRepository.hasUserEntered(eventId, user.uid).catch(() => false);
+    if (alreadyRegistered)
+        throw new AlreadyRegisteredError(eventId);
+    const entry = await eventEntryRepository.create({
+        eventId,
+        userId: user.uid,
+        userDisplayName: user.name ?? "Anonymous",
+        userEmail: user.email ?? "",
+        reviewStatus: "pending",
+        submittedAt: new Date(),
+    });
+    // Increment entry count
+    await eventRepository.incrementTotalEntries(eventId).catch(() => null);
+    return entry;
+}
+export async function cancelEventRegistrationAction(entryId) {
+    const user = await requireRoleUser(["buyer", "seller", "admin"]);
+    const entry = await eventEntryRepository.findById(entryId).catch(() => null);
+    if (!entry || entry.userId !== user.uid) {
+        throw new ValidationError("Registration not found or does not belong to you");
+    }
+    return eventEntryRepository.delete(entryId);
+}

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

@@ -0,0 +1 @@
+export declare const getEventForDetail: (id: string) => Promise<import("../../../..").EventDocument | null>;

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

@@ -0,0 +1,5 @@
+import { cache } from "react";
+import { eventRepository } from "../../../../repositories";
+export const getEventForDetail = cache(async (id) => {
+    return eventRepository.findById(id).catch(() => null);
+});

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

@@ -0,0 +1,5 @@
+export { getEventForDetail } from "./data";
+export { assertEventActive, isEventAcceptingRegistrations } from "./service";
+export { createEventAction, updateEventAction, registerForEventAction, cancelEventRegistrationAction, } from "./actions";
+export { EVENTS_PAGE_SIZE, EVENTS_UPCOMING_LIMIT, EVENT_MAX_ENTRIES_DEFAULT, } from "../../../shared/features/events/config";
+export { renderEventOgImage, renderEventOg, type EventOgData } from "./og";

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

@@ -0,0 +1,5 @@
+export { getEventForDetail } from "./data";
+export { assertEventActive, isEventAcceptingRegistrations } from "./service";
+export { createEventAction, updateEventAction, registerForEventAction, cancelEventRegistrationAction, } from "./actions";
+export { EVENTS_PAGE_SIZE, EVENTS_UPCOMING_LIMIT, EVENT_MAX_ENTRIES_DEFAULT, } from "../../../shared/features/events/config";
+export { renderEventOgImage, renderEventOg } from "./og";

package/dist/_internal/server/features/events/og.d.ts

@@ -0,0 +1,26 @@
+import type { ReactElement } from "react";
+export interface EventOgData {
+    title: string;
+    description?: string | null;
+    typeLabel?: string | null;
+    startsAt?: string | null;
+    coverImageUrl?: string | null;
+}
+interface EventDocLike {
+    title?: string | null;
+    description?: string | null;
+    type?: string | null;
+    startsAt?: Date | string | null;
+    coverImageUrl?: string | null;
+    coverImage?: string | {
+        url?: string | null;
+    } | null;
+}
+/** High-level OG renderer — accepts the raw event document from `getEventForDetail`. */
+export declare function renderEventOg(doc: EventDocLike | null | undefined, opts: {
+    siteName: string;
+    locale?: string;
+    typeLabels?: Record<string, string>;
+}): ReactElement;
+export declare function renderEventOgImage(data: EventOgData, siteName: string): ReactElement;
+export {};

package/dist/_internal/server/features/events/og.js

@@ -0,0 +1,87 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+const EVENT_TYPE_LABEL = {
+    TOURNAMENT: "Tournament",
+    CONVENTION: "Convention",
+    MEETUP: "Meetup",
+    SALE: "Sale",
+    sale: "Sale",
+    offer: "Offer",
+    poll: "Poll",
+    survey: "Survey",
+    feedback: "Feedback",
+};
+/** High-level OG renderer — accepts the raw event document from `getEventForDetail`. */
+export function renderEventOg(doc, opts) {
+    const locale = opts.locale ?? "en-IN";
+    const labels = { ...EVENT_TYPE_LABEL, ...(opts.typeLabels ?? {}) };
+    const eventType = doc?.type ?? null;
+    const coverImageUrl = doc?.coverImageUrl ??
+        (typeof doc?.coverImage === "string"
+            ? doc.coverImage
+            : doc?.coverImage?.url) ??
+        null;
+    const startsAt = doc?.startsAt
+        ? new Date(doc.startsAt).toLocaleDateString(locale, {
+            day: "numeric",
+            month: "short",
+            year: "numeric",
+        })
+        : null;
+    return renderEventOgImage({
+        title: doc?.title ?? `${opts.siteName} Event`,
+        description: (typeof doc?.description === "string" ? doc.description : "").slice(0, 110) || null,
+        typeLabel: eventType ? (labels[eventType] ?? eventType) : null,
+        startsAt,
+        coverImageUrl,
+    }, opts.siteName);
+}
+export function renderEventOgImage(data, siteName) {
+    const { title, description, typeLabel, startsAt, coverImageUrl } = data;
+    return (_jsxs("div", { style: {
+            display: "flex",
+            width: "100%",
+            height: "100%",
+            background: "#0f172a",
+            fontFamily: "sans-serif",
+            position: "relative",
+            overflow: "hidden",
+        }, children: [coverImageUrl && (_jsx("img", { src: coverImageUrl, alt: "", style: { position: "absolute", inset: 0, width: "100%", height: "100%", objectFit: "cover", opacity: 0.15 } })), _jsx("div", { style: {
+                    position: "absolute",
+                    inset: 0,
+                    background: "linear-gradient(135deg, rgba(15,23,42,0.95) 0%, rgba(15,23,42,0.80) 100%)",
+                } }), _jsxs("div", { style: {
+                    position: "relative",
+                    display: "flex",
+                    width: "100%",
+                    height: "100%",
+                    padding: "60px",
+                    gap: "48px",
+                    alignItems: "center",
+                }, children: [coverImageUrl && (_jsx("img", { src: coverImageUrl, alt: title, style: { width: 380, height: 380, objectFit: "cover", borderRadius: 16, flexShrink: 0 } })), _jsxs("div", { style: { display: "flex", flexDirection: "column", gap: 20, flex: 1 }, children: [_jsxs("div", { style: { display: "flex", alignItems: "center", gap: 12 }, children: [_jsxs("div", { style: { fontSize: 16, color: "#a78bfa", fontWeight: 600, letterSpacing: 2, textTransform: "uppercase" }, children: [siteName, " \u00B7 Events"] }), typeLabel && (_jsx("div", { style: {
+                                            fontSize: 13,
+                                            color: "#c4b5fd",
+                                            fontWeight: 500,
+                                            letterSpacing: 1,
+                                            textTransform: "uppercase",
+                                            background: "rgba(167,139,250,0.12)",
+                                            padding: "3px 10px",
+                                            borderRadius: 100,
+                                        }, children: typeLabel }))] }), _jsx("div", { style: {
+                                    fontSize: coverImageUrl ? 44 : 56,
+                                    fontWeight: 700,
+                                    color: "#f1f5f9",
+                                    lineHeight: 1.2,
+                                    display: "-webkit-box",
+                                    WebkitLineClamp: 3,
+                                    WebkitBoxOrient: "vertical",
+                                    overflow: "hidden",
+                                }, children: title }), description && (_jsx("div", { style: {
+                                    fontSize: 22,
+                                    color: "#94a3b8",
+                                    lineHeight: 1.45,
+                                    display: "-webkit-box",
+                                    WebkitLineClamp: 2,
+                                    WebkitBoxOrient: "vertical",
+                                    overflow: "hidden",
+                                }, children: description })), startsAt && (_jsx("div", { style: { fontSize: 22, fontWeight: 600, color: "#a78bfa" }, children: startsAt }))] })] })] }));
+}

package/dist/_internal/server/features/events/service.d.ts

@@ -0,0 +1,2 @@
+export declare function assertEventActive(eventId: string): Promise<import("../../../..").EventDocument>;
+export declare function isEventAcceptingRegistrations(event: Record<string, unknown>): boolean;

package/dist/_internal/server/features/events/service.js

@@ -0,0 +1,27 @@
+import { eventRepository } from "../../../../repositories";
+import { EventNotFoundError, EventNotActiveError, EventEndedError, EventFullError, } from "../../../shared/features/events/errors";
+export async function assertEventActive(eventId) {
+    const event = await eventRepository.findById(eventId).catch(() => null);
+    if (!event)
+        throw new EventNotFoundError(eventId);
+    const status = event.status;
+    if (status !== "active" && status !== "upcoming")
+        throw new EventNotActiveError(status ?? "unknown");
+    const endsAt = event.endsAt
+        ? new Date(event.endsAt)
+        : null;
+    if (endsAt && endsAt.getTime() < Date.now())
+        throw new EventEndedError(eventId);
+    const maxEntries = event.stats?.totalEntries ?? event.maxEntries;
+    const approvedEntries = event.stats?.approvedEntries ?? 0;
+    if (maxEntries && approvedEntries >= maxEntries)
+        throw new EventFullError();
+    return event;
+}
+export function isEventAcceptingRegistrations(event) {
+    const status = event.status;
+    if (status !== "active" && status !== "upcoming")
+        return false;
+    const endsAt = event.endsAt ? new Date(event.endsAt) : null;
+    return !endsAt || endsAt.getTime() > Date.now();
+}

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

@@ -0,0 +1,25 @@
+import { type GroupedListingDocument } from "../../../../features/grouped/schemas/firestore";
+import type { ProductDocument } from "../../../../features/products/schemas/firestore";
+export interface GroupedListingWithItems extends GroupedListingDocument {
+    items: ProductDocument[];
+}
+/** Fetch a grouped listing by slug, deduped per request. */
+export declare const getGroupedListingForDetail: (slug: string) => Promise<GroupedListingDocument | null>;
+/** Fetch a grouped listing with its member products resolved, deduped per request. */
+export declare const getGroupedListingWithItems: (slug: string) => Promise<GroupedListingWithItems | null>;
+export interface ListGroupedListingsParams {
+    limit?: number;
+    featuredOnly?: boolean;
+    storeId?: string;
+    brandSlug?: string;
+    categorySlug?: string;
+}
+/** List active grouped listings, newest first. */
+export declare function listGroupedListings(params?: ListGroupedListingsParams): Promise<GroupedListingDocument[]>;
+/** Featured grouped listings for homepage strips. */
+export declare const listFeaturedGroupedListings: (limit?: number) => Promise<GroupedListingDocument[]>;
+export interface SitemapGroupedListing {
+    slug: string;
+    updatedAt: Date;
+}
+export declare function listSitemapGroupedListings(): Promise<SitemapGroupedListing[]>;