@mohasinac/appkit 3.8.2 → 3.9.1

package/dist/features/payments/repository/__tests__/payout.repository.test.js

@@ -1,292 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { makeMockDb, makeSnap } from "../../../../../tests/helpers/mock-firestore";
-const { db, mockDocRef, mockCollection, mockQuery, mockTxn } = 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("../../../../security", () => ({
-    encryptPiiFields: (d) => d,
-    decryptPiiFields: (d) => d,
-    addPiiIndices: (d) => d,
-    encryptPayoutBankAccount: (d) => d,
-    decryptPayoutBankAccount: (d) => d,
-    PAYOUT_PII_FIELDS: ["sellerName", "sellerEmail"],
-    PAYOUT_PII_INDEX_MAP: {},
-}));
-vi.mock("../../../../errors/normalize", () => ({
-    normalizeError: vi.fn(),
-}));
-import { PayoutRepository } from "../payout.repository";
-const repo = new PayoutRepository();
-function makePayoutDoc(overrides = {}) {
-    return {
-        id: "payout-misty-20260101-a1b2c3",
-        storeId: "store-pokemon-palace",
-        sellerName: "Misty Singh",
-        sellerEmail: "misty@pokemon.com",
-        amount: 50000, // paise
-        netAmount: 50000,
-        status: "pending",
-        orderIds: ["order-1-20260101-abc", "order-2-20260101-def"],
-        requestedAt: new Date(),
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        refundDeductions: [],
-        ...overrides,
-    };
-}
-beforeEach(() => {
-    vi.clearAllMocks();
-    db.collection.mockReturnValue(mockCollection);
-    mockCollection.doc.mockReturnValue(mockDocRef);
-    mockCollection.where.mockReturnValue(mockQuery);
-    mockQuery.where.mockReturnValue(mockQuery);
-    mockQuery.orderBy.mockReturnValue(mockQuery);
-    mockQuery.limit.mockReturnValue(mockQuery);
-    mockQuery.get.mockResolvedValue({ docs: [], empty: true, size: 0 });
-    mockDocRef.get.mockResolvedValue(makeSnap(null));
-    mockDocRef.set.mockResolvedValue(undefined);
-    mockDocRef.update.mockResolvedValue(undefined);
-    db.runTransaction.mockImplementation(async (fn) => fn(mockTxn));
-    mockTxn.get.mockResolvedValue(makeSnap(null));
-    mockTxn.update.mockReturnValue(undefined);
-});
-// ---------------------------------------------------------------------------
-// create
-// ---------------------------------------------------------------------------
-describe("PayoutRepository.create", () => {
-    it("creates payout with status: pending", async () => {
-        const result = await repo.create({
-            storeId: "store-1",
-            sellerName: "Arun",
-            sellerEmail: "arun@test.com",
-            amount: 10000,
-            orderIds: [],
-            paymentMethod: "upi",
-        });
-        expect(result.status).toBe("pending");
-    });
-    it("persists the payout to Firestore", async () => {
-        await repo.create({
-            storeId: "store-1",
-            sellerName: "Arun",
-            sellerEmail: "arun@test.com",
-            amount: 10000,
-            orderIds: [],
-            paymentMethod: "upi",
-        });
-        expect(mockDocRef.set).toHaveBeenCalledOnce();
-    });
-    it("sets requestedAt timestamp", async () => {
-        const result = await repo.create({
-            storeId: "store-1",
-            sellerName: "Arun",
-            sellerEmail: "arun@test.com",
-            amount: 10000,
-            orderIds: [],
-            paymentMethod: "upi",
-        });
-        expect(result.requestedAt).toBeInstanceOf(Date);
-    });
-});
-// ---------------------------------------------------------------------------
-// markProcessing
-// ---------------------------------------------------------------------------
-describe("PayoutRepository.markProcessing", () => {
-    it("sets status: processing on the provided ref", async () => {
-        await repo.markProcessing(mockDocRef);
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ status: "processing" }));
-    });
-    it("sets processedAt timestamp", async () => {
-        await repo.markProcessing(mockDocRef);
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ processedAt: expect.any(Date) }));
-    });
-});
-// ---------------------------------------------------------------------------
-// recordSuccess
-// ---------------------------------------------------------------------------
-describe("PayoutRepository.recordSuccess", () => {
-    it("stores razorpayPayoutId on the payout", async () => {
-        await repo.recordSuccess(mockDocRef, "razorpay-payout-123", "processed");
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ razorpayPayoutId: "razorpay-payout-123" }));
-    });
-    it("stores razorpayStatus on the payout", async () => {
-        await repo.recordSuccess(mockDocRef, "payout-abc", "processed");
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ razorpayStatus: "processed" }));
-    });
-    it("sets updatedAt timestamp", async () => {
-        await repo.recordSuccess(mockDocRef, "payout-abc", "processed");
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ updatedAt: expect.any(Date) }));
-    });
-});
-// ---------------------------------------------------------------------------
-// recordFailure
-// ---------------------------------------------------------------------------
-describe("PayoutRepository.recordFailure", () => {
-    it("isFinal=true → sets status: failed", async () => {
-        await repo.recordFailure(mockDocRef, 3, "Insufficient funds", true);
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ status: "failed" }));
-    });
-    it("isFinal=false → keeps status: pending (retry)", async () => {
-        await repo.recordFailure(mockDocRef, 1, "Timeout", false);
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ status: "pending" }));
-    });
-    it("stores failureCount", async () => {
-        await repo.recordFailure(mockDocRef, 2, "Network error", false);
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ failureCount: 2 }));
-    });
-    it("stores lastFailureReason", async () => {
-        await repo.recordFailure(mockDocRef, 1, "Account blocked", false);
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ lastFailureReason: "Account blocked" }));
-    });
-});
-// ---------------------------------------------------------------------------
-// applyRefundDeduction
-// ---------------------------------------------------------------------------
-describe("PayoutRepository.applyRefundDeduction", () => {
-    it("throws when payout not found in transaction", async () => {
-        mockTxn.get.mockResolvedValue(makeSnap(null));
-        await expect(repo.applyRefundDeduction("payout-ghost", {
-            orderId: "order-1",
-            deductedAmount: 100,
-        })).rejects.toThrow(/not found/i);
-    });
-    it("throws when payout status is not pending", async () => {
-        const payout = makePayoutDoc({ status: "completed" });
-        mockTxn.get.mockResolvedValue({ exists: true, id: payout.id, data: () => payout });
-        await expect(repo.applyRefundDeduction("payout-1", {
-            orderId: "order-1",
-            deductedAmount: 100,
-        })).rejects.toThrow(/status/i);
-    });
-    it("computes netAmount = amount - totalDeducted", async () => {
-        const payout = makePayoutDoc({ amount: 50000, refundDeductions: [] });
-        mockTxn.get.mockResolvedValue({ exists: true, id: payout.id, data: () => payout });
-        const result = await repo.applyRefundDeduction("payout-1", {
-            orderId: "order-1",
-            deductedAmount: 10000,
-        });
-        expect(result.netAmount).toBe(40000);
-    });
-    it("netAmount is floored at 0 when deduction exceeds amount", async () => {
-        const payout = makePayoutDoc({ amount: 5000, refundDeductions: [] });
-        mockTxn.get.mockResolvedValue({ exists: true, id: payout.id, data: () => payout });
-        const result = await repo.applyRefundDeduction("payout-1", {
-            orderId: "order-1",
-            deductedAmount: 10000, // more than amount
-        });
-        expect(result.netAmount).toBe(0);
-    });
-    it("accumulates multiple deductions correctly", async () => {
-        const existing = [{ orderId: "order-old", deductedAmount: 5000, appliedAt: new Date() }];
-        const payout = makePayoutDoc({ amount: 50000, refundDeductions: existing });
-        mockTxn.get.mockResolvedValue({ exists: true, id: payout.id, data: () => payout });
-        const result = await repo.applyRefundDeduction("payout-1", {
-            orderId: "order-new",
-            deductedAmount: 10000,
-        });
-        // total deducted = 5000 + 10000 = 15000, net = 50000 - 15000 = 35000
-        expect(result.netAmount).toBe(35000);
-    });
-    it("sets appliedAt on the deduction entry", async () => {
-        const payout = makePayoutDoc({ amount: 50000, refundDeductions: [] });
-        mockTxn.get.mockResolvedValue({ exists: true, id: payout.id, data: () => payout });
-        const result = await repo.applyRefundDeduction("payout-1", {
-            orderId: "order-1",
-            deductedAmount: 100,
-        });
-        const lastDeduction = result.refundDeductions[result.refundDeductions.length - 1];
-        expect(lastDeduction.appliedAt).toBeInstanceOf(Date);
-    });
-    it("uses a Firestore transaction for atomic read-modify-write", async () => {
-        const payout = makePayoutDoc({ amount: 50000, refundDeductions: [] });
-        mockTxn.get.mockResolvedValue({ exists: true, id: payout.id, data: () => payout });
-        await repo.applyRefundDeduction("payout-1", {
-            orderId: "order-1",
-            deductedAmount: 100,
-        });
-        expect(db.runTransaction).toHaveBeenCalledOnce();
-        expect(mockTxn.get).toHaveBeenCalledOnce();
-        expect(mockTxn.update).toHaveBeenCalledOnce();
-    });
-});
-// ---------------------------------------------------------------------------
-// findPendingByStore
-// ---------------------------------------------------------------------------
-describe("PayoutRepository.findPendingByStore", () => {
-    it("returns null when no pending payout found", async () => {
-        mockQuery.get.mockResolvedValue({ docs: [], empty: true, size: 0 });
-        const result = await repo.findPendingByStore("store-1");
-        expect(result).toBeNull();
-    });
-    it("queries storeId AND status=pending", async () => {
-        mockQuery.get.mockResolvedValue({ docs: [], empty: true, size: 0 });
-        await repo.findPendingByStore("store-abc");
-        expect(mockCollection.where).toHaveBeenCalledWith("storeId", "==", "store-abc");
-        expect(mockQuery.where).toHaveBeenCalledWith("status", "==", "pending");
-    });
-    it("applies limit of 1 (most recent only)", async () => {
-        mockQuery.get.mockResolvedValue({ docs: [], empty: true, size: 0 });
-        await repo.findPendingByStore("store-abc");
-        expect(mockQuery.limit).toHaveBeenCalledWith(1);
-    });
-    it("returns the payout when found", async () => {
-        const payout = makePayoutDoc({ status: "pending" });
-        mockQuery.get.mockResolvedValue({
-            docs: [{ id: payout.id, data: () => payout }],
-            empty: false,
-            size: 1,
-        });
-        const result = await repo.findPendingByStore("store-pokemon-palace");
-        expect(result).not.toBeNull();
-    });
-});
-// ---------------------------------------------------------------------------
-// getPaidOutOrderIds
-// ---------------------------------------------------------------------------
-describe("PayoutRepository.getPaidOutOrderIds", () => {
-    it("returns empty Set when no matching payouts", async () => {
-        mockQuery.get.mockResolvedValue({ docs: [], empty: true, size: 0 });
-        const ids = await repo.getPaidOutOrderIds("store-1");
-        expect(ids.size).toBe(0);
-    });
-    it("collects all orderIds from matching payout documents", async () => {
-        const payout1 = makePayoutDoc({ orderIds: ["order-A", "order-B"] });
-        const payout2 = makePayoutDoc({ id: "payout-2", orderIds: ["order-C"] });
-        mockQuery.get.mockResolvedValue({
-            docs: [
-                { id: payout1.id, data: () => payout1 },
-                { id: payout2.id, data: () => payout2 },
-            ],
-            empty: false,
-            size: 2,
-        });
-        const ids = await repo.getPaidOutOrderIds("store-pokemon-palace");
-        expect(ids.has("order-A")).toBe(true);
-        expect(ids.has("order-B")).toBe(true);
-        expect(ids.has("order-C")).toBe(true);
-    });
-    it("queries storeId AND status in [pending, processing, completed]", async () => {
-        mockQuery.get.mockResolvedValue({ docs: [], empty: true, size: 0 });
-        await repo.getPaidOutOrderIds("store-1");
-        expect(mockCollection.where).toHaveBeenCalledWith("storeId", "==", "store-1");
-        expect(mockQuery.where).toHaveBeenCalledWith("status", "in", expect.arrayContaining(["pending", "processing", "completed"]));
-    });
-    it("handles payout with no orderIds field gracefully", async () => {
-        const payout = { ...makePayoutDoc(), orderIds: undefined };
-        mockQuery.get.mockResolvedValue({
-            docs: [{ id: payout.id, data: () => payout }],
-            empty: false,
-            size: 1,
-        });
-        const ids = await repo.getPaidOutOrderIds("store-1");
-        expect(ids.size).toBe(0);
-    });
-});

package/dist/features/pre-orders/repository/preorders.repository.d.ts

@@ -1,8 +0,0 @@
-import type { IRepository } from "../../../contracts";
-import type { PreorderItem } from "../types";
-export declare class PreordersRepository {
-    private readonly repo;
-    constructor(repo: IRepository<PreorderItem>);
-    findPreorders(): Promise<PreorderItem[]>;
-    findFeaturedPreorders(): Promise<PreorderItem[]>;
-}

package/dist/features/pre-orders/repository/preorders.repository.js

@@ -1,25 +0,0 @@
-import { PRODUCT_FIELDS } from "../../../constants/field-names";
-const { LISTING_TYPE, STATUS, FEATURED, CREATED_AT } = PRODUCT_FIELDS;
-const { PRE_ORDER } = PRODUCT_FIELDS.LISTING_TYPE_VALUES;
-const { PUBLISHED } = PRODUCT_FIELDS.STATUS_VALUES;
-export class PreordersRepository {
-    constructor(repo) {
-        this.repo = repo;
-    }
-    async findPreorders() {
-        const result = await this.repo.findAll({
-            filters: `${LISTING_TYPE}==${PRE_ORDER},${STATUS}==${PUBLISHED}`,
-            sort: CREATED_AT,
-            order: "desc",
-        });
-        return result.data;
-    }
-    async findFeaturedPreorders() {
-        const result = await this.repo.findAll({
-            filters: `${LISTING_TYPE}==${PRE_ORDER},${STATUS}==${PUBLISHED},${FEATURED}==true`,
-            sort: CREATED_AT,
-            order: "desc",
-        });
-        return result.data;
-    }
-}

package/dist/features/products/repository/__tests__/product-features.repository.test.d.ts

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

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

@@ -1,329 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { makeMockDb, makeSnap, makeQuerySnap } from "../../../../../tests/helpers/mock-firestore";
-import { ValidationError } from "../../../../errors";
-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("../../../../contracts/field-ops", () => ({
-    serverTimestamp: () => new Date(),
-    increment: (n) => n,
-    arrayUnion: (...args) => args,
-    arrayRemove: (...args) => args,
-    deleteField: () => null,
-    registerFieldOps: vi.fn(),
-}));
-vi.mock("../../../../errors/normalize", () => ({ normalizeError: vi.fn() }));
-vi.mock("../../../../monitoring", () => ({
-    serverLogger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
-}));
-import { ProductFeaturesRepository } from "../product-features.repository";
-import { MAX_STORE_CUSTOM_FEATURES } from "../../schemas/product-features";
-const repo = new ProductFeaturesRepository();
-function makeFeatureDoc(overrides = {}) {
-    return {
-        id: "feature-free-shipping",
-        slug: "feature-free-shipping",
-        label: "Free Shipping",
-        description: "This item ships for free",
-        icon: "truck",
-        scope: "platform",
-        storeId: undefined,
-        productTypes: ["all"],
-        displayOrder: 0,
-        isActive: true,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        ...overrides,
-    };
-}
-beforeEach(() => {
-    vi.clearAllMocks();
-    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.get.mockResolvedValue(makeQuerySnap([]));
-    mockDocRef.get.mockResolvedValue(makeSnap(makeFeatureDoc(), "feature-free-shipping"));
-    mockDocRef.set.mockResolvedValue(undefined);
-    mockDocRef.update.mockResolvedValue(undefined);
-    mockDocRef.delete.mockResolvedValue(undefined);
-});
-// ---------------------------------------------------------------------------
-// generateId
-// ---------------------------------------------------------------------------
-describe("ProductFeaturesRepository.generateId", () => {
-    it("generates ID with feature- prefix", () => {
-        const id = repo.generateId("Free Shipping");
-        expect(id).toMatch(/^feature-/);
-    });
-    it("slugifies the label (spaces → hyphens, lowercase)", () => {
-        const id = repo.generateId("Free Shipping");
-        expect(id).toBe("feature-free-shipping");
-    });
-    it("does not double-prefix when label already starts with feature-", () => {
-        const id = repo.generateId("feature-checkout");
-        expect(id).toBe("feature-checkout");
-        expect(id).not.toContain("feature-feature-");
-    });
-    it("strips special characters from label", () => {
-        const id = repo.generateId("Fast & Reliable!");
-        expect(id).not.toContain("&");
-        expect(id).not.toContain("!");
-        expect(id).toMatch(/^feature-/);
-    });
-});
-// ---------------------------------------------------------------------------
-// create — scope validations
-// ---------------------------------------------------------------------------
-describe("ProductFeaturesRepository.create — scope validations", () => {
-    it("throws ValidationError when scope=store and storeId is not provided", async () => {
-        await expect(repo.create({
-            label: "Custom Badge",
-            description: "A store badge",
-            icon: "star",
-            scope: "store",
-            productTypes: ["all"],
-            displayOrder: 0,
-            isActive: true,
-        })).rejects.toThrow(ValidationError);
-    });
-    it("throws ValidationError when scope=platform and storeId is provided", async () => {
-        await expect(repo.create({
-            label: "Platform Badge",
-            description: "A platform badge",
-            icon: "award",
-            scope: "platform",
-            storeId: "store-pokemon-palace",
-            productTypes: ["all"],
-            displayOrder: 0,
-            isActive: true,
-        })).rejects.toThrow(ValidationError);
-    });
-    it("throws ValidationError when store feature count reaches MAX_STORE_CUSTOM_FEATURES", async () => {
-        // countByStore will query and return snap with size = MAX_STORE_CUSTOM_FEATURES
-        mockQuery.get.mockResolvedValue({ size: MAX_STORE_CUSTOM_FEATURES, docs: [], empty: false });
-        await expect(repo.create({
-            label: "One Too Many",
-            description: "Exceeds limit",
-            icon: "x",
-            scope: "store",
-            storeId: "store-pokemon-palace",
-            productTypes: ["all"],
-            displayOrder: 0,
-            isActive: true,
-        })).rejects.toThrow(ValidationError);
-    });
-    it("does NOT throw when store feature count is below MAX_STORE_CUSTOM_FEATURES", async () => {
-        mockQuery.get.mockResolvedValue({ size: MAX_STORE_CUSTOM_FEATURES - 1, docs: [], empty: false });
-        // After count check, doc().get() for findByIdOrFail
-        mockDocRef.get.mockResolvedValue(makeSnap(makeFeatureDoc({ scope: "store", storeId: "store-1" }), "feature-custom-badge"));
-        await expect(repo.create({
-            label: "Custom Badge",
-            description: "A store badge",
-            icon: "star",
-            scope: "store",
-            storeId: "store-pokemon-palace",
-            productTypes: ["all"],
-            displayOrder: 0,
-            isActive: true,
-        })).resolves.toBeDefined();
-    });
-    it("platform scope with no storeId creates the feature successfully", async () => {
-        mockDocRef.get.mockResolvedValue(makeSnap(makeFeatureDoc(), "feature-free-shipping"));
-        await expect(repo.create({
-            label: "Free Shipping",
-            description: "Ships for free",
-            icon: "truck",
-            scope: "platform",
-            productTypes: ["all"],
-            displayOrder: 0,
-            isActive: true,
-        })).resolves.toBeDefined();
-    });
-});
-// ---------------------------------------------------------------------------
-// create — field storage
-// ---------------------------------------------------------------------------
-describe("ProductFeaturesRepository.create — field storage", () => {
-    it("uses generated ID from label as document ID", async () => {
-        mockDocRef.get.mockResolvedValue(makeSnap(makeFeatureDoc(), "feature-fast-checkout"));
-        await repo.create({
-            label: "Fast Checkout",
-            description: "Quick buy",
-            icon: "zap",
-            scope: "platform",
-            productTypes: ["all"],
-            displayOrder: 1,
-            isActive: true,
-        });
-        expect(mockDocRef.set).toHaveBeenCalledWith(expect.objectContaining({ slug: "feature-fast-checkout" }));
-    });
-    it("sets createdAt and updatedAt timestamps", async () => {
-        mockDocRef.get.mockResolvedValue(makeSnap(makeFeatureDoc(), "feature-fast-checkout"));
-        await repo.create({
-            label: "Fast Checkout",
-            description: "Quick buy",
-            icon: "zap",
-            scope: "platform",
-            productTypes: ["all"],
-            displayOrder: 1,
-            isActive: true,
-        });
-        const setArg = mockDocRef.set.mock.calls[0][0];
-        expect(setArg.createdAt).toBeInstanceOf(Date);
-        expect(setArg.updatedAt).toBeInstanceOf(Date);
-    });
-});
-// ---------------------------------------------------------------------------
-// delete
-// ---------------------------------------------------------------------------
-describe("ProductFeaturesRepository.delete", () => {
-    it("throws ValidationError when a product references the feature", async () => {
-        // The where chain for the product reference check returns a non-empty snap
-        mockQuery.get.mockResolvedValueOnce({ empty: false, size: 1, docs: [{ id: "prod-1" }] });
-        await expect(repo.delete("feature-free-shipping")).rejects.toThrow(ValidationError);
-    });
-    it("deletes the feature when no product references it", async () => {
-        mockQuery.get.mockResolvedValueOnce(makeQuerySnap([]));
-        await expect(repo.delete("feature-free-shipping")).resolves.toBeUndefined();
-        expect(mockDocRef.delete).toHaveBeenCalledOnce();
-    });
-    it("limits the product reference check to 1 document (efficiency)", async () => {
-        mockQuery.get.mockResolvedValueOnce(makeQuerySnap([]));
-        await repo.delete("feature-free-shipping");
-        expect(mockQuery.limit).toHaveBeenCalledWith(1);
-    });
-    it("does not delete the feature when a product references it", async () => {
-        mockQuery.get.mockResolvedValueOnce({ empty: false, size: 1, docs: [{ id: "prod-1" }] });
-        try {
-            await repo.delete("feature-free-shipping");
-        }
-        catch {
-            // expected
-        }
-        expect(mockDocRef.delete).not.toHaveBeenCalled();
-    });
-});
-// ---------------------------------------------------------------------------
-// countByStore
-// ---------------------------------------------------------------------------
-describe("ProductFeaturesRepository.countByStore", () => {
-    it("returns snap.size as the count", async () => {
-        mockQuery.get.mockResolvedValue({ size: 3, docs: [], empty: false });
-        const count = await repo.countByStore("store-pokemon-palace");
-        expect(count).toBe(3);
-    });
-    it("returns 0 when no store features exist", async () => {
-        mockQuery.get.mockResolvedValue({ size: 0, docs: [], empty: true });
-        const count = await repo.countByStore("store-no-features");
-        expect(count).toBe(0);
-    });
-    it("filters by scope=store and storeId", async () => {
-        mockQuery.get.mockResolvedValue({ size: 0, docs: [], empty: true });
-        await repo.countByStore("store-pokemon-palace");
-        expect(mockCollection.where).toHaveBeenCalledWith(expect.stringContaining("scope"), "==", "store");
-        expect(mockQuery.where).toHaveBeenCalledWith(expect.stringContaining("storeId"), "==", "store-pokemon-palace");
-    });
-});
-// ---------------------------------------------------------------------------
-// update
-// ---------------------------------------------------------------------------
-describe("ProductFeaturesRepository.update", () => {
-    it("updates provided fields plus updatedAt", async () => {
-        await repo.update("feature-free-shipping", { label: "Free Delivery", isActive: false });
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ label: "Free Delivery", isActive: false, updatedAt: expect.any(Date) }));
-    });
-    it("calls doc(id) to target the correct feature", async () => {
-        await repo.update("feature-abc", { label: "Updated" });
-        expect(mockCollection.doc).toHaveBeenCalledWith("feature-abc");
-    });
-});
-// ---------------------------------------------------------------------------
-// listFiltered
-// ---------------------------------------------------------------------------
-describe("ProductFeaturesRepository.listFiltered", () => {
-    it("applies scope filter when provided", async () => {
-        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
-        await repo.listFiltered({ scope: "platform" });
-        expect(mockCollection.where).toHaveBeenCalledWith(expect.stringContaining("scope"), "==", "platform");
-    });
-    it("applies storeId filter when provided", async () => {
-        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
-        await repo.listFiltered({ storeId: "store-1" });
-        expect(mockCollection.where).toHaveBeenCalledWith(expect.stringContaining("storeId"), "==", "store-1");
-    });
-    it("applies isActive filter when provided", async () => {
-        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
-        await repo.listFiltered({ isActive: true });
-        expect(mockCollection.where).toHaveBeenCalledWith("isActive", "==", true);
-    });
-    it("filters by productType in-memory (not Firestore)", async () => {
-        const feature1 = makeFeatureDoc({ id: "f-1", productTypes: ["all"] });
-        const feature2 = makeFeatureDoc({ id: "f-2", productTypes: ["product"] });
-        const feature3 = makeFeatureDoc({ id: "f-3", productTypes: ["auction"] });
-        // No Firestore filters applied for productType-only query → uses mockCollection.get
-        mockCollection.get.mockResolvedValue(makeQuerySnap([
-            { id: "f-1", data: feature1 },
-            { id: "f-2", data: feature2 },
-            { id: "f-3", data: feature3 },
-        ]));
-        const results = await repo.listFiltered({ productType: "product" });
-        // "all" matches everything; "product" matches "product"; "auction" does NOT match "product"
-        expect(results).toHaveLength(2);
-        const ids = results.map((r) => r.id);
-        expect(ids).toContain("f-1");
-        expect(ids).toContain("f-2");
-        expect(ids).not.toContain("f-3");
-    });
-    it("returns results sorted by displayOrder ascending", async () => {
-        const features = [
-            makeFeatureDoc({ id: "f-b", displayOrder: 2 }),
-            makeFeatureDoc({ id: "f-a", displayOrder: 0 }),
-            makeFeatureDoc({ id: "f-c", displayOrder: 5 }),
-        ];
-        // No Firestore filters → uses mockCollection.get
-        mockCollection.get.mockResolvedValue(makeQuerySnap(features.map((f) => ({ id: f.id, data: f }))));
-        const results = await repo.listFiltered({});
-        expect(results[0].id).toBe("f-a");
-        expect(results[1].id).toBe("f-b");
-        expect(results[2].id).toBe("f-c");
-    });
-    it("returns empty array when no features match", async () => {
-        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
-        const results = await repo.listFiltered({ scope: "store", storeId: "store-empty" });
-        expect(results).toEqual([]);
-    });
-});
-// ---------------------------------------------------------------------------
-// listPlatform
-// ---------------------------------------------------------------------------
-describe("ProductFeaturesRepository.listPlatform", () => {
-    it("calls listFiltered with scope=platform and isActive=true", async () => {
-        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
-        await repo.listPlatform();
-        expect(mockCollection.where).toHaveBeenCalledWith(expect.stringContaining("scope"), "==", "platform");
-        expect(mockCollection.where).toHaveBeenCalledWith("isActive", "==", true);
-    });
-});
-// ---------------------------------------------------------------------------
-// listForStore
-// ---------------------------------------------------------------------------
-describe("ProductFeaturesRepository.listForStore", () => {
-    it("calls listFiltered with scope=store, storeId, and isActive=true", async () => {
-        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
-        await repo.listForStore("store-pokemon-palace");
-        expect(mockCollection.where).toHaveBeenCalledWith(expect.stringContaining("storeId"), "==", "store-pokemon-palace");
-        expect(mockCollection.where).toHaveBeenCalledWith("isActive", "==", true);
-    });
-});

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

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