@mohasinac/appkit 3.0.6 → 3.1.0

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

@@ -92,8 +92,8 @@ export declare const productItemSchema: z.ZodObject<{
     categorySlug: z.ZodOptional<z.ZodString>;
     sellerAvatar: z.ZodOptional<z.ZodString>;
     status: z.ZodEnum<["draft", "published", "in_review", "archived"]>;
-    condition: z.ZodOptional<z.ZodEnum<["new", "like_new", "good", "fair", "poor", "used", "refurbished", "broken"]>>;
-    listingType: z.ZodOptional<z.ZodEnum<["standard", "auction", "pre-order", "prize-draw", "bundle"]>>;
+    condition: z.ZodOptional<z.ZodEnum<["new", "like_new", "good", "fair", "poor", "used", "refurbished", "broken", "graded"]>>;
+    listingType: z.ZodOptional<z.ZodEnum<["standard", "auction", "pre-order", "prize-draw", "classified", "digital-code", "live"]>>;
     maxPerUser: z.ZodOptional<z.ZodNumber>;
     partOfBundleIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     partOfBundleTitles: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
@@ -296,7 +296,7 @@ export declare const productItemSchema: z.ZodObject<{
     storeId?: string | undefined;
     category?: string | undefined;
     featured?: boolean | undefined;
-    listingType?: "standard" | "auction" | "pre-order" | "prize-draw" | "bundle" | undefined;
+    listingType?: "standard" | "auction" | "pre-order" | "prize-draw" | "classified" | "digital-code" | "live" | undefined;
     isPromoted?: boolean | undefined;
     createdAt?: string | undefined;
     description?: string | undefined;
@@ -316,7 +316,7 @@ export declare const productItemSchema: z.ZodObject<{
     features?: string[] | undefined;
     shippingInfo?: string | undefined;
     returnPolicy?: string | undefined;
-    condition?: "new" | "used" | "refurbished" | "broken" | "like_new" | "good" | "fair" | "poor" | undefined;
+    condition?: "new" | "used" | "refurbished" | "like_new" | "good" | "fair" | "poor" | "broken" | "graded" | undefined;
     insurance?: boolean | undefined;
     insuranceCost?: number | undefined;
     shippingPaidBy?: "seller" | "buyer" | undefined;
@@ -425,7 +425,7 @@ export declare const productItemSchema: z.ZodObject<{
     storeId?: string | undefined;
     category?: string | undefined;
     featured?: boolean | undefined;
-    listingType?: "standard" | "auction" | "pre-order" | "prize-draw" | "bundle" | undefined;
+    listingType?: "standard" | "auction" | "pre-order" | "prize-draw" | "classified" | "digital-code" | "live" | undefined;
     isPromoted?: boolean | undefined;
     createdAt?: string | undefined;
     description?: string | undefined;
@@ -445,7 +445,7 @@ export declare const productItemSchema: z.ZodObject<{
     features?: string[] | undefined;
     shippingInfo?: string | undefined;
     returnPolicy?: string | undefined;
-    condition?: "new" | "used" | "refurbished" | "broken" | "like_new" | "good" | "fair" | "poor" | undefined;
+    condition?: "new" | "used" | "refurbished" | "like_new" | "good" | "fair" | "poor" | "broken" | "graded" | undefined;
     insurance?: boolean | undefined;
     insuranceCost?: number | undefined;
     shippingPaidBy?: "seller" | "buyer" | undefined;
@@ -547,11 +547,11 @@ export declare const productListParamsSchema: z.ZodObject<{
     q: z.ZodOptional<z.ZodString>;
     category: z.ZodOptional<z.ZodString>;
     status: z.ZodOptional<z.ZodEnum<["draft", "published", "in_review", "archived"]>>;
-    condition: z.ZodOptional<z.ZodEnum<["new", "like_new", "good", "fair", "poor", "used", "refurbished", "broken"]>>;
+    condition: z.ZodOptional<z.ZodEnum<["new", "like_new", "good", "fair", "poor", "used", "refurbished", "broken", "graded"]>>;
     minPrice: z.ZodOptional<z.ZodNumber>;
     maxPrice: z.ZodOptional<z.ZodNumber>;
     inStock: z.ZodOptional<z.ZodBoolean>;
-    listingType: z.ZodOptional<z.ZodEnum<["standard", "auction", "pre-order", "prize-draw", "bundle"]>>;
+    listingType: z.ZodOptional<z.ZodEnum<["standard", "auction", "pre-order", "prize-draw", "classified", "digital-code", "live"]>>;
     storeId: z.ZodOptional<z.ZodString>;
     sort: z.ZodOptional<z.ZodString>;
     page: z.ZodOptional<z.ZodNumber>;
@@ -563,8 +563,8 @@ export declare const productListParamsSchema: z.ZodObject<{
     storeId?: string | undefined;
     category?: string | undefined;
     featured?: boolean | undefined;
-    listingType?: "standard" | "auction" | "pre-order" | "prize-draw" | "bundle" | undefined;
-    condition?: "new" | "used" | "refurbished" | "broken" | "like_new" | "good" | "fair" | "poor" | undefined;
+    listingType?: "standard" | "auction" | "pre-order" | "prize-draw" | "classified" | "digital-code" | "live" | undefined;
+    condition?: "new" | "used" | "refurbished" | "like_new" | "good" | "fair" | "poor" | "broken" | "graded" | undefined;
     page?: number | undefined;
     q?: string | undefined;
     perPage?: number | undefined;
@@ -577,8 +577,8 @@ export declare const productListParamsSchema: z.ZodObject<{
     storeId?: string | undefined;
     category?: string | undefined;
     featured?: boolean | undefined;
-    listingType?: "standard" | "auction" | "pre-order" | "prize-draw" | "bundle" | undefined;
-    condition?: "new" | "used" | "refurbished" | "broken" | "like_new" | "good" | "fair" | "poor" | undefined;
+    listingType?: "standard" | "auction" | "pre-order" | "prize-draw" | "classified" | "digital-code" | "live" | undefined;
+    condition?: "new" | "used" | "refurbished" | "like_new" | "good" | "fair" | "poor" | "broken" | "graded" | undefined;
     page?: number | undefined;
     q?: string | undefined;
     perPage?: number | undefined;

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

@@ -64,11 +64,12 @@ export const productItemSchema = z.object({
         "used",
         "refurbished",
         "broken",
+        "graded",
     ])
         .optional(),
     // SB1-G Phase 4 — canonical discriminator (legacy `isAuction`/`isPreOrder` booleans removed).
     listingType: z
-        .enum(["standard", "auction", "pre-order", "prize-draw", "bundle"])
+        .enum(["standard", "auction", "pre-order", "prize-draw", "classified", "digital-code", "live"])
         .optional(),
     // SB1-C — prize-draw + bundle fields. All optional.
     maxPerUser: z.number().int().positive().optional(),
@@ -205,13 +206,14 @@ export const productListParamsSchema = z.object({
         "used",
         "refurbished",
         "broken",
+        "graded",
     ])
         .optional(),
     minPrice: z.coerce.number().optional(),
     maxPrice: z.coerce.number().optional(),
     inStock: z.coerce.boolean().optional(),
     listingType: z
-        .enum(["standard", "auction", "pre-order", "prize-draw", "bundle"])
+        .enum(["standard", "auction", "pre-order", "prize-draw", "classified", "digital-code", "live"])
         .optional(),
     storeId: z.string().optional(),
     sort: z.string().optional(),

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

@@ -2,7 +2,7 @@ import type { MediaField } from "../../media/types/index";
 import type { CustomField, CustomSection } from "../schemas/firestore";
 export type { CustomField, CustomSection } from "../schemas/firestore";
 export type ProductStatus = "draft" | "published" | "in_review" | "archived";
-export type ProductCondition = "new" | "like_new" | "good" | "fair" | "poor" | "used" | "refurbished" | "broken";
+export type ProductCondition = "new" | "like_new" | "good" | "fair" | "poor" | "used" | "refurbished" | "broken" | "graded";
 /**
  * Canonical listing-kind discriminator (SB1-G Phase 4).
  *

package/dist/features/promotions/repository/__tests__/claimed-coupons.repository.test.d.ts

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

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

@@ -0,0 +1,219 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { makeMockDb, makeSnap, makeQuerySnap } 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(),
+}));
+import { ClaimedCouponsRepository } from "../claimed-coupons.repository";
+import { createClaimedCouponId } from "../../schemas";
+const repo = new ClaimedCouponsRepository();
+function makeClaimInput(overrides = {}) {
+    return {
+        userId: "user-yugi",
+        couponId: "coupon-welcome10",
+        couponCode: "welcome10",
+        source: "manual",
+        couponSnapshot: {
+            name: "10% Off Coupon",
+            type: "percentage",
+            scope: "admin",
+            discount: { value: 10, maxDiscount: 0, minPurchase: 0 },
+            restrictions: { firstTimeUserOnly: false, combineWithSellerCoupons: true },
+        },
+        expiresAt: null,
+        ...overrides,
+    };
+}
+function makeClaimDoc(userId = "user-yugi", code = "WELCOME10") {
+    return {
+        id: createClaimedCouponId(userId, code),
+        userId,
+        couponId: "coupon-welcome10",
+        couponCode: code,
+        source: "manual",
+        status: "active",
+        expiresAt: null,
+        claimedAt: new Date(),
+        updatedAt: new Date(),
+        couponSnapshot: {},
+    };
+}
+beforeEach(() => {
+    vi.clearAllMocks();
+    db.collection.mockReturnValue(mockCollection);
+    mockCollection.doc.mockReturnValue(mockDocRef);
+    mockCollection.where.mockReturnValue(mockQuery);
+    mockQuery.where.mockReturnValue(mockQuery);
+    mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+    mockDocRef.get.mockResolvedValue(makeSnap(null));
+    mockDocRef.set.mockResolvedValue(undefined);
+    mockDocRef.update.mockResolvedValue(undefined);
+});
+// ---------------------------------------------------------------------------
+// findByUserAndCode
+// ---------------------------------------------------------------------------
+describe("ClaimedCouponsRepository.findByUserAndCode", () => {
+    it("existing claim → returns document", async () => {
+        const doc = makeClaimDoc();
+        mockDocRef.get.mockResolvedValue(makeSnap(doc, doc.id));
+        const result = await repo.findByUserAndCode("user-yugi", "WELCOME10");
+        expect(result).not.toBeNull();
+        expect(result.couponCode).toBe("WELCOME10");
+    });
+    it("no claim → returns null", async () => {
+        mockDocRef.get.mockResolvedValue(makeSnap(null));
+        const result = await repo.findByUserAndCode("user-yugi", "NOTFOUND");
+        expect(result).toBeNull();
+    });
+    it("uses deterministic ID based on userId + couponCode", async () => {
+        mockDocRef.get.mockResolvedValue(makeSnap(null));
+        await repo.findByUserAndCode("user-yugi", "WELCOME10");
+        const expectedId = createClaimedCouponId("user-yugi", "WELCOME10");
+        expect(mockCollection.doc).toHaveBeenCalledWith(expectedId);
+    });
+});
+// ---------------------------------------------------------------------------
+// claim
+// ---------------------------------------------------------------------------
+describe("ClaimedCouponsRepository.claim", () => {
+    it("first call → creates record with status: active", async () => {
+        mockDocRef.get.mockResolvedValue(makeSnap(null));
+        const result = await repo.claim(makeClaimInput());
+        expect(result.status).toBe("active");
+        expect(mockDocRef.set).toHaveBeenCalledOnce();
+    });
+    it("second call for same user + code → returns existing record (idempotent)", async () => {
+        const existingDoc = makeClaimDoc();
+        mockDocRef.get.mockResolvedValue(makeSnap(existingDoc, existingDoc.id));
+        const result = await repo.claim(makeClaimInput());
+        expect(mockDocRef.set).not.toHaveBeenCalled();
+        expect(result.id).toBe(existingDoc.id);
+    });
+    it("couponCode normalized to uppercase on create", async () => {
+        mockDocRef.get.mockResolvedValue(makeSnap(null));
+        const result = await repo.claim(makeClaimInput({ couponCode: "welcome10" }));
+        expect(result.couponCode).toBe("WELCOME10");
+    });
+    it("expiresAt stored as provided (null case)", async () => {
+        mockDocRef.get.mockResolvedValue(makeSnap(null));
+        const result = await repo.claim(makeClaimInput({ expiresAt: null }));
+        expect(result.expiresAt).toBeNull();
+    });
+    it("expiresAt stored as provided (date case)", async () => {
+        const exp = new Date(Date.now() + 86400000);
+        mockDocRef.get.mockResolvedValue(makeSnap(null));
+        const result = await repo.claim(makeClaimInput({ expiresAt: exp }));
+        expect(result.expiresAt).toEqual(exp);
+    });
+    it("uses createClaimedCouponId for the document ID", async () => {
+        mockDocRef.get.mockResolvedValue(makeSnap(null));
+        await repo.claim(makeClaimInput({ userId: "user-yugi", couponCode: "SAVE20" }));
+        const expectedId = createClaimedCouponId("user-yugi", "SAVE20");
+        expect(mockCollection.doc).toHaveBeenCalledWith(expectedId);
+    });
+});
+// ---------------------------------------------------------------------------
+// listForUser
+// ---------------------------------------------------------------------------
+describe("ClaimedCouponsRepository.listForUser", () => {
+    it("queries by userId field", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        await repo.listForUser("user-yugi");
+        expect(mockCollection.where).toHaveBeenCalledWith("userId", "==", "user-yugi");
+    });
+    it("valid coupon (not expired) → returned without mutation", async () => {
+        const futureDate = new Date(Date.now() + 86400000);
+        const doc = { ...makeClaimDoc(), status: "active", expiresAt: futureDate };
+        mockQuery.get.mockResolvedValue(makeQuerySnap([{ id: doc.id, data: doc }]));
+        const results = await repo.listForUser("user-yugi");
+        expect(results[0].status).toBe("active");
+        expect(mockDocRef.update).not.toHaveBeenCalled();
+    });
+    it("active coupon with no expiresAt → not lazily expired", async () => {
+        const doc = { ...makeClaimDoc(), status: "active", expiresAt: null };
+        mockQuery.get.mockResolvedValue(makeQuerySnap([{ id: doc.id, data: doc }]));
+        const results = await repo.listForUser("user-yugi");
+        expect(results[0].status).toBe("active");
+        expect(mockDocRef.update).not.toHaveBeenCalled();
+    });
+    it("expired coupon found on read → lazy-flips status to expired in returned item", async () => {
+        const pastDate = new Date(Date.now() - 86400000);
+        const doc = { ...makeClaimDoc(), status: "active", expiresAt: pastDate };
+        mockQuery.get.mockResolvedValue(makeQuerySnap([{ id: doc.id, data: doc }]));
+        const results = await repo.listForUser("user-yugi");
+        expect(results[0].status).toBe("expired");
+    });
+    it("expired coupon → best-effort write-back update called (fire-and-forget)", async () => {
+        const pastDate = new Date(Date.now() - 86400000);
+        const doc = { ...makeClaimDoc(), status: "active", expiresAt: pastDate };
+        mockQuery.get.mockResolvedValue(makeQuerySnap([{ id: doc.id, data: doc }]));
+        await repo.listForUser("user-yugi");
+        // Allow the fire-and-forget to complete
+        await new Promise((r) => setTimeout(r, 10));
+        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ status: "expired" }));
+    });
+    it("already-expired coupon → no write-back (only active transitions)", async () => {
+        const pastDate = new Date(Date.now() - 86400000);
+        const doc = { ...makeClaimDoc(), status: "expired", expiresAt: pastDate };
+        mockQuery.get.mockResolvedValue(makeQuerySnap([{ id: doc.id, data: doc }]));
+        await repo.listForUser("user-yugi");
+        await new Promise((r) => setTimeout(r, 10));
+        expect(mockDocRef.update).not.toHaveBeenCalled();
+    });
+    it("empty list → returns []", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        const results = await repo.listForUser("user-nobody");
+        expect(results).toHaveLength(0);
+    });
+});
+// ---------------------------------------------------------------------------
+// markUsed
+// ---------------------------------------------------------------------------
+describe("ClaimedCouponsRepository.markUsed", () => {
+    it("sets status: used on the claim document", async () => {
+        await repo.markUsed("user-yugi", "WELCOME10", "order-1-20260101-abc");
+        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ status: "used" }));
+    });
+    it("stores usedOrderId on the claim", async () => {
+        await repo.markUsed("user-yugi", "WELCOME10", "order-1-20260101-abc");
+        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ usedOrderId: "order-1-20260101-abc" }));
+    });
+    it("sets usedAt timestamp", async () => {
+        await repo.markUsed("user-yugi", "WELCOME10", "order-x");
+        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ usedAt: expect.any(Date) }));
+    });
+    it("uses the correct document ID (userId + code)", async () => {
+        await repo.markUsed("user-yugi", "WELCOME10", "order-x");
+        const expectedId = createClaimedCouponId("user-yugi", "WELCOME10");
+        expect(mockCollection.doc).toHaveBeenCalledWith(expectedId);
+    });
+});
+// ---------------------------------------------------------------------------
+// softRemove
+// ---------------------------------------------------------------------------
+describe("ClaimedCouponsRepository.softRemove", () => {
+    it("sets status: expired (audit trail preserved, no delete)", async () => {
+        await repo.softRemove("user-yugi", "WELCOME10");
+        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ status: "expired" }));
+        expect(mockDocRef.delete).not.toHaveBeenCalled();
+    });
+    it("does NOT call delete on the document", async () => {
+        await repo.softRemove("user-yugi", "SAVE20");
+        expect(mockDocRef.delete).not.toHaveBeenCalled();
+    });
+    it("uses the correct document ID (userId + code)", async () => {
+        await repo.softRemove("user-yugi", "SAVE20");
+        const expectedId = createClaimedCouponId("user-yugi", "SAVE20");
+        expect(mockCollection.doc).toHaveBeenCalledWith(expectedId);
+    });
+});

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

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