@mohasinac/appkit 4.60.1 → 4.62.0

package/dist/features/products/components/ProductGrid.js

@@ -184,7 +184,7 @@ export function ProductCard({ product, href, onClick, onAddToWishlist, isWishlis
      * `justify-end` keeps it on the side the eye already uses for card actions;
      * `pt-0` because the card body's own bottom padding is the gap.
      */
-    return (_jsxs(Div, { className: "flex h-full flex-col", children: [wrapped, _jsx(Div, { className: "flex justify-end px-[var(--appkit-space-3)] pb-[var(--appkit-space-3)] pt-0", children: ownerActions })] }));
+    return (_jsxs(Div, { layout: "flex-col", className: "h-full", children: [wrapped, _jsx(Div, { layout: "flex", justify: "end", className: "px-[var(--appkit-space-3)] pb-[var(--appkit-space-3)]", children: ownerActions })] }));
 }
 function ProductListRow({ product, onClick, onAddToWishlist, isWishlisted, }) {
     const discount = product.originalPrice && product.originalPrice > product.price

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

@@ -7,6 +7,7 @@
  */
 import { BaseRepository, prepareForFirestore, } from "../../../providers/db-firebase/index.js";
 import { normalizeError } from "../../../errors/normalize.js";
+import { serverLogger } from "../../../monitoring/index.js";
 import { CLAIMED_COUPONS_COLLECTION, createClaimedCouponId } from "../schemas/index.js";
 import { DatabaseError } from "../../../errors/index.js";
 import { COUPON_USAGE_FIELDS } from "../../../constants/field-names.js";
@@ -128,10 +129,39 @@ export class ClaimedCouponsRepository extends BaseRepository {
             if (snap.empty)
                 return 0;
             const writer = this.db.bulkWriter();
+            /*
+             * 🛑 `onWriteError` FIRST, before any write is queued.
+             *
+             * `BulkWriter.update()` returns a promise per write and the contract is
+             * not to await them individually — `close()` is what flushes. But an
+             * un-awaited promise that rejects is an unhandled rejection, which is
+             * what `@typescript-eslint/no-floating-promises` was reporting, and
+             * `void`-ing it would silence the lint while keeping the hazard.
+             *
+             * Registering the handler is the real fix: a failed row is RECORDED and
+             * the batch continues, which is the right behaviour for a denormalised
+             * snapshot refresh — one stale coupon card is not worth abandoning the
+             * other 499, and the method's docstring already says it must not throw.
+             */
+            let failed = 0;
+            writer.onWriteError((err) => {
+                failed++;
+                serverLogger.warn("claimedCoupons: snapshot refresh failed for one row", {
+                    documentPath: err.documentRef.path,
+                    error: err.message,
+                });
+                return false; // do not retry — the next refresh picks it up
+            });
             for (const doc of snap.docs) {
-                writer.update(doc.ref, { couponSnapshot: snapshot, updatedAt: new Date() });
+                void writer.update(doc.ref, { couponSnapshot: snapshot, updatedAt: new Date() });
             }
             await writer.close();
+            if (failed > 0) {
+                serverLogger.warn("claimedCoupons: snapshot refresh partially failed", {
+                    failed,
+                    total: snap.size,
+                });
+            }
             return snap.size;
         }
         catch (error) {

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

@@ -12,6 +12,21 @@ export interface DiscountConfig {
 export interface BXGYConfig {
     buyQuantity: number;
     getQuantity: number;
+    /**
+     * Per-UNIT price ceiling, in decimal rupees. A unit priced above this does
+     * not qualify: it neither counts toward a block nor can be given free.
+     *
+     * 🛑 This is a UNIT price, not a line total and not the order total — the
+     * promotion it exists for is "buy 3 get 1 free on items under ₹2,000", and
+     * `discount.minPurchase` already covers the order-total reading. A line of
+     * quantity 3 at ₹1,500 contributes three qualifying units, not one ₹4,500
+     * item that fails the ceiling.
+     *
+     * Omitted means no ceiling, which is what every BOGO coupon written before
+     * 2026-10-22 means. Do not default it to a number — a ceiling nobody asked
+     * for would silently shrink an existing coupon's discount.
+     */
+    maxItemPrice?: number;
     applicableProducts?: string[];
     applicableCategories?: string[];
 }
@@ -194,6 +209,13 @@ export interface DiscountableLine {
  *
  * 🛑 An INCOMPLETE block earns nothing. "Buy 2 get 1" on 2 units is a block of
  * 2 against a required 3, so the discount is 0 — not a partial credit.
+ *
+ * 🛑 `bxgy.maxItemPrice` filters the UNIT POOL before blocks are formed, so an
+ * over-ceiling unit neither counts toward a block nor can be free. Filtering
+ * only the free-unit selection instead would let four ₹5,000 tops earn a free
+ * one under an "items under ₹2,000" promotion, because the cheapest of four
+ * dear units is still dear. The ceiling defines what the promotion is ABOUT,
+ * not merely what it pays out.
  */
 export declare function calculateBxgyDiscount(bxgy: BXGYConfig | undefined, lines: readonly DiscountableLine[]): number;
 export declare function calculateDiscount(coupon: CouponDocument, orderTotal: number, 

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

@@ -159,6 +159,13 @@ export function canUserUseCoupon(coupon, userUsageCount) {
  *
  * 🛑 An INCOMPLETE block earns nothing. "Buy 2 get 1" on 2 units is a block of
  * 2 against a required 3, so the discount is 0 — not a partial credit.
+ *
+ * 🛑 `bxgy.maxItemPrice` filters the UNIT POOL before blocks are formed, so an
+ * over-ceiling unit neither counts toward a block nor can be free. Filtering
+ * only the free-unit selection instead would let four ₹5,000 tops earn a free
+ * one under an "items under ₹2,000" promotion, because the cheapest of four
+ * dear units is still dear. The ceiling defines what the promotion is ABOUT,
+ * not merely what it pays out.
  */
 export function calculateBxgyDiscount(bxgy, lines) {
     if (!bxgy)
@@ -169,6 +176,16 @@ export function calculateBxgyDiscount(bxgy, lines) {
     // unit free, which is a misconfiguration, not a promotion.
     if (!Number.isFinite(buy) || !Number.isFinite(get) || buy <= 0 || get <= 0)
         return 0;
+    /*
+     * A non-finite or non-positive ceiling is a misconfiguration, and treating
+     * it as "0" would disqualify every unit and silently zero the coupon. Treat
+     * it as absent — the same thing an omitted ceiling means.
+     */
+    const ceiling = typeof bxgy.maxItemPrice === "number" &&
+        Number.isFinite(bxgy.maxItemPrice) &&
+        bxgy.maxItemPrice > 0
+        ? bxgy.maxItemPrice
+        : undefined;
     // Expand to one entry per UNIT — a line of quantity 3 contributes 3 prices,
     // because the free units are counted in units, not in lines.
     const unitPrices = [];
@@ -178,6 +195,11 @@ export function calculateBxgyDiscount(bxgy, lines) {
             continue;
         if (!Number.isFinite(line.price) || line.price < 0)
             continue;
+        // Inclusive: "under ₹2,000" is authored as maxItemPrice 1999 when the
+        // boundary matters. An exclusive test here would make a ₹2,000 ceiling
+        // reject a ₹2,000 item, which is not how a price cap reads to an admin.
+        if (ceiling !== undefined && line.price > ceiling)
+            continue;
         for (let i = 0; i < qty; i++)
             unitPrices.push(line.price);
     }