@mohasinac/appkit 3.0.6 → 3.1.0

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

@@ -0,0 +1,607 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { makeMockDb, makeSnap, makeQuerySnap } from "../../../../../tests/helpers/mock-firestore";
+const { db, mockDocRef, mockCollection, mockQuery, mockBatch } = makeMockDb();
+const { mockCacheManager } = vi.hoisted(() => ({
+    mockCacheManager: {
+        get: vi.fn().mockReturnValue(null),
+        set: vi.fn(),
+        delete: vi.fn(),
+    },
+}));
+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("../../../../contracts/field-ops", () => ({
+    serverTimestamp: () => new Date(),
+    increment: (n) => n,
+    arrayUnion: (...args) => args,
+    arrayRemove: (...args) => args,
+    deleteField: () => null,
+    registerFieldOps: vi.fn(),
+}));
+vi.mock("../../../../core", () => ({
+    cacheManager: mockCacheManager,
+}));
+vi.mock("../../../../errors/normalize", () => ({ normalizeError: vi.fn() }));
+vi.mock("../../../../monitoring", () => ({
+    serverLogger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+}));
+// buildSearchTokens returns an array of tokens — mock as passthrough
+vi.mock("../../../../utils", () => ({
+    generateUniqueId: vi.fn(async (gen, exists) => {
+        const candidate = gen(0);
+        const taken = await exists(candidate);
+        return taken ? gen(1) : candidate;
+    }),
+    slugify: (s) => s.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, ""),
+    buildSearchTokens: (...args) => args.flat().filter(Boolean),
+    tokenizeQuery: (q) => q.trim() ? q.trim().toLowerCase().split(/\s+/) : [],
+    generateBarcodeId: (id) => Promise.resolve(`barcode-${id}`),
+}));
+import { ProductRepository } from "../products.repository";
+const repo = new ProductRepository();
+function makeProductDoc(overrides = {}) {
+    return {
+        id: "product-charizard-psa9",
+        slug: "product-charizard-psa9",
+        title: "Charizard PSA 9",
+        description: "1st Edition base set Charizard PSA 9",
+        brand: "Pokemon",
+        brandSlug: "brand-pokemon",
+        storeId: "store-pokemon-palace",
+        categorySlug: "category-trading-cards",
+        categorySlugs: ["category-trading-cards", "category-pokemon"],
+        listingType: "standard",
+        status: "published",
+        price: 50000,
+        currency: "INR",
+        stockQuantity: 1,
+        availableQuantity: 1,
+        currentBid: 0,
+        bidCount: 0,
+        viewCount: 0,
+        searchTokens: ["charizard", "psa9"],
+        barcodeId: "barcode-product-charizard-psa9",
+        images: [],
+        tags: [],
+        features: [],
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        ...overrides,
+    };
+}
+beforeEach(() => {
+    vi.clearAllMocks();
+    mockCacheManager.get.mockReturnValue(null);
+    db.collection.mockReturnValue(mockCollection);
+    mockCollection.doc.mockReturnValue(mockDocRef);
+    mockCollection.where.mockReturnValue(mockQuery);
+    mockCollection.get = vi.fn().mockResolvedValue(makeQuerySnap([]));
+    mockQuery.where.mockReturnValue(mockQuery);
+    mockQuery.orderBy.mockReturnValue(mockQuery);
+    mockQuery.limit.mockReturnValue(mockQuery);
+    mockQuery.offset = vi.fn().mockReturnValue(mockQuery);
+    mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+    mockQuery.count.mockReturnValue({
+        get: vi.fn().mockResolvedValue({ data: () => ({ count: 0 }) }),
+    });
+    mockDocRef.get.mockResolvedValue(makeSnap(makeProductDoc(), "product-charizard-psa9"));
+    mockDocRef.set.mockResolvedValue(undefined);
+    mockDocRef.update.mockResolvedValue(undefined);
+    mockDocRef.delete.mockResolvedValue(undefined);
+    db.batch.mockReturnValue(mockBatch);
+    db.getAll = vi.fn().mockResolvedValue([]);
+});
+// ---------------------------------------------------------------------------
+// findById — caching
+// ---------------------------------------------------------------------------
+describe("ProductRepository.findById — caching", () => {
+    it("returns cached product without hitting Firestore on warm cache", async () => {
+        const cached = makeProductDoc();
+        mockCacheManager.get.mockReturnValue(cached);
+        const result = await repo.findById("product-charizard-psa9");
+        expect(result?.id).toBe("product-charizard-psa9");
+        expect(mockDocRef.get).not.toHaveBeenCalled();
+    });
+    it("fetches from Firestore on cache miss and caches result", async () => {
+        mockCacheManager.get.mockReturnValue(null);
+        const product = makeProductDoc();
+        mockDocRef.get.mockResolvedValue(makeSnap(product, "product-charizard-psa9"));
+        await repo.findById("product-charizard-psa9");
+        expect(mockDocRef.get).toHaveBeenCalledOnce();
+        expect(mockCacheManager.set).toHaveBeenCalledWith(expect.stringContaining("product-charizard-psa9"), expect.any(Object), expect.objectContaining({ ttl: 30000 }));
+    });
+    it("returns null when product does not exist (Firestore miss)", async () => {
+        mockCacheManager.get.mockReturnValue(null);
+        mockDocRef.get.mockResolvedValue(makeSnap(null));
+        const result = await repo.findById("nonexistent");
+        expect(result).toBeNull();
+    });
+    it("does NOT cache null results (product not found)", async () => {
+        mockCacheManager.get.mockReturnValue(null);
+        mockDocRef.get.mockResolvedValue(makeSnap(null));
+        await repo.findById("nonexistent");
+        expect(mockCacheManager.set).not.toHaveBeenCalled();
+    });
+});
+// ---------------------------------------------------------------------------
+// delete — cache invalidation
+// ---------------------------------------------------------------------------
+describe("ProductRepository.delete — cache invalidation", () => {
+    it("invalidates cache entry before deleting", async () => {
+        await repo.delete("product-charizard-psa9");
+        expect(mockCacheManager.delete).toHaveBeenCalledWith(expect.stringContaining("product-charizard-psa9"));
+        // delete happens before or alongside cache invalidation
+        expect(mockDocRef.delete).toHaveBeenCalledOnce();
+    });
+    it("deletes the Firestore document", async () => {
+        await repo.delete("product-charizard-psa9");
+        expect(mockDocRef.delete).toHaveBeenCalledOnce();
+    });
+});
+// ---------------------------------------------------------------------------
+// create
+// ---------------------------------------------------------------------------
+describe("ProductRepository.create", () => {
+    beforeEach(() => {
+        // After doc.set, findById is called to re-read — return the stored product
+        mockDocRef.get.mockResolvedValue(makeSnap(null));
+    });
+    it("uses title to generate the slug when no explicit slug provided", async () => {
+        await repo.create({
+            title: "Hot Wheels Redline Vintage",
+            storeId: "store-diecast-depot",
+            price: 5000,
+            currency: "INR",
+            stockQuantity: 3,
+            listingType: "standard",
+        });
+        // generateUniqueId calls gen(0) = slugify("Hot Wheels Redline Vintage")
+        expect(mockCollection.doc).toHaveBeenCalledWith("hot-wheels-redline-vintage");
+    });
+    it("uses explicit slug when provided", async () => {
+        await repo.create({
+            title: "Anything",
+            slug: "product-custom-slug",
+            storeId: "store-1",
+            price: 1000,
+            currency: "INR",
+            stockQuantity: 1,
+            listingType: "standard",
+        });
+        expect(mockCollection.doc).toHaveBeenCalledWith("product-custom-slug");
+    });
+    it("builds and stores searchTokens", async () => {
+        await repo.create({
+            title: "Charizard",
+            storeId: "store-1",
+            price: 1000,
+            currency: "INR",
+            stockQuantity: 1,
+            listingType: "standard",
+        });
+        const setArg = mockDocRef.set.mock.calls[0][0];
+        expect(Array.isArray(setArg.searchTokens)).toBe(true);
+    });
+    it("sets availableQuantity from stockQuantity", async () => {
+        await repo.create({
+            title: "Test Product",
+            storeId: "store-1",
+            price: 1000,
+            currency: "INR",
+            stockQuantity: 5,
+            listingType: "standard",
+        });
+        const setArg = mockDocRef.set.mock.calls[0][0];
+        expect(setArg.availableQuantity).toBe(5);
+    });
+    it("generates barcodeId when not provided", async () => {
+        await repo.create({
+            title: "New Product",
+            storeId: "store-1",
+            price: 1000,
+            currency: "INR",
+            stockQuantity: 1,
+            listingType: "standard",
+        });
+        const setArg = mockDocRef.set.mock.calls[0][0];
+        expect(setArg.barcodeId).toBeDefined();
+        expect(typeof setArg.barcodeId).toBe("string");
+    });
+    it("uses provided barcodeId when given", async () => {
+        await repo.create({
+            title: "New Product",
+            barcodeId: "custom-barcode-123",
+            storeId: "store-1",
+            price: 1000,
+            currency: "INR",
+            stockQuantity: 1,
+            listingType: "standard",
+        });
+        const setArg = mockDocRef.set.mock.calls[0][0];
+        expect(setArg.barcodeId).toBe("custom-barcode-123");
+    });
+    it("caches the newly created product", async () => {
+        await repo.create({
+            title: "Cache Me",
+            storeId: "store-1",
+            price: 1000,
+            currency: "INR",
+            stockQuantity: 1,
+            listingType: "standard",
+        });
+        expect(mockCacheManager.set).toHaveBeenCalled();
+    });
+    it("sets createdAt and updatedAt timestamps", async () => {
+        await repo.create({
+            title: "New Product",
+            storeId: "store-1",
+            price: 1000,
+            currency: "INR",
+            stockQuantity: 1,
+            listingType: "standard",
+        });
+        const setArg = mockDocRef.set.mock.calls[0][0];
+        expect(setArg.createdAt).toBeInstanceOf(Date);
+        expect(setArg.updatedAt).toBeInstanceOf(Date);
+    });
+});
+// ---------------------------------------------------------------------------
+// updateBid
+// ---------------------------------------------------------------------------
+describe("ProductRepository.updateBid", () => {
+    it("updates currentBid field", async () => {
+        const product = makeProductDoc();
+        mockDocRef.get.mockResolvedValue(makeSnap(product, product.id));
+        await repo.updateBid("product-charizard-psa9", 75000, 5);
+        const updateArg = mockDocRef.update.mock.calls[0][0];
+        expect(updateArg.currentBid).toBe(75000);
+    });
+    it("updates bidCount field", async () => {
+        const product = makeProductDoc();
+        mockDocRef.get.mockResolvedValue(makeSnap(product, product.id));
+        await repo.updateBid("product-charizard-psa9", 75000, 5);
+        const updateArg = mockDocRef.update.mock.calls[0][0];
+        expect(updateArg.bidCount).toBe(5);
+    });
+});
+// ---------------------------------------------------------------------------
+// startGroup
+// ---------------------------------------------------------------------------
+describe("ProductRepository.startGroup", () => {
+    it("sets groupId, isGroupParent: true, and groupChildSlugs: []", async () => {
+        await repo.startGroup("product-charizard-psa9", "group-pokemon-starter-bundle");
+        expect(mockDocRef.update).toHaveBeenCalledWith({
+            groupId: "group-pokemon-starter-bundle",
+            isGroupParent: true,
+            groupChildSlugs: [],
+        });
+    });
+    it("calls doc(productId) to target the correct product", async () => {
+        await repo.startGroup("product-abc", "group-xyz");
+        expect(mockCollection.doc).toHaveBeenCalledWith("product-abc");
+    });
+});
+// ---------------------------------------------------------------------------
+// dissolveGroup
+// ---------------------------------------------------------------------------
+describe("ProductRepository.dissolveGroup", () => {
+    it("clears groupId and group fields from all members in a batch", async () => {
+        const members = [
+            makeProductDoc({ id: "product-1", groupId: "group-1" }),
+            makeProductDoc({ id: "product-2", groupId: "group-1" }),
+        ];
+        mockQuery.get.mockResolvedValue(makeQuerySnap(members.map((m) => ({ id: m.id, data: m }))));
+        await repo.dissolveGroup("group-1");
+        expect(mockBatch.update).toHaveBeenCalledTimes(2);
+        const calls = mockBatch.update.mock.calls;
+        expect(calls.every((c) => c[1].groupId === null)).toBe(true);
+        expect(mockBatch.commit).toHaveBeenCalledOnce();
+    });
+    it("does not call batch.update when group has no members", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        await repo.dissolveGroup("group-empty");
+        expect(mockBatch.update).not.toHaveBeenCalled();
+        expect(mockBatch.commit).toHaveBeenCalledOnce();
+    });
+    it("clears all group fields (isGroupParent, groupParentSlug, groupChildSlugs, groupTitle)", async () => {
+        const parent = makeProductDoc({ id: "p-1", groupId: "group-1", isGroupParent: true });
+        mockQuery.get.mockResolvedValue(makeQuerySnap([{ id: "p-1", data: parent }]));
+        await repo.dissolveGroup("group-1");
+        const updateArg = mockBatch.update.mock.calls[0][1];
+        expect(updateArg.isGroupParent).toBeNull();
+        expect(updateArg.groupParentSlug).toBeNull();
+        expect(updateArg.groupChildSlugs).toBeNull();
+        expect(updateArg.groupTitle).toBeNull();
+    });
+});
+// ---------------------------------------------------------------------------
+// linkChildToGroup
+// ---------------------------------------------------------------------------
+describe("ProductRepository.linkChildToGroup", () => {
+    it("batch-updates child with groupId, groupParentSlug", async () => {
+        const parent = makeProductDoc({
+            id: "product-parent",
+            groupId: "group-1",
+            groupChildSlugs: [],
+            slug: "product-parent",
+        });
+        const child = makeProductDoc({ id: "product-child", slug: "product-child" });
+        await repo.linkChildToGroup(parent, child);
+        const calls = mockBatch.update.mock.calls;
+        const childUpdate = calls.find((c) => c[1].groupId === "group-1");
+        expect(childUpdate).toBeDefined();
+        expect(childUpdate[1].groupParentSlug).toBe("product-parent");
+        expect(mockBatch.commit).toHaveBeenCalledOnce();
+    });
+    it("appends child id to parent's groupChildSlugs", async () => {
+        const parent = makeProductDoc({
+            id: "product-parent",
+            groupId: "group-1",
+            groupChildSlugs: ["product-existing"],
+            slug: "product-parent",
+        });
+        const child = makeProductDoc({ id: "product-new-child", slug: "product-new-child" });
+        await repo.linkChildToGroup(parent, child);
+        const calls = mockBatch.update.mock.calls;
+        const parentUpdate = calls.find((c) => Array.isArray(c[1].groupChildSlugs));
+        expect(parentUpdate[1].groupChildSlugs).toContain("product-new-child");
+        expect(parentUpdate[1].groupChildSlugs).toContain("product-existing");
+    });
+});
+// ---------------------------------------------------------------------------
+// unlinkChildFromGroup
+// ---------------------------------------------------------------------------
+describe("ProductRepository.unlinkChildFromGroup", () => {
+    it("clears child's groupId and groupParentSlug", async () => {
+        const parent = makeProductDoc({ id: "p-parent", groupChildSlugs: ["p-child"], slug: "p-parent" });
+        const child = makeProductDoc({ id: "p-child", groupId: "group-1", groupParentSlug: "p-parent" });
+        await repo.unlinkChildFromGroup(parent, child);
+        const calls = mockBatch.update.mock.calls;
+        const childUpdate = calls.find((c) => c[1].groupId === null);
+        expect(childUpdate).toBeDefined();
+        expect(childUpdate[1].groupParentSlug).toBeNull();
+        expect(mockBatch.commit).toHaveBeenCalledOnce();
+    });
+    it("removes child from parent's groupChildSlugs", async () => {
+        const parent = makeProductDoc({
+            id: "p-parent",
+            groupChildSlugs: ["p-child", "p-other"],
+            slug: "p-parent",
+        });
+        const child = makeProductDoc({ id: "p-child", slug: "p-child" });
+        await repo.unlinkChildFromGroup(parent, child);
+        const calls = mockBatch.update.mock.calls;
+        const parentUpdate = calls.find((c) => Array.isArray(c[1].groupChildSlugs));
+        expect(parentUpdate[1].groupChildSlugs).not.toContain("p-child");
+        expect(parentUpdate[1].groupChildSlugs).toContain("p-other");
+    });
+});
+// ---------------------------------------------------------------------------
+// getExpiredAuctions
+// ---------------------------------------------------------------------------
+describe("ProductRepository.getExpiredAuctions", () => {
+    it("queries listingType==auction, auctionEndDate < now, status==published", async () => {
+        const now = new Date();
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        await repo.getExpiredAuctions(now);
+        expect(mockCollection.where).toHaveBeenCalledWith(expect.stringContaining("listingType"), "==", "auction");
+        expect(mockQuery.where).toHaveBeenCalledWith(expect.stringContaining("auctionEndDate"), "<", now);
+        expect(mockQuery.where).toHaveBeenCalledWith(expect.stringContaining("status"), "==", "published");
+    });
+    it("limits to 500 documents", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        await repo.getExpiredAuctions(new Date());
+        expect(mockQuery.limit).toHaveBeenCalledWith(500);
+    });
+    it("returns { id, ref, data } tuples", async () => {
+        const auction = makeProductDoc({ id: "auction-expired", listingType: "auction" });
+        mockQuery.get.mockResolvedValue(makeQuerySnap([{ id: "auction-expired", data: auction }]));
+        const result = await repo.getExpiredAuctions(new Date());
+        expect(result).toHaveLength(1);
+        expect(result[0].id).toBe("auction-expired");
+        expect(result[0].data).toBeDefined();
+        expect(result[0].ref).toBeDefined();
+    });
+    it("returns empty array when no expired auctions", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        const result = await repo.getExpiredAuctions(new Date());
+        expect(result).toEqual([]);
+    });
+});
+// ---------------------------------------------------------------------------
+// updateStatusInBatch
+// ---------------------------------------------------------------------------
+describe("ProductRepository.updateStatusInBatch", () => {
+    it("stages status update in the caller's batch without committing", () => {
+        const callerBatch = { update: vi.fn(), commit: vi.fn() };
+        repo.updateStatusInBatch(callerBatch, "product-1", "draft");
+        expect(callerBatch.update).toHaveBeenCalledOnce();
+        expect(callerBatch.update).toHaveBeenCalledWith(expect.any(Object), expect.objectContaining({ status: "draft" }));
+        expect(callerBatch.commit).not.toHaveBeenCalled();
+    });
+    it("sets updatedAt timestamp in the staged update", () => {
+        const callerBatch = { update: vi.fn(), commit: vi.fn() };
+        repo.updateStatusInBatch(callerBatch, "product-1", "suspended");
+        expect(callerBatch.update).toHaveBeenCalledWith(expect.any(Object), expect.objectContaining({ updatedAt: expect.any(Date) }));
+    });
+});
+// ---------------------------------------------------------------------------
+// incrementBidCountInBatch
+// ---------------------------------------------------------------------------
+describe("ProductRepository.incrementBidCountInBatch", () => {
+    it("stages bid count update without committing", () => {
+        const callerBatch = { update: vi.fn(), commit: vi.fn() };
+        repo.incrementBidCountInBatch(callerBatch, "auction-1", 5000);
+        expect(callerBatch.update).toHaveBeenCalledOnce();
+        expect(callerBatch.commit).not.toHaveBeenCalled();
+    });
+    it("sets currentBid to the provided amount", () => {
+        const callerBatch = { update: vi.fn(), commit: vi.fn() };
+        repo.incrementBidCountInBatch(callerBatch, "auction-1", 7500);
+        expect(callerBatch.update).toHaveBeenCalledWith(expect.any(Object), expect.objectContaining({ currentBid: 7500 }));
+    });
+    it("sets bidsHaveStarted: true on first bid", () => {
+        const callerBatch = { update: vi.fn(), commit: vi.fn() };
+        repo.incrementBidCountInBatch(callerBatch, "auction-1", 1000);
+        expect(callerBatch.update).toHaveBeenCalledWith(expect.any(Object), expect.objectContaining({ bidsHaveStarted: true }));
+    });
+    it("includes leadingBidderId when provided", () => {
+        const callerBatch = { update: vi.fn(), commit: vi.fn() };
+        repo.incrementBidCountInBatch(callerBatch, "auction-1", 5000, "user-ravi");
+        expect(callerBatch.update).toHaveBeenCalledWith(expect.any(Object), expect.objectContaining({ leadingBidderId: "user-ravi" }));
+    });
+    it("does NOT include leadingBidderId when not provided", () => {
+        const callerBatch = { update: vi.fn(), commit: vi.fn() };
+        repo.incrementBidCountInBatch(callerBatch, "auction-1", 5000);
+        const updateArg = callerBatch.update.mock.calls[0][1];
+        expect(updateArg).not.toHaveProperty("leadingBidderId");
+    });
+});
+// ---------------------------------------------------------------------------
+// FILTER_ALIASES — pure function tests
+// ---------------------------------------------------------------------------
+describe("ProductRepository.FILTER_ALIASES — listingType", () => {
+    const aliases = ProductRepository.FILTER_ALIASES;
+    it("canonical 'auction' → listingType==auction", () => {
+        expect(aliases.listingType("auction", "==")).toContain("auction");
+    });
+    it("legacy 'preorder' → normalises to pre-order", () => {
+        const result = aliases.listingType("preorder", "==");
+        expect(result).toContain("pre-order");
+    });
+    it("legacy 'product' → normalises to standard", () => {
+        const result = aliases.listingType("product", "==");
+        expect(result).toContain("standard");
+    });
+    it("'standard' → listingType==standard", () => {
+        const result = aliases.listingType("standard", "==");
+        expect(result).toContain("standard");
+    });
+    it("unknown value → returns empty string (dropped)", () => {
+        expect(aliases.listingType("unknown-type", "==")).toBe("");
+    });
+    it("!= operator produces listingType!=<value>", () => {
+        const result = aliases.listingType("auction", "!=");
+        expect(result).toContain("!=");
+        expect(result).toContain("auction");
+    });
+    it("unsupported operator → returns empty string", () => {
+        expect(aliases.listingType("auction", ">")).toBe("");
+    });
+});
+describe("ProductRepository.FILTER_ALIASES — scope", () => {
+    const aliases = ProductRepository.FILTER_ALIASES;
+    it("scope==publicProducts → status==published,listingType==standard", () => {
+        const result = aliases.scope("publicProducts", "==");
+        expect(result).toContain("status");
+        expect(result).toContain("published");
+        expect(result).toContain("standard");
+    });
+    it("scope==publicAuctions → status==published,listingType==auction", () => {
+        const result = aliases.scope("publicAuctions", "==");
+        expect(result).toContain("published");
+        expect(result).toContain("auction");
+    });
+    it("scope==published → status==published only", () => {
+        const result = aliases.scope("published", "==");
+        expect(result).toContain("published");
+        expect(result).not.toContain("listingType");
+    });
+    it("scope with != operator → returns empty string", () => {
+        expect(aliases.scope("published", "!=")).toBe("");
+    });
+    it("unknown scope value → returns empty string", () => {
+        expect(aliases.scope("someUnknownScope", "==")).toBe("");
+    });
+});
+describe("ProductRepository.FILTER_ALIASES — other aliases", () => {
+    const aliases = ProductRepository.FILTER_ALIASES;
+    it("promoted==true → status==published,isPromoted==true", () => {
+        const result = aliases.promoted("true", "==");
+        expect(result).toContain("published");
+        expect(result).toContain("isPromoted");
+    });
+    it("promoted==false → returns empty string (not supported)", () => {
+        expect(aliases.promoted("false", "==")).toBe("");
+    });
+    it("featuredPublic==true → status==published,isFeatured==true", () => {
+        const result = aliases.featuredPublic("true", "==");
+        expect(result).toContain("published");
+        expect(result).toContain("featured");
+    });
+    it("category==slug → expands to categorySlugs@=slug (array-contains)", () => {
+        const result = aliases.category("category-trading-cards", "==");
+        expect(result).toContain("categorySlugs");
+        expect(result).toContain("category-trading-cards");
+        expect(result).toContain("@=");
+    });
+});
+// ---------------------------------------------------------------------------
+// findByCategory
+// ---------------------------------------------------------------------------
+describe("ProductRepository.findByCategory", () => {
+    it("queries categorySlugs array-contains the category slug", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        await repo.findByCategory("category-trading-cards");
+        expect(mockCollection.where).toHaveBeenCalledWith(expect.stringContaining("categorySlugs"), "array-contains", "category-trading-cards");
+    });
+});
+// ---------------------------------------------------------------------------
+// incrementViewCount
+// ---------------------------------------------------------------------------
+describe("ProductRepository.incrementViewCount", () => {
+    it("increments viewCount field (fire-and-forget)", async () => {
+        await repo.incrementViewCount("product-1");
+        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ viewCount: 1 }));
+    });
+    it("does not throw when Firestore update fails", async () => {
+        mockDocRef.update.mockRejectedValue(new Error("Firestore error"));
+        await expect(repo.incrementViewCount("product-1")).resolves.toBeUndefined();
+    });
+});
+// ---------------------------------------------------------------------------
+// deleteByStore
+// ---------------------------------------------------------------------------
+describe("ProductRepository.deleteByStore", () => {
+    it("returns 0 when no products exist for the store", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        const count = await repo.deleteByStore("store-empty");
+        expect(count).toBe(0);
+    });
+    it("batch-deletes all products for the store and returns count", async () => {
+        const products = [
+            makeProductDoc({ id: "p-1", storeId: "store-1" }),
+            makeProductDoc({ id: "p-2", storeId: "store-1" }),
+        ];
+        mockQuery.get.mockResolvedValue(makeQuerySnap(products.map((p) => ({ id: p.id, data: p }))));
+        const count = await repo.deleteByStore("store-1");
+        expect(count).toBe(2);
+        expect(mockBatch.delete).toHaveBeenCalledTimes(2);
+        expect(mockBatch.commit).toHaveBeenCalledOnce();
+    });
+});
+// ---------------------------------------------------------------------------
+// getStaleDraftRefs
+// ---------------------------------------------------------------------------
+describe("ProductRepository.getStaleDraftRefs", () => {
+    it("queries status==draft and updatedAt < cutoff", async () => {
+        const cutoff = new Date("2026-01-01");
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        await repo.getStaleDraftRefs(cutoff);
+        expect(mockCollection.where).toHaveBeenCalledWith(expect.stringContaining("status"), "==", "draft");
+        expect(mockQuery.where).toHaveBeenCalledWith(expect.stringContaining("updatedAt"), "<", cutoff);
+    });
+    it("limits to 200 documents", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        await repo.getStaleDraftRefs(new Date());
+        expect(mockQuery.limit).toHaveBeenCalledWith(200);
+    });
+});

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

@@ -4,6 +4,7 @@
 import { type GenerateProductIdInput, type GenerateAuctionIdInput, type GeneratePreOrderIdInput } from "../../../utils/id-generators";
 import type { ProductStatus, ListingType } from "../types";
 import type { BaseDocument } from "../../../_internal/shared/types/base-document";
+import type { LotteryConfig } from "../../lottery/types";
 export interface ProductVideoField {
     url: string;
     thumbnailUrl: string;
@@ -142,7 +143,7 @@ export interface ProductDocument extends BaseDocument {
     features?: string[];
     shippingInfo?: string;
     returnPolicy?: string;
-    condition?: "new" | "used" | "refurbished" | "broken" | "graded";
+    condition?: "new" | "like_new" | "good" | "fair" | "poor" | "used" | "refurbished" | "broken" | "graded";
     insurance?: boolean;
     insuranceCost?: number;
     shippingPaidBy?: "seller" | "buyer";
@@ -236,6 +237,17 @@ export interface ProductDocument extends BaseDocument {
     prizeRevealDeadlineDays?: number;
     /** Public proof-of-fairness file (commit-reveal scheme). */
     prizeGithubFileUrl?: string;
+    /**
+     * Draw mode for prize-draw listings.
+     * "reveal" = classic buyer-reveal flow (default, backward-compat).
+     * "lottery" = user self-pull with weighted random slot assignment.
+     */
+    prizeDrawMode?: "reveal" | "lottery";
+    /**
+     * Full lottery config. Only set when prizeDrawMode === "lottery".
+     * Includes server-only price/weight fields — stripped by adapter before any client response.
+     */
+    lotteryConfig?: LotteryConfig;
     /**
      * Optional per-item shipping constraints. When absent the store's
      * shippingConfig applies unchanged.
@@ -286,6 +298,8 @@ export interface PrizeDrawItem {
     };
     condition: string;
     estimatedValue?: number;
+    /** Per-slot price in paise for lottery mode. Lower price = higher weight = higher chance. */
+    prizeSlotPrice?: number;
     isWon: boolean;
 }
 /** Runtime-accessible product status values — use instead of bare string literals. */