@mohasinac/appkit 2.3.2 → 2.4.0

package/dist/features/promotions/repository/coupons.repository.d.ts

@@ -52,12 +52,14 @@ export declare class CouponsRepository extends BaseRepository<CouponDocument> {
      */
     getCouponsExpiringSoon(days?: number): Promise<CouponDocument[]>;
     /**
-     * Validate coupon code (format and availability)
+     * Steps shared by all public validate methods:
+     * 1. Code format  2. DB lookup  3. Validity  4. Per-user limit
      *
-     * @param code - Coupon code to validate
-     * @param userId - User ID attempting to use coupon
-     * @param orderTotal - Order total amount (for validation)
-     * @returns Promise<{valid: boolean, coupon?: CouponDocument, message?: string}>
+     * Returns either an early-exit failure result or the resolved coupon.
+     */
+    private _fetchAndValidateCoupon;
+    /**
+     * Validate coupon against a flat order total (no cart breakdown).
      */
     validateCoupon(code: string, userId: string, orderTotal: number): Promise<{
         valid: boolean;
@@ -66,15 +68,19 @@ export declare class CouponsRepository extends BaseRepository<CouponDocument> {
         message?: string;
     }>;
     /**
-     * Apply coupon to order (increment usage counters)
+     * Record coupon usage after a successful checkout.
      *
-     * @param couponId - Coupon ID
-     * @param userId - User ID
-     * @param orderId - Order ID
-     * @param discountAmount - Applied discount amount
-     * @returns Promise<void>
+     * Increments both the global coupon counter and the per-user usage doc so
+     * that subsequent `validateCoupon` calls respect `perUserLimit` and
+     * `totalLimit` correctly.
+     *
+     * @param couponId      - Coupon document ID (e.g. "coupon-welcome10")
+     * @param couponCode    - Human-readable code (e.g. "WELCOME10")
+     * @param userId        - Buyer UID
+     * @param orderIds      - All order IDs created in this checkout that used the coupon
+     * @param discountAmount - Total discount amount applied across all order groups
      */
-    applyCoupon(couponId: string, userId: string, orderId: string, discountAmount: number): Promise<void>;
+    applyCoupon(couponId: string, couponCode: string, userId: string, orderIds: string[], discountAmount: number): Promise<void>;
     /**
      * Get user's coupon usage count for a specific coupon
      *
@@ -109,7 +115,7 @@ export declare class CouponsRepository extends BaseRepository<CouponDocument> {
      *
      * @param sellerId - The seller's user UID
      */
-    getSellerCoupons(sellerId: string): Promise<CouponDocument[]>;
+    getStoreCoupons(storeId: string): Promise<CouponDocument[]>;
     /**
      * Validate a coupon against the cart items and return a per-item breakdown.
      *
@@ -130,7 +136,7 @@ export declare class CouponsRepository extends BaseRepository<CouponDocument> {
      */
     validateCouponForCart(code: string, userId: string, cartItems: Array<{
         productId: string;
-        sellerId: string;
+        storeId: string;
         price: number;
         quantity: number;
         isPreOrder: boolean;
@@ -142,7 +148,7 @@ export declare class CouponsRepository extends BaseRepository<CouponDocument> {
         eligibleSubtotal?: number;
         eligibleProductIds?: string[];
         scope?: "admin" | "seller";
-        sellerId?: string;
+        storeId?: string;
         message?: string;
     }>;
     static readonly SIEVE_FIELDS: {

package/dist/features/promotions/repository/coupons.repository.js

@@ -4,23 +4,11 @@
  * Manages coupon creation, validation, and usage tracking
  */
 import { BaseRepository, prepareForFirestore, } from "../../../providers/db-firebase";
-import { COUPONS_COLLECTION, isValidCouponCode, isCouponValid, canUserUseCoupon, calculateDiscount, createCouponId, } from "../schemas";
+import { COUPONS_COLLECTION, COUPON_FIELDS, isValidCouponCode, isCouponValid, canUserUseCoupon, calculateDiscount, createCouponId, } from "../schemas";
 import { USER_COLLECTION } from "../../auth/schemas";
 import { DatabaseError } from "../../../errors";
-import { increment, serverTimestamp } from "../../../contracts/field-ops";
+import { increment, arrayUnion, serverTimestamp } from "../../../contracts/field-ops";
 const COUPON_USAGE_SUBCOLLECTION = "couponUsage";
-const COUPON_FIELDS = {
-    CODE: "code",
-    TYPE: "type",
-    CREATED_BY: "createdBy",
-    SELLER_ID: "sellerId",
-    CREATED_AT: "createdAt",
-    VALIDITY_FIELDS: {
-        IS_ACTIVE: "validity.isActive",
-        START_DATE: "validity.startDate",
-        END_DATE: "validity.endDate",
-    },
-};
 /**
  * Repository for coupon management
  */
@@ -87,9 +75,9 @@ export class CouponsRepository extends BaseRepository {
             // validity.isActive ASC + validity.endDate ASC (see firestore.indexes.json)
             const snapshot = await this.db
                 .collection(this.collection)
-                .where(COUPON_FIELDS.VALIDITY_FIELDS.IS_ACTIVE, "==", true)
-                .where(COUPON_FIELDS.VALIDITY_FIELDS.END_DATE, ">=", now)
-                .orderBy(COUPON_FIELDS.VALIDITY_FIELDS.END_DATE, "asc")
+                .where(COUPON_FIELDS.VALIDITY.IS_ACTIVE, "==", true)
+                .where(COUPON_FIELDS.VALIDITY.END_DATE, ">=", now)
+                .orderBy(COUPON_FIELDS.VALIDITY.END_DATE, "asc")
                 .get();
             return snapshot.docs
                 .map((doc) => this.mapDoc(doc))
@@ -147,13 +135,13 @@ export class CouponsRepository extends BaseRepository {
         try {
             const now = new Date();
             const futureDate = new Date(now.getTime() + days * 24 * 60 * 60 * 1000);
-            // Firestore-native range filter — reuses the same composite index as getActiveCoupons()
+            // Firestore-native range filter — reuses the same composite index as getActiveCoupons()
             const snapshot = await this.db
                 .collection(this.collection)
-                .where(COUPON_FIELDS.VALIDITY_FIELDS.IS_ACTIVE, "==", true)
-                .where(COUPON_FIELDS.VALIDITY_FIELDS.END_DATE, ">", now)
-                .where(COUPON_FIELDS.VALIDITY_FIELDS.END_DATE, "<=", futureDate)
-                .orderBy(COUPON_FIELDS.VALIDITY_FIELDS.END_DATE, "asc")
+                .where(COUPON_FIELDS.VALIDITY.IS_ACTIVE, "==", true)
+                .where(COUPON_FIELDS.VALIDITY.END_DATE, ">", now)
+                .where(COUPON_FIELDS.VALIDITY.END_DATE, "<=", futureDate)
+                .orderBy(COUPON_FIELDS.VALIDITY.END_DATE, "asc")
                 .get();
             return snapshot.docs.map((doc) => this.mapDoc(doc));
         }
@@ -161,99 +149,91 @@ export class CouponsRepository extends BaseRepository {
             throw new DatabaseError(`Failed to retrieve expiring coupons: ${error instanceof Error ? error.message : "Unknown error"}`);
         }
     }
+    // ---------------------------------------------------------------------------
+    // Private helpers
+    // ---------------------------------------------------------------------------
     /**
-     * Validate coupon code (format and availability)
+     * Steps shared by all public validate methods:
+     * 1. Code format  2. DB lookup  3. Validity  4. Per-user limit
      *
-     * @param code - Coupon code to validate
-     * @param userId - User ID attempting to use coupon
-     * @param orderTotal - Order total amount (for validation)
-     * @returns Promise<{valid: boolean, coupon?: CouponDocument, message?: string}>
+     * Returns either an early-exit failure result or the resolved coupon.
      */
-    async validateCoupon(code, userId, orderTotal) {
-        // Validate code format
+    async _fetchAndValidateCoupon(code, userId) {
         if (!isValidCouponCode(code)) {
-            return {
-                valid: false,
-                message: "Invalid coupon code format",
-            };
+            return { ok: false, result: { valid: false, message: "Invalid coupon code format" } };
         }
-        // Get coupon from database
         const coupon = await this.getCouponByCode(code);
         if (!coupon) {
-            return {
-                valid: false,
-                message: "Coupon not found",
-            };
+            return { ok: false, result: { valid: false, message: "Coupon not found" } };
         }
-        // Check if coupon is valid (active, date range, usage limits)
         if (!isCouponValid(coupon)) {
-            return {
-                valid: false,
-                coupon,
-                message: "Coupon is not currently valid",
-            };
+            return { ok: false, result: { valid: false, coupon, message: "Coupon is not currently valid" } };
         }
-        // Check minimum purchase requirement
-        if (coupon.discount.minPurchase &&
-            orderTotal < coupon.discount.minPurchase) {
-            return {
-                valid: false,
-                coupon,
-                message: "Minimum purchase requirement not met",
-            };
-        }
-        // Check user-specific usage limit
         const userUsageCount = await this.getUserCouponUsageCount(userId, coupon.id);
         if (!canUserUseCoupon(coupon, userUsageCount)) {
-            return {
-                valid: false,
-                coupon,
-                message: "You have reached the usage limit for this coupon",
-            };
+            return { ok: false, result: { valid: false, coupon, message: "You have reached the usage limit for this coupon" } };
+        }
+        return { ok: true, coupon };
+    }
+    // ---------------------------------------------------------------------------
+    // Public validation methods
+    // ---------------------------------------------------------------------------
+    /**
+     * Validate coupon against a flat order total (no cart breakdown).
+     */
+    async validateCoupon(code, userId, orderTotal) {
+        const check = await this._fetchAndValidateCoupon(code, userId);
+        if (!check.ok)
+            return check.result;
+        const { coupon } = check;
+        if (coupon.discount.minPurchase && orderTotal < coupon.discount.minPurchase) {
+            return { valid: false, coupon, message: "Minimum purchase requirement not met" };
         }
-        // Calculate discount
-        const discountAmount = calculateDiscount(coupon, orderTotal);
         return {
             valid: true,
             coupon,
-            discountAmount,
+            discountAmount: calculateDiscount(coupon, orderTotal),
             message: "Coupon is valid",
         };
     }
     /**
-     * Apply coupon to order (increment usage counters)
+     * Record coupon usage after a successful checkout.
      *
-     * @param couponId - Coupon ID
-     * @param userId - User ID
-     * @param orderId - Order ID
-     * @param discountAmount - Applied discount amount
-     * @returns Promise<void>
+     * Increments both the global coupon counter and the per-user usage doc so
+     * that subsequent `validateCoupon` calls respect `perUserLimit` and
+     * `totalLimit` correctly.
+     *
+     * @param couponId      - Coupon document ID (e.g. "coupon-welcome10")
+     * @param couponCode    - Human-readable code (e.g. "WELCOME10")
+     * @param userId        - Buyer UID
+     * @param orderIds      - All order IDs created in this checkout that used the coupon
+     * @param discountAmount - Total discount amount applied across all order groups
      */
-    async applyCoupon(couponId, userId, orderId, discountAmount) {
+    async applyCoupon(couponId, couponCode, userId, orderIds, discountAmount) {
         try {
             const batch = this.db.batch();
-            // Update coupon usage stats
+            // Increment global coupon counters
             const couponRef = this.db.collection(this.collection).doc(couponId);
             batch.update(couponRef, {
                 "usage.currentUsage": increment(1),
-                "stats.totalDiscountGiven": increment(discountAmount),
-                "stats.totalOrders": increment(1),
+                "stats.totalDiscount": increment(discountAmount),
+                "stats.totalUses": increment(1),
                 updatedAt: new Date(),
             });
-            // Create user coupon usage record
-            const usageData = {
-                userId,
-                couponCode: "", // Will be filled by getCouponByCode
-                orderId,
-                discountAmount,
-                usedAt: new Date(),
-            };
+            // Upsert per-user usage doc — safe for perUserLimit > 1
             const usageRef = this.db
                 .collection(USER_COLLECTION)
                 .doc(userId)
                 .collection(COUPON_USAGE_SUBCOLLECTION)
                 .doc(couponId);
-            batch.set(usageRef, prepareForFirestore(usageData));
+            // FieldValue sentinels (increment, arrayUnion) must NOT go through
+            // prepareForFirestore — it recurses into objects and Object.keys() on a
+            // FieldValue returns [] (non-enumerable internals), silently dropping them.
+            batch.set(usageRef, {
+                ...prepareForFirestore({ userId, couponCode: couponCode.toUpperCase(), lastUsedAt: new Date() }),
+                usageCount: increment(1),
+                orders: arrayUnion(...orderIds),
+            }, { merge: true });
             await batch.commit();
         }
         catch (error) {
@@ -275,7 +255,10 @@ export class CouponsRepository extends BaseRepository {
                 .collection(COUPON_USAGE_SUBCOLLECTION)
                 .doc(couponId)
                 .get();
-            return doc.exists ? 1 : 0; // Document exists = used once (per our schema)
+            if (!doc.exists)
+                return 0;
+            const data = doc.data();
+            return data.usageCount ?? 1;
         }
         catch {
             return 0;
@@ -345,17 +328,17 @@ export class CouponsRepository extends BaseRepository {
      *
      * @param sellerId - The seller's user UID
      */
-    async getSellerCoupons(sellerId) {
+    async getStoreCoupons(storeId) {
         try {
             const snapshot = await this.db
                 .collection(this.collection)
-                .where(COUPON_FIELDS.SELLER_ID, "==", sellerId)
+                .where(COUPON_FIELDS.STORE_ID, "==", storeId)
                 .orderBy(COUPON_FIELDS.CREATED_AT, "desc")
                 .get();
             return snapshot.docs.map((doc) => this.mapDoc(doc));
         }
         catch (error) {
-            throw new DatabaseError(`Failed to retrieve seller coupons: ${error instanceof Error ? error.message : "Unknown error"}`);
+            throw new DatabaseError(`Failed to retrieve store coupons: ${error instanceof Error ? error.message : "Unknown error"}`);
         }
     }
     /**
@@ -377,40 +360,27 @@ export class CouponsRepository extends BaseRepository {
      *          and `eligibleProductIds` (the `productId` values that qualify).
      */
     async validateCouponForCart(code, userId, cartItems) {
-        // Format check
-        if (!isValidCouponCode(code)) {
-            return { valid: false, message: "Invalid coupon code format" };
-        }
-        const coupon = await this.getCouponByCode(code);
-        if (!coupon) {
-            return { valid: false, message: "Coupon not found" };
-        }
-        if (!isCouponValid(coupon)) {
-            return { valid: false, coupon, message: "Coupon is not currently valid" };
-        }
-        const userUsageCount = await this.getUserCouponUsageCount(userId, coupon.id);
-        if (!canUserUseCoupon(coupon, userUsageCount)) {
-            return {
-                valid: false,
-                coupon,
-                message: "You have reached the usage limit for this coupon",
-            };
-        }
-        // Determine eligible items
-        // Pre-order items are always excluded
-        let eligible = cartItems.filter((item) => !item.isPreOrder);
+        const check = await this._fetchAndValidateCoupon(code, userId);
+        if (!check.ok)
+            return check.result;
+        const { coupon } = check;
+        // Determine eligible items — no blanket exclusion by product type.
+        // Coupon flags (applicableToAuctions) decide type eligibility below.
+        let eligible = [...cartItems];
         const scope = coupon.scope ?? "admin";
         if (scope === "seller") {
-            // Restrict to this seller's items
-            eligible = eligible.filter((item) => item.sellerId === coupon.sellerId);
-            if (coupon.applicableToAuctions === true) {
-                // Auction-only coupon
-                eligible = eligible.filter((item) => item.isAuction);
-            }
-            else {
-                // Regular (fixed-price) items only — exclude auctions
-                eligible = eligible.filter((item) => !item.isAuction);
-            }
+            // Restrict to this store's items
+            eligible = eligible.filter((item) => item.storeId === coupon.storeId);
+        }
+        // Apply product-type filter based on the coupon's own flag:
+        //   true  → auction-only coupon
+        //   false → explicitly excludes auctions (but includes pre-orders & simple)
+        //   undefined → no restriction; applies to all product types
+        if (coupon.applicableToAuctions === true) {
+            eligible = eligible.filter((item) => item.isAuction);
+        }
+        else if (coupon.applicableToAuctions === false) {
+            eligible = eligible.filter((item) => !item.isAuction);
         }
         // Apply product/category restrictions from the coupon itself
         const { applicableProducts, applicableCategories, excludeProducts } = coupon.restrictions;
@@ -420,16 +390,18 @@ export class CouponsRepository extends BaseRepository {
         if (excludeProducts && excludeProducts.length > 0) {
             eligible = eligible.filter((item) => !excludeProducts.includes(item.productId));
         }
-        // Note: category filtering requires product metadata — skipped here but
+        // Note: category filtering requires product metadata — skipped here but
         // the restriction is stored and can be enforced by the order service.
         void applicableCategories;
         if (eligible.length === 0) {
             return {
                 valid: false,
                 coupon,
-                message: scope === "seller"
-                    ? "This coupon is not valid for the items in your cart from this store"
-                    : "No eligible items found for this coupon",
+                message: coupon.applicableToAuctions === true
+                    ? "This coupon only applies to auction items"
+                    : scope === "seller"
+                        ? "This coupon is not valid for the items in your cart from this seller"
+                        : "No eligible items found for this coupon",
             };
         }
         const eligibleSubtotal = eligible.reduce((sum, item) => sum + item.price * item.quantity, 0);
@@ -449,7 +421,7 @@ export class CouponsRepository extends BaseRepository {
             eligibleSubtotal,
             eligibleProductIds: eligible.map((item) => item.productId),
             scope,
-            sellerId: coupon.sellerId,
+            storeId: coupon.storeId,
             message: "Coupon is valid",
         };
     }
@@ -478,8 +450,8 @@ export class CouponsRepository extends BaseRepository {
     async getExpiredActiveRefs(now) {
         const snap = await this.db
             .collection(this.collection)
-            .where(COUPON_FIELDS.VALIDITY_FIELDS.IS_ACTIVE, "==", true)
-            .where(COUPON_FIELDS.VALIDITY_FIELDS.END_DATE, "<=", now)
+            .where(COUPON_FIELDS.VALIDITY.IS_ACTIVE, "==", true)
+            .where(COUPON_FIELDS.VALIDITY.END_DATE, "<=", now)
             .limit(500)
             .get();
         return snap.docs.map((d) => d.ref);
@@ -489,7 +461,7 @@ export class CouponsRepository extends BaseRepository {
      */
     deactivateInBatch(batch, ref) {
         batch.update(ref, {
-            [COUPON_FIELDS.VALIDITY_FIELDS.IS_ACTIVE]: false,
+            [COUPON_FIELDS.VALIDITY.IS_ACTIVE]: false,
             updatedAt: serverTimestamp(),
         });
     }

package/dist/features/promotions/schemas/firestore.d.ts

@@ -48,8 +48,8 @@ export interface CouponDocument {
     description: string;
     type: CouponType;
     scope: "admin" | "seller";
-    sellerId?: string;
-    storeSlug?: string;
+    /** For seller-scoped coupons: the storeId (= storeSlug = store.id) of the issuing store */
+    storeId?: string;
     applicableToAuctions?: boolean;
     discount: DiscountConfig;
     bxgy?: BXGYConfig;
@@ -73,6 +73,34 @@ export interface CouponUsageDocument {
 export declare const COUPONS_COLLECTION: "coupons";
 export declare const COUPON_USAGE_SUBCOLLECTION: "couponUsage";
 export declare const COUPONS_INDEXED_FIELDS: readonly ["code", "validity.isActive", "validity.startDate", "validity.endDate", "type", "createdBy"];
+export declare const COUPON_FIELDS: {
+    readonly CODE: "code";
+    readonly TYPE: "type";
+    readonly SCOPE: "scope";
+    readonly CREATED_BY: "createdBy";
+    readonly STORE_ID: "storeId";
+    readonly CREATED_AT: "createdAt";
+    readonly UPDATED_AT: "updatedAt";
+    readonly VALIDITY: {
+        readonly IS_ACTIVE: "validity.isActive";
+        readonly START_DATE: "validity.startDate";
+        readonly END_DATE: "validity.endDate";
+    };
+    readonly USAGE: {
+        readonly CURRENT_USAGE: "usage.currentUsage";
+        readonly TOTAL_LIMIT: "usage.totalLimit";
+    };
+    readonly TYPE_VALUES: {
+        readonly PERCENTAGE: CouponType;
+        readonly FIXED: CouponType;
+        readonly FREE_SHIPPING: CouponType;
+        readonly BUY_X_GET_Y: CouponType;
+    };
+    readonly SCOPE_VALUES: {
+        readonly ADMIN: "admin";
+        readonly SELLER: "seller";
+    };
+};
 export declare const COUPON_TYPE_LABELS: Record<CouponType, string>;
 export declare const DEFAULT_COUPON_DATA: Partial<CouponDocument>;
 export declare const COUPONS_PUBLIC_FIELDS: readonly ["id", "code", "name", "description", "type", "discount", "validity.startDate", "validity.endDate", "usage.totalLimit", "usage.perUserLimit"];
@@ -93,6 +121,7 @@ export declare const couponQueryHelpers: {
     readonly inactive: () => readonly ["validity.isActive", "==", false];
     readonly byType: (type: CouponType) => readonly ["type", "==", CouponType];
     readonly byCreator: (userId: string) => readonly ["createdBy", "==", string];
+    readonly byStore: (storeId: string) => readonly ["storeId", "==", string];
     readonly expiringSoon: (days?: number) => readonly ["validity.endDate", "<=", Date];
 };
 export declare function createCouponId(code: string): string;

package/dist/features/promotions/schemas/firestore.js

@@ -12,6 +12,34 @@ export const COUPONS_INDEXED_FIELDS = [
     "type",
     "createdBy",
 ];
+export const COUPON_FIELDS = {
+    CODE: "code",
+    TYPE: "type",
+    SCOPE: "scope",
+    CREATED_BY: "createdBy",
+    STORE_ID: "storeId",
+    CREATED_AT: "createdAt",
+    UPDATED_AT: "updatedAt",
+    VALIDITY: {
+        IS_ACTIVE: "validity.isActive",
+        START_DATE: "validity.startDate",
+        END_DATE: "validity.endDate",
+    },
+    USAGE: {
+        CURRENT_USAGE: "usage.currentUsage",
+        TOTAL_LIMIT: "usage.totalLimit",
+    },
+    TYPE_VALUES: {
+        PERCENTAGE: "percentage",
+        FIXED: "fixed",
+        FREE_SHIPPING: "free_shipping",
+        BUY_X_GET_Y: "buy_x_get_y",
+    },
+    SCOPE_VALUES: {
+        ADMIN: "admin",
+        SELLER: "seller",
+    },
+};
 export const COUPON_TYPE_LABELS = {
     percentage: "Percentage Discount",
     fixed: "Fixed Amount Discount",
@@ -52,6 +80,7 @@ export const couponQueryHelpers = {
     inactive: () => ["validity.isActive", "==", false],
     byType: (type) => ["type", "==", type],
     byCreator: (userId) => ["createdBy", "==", userId],
+    byStore: (storeId) => ["storeId", "==", storeId],
     expiringSoon: (days = 7) => {
         const futureDate = new Date();
         futureDate.setDate(futureDate.getDate() + days);

package/dist/features/promotions/schemas/index.d.ts

@@ -31,7 +31,6 @@ export declare const couponItemSchema: z.ZodObject<{
     getQuantity: z.ZodOptional<z.ZodNumber>;
     applicableProductIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     applicableCategoryIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    sellerId: z.ZodOptional<z.ZodString>;
     storeId: z.ZodOptional<z.ZodString>;
     isPublic: z.ZodBoolean;
     isActive: z.ZodBoolean;
@@ -49,17 +48,16 @@ export declare const couponItemSchema: z.ZodObject<{
     updatedAt: string;
     isActive: boolean;
     description: string;
-    isPublic: boolean;
     discountValue: number;
+    isPublic: boolean;
     usageCount: number;
-    sellerId?: string | undefined;
-    startsAt?: string | undefined;
     storeId?: string | undefined;
+    startsAt?: string | undefined;
+    perUserLimit?: number | undefined;
     expiresAt?: string | undefined;
     minOrderAmount?: number | undefined;
     maxDiscountAmount?: number | undefined;
     maxUsageCount?: number | undefined;
-    perUserLimit?: number | undefined;
     buyQuantity?: number | undefined;
     getQuantity?: number | undefined;
     applicableProductIds?: string[] | undefined;
@@ -74,17 +72,16 @@ export declare const couponItemSchema: z.ZodObject<{
     updatedAt: string;
     isActive: boolean;
     description: string;
-    isPublic: boolean;
     discountValue: number;
+    isPublic: boolean;
     usageCount: number;
-    sellerId?: string | undefined;
-    startsAt?: string | undefined;
     storeId?: string | undefined;
+    startsAt?: string | undefined;
+    perUserLimit?: number | undefined;
     expiresAt?: string | undefined;
     minOrderAmount?: number | undefined;
     maxDiscountAmount?: number | undefined;
     maxUsageCount?: number | undefined;
-    perUserLimit?: number | undefined;
     buyQuantity?: number | undefined;
     getQuantity?: number | undefined;
     applicableProductIds?: string[] | undefined;
@@ -93,7 +90,7 @@ export declare const couponItemSchema: z.ZodObject<{
 export declare const promotionsListParamsSchema: z.ZodObject<{
     scope: z.ZodOptional<z.ZodEnum<["admin", "seller"]>>;
     isActive: z.ZodOptional<z.ZodBoolean>;
-    sellerId: z.ZodOptional<z.ZodString>;
+    storeId: z.ZodOptional<z.ZodString>;
     page: z.ZodOptional<z.ZodNumber>;
     pageSize: z.ZodOptional<z.ZodNumber>;
     filters: z.ZodOptional<z.ZodString>;
@@ -105,7 +102,7 @@ export declare const promotionsListParamsSchema: z.ZodObject<{
     page?: number | undefined;
     pageSize?: number | undefined;
     filters?: string | undefined;
-    sellerId?: string | undefined;
+    storeId?: string | undefined;
 }, {
     sort?: string | undefined;
     scope?: "admin" | "seller" | undefined;
@@ -113,5 +110,5 @@ export declare const promotionsListParamsSchema: z.ZodObject<{
     page?: number | undefined;
     pageSize?: number | undefined;
     filters?: string | undefined;
-    sellerId?: string | undefined;
+    storeId?: string | undefined;
 }>;

package/dist/features/promotions/schemas/index.js

@@ -38,7 +38,6 @@ export const couponItemSchema = z.object({
     getQuantity: z.number().optional(),
     applicableProductIds: z.array(z.string()).optional(),
     applicableCategoryIds: z.array(z.string()).optional(),
-    sellerId: z.string().optional(),
     storeId: z.string().optional(),
     isPublic: z.boolean(),
     isActive: z.boolean(),
@@ -50,7 +49,7 @@ export const couponItemSchema = z.object({
 export const promotionsListParamsSchema = z.object({
     scope: couponScopeSchema.optional(),
     isActive: z.coerce.boolean().optional(),
-    sellerId: z.string().optional(),
+    storeId: z.string().optional(),
     page: z.coerce.number().optional(),
     pageSize: z.coerce.number().optional(),
     filters: z.string().optional(),

package/dist/features/promotions/types/index.d.ts

@@ -17,7 +17,6 @@ export interface CouponItem {
     getQuantity?: number;
     applicableProductIds?: string[];
     applicableCategoryIds?: string[];
-    sellerId?: string;
     storeId?: string;
     isPublic: boolean;
     isActive: boolean;
@@ -43,7 +42,7 @@ export interface PromotionsListResponse {
 export interface PromotionsListParams {
     scope?: CouponScope;
     isActive?: boolean;
-    sellerId?: string;
+    storeId?: string;
     page?: number;
     pageSize?: number;
     filters?: string;

package/dist/features/reviews/actions/review-actions.js

@@ -29,7 +29,8 @@ export async function createReview(userId, input) {
     return reviewRepository.create({
         productId: input.productId,
         productTitle: product.title,
-        sellerId: product.sellerId,
+        storeId: product.storeId,
+        storeName: product.storeName,
         userId,
         userName: profile?.displayName ?? "Anonymous",
         userAvatar: profile?.photoURL ?? "",
@@ -159,7 +160,7 @@ export async function listAdminReviews(params) {
     return reviewRepository.listAll(sieve);
 }
 export async function listReviewsBySeller(sellerId) {
-    const products = await productRepository.findBySeller(sellerId);
+    const products = await productRepository.findByStore(sellerId);
     const productIds = products
         .filter((product) => product.status === ProductStatusValues.PUBLISHED)
         .map((product) => product.id);