@mohasinac/appkit 3.0.4 → 3.1.0

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

@@ -0,0 +1,386 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { makeMockDb, makeSnap, makeQuerySnap } from "../../../../../tests/helpers/mock-firestore";
+import { DatabaseError } from "../../../../errors";
+const { db, mockDocRef, mockCollection, mockQuery, mockBatch } = makeMockDb();
+const { mockEncryptPiiFields, mockDecryptPiiFields } = vi.hoisted(() => ({
+    mockEncryptPiiFields: vi.fn((d) => d),
+    mockDecryptPiiFields: vi.fn((d) => d),
+}));
+const { mockGetFirestoreCount } = vi.hoisted(() => ({
+    mockGetFirestoreCount: vi.fn().mockResolvedValue(0),
+}));
+vi.mock("../../../../providers/db-firebase/admin", () => ({
+    getAdminDb: () => db,
+}));
+vi.mock("../../../../providers/db-firebase", async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        prepareForFirestore: (d) => d,
+        getFirestoreCount: mockGetFirestoreCount,
+    };
+});
+vi.mock("../../../../security", () => ({
+    encryptPiiFields: mockEncryptPiiFields,
+    decryptPiiFields: mockDecryptPiiFields,
+    ADDRESS_PII_FIELDS: ["fullName", "phone", "addressLine1"],
+}));
+vi.mock("../../../../errors/normalize", () => ({
+    normalizeError: vi.fn(),
+}));
+vi.mock("../../../../monitoring", () => ({
+    serverLogger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+}));
+import { AddressesRepository } from "../addresses.repository";
+const repo = new AddressesRepository();
+function makeAddressDoc(overrides = {}) {
+    return {
+        id: "addr-1",
+        ownerType: "user",
+        ownerId: "user-1",
+        label: "Home",
+        fullName: "Ravi Kumar",
+        phone: "+91-9876543210",
+        addressLine1: "123 Main St",
+        city: "Mumbai",
+        state: "Maharashtra",
+        postalCode: "400001",
+        country: "IN",
+        isDefault: false,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        ...overrides,
+    };
+}
+function makeAddressInput(overrides = {}) {
+    return {
+        label: "Home",
+        fullName: "Ravi Kumar",
+        phone: "+91-9876543210",
+        addressLine1: "123 Main St",
+        city: "Mumbai",
+        state: "Maharashtra",
+        postalCode: "400001",
+        country: "IN",
+        isDefault: false,
+        ...overrides,
+    };
+}
+beforeEach(() => {
+    vi.clearAllMocks();
+    // Restore passthrough encryption mocks after clearAllMocks
+    mockEncryptPiiFields.mockImplementation((d) => d);
+    mockDecryptPiiFields.mockImplementation((d) => d);
+    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(makeQuerySnap([]));
+    mockDocRef.get.mockResolvedValue(makeSnap(null));
+    mockDocRef.set.mockResolvedValue(undefined);
+    mockDocRef.update.mockResolvedValue(undefined);
+    mockDocRef.delete.mockResolvedValue(undefined);
+    db.batch.mockReturnValue(mockBatch);
+    mockGetFirestoreCount.mockResolvedValue(0);
+});
+// ---------------------------------------------------------------------------
+// listByOwner
+// ---------------------------------------------------------------------------
+describe("AddressesRepository.listByOwner", () => {
+    it("returns addresses for the owner", async () => {
+        const addr = makeAddressDoc();
+        mockQuery.get.mockResolvedValue(makeQuerySnap([{ id: addr.id, data: addr }]));
+        const results = await repo.listByOwner("user", "user-1");
+        expect(results).toHaveLength(1);
+    });
+    it("queries with ownerType AND ownerId filters", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        await repo.listByOwner("user", "user-1");
+        expect(mockCollection.where).toHaveBeenCalledWith("ownerType", "==", "user");
+        expect(mockQuery.where).toHaveBeenCalledWith("ownerId", "==", "user-1");
+    });
+    it("orders results by createdAt descending", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        await repo.listByOwner("user", "user-1");
+        expect(mockQuery.orderBy).toHaveBeenCalledWith("createdAt", "desc");
+    });
+    it("returns empty array when no addresses found", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        const results = await repo.listByOwner("user", "nobody");
+        expect(results).toHaveLength(0);
+    });
+    it("returns store addresses when ownerType=store", async () => {
+        const addr = makeAddressDoc({ ownerType: "store", ownerId: "store-1" });
+        mockQuery.get.mockResolvedValue(makeQuerySnap([{ id: addr.id, data: addr }]));
+        const results = await repo.listByOwner("store", "store-1");
+        expect(results).toHaveLength(1);
+        expect(mockCollection.where).toHaveBeenCalledWith("ownerType", "==", "store");
+    });
+});
+// ---------------------------------------------------------------------------
+// listByOwnerType
+// ---------------------------------------------------------------------------
+describe("AddressesRepository.listByOwnerType", () => {
+    it("queries only by ownerType (no ownerId filter)", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        await repo.listByOwnerType("user");
+        expect(mockCollection.where).toHaveBeenCalledWith("ownerType", "==", "user");
+        // Ensure ownerId filter NOT applied (only one where call at collection level)
+        const collectionWhereCalls = mockCollection.where.mock.calls.filter((c) => c[0] === "ownerId");
+        expect(collectionWhereCalls).toHaveLength(0);
+    });
+    it("applies the limit (default 500)", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        await repo.listByOwnerType("store");
+        expect(mockQuery.limit).toHaveBeenCalledWith(500);
+    });
+    it("applies custom limit when provided", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        await repo.listByOwnerType("store", 100);
+        expect(mockQuery.limit).toHaveBeenCalledWith(100);
+    });
+});
+// ---------------------------------------------------------------------------
+// countByOwner
+// ---------------------------------------------------------------------------
+describe("AddressesRepository.countByOwner", () => {
+    it("returns count from getFirestoreCount", async () => {
+        mockGetFirestoreCount.mockResolvedValue(3);
+        const count = await repo.countByOwner("user", "user-1");
+        expect(count).toBe(3);
+    });
+    it("queries by ownerType AND ownerId", async () => {
+        await repo.countByOwner("user", "user-1");
+        expect(mockCollection.where).toHaveBeenCalledWith("ownerType", "==", "user");
+        expect(mockQuery.where).toHaveBeenCalledWith("ownerId", "==", "user-1");
+    });
+    it("returns 0 when no addresses exist", async () => {
+        mockGetFirestoreCount.mockResolvedValue(0);
+        const count = await repo.countByOwner("user", "ghost-user");
+        expect(count).toBe(0);
+    });
+});
+// ---------------------------------------------------------------------------
+// createForOwner
+// ---------------------------------------------------------------------------
+describe("AddressesRepository.createForOwner", () => {
+    it("isDefault:false — no batch operations, docRef.set called", async () => {
+        const address = makeAddressDoc();
+        mockDocRef.get.mockResolvedValue(makeSnap(address, "mock-doc-id"));
+        await repo.createForOwner("user", "user-1", makeAddressInput({ isDefault: false }));
+        expect(mockDocRef.set).toHaveBeenCalledOnce();
+        expect(mockBatch.update).not.toHaveBeenCalled();
+        expect(mockBatch.commit).not.toHaveBeenCalled();
+    });
+    it("isDefault:true with no existing defaults — no batch commit, docRef.set still called", async () => {
+        // clearDefaultFlag: empty snap → early return without batch
+        mockQuery.get.mockResolvedValue({ docs: [], empty: true, size: 0 });
+        const address = makeAddressDoc({ isDefault: true });
+        mockDocRef.get.mockResolvedValue(makeSnap(address, "mock-doc-id"));
+        await repo.createForOwner("user", "user-1", makeAddressInput({ isDefault: true }));
+        expect(mockDocRef.set).toHaveBeenCalledOnce();
+        expect(mockBatch.commit).not.toHaveBeenCalled();
+    });
+    it("isDefault:true with existing defaults — clears them via batch before creating", async () => {
+        const existingDefault = makeAddressDoc({ isDefault: true, id: "addr-old" });
+        const existingSnap = makeSnap(existingDefault, "addr-old");
+        mockQuery.get.mockResolvedValue({ docs: [existingSnap], empty: false, size: 1 });
+        const newAddress = makeAddressDoc({ isDefault: true });
+        mockDocRef.get.mockResolvedValue(makeSnap(newAddress, "mock-doc-id"));
+        await repo.createForOwner("user", "user-1", makeAddressInput({ isDefault: true }));
+        expect(mockBatch.update).toHaveBeenCalledWith(existingSnap.ref, expect.objectContaining({ isDefault: false }));
+        expect(mockBatch.commit).toHaveBeenCalledOnce();
+        expect(mockDocRef.set).toHaveBeenCalledOnce();
+    });
+    it("sets ownerType and ownerId on the written document", async () => {
+        const address = makeAddressDoc();
+        mockDocRef.get.mockResolvedValue(makeSnap(address, "mock-doc-id"));
+        await repo.createForOwner("store", "store-abc", makeAddressInput());
+        expect(mockDocRef.set).toHaveBeenCalledWith(expect.objectContaining({ ownerType: "store", ownerId: "store-abc" }));
+    });
+    it("re-fetches the address after write to return consistent data", async () => {
+        const address = makeAddressDoc();
+        mockDocRef.get.mockResolvedValue(makeSnap(address, "mock-doc-id"));
+        const result = await repo.createForOwner("user", "user-1", makeAddressInput());
+        // The re-fetch (findById) uses mockDocRef.get — result reflects that
+        expect(result).toBeDefined();
+        expect(mockDocRef.get).toHaveBeenCalled();
+    });
+    it("throws DatabaseError when re-fetch returns null (doc not readable after write)", async () => {
+        mockDocRef.get.mockResolvedValue(makeSnap(null));
+        await expect(repo.createForOwner("user", "user-1", makeAddressInput())).rejects.toThrow(DatabaseError);
+    });
+    it("calls encryptPiiFields with the address data on write", async () => {
+        const address = makeAddressDoc();
+        mockDocRef.get.mockResolvedValue(makeSnap(address, "mock-doc-id"));
+        await repo.createForOwner("user", "user-1", makeAddressInput({ fullName: "Jane Doe" }));
+        expect(mockEncryptPiiFields).toHaveBeenCalledWith(expect.objectContaining({ fullName: "Jane Doe" }), expect.arrayContaining(["fullName", "phone", "addressLine1"]));
+    });
+    it("uses an auto-generated Firestore ID (getCollection().doc() called without args)", async () => {
+        const address = makeAddressDoc();
+        mockDocRef.get.mockResolvedValue(makeSnap(address, "mock-doc-id"));
+        await repo.createForOwner("user", "user-1", makeAddressInput());
+        // doc() called with no argument = auto-ID
+        const callsWithNoArg = mockCollection.doc.mock.calls.filter((args) => args.length === 0);
+        expect(callsWithNoArg).not.toHaveLength(0);
+    });
+});
+// ---------------------------------------------------------------------------
+// updateForOwner
+// ---------------------------------------------------------------------------
+describe("AddressesRepository.updateForOwner", () => {
+    it("throws DatabaseError when address not found", async () => {
+        mockDocRef.get.mockResolvedValue(makeSnap(null));
+        await expect(repo.updateForOwner("user", "user-1", "addr-x", { label: "Work" })).rejects.toThrow(DatabaseError);
+    });
+    it("throws DatabaseError when ownerType does not match", async () => {
+        const address = makeAddressDoc({ ownerType: "store", ownerId: "store-1" });
+        mockDocRef.get.mockResolvedValue(makeSnap(address, "addr-1"));
+        await expect(repo.updateForOwner("user", "user-1", "addr-1", { label: "Work" })).rejects.toThrow(DatabaseError);
+    });
+    it("throws DatabaseError when ownerId does not match", async () => {
+        const address = makeAddressDoc({ ownerType: "user", ownerId: "user-other" });
+        mockDocRef.get.mockResolvedValue(makeSnap(address, "addr-1"));
+        await expect(repo.updateForOwner("user", "user-1", "addr-1", { label: "Work" })).rejects.toThrow(DatabaseError);
+    });
+    it("updates the address when ownership matches", async () => {
+        const address = makeAddressDoc({ ownerType: "user", ownerId: "user-1" });
+        mockDocRef.get.mockResolvedValue(makeSnap(address, "addr-1"));
+        mockQuery.get.mockResolvedValue({ docs: [], empty: true, size: 0 });
+        await repo.updateForOwner("user", "user-1", "addr-1", { label: "Office" });
+        expect(mockDocRef.update).toHaveBeenCalled();
+    });
+    it("isDefault:true — clears existing defaults before updating", async () => {
+        const address = makeAddressDoc({ ownerType: "user", ownerId: "user-1" });
+        mockDocRef.get.mockResolvedValue(makeSnap(address, "addr-1"));
+        const existingDefault = makeAddressDoc({ isDefault: true, id: "addr-old" });
+        const existingSnap = makeSnap(existingDefault, "addr-old");
+        mockQuery.get.mockResolvedValue({ docs: [existingSnap], empty: false, size: 1 });
+        await repo.updateForOwner("user", "user-1", "addr-1", { isDefault: true });
+        expect(mockBatch.update).toHaveBeenCalledWith(existingSnap.ref, expect.objectContaining({ isDefault: false }));
+        expect(mockBatch.commit).toHaveBeenCalledOnce();
+    });
+    it("isDefault:false — does NOT clear existing defaults", async () => {
+        const address = makeAddressDoc({ ownerType: "user", ownerId: "user-1" });
+        mockDocRef.get.mockResolvedValue(makeSnap(address, "addr-1"));
+        await repo.updateForOwner("user", "user-1", "addr-1", { isDefault: false });
+        expect(mockBatch.commit).not.toHaveBeenCalled();
+    });
+    it("encrypts PII fields on update", async () => {
+        const address = makeAddressDoc({ ownerType: "user", ownerId: "user-1" });
+        mockDocRef.get.mockResolvedValue(makeSnap(address, "addr-1"));
+        await repo.updateForOwner("user", "user-1", "addr-1", { fullName: "New Name" });
+        expect(mockEncryptPiiFields).toHaveBeenCalledWith(expect.objectContaining({ fullName: "New Name" }), expect.arrayContaining(["fullName", "phone", "addressLine1"]));
+    });
+});
+// ---------------------------------------------------------------------------
+// deleteForOwner
+// ---------------------------------------------------------------------------
+describe("AddressesRepository.deleteForOwner", () => {
+    it("throws DatabaseError when address not found", async () => {
+        mockDocRef.get.mockResolvedValue(makeSnap(null));
+        await expect(repo.deleteForOwner("user", "user-1", "addr-x")).rejects.toThrow(DatabaseError);
+    });
+    it("throws DatabaseError when address belongs to a different ownerId", async () => {
+        const address = makeAddressDoc({ ownerType: "user", ownerId: "user-other" });
+        mockDocRef.get.mockResolvedValue(makeSnap(address, "addr-1"));
+        await expect(repo.deleteForOwner("user", "user-1", "addr-1")).rejects.toThrow(DatabaseError);
+    });
+    it("throws DatabaseError when address belongs to a different ownerType", async () => {
+        const address = makeAddressDoc({ ownerType: "store", ownerId: "user-1" });
+        mockDocRef.get.mockResolvedValue(makeSnap(address, "addr-1"));
+        await expect(repo.deleteForOwner("user", "user-1", "addr-1")).rejects.toThrow(DatabaseError);
+    });
+    it("deletes the address when ownership matches", async () => {
+        const address = makeAddressDoc({ ownerType: "user", ownerId: "user-1" });
+        mockDocRef.get.mockResolvedValue(makeSnap(address, "addr-1"));
+        await repo.deleteForOwner("user", "user-1", "addr-1");
+        expect(mockDocRef.delete).toHaveBeenCalledOnce();
+    });
+    it("does NOT delete address for a different store-owner", async () => {
+        const storeAddr = makeAddressDoc({ ownerType: "store", ownerId: "store-2" });
+        mockDocRef.get.mockResolvedValue(makeSnap(storeAddr, "addr-1"));
+        await expect(repo.deleteForOwner("store", "store-1", "addr-1")).rejects.toThrow(DatabaseError);
+        expect(mockDocRef.delete).not.toHaveBeenCalled();
+    });
+});
+// ---------------------------------------------------------------------------
+// setDefault
+// ---------------------------------------------------------------------------
+describe("AddressesRepository.setDefault", () => {
+    it("throws DatabaseError when address not found", async () => {
+        mockDocRef.get.mockResolvedValue(makeSnap(null));
+        await expect(repo.setDefault("user", "user-1", "addr-x")).rejects.toThrow(DatabaseError);
+    });
+    it("throws DatabaseError when address belongs to a different owner", async () => {
+        const address = makeAddressDoc({ ownerType: "user", ownerId: "user-other" });
+        mockDocRef.get.mockResolvedValue(makeSnap(address, "addr-1"));
+        await expect(repo.setDefault("user", "user-1", "addr-1")).rejects.toThrow(DatabaseError);
+    });
+    it("clears all existing defaults for the owner before setting the new one", async () => {
+        const address = makeAddressDoc({ ownerType: "user", ownerId: "user-1" });
+        mockDocRef.get.mockResolvedValue(makeSnap(address, "addr-1"));
+        const existingDefault = makeAddressDoc({ isDefault: true, id: "addr-old" });
+        const existingSnap = makeSnap(existingDefault, "addr-old");
+        mockQuery.get.mockResolvedValue({ docs: [existingSnap], empty: false, size: 1 });
+        await repo.setDefault("user", "user-1", "addr-1");
+        // clearDefaultFlag ran and batched the update
+        expect(mockBatch.update).toHaveBeenCalledWith(existingSnap.ref, expect.objectContaining({ isDefault: false }));
+        expect(mockBatch.commit).toHaveBeenCalledOnce();
+    });
+    it("sets isDefault:true on the target address", async () => {
+        const address = makeAddressDoc({ ownerType: "user", ownerId: "user-1" });
+        mockDocRef.get.mockResolvedValue(makeSnap(address, "addr-1"));
+        mockQuery.get.mockResolvedValue({ docs: [], empty: true, size: 0 });
+        await repo.setDefault("user", "user-1", "addr-1");
+        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ isDefault: true }));
+    });
+    it("uses a batch for atomicity (clear + set in single WriteBatch)", async () => {
+        const address = makeAddressDoc({ ownerType: "user", ownerId: "user-1" });
+        mockDocRef.get.mockResolvedValue(makeSnap(address, "addr-1"));
+        // Two existing defaults to clear
+        const s1 = makeSnap(makeAddressDoc({ isDefault: true, id: "old-1" }), "old-1");
+        const s2 = makeSnap(makeAddressDoc({ isDefault: true, id: "old-2" }), "old-2");
+        mockQuery.get.mockResolvedValue({ docs: [s1, s2], empty: false, size: 2 });
+        await repo.setDefault("user", "user-1", "addr-1");
+        expect(mockBatch.update).toHaveBeenCalledTimes(2);
+        expect(mockBatch.commit).toHaveBeenCalledOnce();
+    });
+});
+// ---------------------------------------------------------------------------
+// deleteAllForOwner
+// ---------------------------------------------------------------------------
+describe("AddressesRepository.deleteAllForOwner", () => {
+    it("returns 0 and does not start a batch when no addresses found", async () => {
+        mockQuery.get.mockResolvedValue({ docs: [], empty: true, size: 0 });
+        const count = await repo.deleteAllForOwner("user", "user-1");
+        expect(count).toBe(0);
+        expect(mockBatch.delete).not.toHaveBeenCalled();
+        expect(mockBatch.commit).not.toHaveBeenCalled();
+    });
+    it("batch-deletes all matching addresses and returns the count", async () => {
+        const s1 = makeSnap(makeAddressDoc({ id: "addr-1" }), "addr-1");
+        const s2 = makeSnap(makeAddressDoc({ id: "addr-2" }), "addr-2");
+        mockQuery.get.mockResolvedValue({ docs: [s1, s2], empty: false, size: 2 });
+        const count = await repo.deleteAllForOwner("user", "user-1");
+        expect(count).toBe(2);
+        expect(mockBatch.delete).toHaveBeenCalledWith(s1.ref);
+        expect(mockBatch.delete).toHaveBeenCalledWith(s2.ref);
+        expect(mockBatch.commit).toHaveBeenCalledOnce();
+    });
+    it("queries by ownerType AND ownerId", async () => {
+        mockQuery.get.mockResolvedValue({ docs: [], empty: true, size: 0 });
+        await repo.deleteAllForOwner("store", "store-xyz");
+        expect(mockCollection.where).toHaveBeenCalledWith("ownerType", "==", "store");
+        expect(mockQuery.where).toHaveBeenCalledWith("ownerId", "==", "store-xyz");
+    });
+    it("returns count matching the number of docs deleted", async () => {
+        const snaps = Array.from({ length: 5 }, (_, i) => makeSnap(makeAddressDoc({ id: `addr-${i}` }), `addr-${i}`));
+        mockQuery.get.mockResolvedValue({ docs: snaps, empty: false, size: 5 });
+        const count = await repo.deleteAllForOwner("user", "user-1");
+        expect(count).toBe(5);
+        expect(mockBatch.delete).toHaveBeenCalledTimes(5);
+    });
+});

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

@@ -7,9 +7,9 @@
  * are encrypted at rest via the existing `encryptPiiFields` pipeline; the
  * repository overrides `createWithId` and `create` to inject encryption.
  */
+import type { BaseDocument } from "../../../_internal/shared/types/base-document";
 export type AddressOwnerType = "user" | "store";
-export interface AddressDocument {
-    id: string;
+export interface AddressDocument extends BaseDocument {
     ownerType: AddressOwnerType;
     ownerId: string;
     label: string;
@@ -23,8 +23,6 @@ export interface AddressDocument {
     postalCode: string;
     country: string;
     isDefault: boolean;
-    createdAt: Date;
-    updatedAt: Date;
 }
 export declare const ADDRESSES_COLLECTION: "addresses";
 export declare const ADDRESS_INDEXED_FIELDS: readonly ["ownerType", "ownerId", "isDefault", "createdAt"];

package/dist/features/admin/api/bids/route.d.ts

@@ -9,6 +9,6 @@
  * export { adminBidsGET as GET } from "@mohasinac/feat-admin";
  * ```
  */
-export declare const GET: (request: Request, context: {
+export declare const GET: (request: Request, context?: {
     params: Promise<Record<string, string>>;
-}) => Promise<Response>;
+} | undefined) => Promise<Response>;

package/dist/features/admin/api/coupons/route.d.ts

@@ -9,6 +9,6 @@
  * export { adminCouponsGET as GET } from "@mohasinac/feat-admin";
  * ```
  */
-export declare const GET: (request: Request, context: {
+export declare const GET: (request: Request, context?: {
     params: Promise<Record<string, string>>;
-}) => Promise<Response>;
+} | undefined) => Promise<Response>;

package/dist/features/admin/api/products/route.d.ts

@@ -9,6 +9,6 @@
  * export { adminProductsGET as GET } from "@mohasinac/feat-admin";
  * ```
  */
-export declare const GET: (request: Request, context: {
+export declare const GET: (request: Request, context?: {
     params: Promise<Record<string, string>>;
-}) => Promise<Response>;
+} | undefined) => Promise<Response>;

package/dist/features/admin/api/reviews/route.d.ts

@@ -9,6 +9,6 @@
  * export { adminReviewsGET as GET } from "@mohasinac/feat-admin";
  * ```
  */
-export declare const GET: (request: Request, context: {
+export declare const GET: (request: Request, context?: {
     params: Promise<Record<string, string>>;
-}) => Promise<Response>;
+} | undefined) => Promise<Response>;

package/dist/features/admin/components/AdminFulfillmentView.d.ts

@@ -0,0 +1,6 @@
+export interface AdminFulfillmentViewProps {
+    /** Pre-selected store ID — skips the store picker when provided. */
+    initialStoreId?: string;
+    initialStoreName?: string;
+}
+export declare function AdminFulfillmentView({ initialStoreId, initialStoreName, }: AdminFulfillmentViewProps): import("react/jsx-runtime").JSX.Element;

package/dist/features/admin/components/AdminFulfillmentView.js

@@ -0,0 +1,107 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useCallback, useEffect, useState } from "react";
+import { Heading, Text } from "../../../ui/components/Typography";
+import { Stack, Row } from "../../../ui/components/Layout";
+import { Button } from "../../../ui/components/Button";
+import { Badge } from "../../../ui/components/Badge";
+import { PaginatedSelect } from "../../../ui/components/PaginatedSelect";
+import { apiClient } from "../../../http";
+import { ADMIN_ENDPOINTS } from "../../../constants/api-endpoints";
+import { normalizeError } from "../../../errors/normalize";
+import { useToast } from "../../../ui";
+async function loadStoreOptions(query, page) {
+    const params = new URLSearchParams({ page: String(page), pageSize: "25" });
+    if (query)
+        params.set("q", query);
+    const res = await apiClient.get(`${ADMIN_ENDPOINTS.STORES}?${params.toString()}`);
+    const items = (res.items ?? []).map((s) => ({ value: s.id, label: s.storeName }));
+    return { items, hasMore: res.hasMore ?? false };
+}
+function statusBadgeVariant(status) {
+    if (status === "confirmed")
+        return "warning";
+    if (status === "processing")
+        return "info";
+    if (status === "shipped")
+        return "success";
+    return "default";
+}
+export function AdminFulfillmentView({ initialStoreId, initialStoreName, }) {
+    const [storeId, setStoreId] = useState(initialStoreId ?? null);
+    const [orders, setOrders] = useState([]);
+    const [isLoading, setIsLoading] = useState(false);
+    const [actionLoadingId, setActionLoadingId] = useState(null);
+    const { showToast } = useToast();
+    const fetchOrders = useCallback(async (sid) => {
+        // toast-intentionally-silent: background data loader — stale list is kept on error
+        setIsLoading(true);
+        try {
+            const res = await apiClient.get(ADMIN_ENDPOINTS.ADMIN_FULFILLMENT(sid));
+            setOrders(res.orders ?? []);
+        }
+        catch {
+            // keep stale list on error
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, []);
+    useEffect(() => {
+        if (storeId)
+            void fetchOrders(storeId);
+    }, [storeId, fetchOrders]);
+    const handleMarkPicked = useCallback(async (orderId) => {
+        if (!storeId)
+            return;
+        setActionLoadingId(orderId + ":picked");
+        try {
+            await apiClient.patch(`/api/store/orders/${orderId}`, { markPicked: true });
+            showToast("Order marked as picked.", "success");
+            await fetchOrders(storeId);
+        }
+        catch (err) {
+            showToast(normalizeError(err).message, "error");
+        }
+        finally {
+            setActionLoadingId(null);
+        }
+    }, [storeId, fetchOrders, showToast]);
+    const handleMarkPacked = useCallback(async (orderId) => {
+        if (!storeId)
+            return;
+        setActionLoadingId(orderId + ":packed");
+        try {
+            await apiClient.patch(`/api/store/orders/${orderId}`, { markPacked: true });
+            showToast("Order marked as packed.", "success");
+            await fetchOrders(storeId);
+        }
+        catch (err) {
+            showToast(normalizeError(err).message, "error");
+        }
+        finally {
+            setActionLoadingId(null);
+        }
+    }, [storeId, fetchOrders, showToast]);
+    const handleUnassign = useCallback(async (orderId) => {
+        if (!storeId)
+            return;
+        setActionLoadingId(orderId + ":unassign");
+        try {
+            await apiClient.patch(`/api/store/orders/${orderId}/assign`, { workerId: null });
+            showToast("Worker unassigned.", "success");
+            await fetchOrders(storeId);
+        }
+        catch (err) {
+            showToast(normalizeError(err).message, "error");
+        }
+        finally {
+            setActionLoadingId(null);
+        }
+    }, [storeId, fetchOrders, showToast]);
+    return (_jsxs(Stack, { gap: "md", padding: "md", children: [_jsxs(Row, { align: "center", justify: "between", gap: "sm", wrap: true, children: [_jsx(Heading, { level: 3, children: "Fulfillment Queue" }), storeId && (_jsx(Button, { variant: "secondary", size: "sm", onClick: () => {
+                            setStoreId(null);
+                            setOrders([]);
+                        }, children: "Change Store" }))] }), !storeId && (_jsxs(Stack, { gap: "sm", children: [_jsx(Text, { size: "sm", color: "muted", children: "Select a store to view its fulfilment queue." }), _jsx(PaginatedSelect, { value: null, onChange: (v) => { if (v)
+                            setStoreId(v); }, loadOptions: loadStoreOptions, placeholder: "Search stores\u2026", searchPlaceholder: "Type store name\u2026", noResultsText: "No stores found", ariaLabel: "Store" })] })), storeId && (_jsxs(Stack, { gap: "sm", children: [isLoading && (_jsx(Text, { size: "sm", color: "muted", children: "Loading orders\u2026" })), !isLoading && orders.length === 0 && (_jsx(Text, { color: "muted", children: "No orders in the fulfillment queue \u2014 great work!" })), orders.map((order) => (_jsxs(Stack, { surface: "card", padding: "sm", rounded: "md", gap: "xs", children: [_jsxs(Row, { align: "center", gap: "xs", wrap: true, children: [_jsxs(Text, { size: "sm", weight: "medium", children: ["#", order.id] }), _jsx(Badge, { variant: statusBadgeVariant(order.status), children: order.status }), order.pickedAt && _jsx(Badge, { variant: "success", children: "Picked" }), order.packedAt && _jsx(Badge, { variant: "success", children: "Packed" })] }), _jsxs(Text, { size: "xs", color: "muted", children: [order.userName, order.items && order.items.length > 0 && (_jsxs(_Fragment, { children: [" \u00B7 ", order.items.map((i) => i.productTitle).join(", ")] }))] }), order.assignedWorkerId && (_jsxs(Text, { size: "xs", color: "muted", children: ["Assigned to: ", order.assignedWorkerId] })), _jsxs(Row, { gap: "xs", children: [!order.pickedAt && (_jsx(Button, { size: "sm", variant: "secondary", onClick: () => handleMarkPicked(order.id), isLoading: actionLoadingId === order.id + ":picked", children: "Mark Picked" })), order.pickedAt && !order.packedAt && (_jsx(Button, { size: "sm", variant: "secondary", onClick: () => handleMarkPacked(order.id), isLoading: actionLoadingId === order.id + ":packed", children: "Mark Packed" })), order.assignedWorkerId && (_jsx(Button, { size: "sm", variant: "secondary", onClick: () => handleUnassign(order.id), isLoading: actionLoadingId === order.id + ":unassign", children: "Unassign" }))] })] }, order.id)))] })), initialStoreName && !storeId && (_jsxs(Text, { size: "xs", color: "muted", children: ["Previously viewing: ", initialStoreName] }))] }));
+}

package/dist/features/admin/components/AdminProductEditorView.js

@@ -13,8 +13,10 @@ import { GroupSettingsPanel } from "../../products/components/GroupSettingsPanel
 import { GroupInlineSelect } from "../../seller/components/GroupInlineSelect";
 import { CategoryQuickCreateForm } from "./CategoryQuickCreateForm";
 import { BrandQuickCreateForm } from "./BrandQuickCreateForm";
+import { BarcodeField } from "../../seller/components/BarcodeField";
 const __P = {
     p4: "p-4",
+    sectionLabel: "tracking-widest mb-4",
 };
 const __O = {
     yAuto: "overflow-y-auto",
@@ -25,6 +27,14 @@ function modeFromProduct(product) {
         return "auction";
     if (lt === "pre-order")
         return "preorder";
+    if (lt === "prize-draw")
+        return "prize-draw";
+    if (lt === "classified")
+        return "classified";
+    if (lt === "digital-code")
+        return "digital-code";
+    if (lt === "live")
+        return "live";
     return "standard";
 }
 /**
@@ -32,14 +42,16 @@ function modeFromProduct(product) {
  * `listingType` discriminator. Nothing else needs to be written for the mode flip.
  */
 function applyMode(product, mode) {
-    return {
-        ...product,
-        listingType: mode === "auction"
-            ? "auction"
-            : mode === "preorder"
-                ? "pre-order"
-                : "standard",
+    const map = {
+        standard: "standard",
+        auction: "auction",
+        preorder: "pre-order",
+        "prize-draw": "prize-draw",
+        classified: "classified",
+        "digital-code": "digital-code",
+        live: "live",
     };
+    return { ...product, listingType: map[mode] };
 }
 async function loadStoreOptions(query, page) {
     const params = new URLSearchParams({ page: String(page), pageSize: "25" });
@@ -154,9 +166,9 @@ export function AdminProductEditorView({ productId, onSaved, onDeleted, embedded
     const formContent = (_jsxs(Form, { id: "product-editor-form", onSubmit: (e) => {
             e.preventDefault();
             saveMutation.mutate();
-        }, spacing: "lg", children: [_jsxs(Card, { variant: "outlined", padding: "lg", children: [_jsx(Text, { className: "tracking-widest mb-4", color: "muted", size: "xs", weight: "semibold", transform: "uppercase", children: "Listing Type" }), _jsxs(Tabs, { value: mode, onChange: handleModeChange, children: [_jsxs(TabsList, { children: [(!enabledListingTypes || enabledListingTypes.includes("standard")) && (_jsx(TabsTrigger, { value: "standard", children: "Standard" })), (!enabledListingTypes || enabledListingTypes.includes("auction")) && (_jsx(TabsTrigger, { value: "auction", children: "Auction" })), (!enabledListingTypes || enabledListingTypes.includes("pre-order")) && (_jsx(TabsTrigger, { value: "preorder", children: "Pre-order" }))] }), _jsx(TabsContent, { value: "standard" }), _jsx(TabsContent, { value: "auction" }), _jsx(TabsContent, { value: "preorder" })] })] }), _jsxs(Card, { variant: "outlined", padding: "lg", children: [_jsx(Text, { className: "tracking-widest mb-4", color: "muted", size: "xs", weight: "semibold", transform: "uppercase", children: "Classification" }), _jsxs(Stack, { gap: "md", children: [_jsxs(Stack, { gap: "xs", children: [_jsx(Text, { size: "sm", weight: "medium", color: "primary", children: "Store" }), _jsx(PaginatedSelect, { value: product.storeId ?? null, onChange: handleStoreSelect, loadOptions: loadStoreOptions, placeholder: "Search stores\u2026", searchPlaceholder: "Type store name\u2026", noResultsText: "No stores found", ariaLabel: "Store" })] }), _jsx(ProductForm, { product: product, onChange: setProduct, renderGroupSettings: isEdit && productId
+        }, spacing: "lg", children: [_jsxs(Card, { variant: "outlined", padding: "lg", children: [_jsx(Text, { className: __P.sectionLabel, color: "muted", size: "xs", weight: "semibold", transform: "uppercase", children: "Listing Type" }), _jsxs(Tabs, { value: mode, onChange: handleModeChange, children: [_jsxs(TabsList, { children: [(!enabledListingTypes || enabledListingTypes.includes("standard")) && (_jsx(TabsTrigger, { value: "standard", children: "Standard" })), (!enabledListingTypes || enabledListingTypes.includes("auction")) && (_jsx(TabsTrigger, { value: "auction", children: "Auction" })), (!enabledListingTypes || enabledListingTypes.includes("pre-order")) && (_jsx(TabsTrigger, { value: "preorder", children: "Pre-order" })), (!enabledListingTypes || enabledListingTypes.includes("prize-draw")) && (_jsx(TabsTrigger, { value: "prize-draw", children: "Prize Draw" })), (!enabledListingTypes || enabledListingTypes.includes("classified")) && (_jsx(TabsTrigger, { value: "classified", children: "Classified" })), (!enabledListingTypes || enabledListingTypes.includes("digital-code")) && (_jsx(TabsTrigger, { value: "digital-code", children: "Digital Code" })), (!enabledListingTypes || enabledListingTypes.includes("live")) && (_jsx(TabsTrigger, { value: "live", children: "Live Item" }))] }), _jsx(TabsContent, { value: "standard" }), _jsx(TabsContent, { value: "auction" }), _jsx(TabsContent, { value: "preorder" }), _jsx(TabsContent, { value: "prize-draw" }), _jsx(TabsContent, { value: "classified" }), _jsx(TabsContent, { value: "digital-code" }), _jsx(TabsContent, { value: "live" })] })] }), _jsxs(Card, { variant: "outlined", padding: "lg", children: [_jsx(Text, { className: __P.sectionLabel, color: "muted", size: "xs", weight: "semibold", transform: "uppercase", children: "Classification" }), _jsxs(Stack, { gap: "md", children: [_jsxs(Stack, { gap: "xs", children: [_jsx(Text, { size: "sm", weight: "medium", color: "primary", children: "Store" }), _jsx(PaginatedSelect, { value: product.storeId ?? null, onChange: handleStoreSelect, loadOptions: loadStoreOptions, placeholder: "Search stores\u2026", searchPlaceholder: "Type store name\u2026", noResultsText: "No stores found", ariaLabel: "Store" })] }), _jsx(ProductForm, { product: product, onChange: setProduct, renderGroupSettings: isEdit && productId
                                     ? (p) => (_jsx(GroupSettingsPanel, { productId: productId, productSlug: p.slug ?? productId, groupId: p.groupId, isGroupParent: p.isGroupParent, groupParentSlug: p.groupParentSlug, groupChildSlugs: p.groupChildSlugs, groupTitle: p.groupTitle, isAuction: modeFromProduct(p) === "auction", storeProductsEndpoint: "/api/admin/products", onGroupChanged: () => productQuery.refetch() }))
-                                    : undefined, renderGroupJoinField: ({ label, value, onChange, disabled }) => (_jsx(GroupInlineSelect, { scope: "admin", value: value ?? "", onChange: (id) => onChange(id || undefined), disabled: disabled, label: label, placeholder: "None (standalone product)", allowCreate: false })), renderCategorySelector: ({ label, value, onChange, disabled }) => (_jsxs(Stack, { gap: "xs", children: [_jsx(Text, { size: "sm", weight: "medium", color: "primary", children: label }), _jsx(PaginatedSelect, { value: value || null, onChange: (v) => onChange(v ?? ""), loadOptions: loadCategoryOptions, placeholder: "Search categories\u2026", searchPlaceholder: "Type category name\u2026", noResultsText: "No categories found", ariaLabel: label, disabled: disabled, createLabel: "Category", renderCreateForm: ({ onCreated, onCancel }) => (_jsx(CategoryQuickCreateForm, { onSaved: (id, name) => onCreated({ value: id, label: name }), onCancel: onCancel })) })] })), renderBrandSelector: (args) => (_jsxs(Stack, { gap: "xs", children: [_jsx(Text, { size: "sm", weight: "medium", color: "primary", children: args.label }), _jsx(PaginatedSelect, { value: args.multi ? null : (args.value || null), onChange: (v) => args.onValueChange(v ?? ""), loadOptions: loadBrandOptions, placeholder: "Search brands\u2026", searchPlaceholder: "Type brand name\u2026", noResultsText: "No brands found", ariaLabel: args.label, disabled: args.disabled, createLabel: "Brand", renderCreateForm: ({ onCreated, onCancel }) => (_jsx(BrandQuickCreateForm, { onSaved: (id, name) => onCreated({ value: id, label: name }), onCancel: onCancel })) })] })) })] })] }), _jsxs(Row, { gap: "3", className: "lg:hidden", children: [_jsx(Button, { type: "submit", isLoading: isSubmitting, disabled: !product.title || isSubmitting, children: isEdit ? "Save changes" : "Create product" }), isEdit && (_jsx(Button, { type: "button", variant: "danger", isLoading: deleteMutation.isPending, onClick: () => setDeleteOpen(true), children: "Delete product" }))] })] }, "product-form"));
+                                    : undefined, renderGroupJoinField: ({ label, value, onChange, disabled }) => (_jsx(GroupInlineSelect, { scope: "admin", value: value ?? "", onChange: (id) => onChange(id || undefined), disabled: disabled, label: label, placeholder: "None (standalone product)", allowCreate: false })), renderCategorySelector: ({ label, value, onChange, disabled }) => (_jsxs(Stack, { gap: "xs", children: [_jsx(Text, { size: "sm", weight: "medium", color: "primary", children: label }), _jsx(PaginatedSelect, { value: value || null, onChange: (v) => onChange(v ?? ""), loadOptions: loadCategoryOptions, placeholder: "Search categories\u2026", searchPlaceholder: "Type category name\u2026", noResultsText: "No categories found", ariaLabel: label, disabled: disabled, createLabel: "Category", renderCreateForm: ({ onCreated, onCancel }) => (_jsx(CategoryQuickCreateForm, { onSaved: (id, name) => onCreated({ value: id, label: name }), onCancel: onCancel })) })] })), renderBrandSelector: (args) => (_jsxs(Stack, { gap: "xs", children: [_jsx(Text, { size: "sm", weight: "medium", color: "primary", children: args.label }), _jsx(PaginatedSelect, { value: args.multi ? null : (args.value || null), onChange: (v) => args.onValueChange(v ?? ""), loadOptions: loadBrandOptions, placeholder: "Search brands\u2026", searchPlaceholder: "Type brand name\u2026", noResultsText: "No brands found", ariaLabel: args.label, disabled: args.disabled, createLabel: "Brand", renderCreateForm: ({ onCreated, onCancel }) => (_jsx(BrandQuickCreateForm, { onSaved: (id, name) => onCreated({ value: id, label: name }), onCancel: onCancel })) })] })) })] })] }), _jsxs(Card, { variant: "outlined", padding: "lg", children: [_jsx(Text, { className: __P.sectionLabel, color: "muted", size: "xs", weight: "semibold", transform: "uppercase", children: "Inventory" }), _jsx(BarcodeField, { value: product.barcodeId ?? "", onChange: (v) => setProduct((prev) => ({ ...prev, barcodeId: v || undefined })), onScan: (v) => setProduct((prev) => ({ ...prev, barcodeId: v })), helperText: "Leave blank to auto-generate. Scan a pre-printed sticker to link it." })] }), _jsxs(Row, { gap: "3", className: "lg:hidden", children: [_jsx(Button, { type: "submit", isLoading: isSubmitting, disabled: !product.title || isSubmitting, children: isEdit ? "Save changes" : "Create product" }), isEdit && (_jsx(Button, { type: "button", variant: "danger", isLoading: deleteMutation.isPending, onClick: () => setDeleteOpen(true), children: "Delete product" }))] })] }, "product-form"));
     if (embedded) {
         return _jsx(Div, { className: `${__O.yAuto} ${__P.p4}`, children: formContent });
     }