@mohasinac/appkit 3.8.2 → 3.9.0

package/dist/features/seller/repository/__tests__/offer.repository.test.js

@@ -1,458 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { makeMockDb, makeSnap, makeQuerySnap } from "../../../../../tests/helpers/mock-firestore";
-const { db, mockDocRef, mockCollection, mockQuery, mockBatch } = 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,
-    OFFER_PII_FIELDS: ["buyerName", "buyerEmail"],
-}));
-vi.mock("../../../../monitoring", () => ({
-    serverLogger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
-}));
-vi.mock("../../../../errors/normalize", () => ({
-    normalizeError: vi.fn(),
-}));
-import { OfferRepository } from "../offer.repository";
-const repo = new OfferRepository();
-function makeOfferDoc(overrides = {}) {
-    return {
-        id: "offer-product-charizard-user-ravi-20260627-abc123",
-        productId: "product-charizard-psa9",
-        storeId: "store-pokemon-palace",
-        buyerUid: "user-ravi",
-        buyerName: "Ravi Kumar",
-        buyerEmail: "ravi@test.com",
-        offerAmount: 45000, // paise
-        status: "pending",
-        expiresAt: new Date(Date.now() + 48 * 60 * 60 * 1000),
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        ...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.select = vi.fn().mockReturnValue(mockQuery);
-    mockQuery.get.mockResolvedValue(makeQuerySnap([]));
-    const offerDoc = makeOfferDoc();
-    mockDocRef.get.mockResolvedValue(makeSnap(offerDoc, offerDoc.id));
-    mockDocRef.set.mockResolvedValue(undefined);
-    mockDocRef.update.mockResolvedValue(undefined);
-    db.batch.mockReturnValue(mockBatch);
-});
-// ---------------------------------------------------------------------------
-// create
-// ---------------------------------------------------------------------------
-describe("OfferRepository.create", () => {
-    it("sets status: pending on creation", async () => {
-        await repo.create({
-            productId: "product-charizard-psa9",
-            storeId: "store-pokemon-palace",
-            buyerUid: "user-ravi",
-            buyerName: "Ravi Kumar",
-            buyerEmail: "ravi@test.com",
-            offerAmount: 45000,
-        });
-        const setArg = mockDocRef.set.mock.calls[0][0];
-        expect(setArg.status).toBe("pending");
-    });
-    it("sets expiresAt to approximately 48 hours from now", async () => {
-        const before = Date.now();
-        await repo.create({
-            productId: "product-1",
-            storeId: "store-1",
-            buyerUid: "user-1",
-            buyerName: "Buyer",
-            buyerEmail: "b@test.com",
-            offerAmount: 10000,
-        });
-        const after = Date.now();
-        const setArg = mockDocRef.set.mock.calls[0][0];
-        const expiresAt = setArg.expiresAt.getTime();
-        const expectedMs = 48 * 60 * 60 * 1000;
-        expect(expiresAt).toBeGreaterThanOrEqual(before + expectedMs - 100);
-        expect(expiresAt).toBeLessThanOrEqual(after + expectedMs + 100);
-    });
-    it("persists to Firestore via doc.set", async () => {
-        await repo.create({
-            productId: "p-1",
-            storeId: "s-1",
-            buyerUid: "u-1",
-            buyerName: "Buyer",
-            buyerEmail: "b@test.com",
-            offerAmount: 20000,
-        });
-        expect(mockDocRef.set).toHaveBeenCalledOnce();
-    });
-    it("returns plaintext document (not encrypted) to caller", async () => {
-        const result = await repo.create({
-            productId: "p-1",
-            storeId: "s-1",
-            buyerUid: "u-1",
-            buyerName: "Ravi Kumar",
-            buyerEmail: "ravi@test.com",
-            offerAmount: 10000,
-        });
-        // Passthrough mock means plaintext === encrypted; verify field is accessible
-        expect(result.buyerName).toBe("Ravi Kumar");
-    });
-    it("sets createdAt and updatedAt timestamps", async () => {
-        const result = await repo.create({
-            productId: "p-1",
-            storeId: "s-1",
-            buyerUid: "u-1",
-            buyerName: "Buyer",
-            buyerEmail: "b@test.com",
-            offerAmount: 5000,
-        });
-        expect(result.createdAt).toBeInstanceOf(Date);
-        expect(result.updatedAt).toBeInstanceOf(Date);
-    });
-});
-// ---------------------------------------------------------------------------
-// hasActiveOffer
-// ---------------------------------------------------------------------------
-describe("OfferRepository.hasActiveOffer", () => {
-    it("returns true when a pending offer exists for buyer + product", async () => {
-        const offer = makeOfferDoc({ status: "pending" });
-        mockQuery.get.mockResolvedValue({
-            empty: false,
-            size: 1,
-            docs: [makeSnap(offer, offer.id)],
-        });
-        const result = await repo.hasActiveOffer("user-ravi", "product-charizard-psa9");
-        expect(result).toBe(true);
-    });
-    it("returns true when a countered offer exists for buyer + product", async () => {
-        const offer = makeOfferDoc({ status: "countered" });
-        mockQuery.get.mockResolvedValue({
-            empty: false,
-            size: 1,
-            docs: [makeSnap(offer, offer.id)],
-        });
-        const result = await repo.hasActiveOffer("user-ravi", "product-charizard-psa9");
-        expect(result).toBe(true);
-    });
-    it("returns false when only expired/declined offers exist", async () => {
-        mockQuery.get.mockResolvedValue({ empty: true, size: 0, docs: [] });
-        const result = await repo.hasActiveOffer("user-ravi", "product-1");
-        expect(result).toBe(false);
-    });
-    it("returns false when no offers exist at all", async () => {
-        mockQuery.get.mockResolvedValue({ empty: true, size: 0, docs: [] });
-        const result = await repo.hasActiveOffer("user-nobody", "product-1");
-        expect(result).toBe(false);
-    });
-    it("queries by buyerUid, productId, and status in [pending, countered]", async () => {
-        mockQuery.get.mockResolvedValue({ empty: true, size: 0, docs: [] });
-        await repo.hasActiveOffer("user-xyz", "product-abc");
-        expect(mockCollection.where).toHaveBeenCalledWith(expect.stringContaining("buyerUid"), "==", "user-xyz");
-        expect(mockQuery.where).toHaveBeenCalledWith(expect.stringContaining("productId"), "==", "product-abc");
-        expect(mockQuery.where).toHaveBeenCalledWith(expect.stringContaining("status"), "in", ["pending", "countered"]);
-    });
-    it("uses select() stub read for minimal Firestore cost", async () => {
-        mockQuery.get.mockResolvedValue({ empty: false, size: 1, docs: [] });
-        await repo.hasActiveOffer("user-ravi", "product-1");
-        expect(mockQuery.select).toHaveBeenCalled();
-    });
-    it("uses limit(1) to avoid scanning all offers", async () => {
-        mockQuery.get.mockResolvedValue({ empty: true, size: 0, docs: [] });
-        await repo.hasActiveOffer("user-ravi", "product-1");
-        expect(mockQuery.limit).toHaveBeenCalledWith(1);
-    });
-});
-// ---------------------------------------------------------------------------
-// countByBuyerAndProduct
-// ---------------------------------------------------------------------------
-describe("OfferRepository.countByBuyerAndProduct", () => {
-    it("returns 0 when no offers match", async () => {
-        mockQuery.get.mockResolvedValue({ empty: true, size: 0, docs: [] });
-        const count = await repo.countByBuyerAndProduct("user-ravi", "product-1", new Date(Date.now() - 7 * 24 * 60 * 60 * 1000));
-        expect(count).toBe(0);
-    });
-    it("returns correct count when offers exist", async () => {
-        mockQuery.get.mockResolvedValue({ empty: false, size: 3, docs: [] });
-        const count = await repo.countByBuyerAndProduct("user-ravi", "product-1", new Date());
-        expect(count).toBe(3);
-    });
-    it("queries by buyerUid, productId, and createdAt >= since", async () => {
-        mockQuery.get.mockResolvedValue({ empty: false, size: 2, docs: [] });
-        const since = new Date(Date.now() - 86400000);
-        await repo.countByBuyerAndProduct("user-abc", "product-xyz", since);
-        expect(mockCollection.where).toHaveBeenCalledWith(expect.stringContaining("buyerUid"), "==", "user-abc");
-        expect(mockQuery.where).toHaveBeenCalledWith(expect.stringContaining("productId"), "==", "product-xyz");
-        expect(mockQuery.where).toHaveBeenCalledWith(expect.stringContaining("createdAt"), ">=", since);
-    });
-    it("uses select() stub read for minimal Firestore cost", async () => {
-        mockQuery.get.mockResolvedValue({ empty: true, size: 0, docs: [] });
-        await repo.countByBuyerAndProduct("user-1", "product-1", new Date());
-        expect(mockQuery.select).toHaveBeenCalled();
-    });
-    it("returns snap.size (not docs.length)", async () => {
-        // size may differ from docs.length in real Firestore (SELECT stub reads)
-        mockQuery.get.mockResolvedValue({ empty: false, size: 5, docs: [] });
-        const count = await repo.countByBuyerAndProduct("user-1", "product-1", new Date());
-        expect(count).toBe(5);
-    });
-});
-// ---------------------------------------------------------------------------
-// findExpiredActive
-// ---------------------------------------------------------------------------
-describe("OfferRepository.findExpiredActive", () => {
-    it("returns offers with status in [pending, countered] and expiresAt <= now", async () => {
-        const now = new Date();
-        const expiredOffer = makeOfferDoc({
-            status: "pending",
-            expiresAt: new Date(now.getTime() - 3600000),
-        });
-        mockQuery.get.mockResolvedValue(makeQuerySnap([{ id: expiredOffer.id, data: expiredOffer }]));
-        const results = await repo.findExpiredActive(now);
-        expect(results).toHaveLength(1);
-    });
-    it("queries status in [pending, countered]", async () => {
-        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
-        await repo.findExpiredActive(new Date());
-        expect(mockCollection.where).toHaveBeenCalledWith(expect.stringContaining("status"), "in", ["pending", "countered"]);
-    });
-    it("queries expiresAt <= now", async () => {
-        const now = new Date();
-        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
-        await repo.findExpiredActive(now);
-        expect(mockQuery.where).toHaveBeenCalledWith(expect.stringContaining("expiresAt"), "<=", now);
-    });
-    it("applies limit(500) to avoid unbounded scans", async () => {
-        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
-        await repo.findExpiredActive(new Date());
-        expect(mockQuery.limit).toHaveBeenCalledWith(500);
-    });
-    it("returns empty array when no expired active offers", async () => {
-        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
-        const results = await repo.findExpiredActive(new Date());
-        expect(results).toHaveLength(0);
-    });
-});
-// ---------------------------------------------------------------------------
-// expireMany
-// ---------------------------------------------------------------------------
-describe("OfferRepository.expireMany", () => {
-    it("batch-updates each offer ID to status: expired", async () => {
-        await repo.expireMany(["offer-1", "offer-2", "offer-3"]);
-        expect(mockBatch.update).toHaveBeenCalledTimes(3);
-        const calls = mockBatch.update.mock.calls;
-        expect(calls.every((c) => c[1].status === "expired")).toBe(true);
-    });
-    it("sets updatedAt on every expired offer", async () => {
-        await repo.expireMany(["offer-1", "offer-2"]);
-        const calls = mockBatch.update.mock.calls;
-        expect(calls.every((c) => c[1].updatedAt instanceof Date)).toBe(true);
-    });
-    it("commits the batch exactly once", async () => {
-        await repo.expireMany(["offer-a", "offer-b"]);
-        expect(mockBatch.commit).toHaveBeenCalledOnce();
-    });
-    it("empty ID list → batch.commit called, no updates staged", async () => {
-        await repo.expireMany([]);
-        expect(mockBatch.update).not.toHaveBeenCalled();
-        expect(mockBatch.commit).toHaveBeenCalledOnce();
-    });
-    it("single offer → one batch.update call", async () => {
-        await repo.expireMany(["offer-only"]);
-        expect(mockBatch.update).toHaveBeenCalledTimes(1);
-    });
-});
-// ---------------------------------------------------------------------------
-// accept
-// ---------------------------------------------------------------------------
-describe("OfferRepository.accept", () => {
-    it("sets status: accepted", async () => {
-        await repo.accept("offer-1", 40000);
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ status: "accepted" }));
-    });
-    it("stores lockedPrice on accept", async () => {
-        await repo.accept("offer-1", 40000);
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ lockedPrice: 40000 }));
-    });
-    it("sets acceptedAt timestamp", async () => {
-        await repo.accept("offer-1", 40000);
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ acceptedAt: expect.any(Date) }));
-    });
-    it("sets respondedAt timestamp", async () => {
-        await repo.accept("offer-1", 40000);
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ respondedAt: expect.any(Date) }));
-    });
-    it("stores sellerNote when provided", async () => {
-        await repo.accept("offer-1", 40000, "Deal accepted!");
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ sellerNote: "Deal accepted!" }));
-    });
-    it("sets updatedAt timestamp", async () => {
-        await repo.accept("offer-1", 40000);
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ updatedAt: expect.any(Date) }));
-    });
-});
-// ---------------------------------------------------------------------------
-// decline
-// ---------------------------------------------------------------------------
-describe("OfferRepository.decline", () => {
-    it("sets status: declined", async () => {
-        await repo.decline("offer-1");
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ status: "declined" }));
-    });
-    it("sets respondedAt timestamp", async () => {
-        await repo.decline("offer-1");
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ respondedAt: expect.any(Date) }));
-    });
-    it("stores sellerNote when provided", async () => {
-        await repo.decline("offer-1", "Not interested");
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ sellerNote: "Not interested" }));
-    });
-    it("does NOT set lockedPrice on decline", async () => {
-        await repo.decline("offer-1");
-        const updateArg = mockDocRef.update.mock.calls[0][0];
-        expect(Object.keys(updateArg)).not.toContain("lockedPrice");
-    });
-});
-// ---------------------------------------------------------------------------
-// counter
-// ---------------------------------------------------------------------------
-describe("OfferRepository.counter", () => {
-    it("sets status: countered", async () => {
-        await repo.counter("offer-1", 38000);
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ status: "countered" }));
-    });
-    it("stores counterAmount", async () => {
-        await repo.counter("offer-1", 38000);
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ counterAmount: 38000 }));
-    });
-    it("sets respondedAt timestamp", async () => {
-        await repo.counter("offer-1", 38000);
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ respondedAt: expect.any(Date) }));
-    });
-    it("stores sellerNote when provided", async () => {
-        await repo.counter("offer-1", 38000, "Best I can do");
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ sellerNote: "Best I can do" }));
-    });
-});
-// ---------------------------------------------------------------------------
-// acceptCounter
-// ---------------------------------------------------------------------------
-describe("OfferRepository.acceptCounter", () => {
-    it("sets lockedPrice = counterAmount from existing offer", async () => {
-        const offerDoc = makeOfferDoc({ status: "countered", counterAmount: 38000 });
-        mockDocRef.get.mockResolvedValue(makeSnap(offerDoc, "offer-1"));
-        await repo.acceptCounter("offer-1");
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ lockedPrice: 38000 }));
-    });
-    it("sets status: accepted", async () => {
-        const offerDoc = makeOfferDoc({ status: "countered", counterAmount: 38000 });
-        mockDocRef.get.mockResolvedValue(makeSnap(offerDoc, "offer-1"));
-        await repo.acceptCounter("offer-1");
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ status: "accepted" }));
-    });
-    it("sets acceptedAt and respondedAt", async () => {
-        const offerDoc = makeOfferDoc({ status: "countered", counterAmount: 38000 });
-        mockDocRef.get.mockResolvedValue(makeSnap(offerDoc, "offer-1"));
-        await repo.acceptCounter("offer-1");
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({
-            acceptedAt: expect.any(Date),
-            respondedAt: expect.any(Date),
-        }));
-    });
-    it("throws when offer not found", async () => {
-        mockDocRef.get.mockResolvedValue(makeSnap(null));
-        await expect(repo.acceptCounter("offer-ghost")).rejects.toThrow(/offer.*not found|counter.*not found/i);
-    });
-    it("throws when offer has no counterAmount", async () => {
-        const offerDoc = makeOfferDoc({ status: "pending", counterAmount: undefined });
-        mockDocRef.get.mockResolvedValue(makeSnap(offerDoc, "offer-1"));
-        await expect(repo.acceptCounter("offer-1")).rejects.toThrow();
-    });
-});
-// ---------------------------------------------------------------------------
-// withdraw
-// ---------------------------------------------------------------------------
-describe("OfferRepository.withdraw", () => {
-    it("sets status: withdrawn", async () => {
-        await repo.withdraw("offer-1");
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ status: "withdrawn" }));
-    });
-    it("sets respondedAt timestamp", async () => {
-        await repo.withdraw("offer-1");
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ respondedAt: expect.any(Date) }));
-    });
-    it("sets updatedAt timestamp", async () => {
-        await repo.withdraw("offer-1");
-        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ updatedAt: expect.any(Date) }));
-    });
-    it("does NOT set lockedPrice on withdraw", async () => {
-        await repo.withdraw("offer-1");
-        const updateArg = mockDocRef.update.mock.calls[0][0];
-        expect(Object.keys(updateArg)).not.toContain("lockedPrice");
-    });
-});
-// ---------------------------------------------------------------------------
-// findPendingByStore
-// ---------------------------------------------------------------------------
-describe("OfferRepository.findPendingByStore", () => {
-    it("returns only pending offers for the given storeId", async () => {
-        const offer = makeOfferDoc({ status: "pending", storeId: "store-pokemon-palace" });
-        mockQuery.get.mockResolvedValue(makeQuerySnap([{ id: offer.id, data: offer }]));
-        const results = await repo.findPendingByStore("store-pokemon-palace");
-        expect(results).toHaveLength(1);
-    });
-    it("queries by storeId and status == pending", async () => {
-        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
-        await repo.findPendingByStore("store-xyz");
-        expect(mockCollection.where).toHaveBeenCalledWith(expect.stringContaining("storeId"), "==", "store-xyz");
-        expect(mockQuery.where).toHaveBeenCalledWith(expect.stringContaining("status"), "==", "pending");
-    });
-    it("orders by createdAt ascending (oldest first for seller to act on)", async () => {
-        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
-        await repo.findPendingByStore("store-1");
-        expect(mockQuery.orderBy).toHaveBeenCalledWith(expect.stringContaining("createdAt"), "asc");
-    });
-    it("returns empty array when no pending offers", async () => {
-        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
-        const results = await repo.findPendingByStore("store-empty");
-        expect(results).toHaveLength(0);
-    });
-});
-// ---------------------------------------------------------------------------
-// findExpired
-// ---------------------------------------------------------------------------
-describe("OfferRepository.findExpired", () => {
-    it("returns offers with status in [pending, countered] and expiresAt <= now", async () => {
-        const expired = makeOfferDoc({
-            status: "pending",
-            expiresAt: new Date(Date.now() - 1000),
-        });
-        mockQuery.get.mockResolvedValue(makeQuerySnap([{ id: expired.id, data: expired }]));
-        const results = await repo.findExpired();
-        expect(results).toHaveLength(1);
-    });
-    it("queries status in [pending, countered]", async () => {
-        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
-        await repo.findExpired();
-        expect(mockCollection.where).toHaveBeenCalledWith(expect.stringContaining("status"), "in", ["pending", "countered"]);
-    });
-    it("queries expiresAt <= current time", async () => {
-        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
-        await repo.findExpired();
-        expect(mockQuery.where).toHaveBeenCalledWith(expect.stringContaining("expiresAt"), "<=", expect.any(Date));
-    });
-});

package/dist/features/seller/repository/seller.repository.d.ts

@@ -1,22 +0,0 @@
-import type { IRepository, PagedResult, SieveQuery } from "../../../contracts";
-import type { SellerStore, PayoutRecord } from "../types";
-export declare class SellerRepository {
-    private readonly repo;
-    constructor(repo: IRepository<SellerStore>);
-    findAll(query?: SieveQuery): Promise<PagedResult<SellerStore>>;
-    findById(id: string): Promise<SellerStore | null>;
-    findByOwner(ownerId: string): Promise<SellerStore | null>;
-    findBySlug(storeSlug: string): Promise<SellerStore | null>;
-    findActive(page?: number, perPage?: number): Promise<PagedResult<SellerStore>>;
-    create(data: Omit<SellerStore, "id" | "createdAt" | "updatedAt">): Promise<SellerStore>;
-    update(id: string, data: Partial<SellerStore>): Promise<SellerStore>;
-}
-export declare class PayoutsRepository {
-    private readonly repo;
-    constructor(repo: IRepository<PayoutRecord>);
-    findAll(query?: SieveQuery): Promise<PagedResult<PayoutRecord>>;
-    findBySeller(sellerId: string, page?: number, perPage?: number): Promise<PagedResult<PayoutRecord>>;
-    findPending(): Promise<PayoutRecord[]>;
-    create(data: Omit<PayoutRecord, "id" | "createdAt" | "updatedAt">): Promise<PayoutRecord>;
-    updateStatus(id: string, status: "processing" | "completed" | "failed", adminNote?: string): Promise<PayoutRecord>;
-}

package/dist/features/seller/repository/seller.repository.js

@@ -1,72 +0,0 @@
-export class SellerRepository {
-    constructor(repo) {
-        this.repo = repo;
-    }
-    async findAll(query) {
-        return this.repo.findAll(query ?? {});
-    }
-    async findById(id) {
-        return this.repo.findById(id);
-    }
-    async findByOwner(ownerId) {
-        const result = await this.repo.findAll({
-            filters: `ownerId==${ownerId}`,
-            perPage: 1,
-        });
-        return result.data[0] ?? null;
-    }
-    async findBySlug(storeSlug) {
-        const result = await this.repo.findAll({
-            filters: `storeSlug==${storeSlug},status==active`,
-            perPage: 1,
-        });
-        return result.data[0] ?? null;
-    }
-    async findActive(page = 1, perPage = 20) {
-        return this.repo.findAll({
-            filters: "status==active,isPublic==true",
-            sort: "-stats.totalProducts",
-            page,
-            perPage,
-        });
-    }
-    async create(data) {
-        return this.repo.create(data);
-    }
-    async update(id, data) {
-        return this.repo.update(id, data);
-    }
-}
-export class PayoutsRepository {
-    constructor(repo) {
-        this.repo = repo;
-    }
-    async findAll(query) {
-        return this.repo.findAll(query ?? {});
-    }
-    async findBySeller(sellerId, page = 1, perPage = 20) {
-        return this.repo.findAll({
-            filters: `sellerId==${sellerId}`,
-            sort: "-requestedAt",
-            page,
-            perPage,
-        });
-    }
-    async findPending() {
-        const result = await this.repo.findAll({
-            filters: "status==pending",
-            sort: "requestedAt",
-        });
-        return result.data;
-    }
-    async create(data) {
-        return this.repo.create(data);
-    }
-    async updateStatus(id, status, adminNote) {
-        return this.repo.update(id, {
-            status,
-            adminNote,
-            processedAt: new Date().toISOString(),
-        });
-    }
-}

package/dist/features/site-settings/components/__tests__/ThemeManagerView.test.d.ts

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

package/dist/features/site-settings/components/__tests__/ThemeManagerView.test.js

@@ -1,37 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { render, screen, fireEvent } from "@testing-library/react";
-import { describe, it, expect, vi } from "vitest";
-import { ThemeManagerView } from "../ThemeManagerView";
-import { BUILT_IN_THEMES, DEFAULT_DARK_THEME, DEFAULT_LIGHT_THEME, } from "../../../../tokens/themes";
-const EMPTY_VALUE = {
-    themes: [],
-    defaultLightThemeId: DEFAULT_LIGHT_THEME.id,
-    defaultDarkThemeId: DEFAULT_DARK_THEME.id,
-};
-describe("ThemeManagerView", () => {
-    it("lists both built-in theme records", () => {
-        render(_jsx(ThemeManagerView, { value: EMPTY_VALUE, onChange: () => undefined }));
-        for (const theme of BUILT_IN_THEMES) {
-            expect(screen.getByText(theme.name)).not.toBeNull();
-        }
-    });
-    it("flags built-in themes as undeletable", () => {
-        render(_jsx(ThemeManagerView, { value: EMPTY_VALUE, onChange: () => undefined }));
-        const deleteButtons = screen.getAllByRole("button", { name: /Delete/ });
-        // Both built-ins should expose disabled delete buttons.
-        expect(deleteButtons.length).toBeGreaterThanOrEqual(2);
-        for (const btn of deleteButtons) {
-            expect(btn.disabled).toBe(true);
-        }
-    });
-    it("emits an onChange with the admin record when saving a new draft", () => {
-        const onChange = vi.fn();
-        render(_jsx(ThemeManagerView, { value: EMPTY_VALUE, onChange: onChange }));
-        fireEvent.click(screen.getByRole("button", { name: /\+ New light theme/ }));
-        fireEvent.click(screen.getByRole("button", { name: /^Save theme$/ }));
-        expect(onChange).toHaveBeenCalledOnce();
-        const next = onChange.mock.calls[0][0];
-        expect(next.themes.length).toBe(1);
-        expect(next.themes[0].mode).toBe("light");
-    });
-});

package/dist/features/stores/repository/__tests__/store.repository.test.d.ts

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