@mohasinac/appkit 3.0.6 → 3.1.0

package/dist/features/cart/repository/__tests__/cart.repository.test.js

@@ -0,0 +1,371 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { makeMockDb, makeSnap } from "../../../../../tests/helpers/mock-firestore";
+const { db, mockDocRef, mockCollection, mockQuery } = makeMockDb();
+vi.mock("../../../../providers/db-firebase/admin", () => ({
+    getAdminDb: () => db,
+}));
+vi.mock("../../../../providers/db-firebase", async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        prepareForFirestore: (d) => d,
+    };
+});
+vi.mock("../../../../errors/normalize", () => ({
+    normalizeError: vi.fn(),
+}));
+vi.mock("../../../../security", () => ({
+    decryptPii: (v) => v,
+    encryptPii: (v) => v,
+}));
+import { CartRepository } from "../cart.repository";
+import { ValidationError, NotFoundError } from "../../../../errors";
+const repo = new CartRepository();
+function makeItem(overrides = {}) {
+    return {
+        itemId: "item-1",
+        productId: "product-x",
+        productTitle: "Test Product",
+        productImage: "img.jpg",
+        price: 1000,
+        currency: "INR",
+        quantity: 1,
+        storeId: "store-1",
+        storeName: "Store",
+        listingType: "standard",
+        locked: false,
+        addedAt: new Date(),
+        updatedAt: new Date(),
+        ...overrides,
+    };
+}
+function makeCart(overrides = {}) {
+    return {
+        id: "user-1",
+        userId: "user-1",
+        items: [],
+        appliedCoupons: [],
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        ...overrides,
+    };
+}
+function makeAddInput(overrides = {}) {
+    return {
+        productId: "product-new",
+        productTitle: "New Product",
+        productImage: "new.jpg",
+        price: 500,
+        currency: "INR",
+        quantity: 1,
+        storeId: "store-1",
+        storeName: "Store",
+        listingType: "standard",
+        ...overrides,
+    };
+}
+beforeEach(() => {
+    vi.clearAllMocks();
+    db.collection.mockReturnValue(mockCollection);
+    mockCollection.doc.mockReturnValue(mockDocRef);
+    mockCollection.where.mockReturnValue(mockQuery);
+    mockQuery.where.mockReturnValue(mockQuery);
+    mockQuery.limit.mockReturnValue(mockQuery);
+    mockQuery.get.mockResolvedValue({ docs: [], empty: true });
+    mockDocRef.get.mockResolvedValue(makeSnap(null));
+    mockDocRef.set.mockResolvedValue(undefined);
+    mockDocRef.update.mockResolvedValue(undefined);
+});
+// ---------------------------------------------------------------------------
+// getOrCreate
+// ---------------------------------------------------------------------------
+describe("CartRepository.getOrCreate", () => {
+    it("existing cart → returns it without writing", async () => {
+        const cart = makeCart({ items: [makeItem()] });
+        mockDocRef.get.mockResolvedValue(makeSnap(cart, "user-1"));
+        const result = await repo.getOrCreate("user-1");
+        expect(result.id).toBe("user-1");
+        expect(mockDocRef.set).not.toHaveBeenCalled();
+    });
+    it("no cart → creates empty cart and returns it", async () => {
+        mockDocRef.get.mockResolvedValue(makeSnap(null));
+        const result = await repo.getOrCreate("user-2");
+        expect(result.items).toHaveLength(0);
+        expect(mockDocRef.set).toHaveBeenCalledOnce();
+    });
+    it("created cart has userId and id set", async () => {
+        mockDocRef.get.mockResolvedValue(makeSnap(null));
+        const result = await repo.getOrCreate("user-3");
+        expect(result.userId).toBe("user-3");
+        expect(result.id).toBe("user-3");
+    });
+});
+// ---------------------------------------------------------------------------
+// addItem
+// ---------------------------------------------------------------------------
+describe("CartRepository.addItem", () => {
+    it("new productId → appended to items array", async () => {
+        const cart = makeCart({ items: [] });
+        mockDocRef.get.mockResolvedValue(makeSnap(cart, "user-1"));
+        const result = await repo.addItem("user-1", makeAddInput({ productId: "product-a" }));
+        expect(result.items).toHaveLength(1);
+        expect(result.items[0].productId).toBe("product-a");
+    });
+    it("duplicate productId (no offerId) → quantity merged, no duplicate item", async () => {
+        const cart = makeCart({ items: [makeItem({ productId: "product-x", quantity: 2 })] });
+        mockDocRef.get.mockResolvedValue(makeSnap(cart, "user-1"));
+        const result = await repo.addItem("user-1", makeAddInput({ productId: "product-x", quantity: 3 }));
+        expect(result.items).toHaveLength(1);
+        expect(result.items[0].quantity).toBe(5);
+    });
+    it("duplicate productId with offerId → treated as separate item", async () => {
+        const cart = makeCart({
+            items: [makeItem({ productId: "product-x", offerId: "offer-1" })],
+        });
+        mockDocRef.get.mockResolvedValue(makeSnap(cart, "user-1"));
+        const result = await repo.addItem("user-1", makeAddInput({ productId: "product-x", offerId: "offer-2" }));
+        expect(result.items).toHaveLength(2);
+    });
+    it("same offerId already in cart → idempotent, cart unchanged", async () => {
+        const cart = makeCart({
+            items: [makeItem({ productId: "product-x", offerId: "offer-1" })],
+        });
+        mockDocRef.get.mockResolvedValue(makeSnap(cart, "user-1"));
+        const result = await repo.addItem("user-1", makeAddInput({ productId: "product-x", offerId: "offer-1" }));
+        expect(result.items).toHaveLength(1);
+        expect(mockDocRef.set).not.toHaveBeenCalled();
+    });
+    it("stores bundleCategorySlug and bundleProductIds when present", async () => {
+        const cart = makeCart({ items: [] });
+        mockDocRef.get.mockResolvedValue(makeSnap(cart, "user-1"));
+        const result = await repo.addItem("user-1", makeAddInput({
+            bundleCategorySlug: "category-pokemon",
+            bundleProductIds: ["product-a", "product-b"],
+        }));
+        expect(result.items[0].bundleCategorySlug).toBe("category-pokemon");
+        expect(result.items[0].bundleProductIds).toEqual(["product-a", "product-b"]);
+    });
+    it("assigns a random itemId to new items", async () => {
+        const cart = makeCart({ items: [] });
+        mockDocRef.get.mockResolvedValue(makeSnap(cart, "user-1"));
+        const result = await repo.addItem("user-1", makeAddInput());
+        expect(result.items[0].itemId).toBeTruthy();
+        expect(typeof result.items[0].itemId).toBe("string");
+    });
+});
+// ---------------------------------------------------------------------------
+// removeItem
+// ---------------------------------------------------------------------------
+describe("CartRepository.removeItem", () => {
+    it("unlocked item → removed, remaining items intact", async () => {
+        const item1 = makeItem({ itemId: "item-1", productId: "p1" });
+        const item2 = makeItem({ itemId: "item-2", productId: "p2" });
+        const cart = makeCart({ items: [item1, item2] });
+        mockDocRef.get.mockResolvedValue(makeSnap(cart, "user-1"));
+        const result = await repo.removeItem("user-1", "item-1");
+        expect(result.items).toHaveLength(1);
+        expect(result.items[0].itemId).toBe("item-2");
+    });
+    it("locked item → throws ValidationError", async () => {
+        const lockedItem = makeItem({ itemId: "item-locked", locked: true });
+        const cart = makeCart({ items: [lockedItem] });
+        mockDocRef.get.mockResolvedValue(makeSnap(cart, "user-1"));
+        await expect(repo.removeItem("user-1", "item-locked")).rejects.toBeInstanceOf(ValidationError);
+    });
+    it("non-existent itemId → throws NotFoundError", async () => {
+        const cart = makeCart({ items: [makeItem()] });
+        mockDocRef.get.mockResolvedValue(makeSnap(cart, "user-1"));
+        await expect(repo.removeItem("user-1", "item-nonexistent")).rejects.toBeInstanceOf(NotFoundError);
+    });
+});
+// ---------------------------------------------------------------------------
+// updateItem
+// ---------------------------------------------------------------------------
+describe("CartRepository.updateItem", () => {
+    it("unlocked item → quantity updated", async () => {
+        const item = makeItem({ itemId: "item-1", quantity: 1 });
+        const cart = makeCart({ items: [item] });
+        mockDocRef.get.mockResolvedValue(makeSnap(cart, "user-1"));
+        const result = await repo.updateItem("user-1", "item-1", { quantity: 5 });
+        expect(result.items[0].quantity).toBe(5);
+    });
+    it("locked item → throws ValidationError", async () => {
+        const item = makeItem({ itemId: "item-1", locked: true });
+        const cart = makeCart({ items: [item] });
+        mockDocRef.get.mockResolvedValue(makeSnap(cart, "user-1"));
+        await expect(repo.updateItem("user-1", "item-1", { quantity: 5 })).rejects.toBeInstanceOf(ValidationError);
+    });
+    it("non-existent itemId → throws NotFoundError", async () => {
+        const cart = makeCart({ items: [] });
+        mockDocRef.get.mockResolvedValue(makeSnap(cart, "user-1"));
+        await expect(repo.updateItem("user-1", "item-x", { quantity: 1 })).rejects.toBeInstanceOf(NotFoundError);
+    });
+});
+// ---------------------------------------------------------------------------
+// clearCart
+// ---------------------------------------------------------------------------
+describe("CartRepository.clearCart", () => {
+    it("unlocked items removed, locked items remain", async () => {
+        const unlocked = makeItem({ itemId: "item-u", locked: false });
+        const locked = makeItem({ itemId: "item-l", locked: true });
+        const cart = makeCart({ items: [unlocked, locked] });
+        mockDocRef.get.mockResolvedValue(makeSnap(cart, "user-1"));
+        const result = await repo.clearCart("user-1");
+        expect(result.items).toHaveLength(1);
+        expect(result.items[0].itemId).toBe("item-l");
+    });
+    it("no locked items → items cleared to empty", async () => {
+        const cart = makeCart({ items: [makeItem({ locked: false })] });
+        mockDocRef.get.mockResolvedValue(makeSnap(cart, "user-1"));
+        const result = await repo.clearCart("user-1");
+        expect(result.items).toHaveLength(0);
+    });
+});
+// ---------------------------------------------------------------------------
+// getSubtotal
+// ---------------------------------------------------------------------------
+describe("CartRepository.getSubtotal", () => {
+    it("single item: price * quantity", () => {
+        const cart = makeCart({ items: [makeItem({ price: 200, quantity: 3 })] });
+        expect(repo.getSubtotal(cart)).toBe(600);
+    });
+    it("multiple items: summed correctly", () => {
+        const cart = makeCart({
+            items: [
+                makeItem({ price: 1000, quantity: 1 }),
+                makeItem({ itemId: "item-2", productId: "p2", price: 500, quantity: 2 }),
+            ],
+        });
+        expect(repo.getSubtotal(cart)).toBe(2000);
+    });
+    it("empty cart → 0", () => {
+        expect(repo.getSubtotal(makeCart())).toBe(0);
+    });
+    it("uses item.price (not lockedPrice) in the calculation", () => {
+        const item = makeItem({ price: 1000, quantity: 1, lockedPrice: 750 });
+        const cart = makeCart({ items: [item] });
+        // current implementation uses price, not lockedPrice
+        expect(repo.getSubtotal(cart)).toBe(1000);
+    });
+});
+// ---------------------------------------------------------------------------
+// getItemCount
+// ---------------------------------------------------------------------------
+describe("CartRepository.getItemCount", () => {
+    it("returns sum of all item quantities (not distinct item count)", () => {
+        const cart = makeCart({
+            items: [
+                makeItem({ quantity: 3 }),
+                makeItem({ itemId: "item-2", productId: "p2", quantity: 2 }),
+            ],
+        });
+        // 3 + 2 = 5 total quantity units
+        expect(repo.getItemCount(cart)).toBe(5);
+    });
+    it("single item qty 1 → 1", () => {
+        const cart = makeCart({ items: [makeItem({ quantity: 1 })] });
+        expect(repo.getItemCount(cart)).toBe(1);
+    });
+    it("empty cart → 0", () => {
+        expect(repo.getItemCount(makeCart())).toBe(0);
+    });
+});
+// ---------------------------------------------------------------------------
+// addCoupon / removeCoupon / clearAllCoupons
+// ---------------------------------------------------------------------------
+describe("CartRepository.addCoupon", () => {
+    it("stores coupon in appliedCoupons", async () => {
+        const cart = makeCart({ appliedCoupons: [] });
+        mockDocRef.get.mockResolvedValue(makeSnap(cart, "user-1"));
+        await repo.addCoupon("user-1", { code: "SAVE10", scope: "admin", discountAmount: 100 });
+        expect(mockDocRef.set).toHaveBeenCalledWith(expect.objectContaining({
+            appliedCoupons: expect.arrayContaining([
+                expect.objectContaining({ code: "SAVE10" }),
+            ]),
+        }), { merge: true });
+    });
+    it("same code already applied → replaces it (upsert)", async () => {
+        const cart = makeCart({
+            appliedCoupons: [{ code: "SAVE10", scope: "admin", discountAmount: 50 }],
+        });
+        mockDocRef.get.mockResolvedValue(makeSnap(cart, "user-1"));
+        await repo.addCoupon("user-1", { code: "SAVE10", scope: "admin", discountAmount: 100 });
+        const setCall = mockDocRef.set.mock.calls[0][0];
+        const codes = setCall.appliedCoupons.map((c) => c.code);
+        expect(codes.filter((c) => c === "SAVE10")).toHaveLength(1);
+        expect(setCall.appliedCoupons[0].discountAmount).toBe(100);
+    });
+});
+describe("CartRepository.removeCoupon", () => {
+    it("removes coupon matching given code, leaves others", async () => {
+        const cart = makeCart({
+            appliedCoupons: [
+                { code: "SAVE10", scope: "admin" },
+                { code: "STORE5", scope: "seller" },
+            ],
+        });
+        mockDocRef.get.mockResolvedValue(makeSnap(cart, "user-1"));
+        await repo.removeCoupon("user-1", "SAVE10");
+        const setCall = mockDocRef.set.mock.calls[0][0];
+        expect(setCall.appliedCoupons).toHaveLength(1);
+        expect(setCall.appliedCoupons[0].code).toBe("STORE5");
+    });
+    it("code not present → no change, no error", async () => {
+        const cart = makeCart({ appliedCoupons: [{ code: "STORE5", scope: "seller" }] });
+        mockDocRef.get.mockResolvedValue(makeSnap(cart, "user-1"));
+        await repo.removeCoupon("user-1", "NOTHERE");
+        const setCall = mockDocRef.set.mock.calls[0][0];
+        expect(setCall.appliedCoupons).toHaveLength(1);
+    });
+});
+describe("CartRepository.clearAllCoupons", () => {
+    it("sets appliedCoupons: []", async () => {
+        await repo.clearAllCoupons("user-1");
+        expect(mockDocRef.set).toHaveBeenCalledWith(expect.objectContaining({ appliedCoupons: [] }), { merge: true });
+    });
+});
+// ---------------------------------------------------------------------------
+// setSelectedItems
+// ---------------------------------------------------------------------------
+describe("CartRepository.setSelectedItems", () => {
+    it("stores itemIds array in selectedItemIds", async () => {
+        await repo.setSelectedItems("user-1", ["item-1", "item-2"]);
+        expect(mockDocRef.set).toHaveBeenCalledWith(expect.objectContaining({ selectedItemIds: ["item-1", "item-2"] }), { merge: true });
+    });
+    it("null → clears selectedItemIds (all items selected)", async () => {
+        await repo.setSelectedItems("user-1", null);
+        expect(mockDocRef.set).toHaveBeenCalledWith(expect.objectContaining({ selectedItemIds: null }), { merge: true });
+    });
+});
+// ---------------------------------------------------------------------------
+// getStaleRefs
+// ---------------------------------------------------------------------------
+describe("CartRepository.getStaleRefs", () => {
+    it("queries where updatedAt < cutoff date", async () => {
+        mockQuery.get.mockResolvedValue({ docs: [] });
+        await repo.getStaleRefs(30);
+        expect(mockCollection.where).toHaveBeenCalledWith("updatedAt", "<", expect.any(Date));
+    });
+    it("default ttl is 30 days", async () => {
+        const before = new Date();
+        before.setDate(before.getDate() - 30);
+        mockQuery.get.mockResolvedValue({ docs: [] });
+        await repo.getStaleRefs();
+        const whereCall = mockCollection.where.mock.calls[0];
+        const cutoff = whereCall[2];
+        expect(cutoff.getTime()).toBeLessThanOrEqual(new Date().getTime());
+        expect(cutoff.getTime()).toBeGreaterThanOrEqual(before.getTime() - 1000);
+    });
+    it("returns refs for stale carts", async () => {
+        const fakeRef = { id: "old-cart" };
+        mockQuery.get.mockResolvedValue({ docs: [{ ref: fakeRef }] });
+        const refs = await repo.getStaleRefs(30);
+        expect(refs).toHaveLength(1);
+        expect(refs[0]).toBe(fakeRef);
+    });
+    it("no stale carts → empty array", async () => {
+        mockQuery.get.mockResolvedValue({ docs: [] });
+        const refs = await repo.getStaleRefs(30);
+        expect(refs).toHaveLength(0);
+    });
+});

package/dist/features/cart/repository/cart.repository.js

@@ -151,7 +151,7 @@ export class CartRepository extends BaseRepository {
             return updatedCart;
         }
         catch (error) {
-            if (error instanceof DatabaseError || error instanceof NotFoundError) {
+            if (error instanceof DatabaseError || error instanceof NotFoundError || error instanceof ValidationError) {
                 throw error;
             }
             throw new DatabaseError("Failed to update cart item", error);
@@ -180,7 +180,7 @@ export class CartRepository extends BaseRepository {
             return updatedCart;
         }
         catch (error) {
-            if (error instanceof DatabaseError || error instanceof NotFoundError) {
+            if (error instanceof DatabaseError || error instanceof NotFoundError || error instanceof ValidationError) {
                 throw error;
             }
             throw new DatabaseError("Failed to remove cart item", error);

package/dist/features/categories/api/[id]/route.d.ts

@@ -15,9 +15,9 @@ export declare function GET(_request: Request, context: {
     }>;
 }): Promise<NextResponse>;
 export { GET as categoryItemGET };
-export declare const categoryItemPATCH: (request: Request, context: {
+export declare const categoryItemPATCH: (request: Request, context?: {
     params: Promise<Record<string, string>>;
-}) => Promise<Response>;
-export declare const categoryItemDELETE: (request: Request, context: {
+} | undefined) => Promise<Response>;
+export declare const categoryItemDELETE: (request: Request, context?: {
     params: Promise<Record<string, string>>;
-}) => Promise<Response>;
+} | undefined) => Promise<Response>;

package/dist/features/categories/api/route.d.ts

@@ -14,6 +14,6 @@
  */
 import { NextResponse } from "next/server.js";
 export declare function GET(request: Request): Promise<NextResponse>;
-export declare const POST: (request: Request, context: {
+export declare const POST: (request: Request, context?: {
     params: Promise<Record<string, string>>;
-}) => Promise<Response>;
+} | undefined) => Promise<Response>;

package/dist/features/categories/repository/__tests__/categories.repository.test.d.ts

@@ -0,0 +1 @@
+export {};