@mohasinac/appkit 3.0.4 → 3.1.0

package/dist/features/seller/components/PrintCenterView.js

@@ -1,7 +1,55 @@
 "use client";
-import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useEffect, useRef, useState } from "react";
+import JsBarcode from "jsbarcode";
 import { Heading, Text } from "../../../ui/components/Typography";
-import { Stack } from "@mohasinac/appkit";
-export function PrintCenterView({ store, brandName = "LetItRip" }) {
-    return (_jsxs(Stack, { justify: "center", padding: "y-6xl", className: "text-center", align: "center", gap: "md", children: [_jsxs(Heading, { level: 2, children: [brandName, " Print Center"] }), store && _jsx(Text, { size: "sm", variant: "muted", children: store.storeName }), _jsx(Text, { size: "sm", variant: "muted", children: "Print center features are coming soon." })] }));
+import { Stack, Row } from "../../../ui/components/Layout";
+import { Button } from "../../../ui/components/Button";
+import { FieldCheckbox } from "../../../ui/forms/FieldCheckbox";
+function ProductLabel({ product }) {
+    const svgRef = useRef(null);
+    useEffect(() => {
+        if (svgRef.current && product.barcodeId) {
+            try {
+                JsBarcode(svgRef.current, product.barcodeId, {
+                    format: "CODE128",
+                    width: 2,
+                    height: 50,
+                    displayValue: true,
+                    fontSize: 12,
+                    margin: 8,
+                });
+            }
+            catch {
+                // Invalid barcode value — render nothing
+            }
+        }
+    }, [product.barcodeId]);
+    return (_jsxs(Stack, { surface: "card", padding: "sm", rounded: "sm", gap: "xs", className: "break-inside-avoid text-center w-[200px]", children: [product.barcodeId ? (_jsx("svg", { ref: svgRef })) : (_jsx(Text, { size: "xs", color: "muted", children: "No barcode" })), _jsx(Text, { size: "xs", weight: "medium", truncate: 1, children: product.name }), _jsxs(Text, { size: "xs", color: "muted", children: ["\u20B9", (product.price / 100).toLocaleString("en-IN")] }), product.physicalLocation && (_jsx(Text, { size: "xs", color: "muted", children: product.physicalLocation }))] }));
+}
+function PackingSlip({ order, brandName }) {
+    return (_jsxs(Stack, { surface: "card", padding: "md", rounded: "sm", className: "break-inside-avoid mb-4 max-w-[480px]", children: [_jsxs(Row, { justify: "between", className: "mb-2", children: [_jsx(Heading, { level: 5, children: brandName }), _jsxs(Text, { size: "xs", color: "muted", children: ["#", order.id] })] }), _jsx(Text, { size: "xs", color: "muted", children: new Date(order.createdAt).toLocaleDateString("en-IN") }), order.buyerDisplayName && _jsx(Text, { size: "sm", weight: "medium", children: order.buyerDisplayName }), order.buyerCity && _jsx(Text, { size: "xs", color: "muted", children: order.buyerCity }), order.physicalLocation && (_jsxs(Text, { size: "xs", color: "muted", children: ["Staging: ", order.physicalLocation] })), _jsx(Stack, { className: "mt-3 border-t pt-2", children: order.items.map((item, i) => (
+                // audit-variant-ok: py-1 is vertical-only padding; border-b last:border-b-0 uses pseudo-selector — no Row variant covers these
+                _jsxs(Row, { justify: "between", className: "py-1 border-b last:border-b-0", children: [_jsxs(Stack, { gap: "xs", children: [_jsx(Text, { size: "xs", weight: "medium", children: item.productName }), item.barcodeId && _jsx(Text, { size: "xs", color: "muted", children: item.barcodeId })] }), _jsxs(Stack, { className: "text-right", children: [_jsxs(Text, { size: "xs", children: ["\u00D7", item.quantity] }), _jsxs(Text, { size: "xs", color: "muted", children: ["\u20B9", (item.price / 100).toLocaleString("en-IN")] })] })] }, i))) })] }));
+}
+export function PrintCenterView({ store, brandName = "LetItRip", initialProducts = [], initialOrders = [], }) {
+    const [tab, setTab] = useState("labels");
+    const [selectedProducts, setSelectedProducts] = useState(new Set());
+    const [selectedOrders, setSelectedOrders] = useState(new Set());
+    const toggleProduct = (id) => setSelectedProducts((prev) => {
+        const next = new Set(prev);
+        next.has(id) ? next.delete(id) : next.add(id);
+        return next;
+    });
+    const toggleOrder = (id) => setSelectedOrders((prev) => {
+        const next = new Set(prev);
+        next.has(id) ? next.delete(id) : next.add(id);
+        return next;
+    });
+    const printSelected = () => window.print();
+    return (_jsxs(Stack, { gap: "md", padding: "md", children: [_jsx("style", { children: `@media print { .no-print { display: none !important; } }` }), _jsxs(Stack, { className: "no-print", children: [_jsxs(Heading, { level: 3, children: ["Print Center", store ? ` — ${store.storeName}` : ""] }), _jsxs(Row, { gap: "xs", className: "mt-3", children: [_jsx(Button, { onClick: () => setTab("labels"), variant: tab === "labels" ? "primary" : "secondary", size: "sm", children: "Product Labels" }), _jsx(Button, { onClick: () => setTab("slips"), variant: tab === "slips" ? "primary" : "secondary", size: "sm", children: "Packing Slips" })] })] }), tab === "labels" && (_jsxs(_Fragment, { children: [_jsx(Stack, { className: "no-print", children: _jsxs(Stack, { gap: "sm", children: [initialProducts.length === 0 ? (_jsx(Text, { color: "muted", children: "No products available." })) : (initialProducts.map((p) => (_jsx(FieldCheckbox, { name: `product-${p.id}`, label: p.name, checked: selectedProducts.has(p.id), onChange: () => toggleProduct(p.id) }, p.id)))), _jsxs(Button, { onClick: printSelected, disabled: selectedProducts.size === 0, children: ["Print Selected (", selectedProducts.size, ")"] })] }) }), _jsx(Row, { wrap: true, gap: "sm", className: "mt-4", children: initialProducts
+                            .filter((p) => selectedProducts.has(p.id))
+                            .map((p) => (_jsx(ProductLabel, { product: p }, p.id))) })] })), tab === "slips" && (_jsxs(_Fragment, { children: [_jsx(Stack, { className: "no-print", children: _jsxs(Stack, { gap: "sm", children: [initialOrders.length === 0 ? (_jsx(Text, { color: "muted", children: "No orders available." })) : (initialOrders.map((o) => (_jsx(FieldCheckbox, { name: `order-${o.id}`, label: `#${o.id}${o.buyerDisplayName ? ` — ${o.buyerDisplayName}` : ""}`, checked: selectedOrders.has(o.id), onChange: () => toggleOrder(o.id) }, o.id)))), _jsxs(Button, { onClick: printSelected, disabled: selectedOrders.size === 0, children: ["Print Selected (", selectedOrders.size, ")"] })] }) }), _jsx(Stack, { gap: "sm", children: initialOrders
+                            .filter((o) => selectedOrders.has(o.id))
+                            .map((o) => (_jsx(PackingSlip, { order: o, brandName: brandName }, o.id))) })] }))] }));
 }

package/dist/features/seller/components/SellerProductShell.d.ts

@@ -59,6 +59,8 @@ export interface SellerProductDraft {
     liveHandlingFee?: number;
     liveJurisdictions?: string[];
     liveCites?: boolean;
+    /** Barcode ID of the physical sticker on this item. Auto-generated on save if blank. */
+    barcodeId?: string;
 }
 export interface SellerProductShellProps {
     mode: "create" | "edit";

package/dist/features/seller/components/SellerProductShell.js

@@ -9,6 +9,7 @@ import { Alert, Button, Div, FormField, FormGroup, Heading, Section, Stack, Text
 import { ImageUpload, MediaUploadField, MediaUploadList, useMediaUpload } from "../../media";
 import { StoreAddressSelectorCreate } from "../../stores/components/StoreAddressSelectorCreate";
 import { QuickProductForm } from "./QuickProductForm";
+import { BarcodeField } from "./BarcodeField";
 import { normalizeError } from "../../../errors/normalize";
 const sellerProductSchema = z.object({
     title: z.string().min(1, "Product title is required").max(200),
@@ -39,7 +40,7 @@ function toPaise(rupeeStr) {
 }
 // ── Step 1: Basic ─────────────────────────────────────────────────────────────
 function StepBasic({ values, onChange, renderCategorySelector, renderBrandSelector, renderTemplateSelector, }) {
-    return (_jsxs(Stack, { gap: "md", children: [renderTemplateSelector?.({ onApply: onChange }), _jsx(FormField, { name: "title", label: "Title", type: "text", value: values.title ?? "", onChange: (v) => onChange({ title: v }), placeholder: "e.g. Charizard Base Set PSA 9" }), _jsx(FormField, { name: "description", label: "Description", type: "textarea", value: values.description ?? "", onChange: (v) => onChange({ description: v }), placeholder: "Describe your listing in detail\u2026" }), _jsxs(FormGroup, { columns: 2, children: [renderCategorySelector ? (_jsxs(_Fragment, { children: [_jsx(Text, { className: "text-[var(--appkit-color-text)] mb-1", size: "sm", weight: "medium", children: "Category" }), renderCategorySelector({ value: values.category ?? "", onChange: (v) => onChange({ category: v }) })] })) : (_jsx(FormField, { name: "category", label: "Category", type: "text", value: values.category ?? "", onChange: (v) => onChange({ category: v }), placeholder: "e.g. Trading Cards" })), _jsx(FormField, { name: "condition", label: "Condition", type: "select", value: values.condition ?? "new", onChange: (v) => onChange({ condition: v }), options: CONDITION_OPTIONS })] }), renderBrandSelector ? (_jsxs(_Fragment, { children: [_jsx(Text, { className: "text-[var(--appkit-color-text)] mb-1", size: "sm", weight: "medium", children: "Brand" }), renderBrandSelector({ value: values.brand ?? "", onChange: (v) => onChange({ brand: v }) })] })) : (_jsx(FormField, { name: "brand", label: "Brand", type: "text", value: values.brand ?? "", onChange: (v) => onChange({ brand: v }), placeholder: "e.g. Pok\u00E9mon Company" })), _jsx(FormField, { name: "tags", label: "Tags (comma-separated)", type: "text", value: (values.tags ?? []).join(", "), onChange: (v) => onChange({ tags: v.split(",").map((t) => t.trim()).filter(Boolean) }), placeholder: "pokemon, psa9, charizard, holo" })] }));
+    return (_jsxs(Stack, { gap: "md", children: [renderTemplateSelector?.({ onApply: onChange }), _jsx(FormField, { name: "title", label: "Title", type: "text", value: values.title ?? "", onChange: (v) => onChange({ title: v }), placeholder: "e.g. Charizard Base Set PSA 9" }), _jsx(FormField, { name: "description", label: "Description", type: "textarea", value: values.description ?? "", onChange: (v) => onChange({ description: v }), placeholder: "Describe your listing in detail\u2026" }), _jsxs(FormGroup, { columns: 2, children: [renderCategorySelector ? (_jsxs(_Fragment, { children: [_jsx(Text, { className: "text-[var(--appkit-color-text)] mb-1", size: "sm", weight: "medium", children: "Category" }), renderCategorySelector({ value: values.category ?? "", onChange: (v) => onChange({ category: v }) })] })) : (_jsx(FormField, { name: "category", label: "Category", type: "text", value: values.category ?? "", onChange: (v) => onChange({ category: v }), placeholder: "e.g. Trading Cards" })), _jsx(FormField, { name: "condition", label: "Condition", type: "select", value: values.condition ?? "new", onChange: (v) => onChange({ condition: v }), options: CONDITION_OPTIONS })] }), renderBrandSelector ? (_jsxs(_Fragment, { children: [_jsx(Text, { className: "text-[var(--appkit-color-text)] mb-1", size: "sm", weight: "medium", children: "Brand" }), renderBrandSelector({ value: values.brand ?? "", onChange: (v) => onChange({ brand: v }) })] })) : (_jsx(FormField, { name: "brand", label: "Brand", type: "text", value: values.brand ?? "", onChange: (v) => onChange({ brand: v }), placeholder: "e.g. Pok\u00E9mon Company" })), _jsx(FormField, { name: "tags", label: "Tags (comma-separated)", type: "text", value: (values.tags ?? []).join(", "), onChange: (v) => onChange({ tags: v.split(",").map((t) => t.trim()).filter(Boolean) }), placeholder: "pokemon, psa9, charizard, holo" }), _jsx(BarcodeField, { value: values.barcodeId ?? "", onChange: (v) => onChange({ barcodeId: v || undefined }), onScan: (v) => onChange({ barcodeId: v }), helperText: "Leave blank to auto-generate. Scan a pre-printed sticker to link it." })] }));
 }
 // ── Step 2: Media ─────────────────────────────────────────────────────────────
 function StepMedia({ values, onChange, storeSlug = "store", }) {

package/dist/features/seller/components/index.d.ts

@@ -128,3 +128,7 @@ export { SellerDigitalCodesView } from "./SellerDigitalCodesView";
 export type { SellerDigitalCodesViewProps } from "./SellerDigitalCodesView";
 export { SellerLiveView } from "./SellerLiveView";
 export type { SellerLiveViewProps } from "./SellerLiveView";
+export { BarcodeField } from "./BarcodeField";
+export type { BarcodeFieldProps } from "./BarcodeField";
+export { FulfillmentView } from "./FulfillmentView";
+export type { FulfillmentViewProps } from "./FulfillmentView";

package/dist/features/seller/components/index.js

@@ -67,3 +67,5 @@ export { SellerBundlesView } from "./SellerBundlesView";
 export { SellerClassifiedView } from "./SellerClassifiedView";
 export { SellerDigitalCodesView } from "./SellerDigitalCodesView";
 export { SellerLiveView } from "./SellerLiveView";
+export { BarcodeField } from "./BarcodeField";
+export { FulfillmentView } from "./FulfillmentView";

package/dist/features/seller/repository/__tests__/offer.repository.test.d.ts

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

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

@@ -0,0 +1,458 @@
+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/schemas/index.d.ts

@@ -87,8 +87,8 @@ export declare const sellerStoreSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     status: "pending" | "active" | "rejected" | "suspended";
     createdAt: string;
-    id: string;
     storeName: string;
+    id: string;
     updatedAt: string;
     isPublic: boolean;
     storeSlug: string;
@@ -119,8 +119,8 @@ export declare const sellerStoreSchema: z.ZodObject<{
 }, {
     status: "pending" | "active" | "rejected" | "suspended";
     createdAt: string;
-    id: string;
     storeName: string;
+    id: string;
     updatedAt: string;
     isPublic: boolean;
     storeSlug: string;