@mohasinac/appkit 2.8.9 → 3.0.0

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

@@ -1,35 +1,47 @@
 "use server";
+import { wrapAction } from "@mohasinac/appkit/server";
 import { cartRepository } from "../../../../repositories";
 import { requireRoleUser } from "../../../../providers/auth-firebase/helpers";
 import { addToCartSchema, removeFromCartSchema, mergeGuestCartSchema, } from "../../../shared/features/cart/schema";
 import { upsertCartItem, mergeGuestItems } from "./service";
 import { ValidationError } from "../../../shared/errors/index";
+// audit-unknown-ok: callback entry point — accepts arbitrary payload value
 export async function addToCartAction(input) {
-    const user = await requireRoleUser(["buyer", "seller", "admin"]);
-    const parsed = addToCartSchema.safeParse(input);
-    if (!parsed.success)
-        throw new ValidationError(parsed.error.issues[0]?.message ?? "Invalid cart input");
-    await upsertCartItem(user.uid, parsed.data);
-    return { success: true };
+    return wrapAction(async () => {
+        const user = await requireRoleUser(["buyer", "seller", "admin"]);
+        const parsed = addToCartSchema.safeParse(input);
+        if (!parsed.success)
+            throw new ValidationError(parsed.error.issues[0]?.message ?? "Invalid cart input");
+        await upsertCartItem(user.uid, parsed.data);
+        return { success: true };
+    });
 }
+// audit-unknown-ok: callback entry point — accepts arbitrary payload value
 export async function removeFromCartAction(input) {
-    const user = await requireRoleUser(["buyer", "seller", "admin"]);
-    const parsed = removeFromCartSchema.safeParse(input);
-    if (!parsed.success)
-        throw new ValidationError(parsed.error.issues[0]?.message ?? "Invalid input");
-    await cartRepository.removeItem(user.uid, parsed.data.productId);
-    return { success: true };
+    return wrapAction(async () => {
+        const user = await requireRoleUser(["buyer", "seller", "admin"]);
+        const parsed = removeFromCartSchema.safeParse(input);
+        if (!parsed.success)
+            throw new ValidationError(parsed.error.issues[0]?.message ?? "Invalid input");
+        await cartRepository.removeItem(user.uid, parsed.data.productId);
+        return { success: true };
+    });
 }
 export async function clearCartAction() {
-    const user = await requireRoleUser(["buyer", "seller", "admin"]);
-    await cartRepository.clearCart(user.uid);
-    return { success: true };
+    return wrapAction(async () => {
+        const user = await requireRoleUser(["buyer", "seller", "admin"]);
+        await cartRepository.clearCart(user.uid);
+        return { success: true };
+    });
 }
+// audit-unknown-ok: callback entry point — accepts arbitrary payload value
 export async function mergeGuestCartAction(input) {
-    const user = await requireRoleUser(["buyer", "seller", "admin"]);
-    const parsed = mergeGuestCartSchema.safeParse(input);
-    if (!parsed.success)
-        throw new ValidationError(parsed.error.issues[0]?.message ?? "Invalid cart data");
-    await mergeGuestItems(user.uid, parsed.data.guestItems);
-    return { success: true };
+    return wrapAction(async () => {
+        const user = await requireRoleUser(["buyer", "seller", "admin"]);
+        const parsed = mergeGuestCartSchema.safeParse(input);
+        if (!parsed.success)
+            throw new ValidationError(parsed.error.issues[0]?.message ?? "Invalid cart data");
+        await mergeGuestItems(user.uid, parsed.data.guestItems);
+        return { success: true };
+    });
 }

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

@@ -1,11 +1,3 @@
-/**
- * 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 { type CheckoutPaymentMethod } from "../../../shared/features/checkout/config";
 import { type CheckoutOrderResult } from "./data";
 export interface CreateCheckoutOrderInput {

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

@@ -1,3 +1,4 @@
+import { normalizeError } from "../../../../errors/normalize";
 /**
  * Checkout server actions (appkit).
  *
@@ -111,8 +112,9 @@ function emitOrderPlacedNotifications(args) {
         relatedType: "order",
         actionUrl: `/user/orders/view/${orderId}`,
     })
+        // audit-unknown-ok: error-handler entry point — accepts thrown values of any shape
         .catch((err) => serverLogger.warn("Failed to create buyer order_placed notification", {
-        err,
+        err: err instanceof Error ? err.message : String(err),
         orderId,
     }));
     const sellerNotif = storeOwnerId
@@ -127,8 +129,9 @@ function emitOrderPlacedNotifications(args) {
             relatedType: "order",
             actionUrl: `/store/orders/${orderId}/view`,
         })
+            // audit-unknown-ok: error-handler entry point — accepts thrown values of any shape
             .catch((err) => serverLogger.warn("Failed to create seller order_placed notification", {
-            err,
+            err: err instanceof Error ? err.message : String(err),
             orderId,
         }))
         : Promise.resolve();
@@ -176,22 +179,33 @@ function buildStockUpdatePayload(product, qtyDelta) {
 async function flushCouponUsageAccumulator(accumulator, uid) {
     if (accumulator.size === 0)
         return;
-    Promise.all([...accumulator.values()].map(async ({ couponId, code, orderIds: ids, totalDiscount }) => {
-        await couponsRepository.applyCoupon(couponId, code, uid, ids, totalDiscount);
-        try {
-            const coupon = await couponsRepository.findById(couponId);
-            const perUserLimit = coupon?.usage?.perUserLimit ?? 1;
-            const newCount = await couponsRepository.getUserCouponUsageCount(uid, couponId);
-            if (newCount >= perUserLimit) {
-                await claimedCouponsRepository
-                    .markUsed(uid, code, ids[0] ?? "")
-                    .catch(() => { });
+    // W4 FIX: was a fire-and-forget `Promise.all(...).catch(...)` — the Vercel
+    // lambda could terminate before these writes committed and coupon usage was
+    // silently lost. The await below ensures every batch.commit() lands before
+    // the caller resolves.
+    try {
+        await Promise.all([...accumulator.values()].map(async ({ couponId, code, orderIds: ids, totalDiscount }) => {
+            await couponsRepository.applyCoupon(couponId, code, uid, ids, totalDiscount);
+            try {
+                const coupon = await couponsRepository.findById(couponId);
+                const perUserLimit = coupon?.usage?.perUserLimit ?? 1;
+                const newCount = await couponsRepository.getUserCouponUsageCount(uid, couponId);
+                if (newCount >= perUserLimit) {
+                    await claimedCouponsRepository
+                        .markUsed(uid, code, ids[0] ?? "")
+                        .catch(() => { });
+                }
             }
-        }
-        catch (err) {
-            serverLogger.warn("Failed to update claimed-coupon status", { err });
-        }
-    })).catch((err) => serverLogger.error("Failed to record coupon usage:", err));
+            catch (err) {
+                void normalizeError(err);
+                serverLogger.warn("Failed to update claimed-coupon status", { err: err instanceof Error ? err.message : String(err) });
+            }
+        }));
+    }
+    catch (err) {
+        void normalizeError(err);
+        serverLogger.error("Failed to record coupon usage:", { err: err instanceof Error ? err.message : String(err) });
+    }
 }
 function grantConsentOtpBypassCredit(db, uid, emailOtpUsed, unavailableCount) {
     if (!emailOtpUsed || unavailableCount === 0)
@@ -203,12 +217,15 @@ function grantConsentOtpBypassCredit(db, uid, emailOtpUsed, unavailableCount) {
         const cur = snap.exists ? (snap.data()?.bypassCredits ?? 0) : 0;
         return metaRef.set({ bypassCredits: Math.min(cur + 1, CONSENT_OTP_MAX_BYPASS_CREDITS) }, { merge: true });
     })
+        // audit-unknown-ok: error-handler entry point — accepts thrown values of any shape
         .catch((err) => serverLogger.warn("Failed to grant consent OTP bypass credit", { err }));
 }
 function dispatchOrderConfirmationEmails(emailsToSend) {
     if (emailsToSend.length === 0)
         return;
-    Promise.all(emailsToSend.map((e) => sendOrderConfirmationEmail(e))).catch((err) => serverLogger.error("Order confirmation email error:", err));
+    Promise.all(emailsToSend.map((e) => sendOrderConfirmationEmail(e))).catch(
+    // audit-unknown-ok: error-handler entry point — accepts thrown values of any shape
+    (err) => serverLogger.error("Order confirmation email error:", err));
 }
 /**
  * Place order(s) from the user's cart in a single Firestore transaction.
@@ -383,8 +400,10 @@ export async function createCheckoutOrderAction(input) {
             }
             return { available: availableItems, unavailable: unavailableItems, emailOtpUsed };
         });
+        // audit-unknown-ok: error-handler entry point — accepts thrown values of any shape
     }
     catch (err) {
+        void normalizeError(err);
         const reason = err?._failReason === "consent_expired"
             ? "consent_expired"
             : err?._failReason === "otp_not_verified"
@@ -980,12 +999,15 @@ export async function verifyAndPlaceRazorpayOrderAction(input) {
         otpRefForDelete.delete().catch(() => { }); // audit-silent-catch-ok: fire-and-forget side effect must not abort checkout
     }
     if (emailsToSend.length > 0) {
-        Promise.all(emailsToSend.map((e) => sendOrderConfirmationEmail(e))).catch((err) => serverLogger.error("Order confirmation email error:", err));
+        Promise.all(emailsToSend.map((e) => sendOrderConfirmationEmail(e))).catch(
+        // audit-unknown-ok: error-handler entry point — accepts thrown values of any shape
+        (err) => serverLogger.error("Order confirmation email error:", err));
     }
     serverLogger.info(`verifyAndPlaceRazorpayOrderAction: ${orderIds.length} order(s) placed for uid=${uid} — payment ${razorpay_payment_id}`);
     getAdminRealtimeDb()
         .ref(`${RTDB_PATHS.PAYMENT_EVENTS}/${razorpay_order_id}`)
         .update({ status: "success", orderIds, updatedAt: Date.now() })
+        // audit-unknown-ok: error-handler entry point — accepts thrown values of any shape
         .catch((err) => serverLogger.warn("Payment event RTDB signal failed (non-critical)", { err }));
     return { orderIds, total, itemCount: orderIds.length };
 }

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

@@ -1,3 +1,4 @@
+import { type ActionResult } from "@mohasinac/appkit/server";
 import type { ConversationDocument } from "../../../../features/messages/schemas/firestore";
 export interface StartConversationInput {
     productId: string;
@@ -8,4 +9,4 @@ export interface StartConversationInput {
  * Idempotent — returns the existing conversation if one already exists for
  * this buyer × store × product tuple.
  */
-export declare function startClassifiedConversationAction(input: StartConversationInput): Promise<ConversationDocument>;
+export declare function startClassifiedConversationAction(input: StartConversationInput): Promise<ActionResult<ConversationDocument>>;

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

@@ -1,4 +1,5 @@
 "use server";
+import { wrapAction } from "@mohasinac/appkit/server";
 import { conversationsRepository } from "../../../../features/messages/repository/conversations.repository";
 import { requireRoleUser } from "../../../../providers/auth-firebase/helpers";
 import { storeRepository, productRepository } from "../../../../repositories";
@@ -9,22 +10,24 @@ import { storeRepository, productRepository } from "../../../../repositories";
  * this buyer × store × product tuple.
  */
 export async function startClassifiedConversationAction(input) {
-    const user = await requireRoleUser(["user", "buyer", "seller", "admin"]);
-    const product = await productRepository.findByIdOrSlug(input.productId);
-    if (!product || product.listingType !== "classified") {
-        throw new Error("Product not found or not a classified listing");
-    }
-    const store = await storeRepository.findById(product.storeId);
-    if (!store) {
-        throw new Error("Store not found");
-    }
-    return conversationsRepository.findOrCreateByContext({
-        buyerId: user.uid,
-        buyerDisplayName: user.name ?? user.email ?? user.uid,
-        storeId: product.storeId,
-        storeName: store.storeName,
-        sellerDisplayName: store.storeName,
-        productId: product.id,
-        productTitle: product.title,
+    return wrapAction(async () => {
+        const user = await requireRoleUser(["user", "buyer", "seller", "admin"]);
+        const product = await productRepository.findByIdOrSlug(input.productId);
+        if (!product || product.listingType !== "classified") {
+            throw new Error("Product not found or not a classified listing");
+        }
+        const store = await storeRepository.findById(product.storeId);
+        if (!store) {
+            throw new Error("Store not found");
+        }
+        return conversationsRepository.findOrCreateByContext({
+            buyerId: user.uid,
+            buyerDisplayName: user.name ?? user.email ?? user.uid,
+            storeId: product.storeId,
+            storeName: store.storeName,
+            sellerDisplayName: store.storeName,
+            productId: product.id,
+            productTitle: product.title,
+        });
     });
 }

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

@@ -1,3 +1,4 @@
+import { type ActionResult } from "@mohasinac/appkit/server";
 import type { ConversationDocument } from "../../../../features/messages/schemas/firestore";
 export interface StartDigitalCodeConversationInput {
     productId: string;
@@ -8,4 +9,4 @@ export interface StartDigitalCodeConversationInput {
  * is handled by the existing `/api/orders/[id]/code` endpoint, not a server
  * action — the code reveal panel lives in the order detail view.
  */
-export declare function startDigitalCodeConversationAction(input: StartDigitalCodeConversationInput): Promise<ConversationDocument>;
+export declare function startDigitalCodeConversationAction(input: StartDigitalCodeConversationInput): Promise<ActionResult<ConversationDocument>>;

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

@@ -1,4 +1,5 @@
 "use server";
+import { wrapAction } from "@mohasinac/appkit/server";
 import { conversationsRepository } from "../../../../features/messages/repository/conversations.repository";
 import { requireRoleUser } from "../../../../providers/auth-firebase/helpers";
 import { storeRepository, productRepository } from "../../../../repositories";
@@ -9,22 +10,24 @@ import { storeRepository, productRepository } from "../../../../repositories";
  * action — the code reveal panel lives in the order detail view.
  */
 export async function startDigitalCodeConversationAction(input) {
-    const user = await requireRoleUser(["user", "buyer", "seller", "admin"]);
-    const product = await productRepository.findByIdOrSlug(input.productId);
-    if (!product || product.listingType !== "digital-code") {
-        throw new Error("Product not found or not a digital-code listing");
-    }
-    const store = await storeRepository.findById(product.storeId);
-    if (!store) {
-        throw new Error("Store not found");
-    }
-    return conversationsRepository.findOrCreateByContext({
-        buyerId: user.uid,
-        buyerDisplayName: user.name ?? user.email ?? user.uid,
-        storeId: product.storeId,
-        storeName: store.storeName,
-        sellerDisplayName: store.storeName,
-        productId: product.id,
-        productTitle: product.title,
+    return wrapAction(async () => {
+        const user = await requireRoleUser(["user", "buyer", "seller", "admin"]);
+        const product = await productRepository.findByIdOrSlug(input.productId);
+        if (!product || product.listingType !== "digital-code") {
+            throw new Error("Product not found or not a digital-code listing");
+        }
+        const store = await storeRepository.findById(product.storeId);
+        if (!store) {
+            throw new Error("Store not found");
+        }
+        return conversationsRepository.findOrCreateByContext({
+            buyerId: user.uid,
+            buyerDisplayName: user.name ?? user.email ?? user.uid,
+            storeId: product.storeId,
+            storeName: store.storeName,
+            sellerDisplayName: store.storeName,
+            productId: product.id,
+            productTitle: product.title,
+        });
     });
 }

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

@@ -1,4 +1,5 @@
-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>;
+import { type ActionResult } from "@mohasinac/appkit/server";
+export declare function createEventAction(input: unknown): Promise<ActionResult<unknown>>;
+export declare function updateEventAction(eventId: string, input: unknown): Promise<ActionResult<unknown>>;
+export declare function registerForEventAction(input: unknown): Promise<ActionResult<unknown>>;
+export declare function cancelEventRegistrationAction(entryId: string): Promise<ActionResult<unknown>>;

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

@@ -1,60 +1,72 @@
 "use server";
+import { wrapAction } from "@mohasinac/appkit/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";
+// audit-unknown-ok: callback entry point — accepts arbitrary payload value
 export async function createEventAction(input) {
-    const user = await requireRoleUser(["admin", "moderator"]);
-    const parsed = eventInputSchema.safeParse(input);
-    if (!parsed.success)
-        throw new ValidationError(parsed.error.issues[0]?.message ?? "Invalid event input");
-    return eventRepository.createEvent({
-        ...parsed.data,
-        createdBy: user.uid,
-        status: "draft",
-        stats: { totalEntries: 0, approvedEntries: 0, flaggedEntries: 0 },
+    return wrapAction(async () => {
+        const user = await requireRoleUser(["admin", "moderator"]);
+        const parsed = eventInputSchema.safeParse(input);
+        if (!parsed.success)
+            throw new ValidationError(parsed.error.issues[0]?.message ?? "Invalid event input");
+        return eventRepository.createEvent({
+            ...parsed.data,
+            createdBy: user.uid,
+            status: "draft",
+            stats: { totalEntries: 0, approvedEntries: 0, flaggedEntries: 0 },
+        });
     });
 }
+// audit-unknown-ok: callback entry point — accepts arbitrary payload value
 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.issues[0]?.message ?? "Invalid event input");
-    return eventRepository.updateEvent(eventId, parsed.data);
+    return wrapAction(async () => {
+        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.issues[0]?.message ?? "Invalid event input");
+        return eventRepository.updateEvent(eventId, parsed.data);
+    });
 }
+// audit-unknown-ok: callback entry point — accepts arbitrary payload value
 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.issues[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(),
+    return wrapAction(async () => {
+        const user = await requireRoleUser(["buyer", "seller", "admin"]);
+        const parsed = registerForEventSchema.safeParse(input);
+        if (!parsed.success)
+            throw new ValidationError(parsed.error.issues[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;
     });
-    // 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);
+    return wrapAction(async () => {
+        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/og.js

@@ -23,6 +23,7 @@ export function renderEventOg(doc, opts) {
         null;
     const coverImageUrl = resolveOgImageUrl(rawCoverImageUrl, opts.baseUrl);
     const startsAt = doc?.startsAt
+        // audit-unknown-ok: TS structural escape — primitive cast
         ? new Date(doc.startsAt).toLocaleDateString(locale, {
             day: "numeric",
             month: "short",

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

@@ -1,2 +1,3 @@
-export declare function assertEventActive(eventId: string): Promise<import("../../../..").EventDocument>;
-export declare function isEventAcceptingRegistrations(event: Record<string, unknown>): boolean;
+import type { JsonValue } from "@mohasinac/appkit";
+export declare function assertEventActive(eventId: string): Promise<import("@mohasinac/appkit").EventDocument>;
+export declare function isEventAcceptingRegistrations(event: Record<string, JsonValue>): boolean;

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

@@ -8,6 +8,7 @@ export async function assertEventActive(eventId) {
     if (status !== "active" && status !== "upcoming")
         throw new EventNotActiveError(status ?? "unknown");
     const endsAt = event.endsAt
+        // audit-unknown-ok: TS structural escape — primitive cast
         ? new Date(event.endsAt)
         : null;
     if (endsAt && endsAt.getTime() < Date.now())
@@ -22,6 +23,7 @@ export function isEventAcceptingRegistrations(event) {
     const status = event.status;
     if (status !== "active" && status !== "upcoming")
         return false;
+    // audit-unknown-ok: TS structural escape — primitive cast
     const endsAt = event.endsAt ? new Date(event.endsAt) : null;
     return !endsAt || endsAt.getTime() > Date.now();
 }

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

@@ -6,6 +6,7 @@ import { PRODUCT_FIELDS, CATEGORY_FIELDS } from "../../../../constants/field-nam
 import { GROUPED_LISTINGS_FEATURED_LIMIT, GROUPED_LISTINGS_PAGE_SIZE, GROUPED_LISTINGS_SITEMAP_LIMIT, } from "../../../shared/features/grouped/config";
 function mapDoc(doc) {
     const data = doc.data();
+    // audit-unknown-ok: type-narrowing entry point — accepts any value, narrows by typeof/Array.isArray
     const ts = (v) => {
         const d = v?.toDate?.();
         return d ?? (v instanceof Date ? v : new Date());
@@ -51,6 +52,7 @@ export const getGroupedListingForDetail = cache(async (slug) => {
             const byId = await db.collection(GROUPED_LISTINGS_COLLECTION).doc(slug).get();
             if (!byId.exists)
                 return null;
+            // audit-unknown-ok: TS structural escape — Firebase SDK type
             return mapDoc(byId);
         }
         return mapDoc(snap.docs[0]);

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

@@ -1,8 +1,9 @@
+import { type ActionResult } from "@mohasinac/appkit/server";
 import { type UserHistoryItem, type HistoryProductType } from "../../../../repositories";
-export declare function trackProductViewAction(productId: string, productType: HistoryProductType, productSnapshot?: UserHistoryItem["productSnapshot"]): Promise<void>;
+export declare function trackProductViewAction(productId: string, productType: HistoryProductType, productSnapshot?: UserHistoryItem["productSnapshot"]): Promise<ActionResult<unknown>>;
 export declare function mergeGuestHistoryAction(guestItems: Array<{
     productId: string;
     productType: HistoryProductType;
     viewedAt?: Date;
     productSnapshot?: UserHistoryItem["productSnapshot"];
-}>): Promise<number>;
+}>): Promise<ActionResult<unknown>>;

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

@@ -1,15 +1,20 @@
 "use server";
+import { wrapAction } from "@mohasinac/appkit/server";
 import { requireRoleUser } from "../../../../providers/auth-firebase/helpers";
 import { historyRepository, } from "../../../../repositories";
 export async function trackProductViewAction(productId, productType, productSnapshot) {
-    const user = await requireRoleUser(["buyer", "seller", "admin"]);
-    await historyRepository.track(user.uid, {
-        productId,
-        productType,
-        productSnapshot,
+    return wrapAction(async () => {
+        const user = await requireRoleUser(["buyer", "seller", "admin"]);
+        await historyRepository.track(user.uid, {
+            productId,
+            productType,
+            productSnapshot,
+        });
     });
 }
 export async function mergeGuestHistoryAction(guestItems) {
-    const user = await requireRoleUser(["buyer", "seller", "admin"]);
-    return historyRepository.merge(user.uid, guestItems);
+    return wrapAction(async () => {
+        const user = await requireRoleUser(["buyer", "seller", "admin"]);
+        return historyRepository.merge(user.uid, guestItems);
+    });
 }

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

@@ -1,5 +1,6 @@
+import { type ActionResult } from "@mohasinac/appkit/server";
 import type { ConversationDocument } from "../../../../features/messages/schemas/firestore";
 export interface StartLiveConversationInput {
     productId: string;
 }
-export declare function startLiveConversationAction(input: StartLiveConversationInput): Promise<ConversationDocument>;
+export declare function startLiveConversationAction(input: StartLiveConversationInput): Promise<ActionResult<ConversationDocument>>;

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

@@ -1,24 +1,27 @@
 "use server";
+import { wrapAction } from "@mohasinac/appkit/server";
 import { conversationsRepository } from "../../../../features/messages/repository/conversations.repository";
 import { requireRoleUser } from "../../../../providers/auth-firebase/helpers";
 import { storeRepository, productRepository } from "../../../../repositories";
 export async function startLiveConversationAction(input) {
-    const user = await requireRoleUser(["user", "buyer", "seller", "admin"]);
-    const product = await productRepository.findByIdOrSlug(input.productId);
-    if (!product || product.listingType !== "live") {
-        throw new Error("Product not found or not a live-item listing");
-    }
-    const store = await storeRepository.findById(product.storeId);
-    if (!store) {
-        throw new Error("Store not found");
-    }
-    return conversationsRepository.findOrCreateByContext({
-        buyerId: user.uid,
-        buyerDisplayName: user.name ?? user.email ?? user.uid,
-        storeId: product.storeId,
-        storeName: store.storeName,
-        sellerDisplayName: store.storeName,
-        productId: product.id,
-        productTitle: product.title,
+    return wrapAction(async () => {
+        const user = await requireRoleUser(["user", "buyer", "seller", "admin"]);
+        const product = await productRepository.findByIdOrSlug(input.productId);
+        if (!product || product.listingType !== "live") {
+            throw new Error("Product not found or not a live-item listing");
+        }
+        const store = await storeRepository.findById(product.storeId);
+        if (!store) {
+            throw new Error("Store not found");
+        }
+        return conversationsRepository.findOrCreateByContext({
+            buyerId: user.uid,
+            buyerDisplayName: user.name ?? user.email ?? user.uid,
+            storeId: product.storeId,
+            storeName: store.storeName,
+            sellerDisplayName: store.storeName,
+            productId: product.id,
+            productTitle: product.title,
+        });
     });
 }