@mohasinac/appkit 2.3.0 → 2.3.1

package/dist/features/seller/hooks/useSellerListingData.js

@@ -0,0 +1,87 @@
+"use client";
+import { useQuery } from "@tanstack/react-query";
+import { apiClient, ApiClientError } from "../../../http";
+function withQueryParams(endpoint, params) {
+    const hasQuery = endpoint.includes("?");
+    const query = new URLSearchParams(params).toString();
+    return `${endpoint}${hasQuery ? "&" : "?"}${query}`;
+}
+export function useSellerListingData({ queryKey, endpoint, page = 1, pageSize = 25, sorts = "-createdAt", filters = "", mapRows, getTotal, }) {
+    const params = {
+        page: String(page),
+        pageSize: String(pageSize),
+        sorts,
+    };
+    if (filters) {
+        params.filters = filters;
+    }
+    const query = useQuery({
+        queryKey: [...queryKey, page, pageSize, sorts, filters],
+        queryFn: () => apiClient.get(withQueryParams(endpoint, params)),
+        staleTime: 60000,
+    });
+    const rows = query.data ? mapRows(query.data) : [];
+    const total = query.data
+        ? (getTotal?.(query.data, rows) ?? rows.length)
+        : rows.length;
+    return {
+        rows,
+        total,
+        isLoading: query.isLoading,
+        errorMessage: query.error instanceof ApiClientError
+            ? query.error.message
+            : query.error
+                ? "Unable to load records"
+                : undefined,
+    };
+}
+export function toRecordArray(value) {
+    return Array.isArray(value) ? value.filter(Boolean) : [];
+}
+export function toStringValue(value, fallback = "-") {
+    if (typeof value === "string") {
+        return value.trim() || fallback;
+    }
+    if (typeof value === "number" || typeof value === "boolean") {
+        return String(value);
+    }
+    return fallback;
+}
+export function toRupees(value) {
+    if (typeof value !== "number" || Number.isNaN(value)) {
+        return "-";
+    }
+    return `₹${value.toLocaleString("en-IN")}`;
+}
+export function toRelativeDate(value) {
+    const date = parseDate(value);
+    if (!date) {
+        return "-";
+    }
+    const deltaMs = Date.now() - date.getTime();
+    const minute = 60000;
+    const hour = 60 * minute;
+    const day = 24 * hour;
+    if (deltaMs < minute)
+        return "just now";
+    if (deltaMs < hour)
+        return `${Math.floor(deltaMs / minute)}m ago`;
+    if (deltaMs < day)
+        return `${Math.floor(deltaMs / hour)}h ago`;
+    if (deltaMs < 7 * day)
+        return `${Math.floor(deltaMs / day)}d ago`;
+    return date.toLocaleDateString("en-IN", { year: "numeric", month: "short", day: "numeric" });
+}
+function parseDate(value) {
+    if (value instanceof Date)
+        return value;
+    if (typeof value === "string") {
+        const parsed = new Date(value);
+        return Number.isNaN(parsed.getTime()) ? null : parsed;
+    }
+    if (typeof value === "number") {
+        const parsed = new Date(value);
+        return Number.isNaN(parsed.getTime()) ? null : parsed;
+    }
+    return null;
+}

package/dist/features/seller/hooks/useSellerPayouts.d.ts

@@ -0,0 +1,25 @@
+import type { PayoutListResponse, SellerPayoutSettings } from "../types";
+export declare function useSellerPayouts(params?: {
+    page?: number;
+    pageSize?: number;
+    status?: string;
+}, opts?: {
+    enabled?: boolean;
+    endpoint?: string;
+}): {
+    payouts: import("..").PayoutRecord[];
+    total: number;
+    totalPages: number;
+    isLoading: boolean;
+    error: string | null;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<PayoutListResponse, Error>>;
+};
+export declare function useSellerPayoutSettings(opts?: {
+    enabled?: boolean;
+    endpoint?: string;
+}): {
+    settings: SellerPayoutSettings | null;
+    isLoading: boolean;
+    error: string | null;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<SellerPayoutSettings | null, Error>>;
+};

package/dist/features/seller/hooks/useSellerPayouts.js

@@ -0,0 +1,41 @@
+import { useQuery } from "@tanstack/react-query";
+import { apiClient } from "../../../http";
+import { SELLER_ENDPOINTS } from "../../../constants/api-endpoints";
+export function useSellerPayouts(params = {}, opts) {
+    const sp = new URLSearchParams();
+    if (params.page)
+        sp.set("page", String(params.page));
+    if (params.pageSize)
+        sp.set("pageSize", String(params.pageSize));
+    if (params.status)
+        sp.set("status", params.status);
+    const qs = sp.toString();
+    const endpoint = opts?.endpoint ?? `${SELLER_ENDPOINTS.PAYOUTS}${qs ? `?${qs}` : ""}`;
+    const { data, isLoading, error, refetch } = useQuery({
+        queryKey: ["seller-payouts", qs],
+        queryFn: () => apiClient.get(endpoint),
+        enabled: opts?.enabled ?? true,
+    });
+    return {
+        payouts: data?.items ?? [],
+        total: data?.total ?? 0,
+        totalPages: data?.totalPages ?? 0,
+        isLoading,
+        error: error instanceof Error ? error.message : null,
+        refetch,
+    };
+}
+export function useSellerPayoutSettings(opts) {
+    const endpoint = opts?.endpoint ?? SELLER_ENDPOINTS.PAYOUT_SETTINGS;
+    const { data, isLoading, error, refetch } = useQuery({
+        queryKey: ["seller-payout-settings"],
+        queryFn: () => apiClient.get(endpoint),
+        enabled: opts?.enabled ?? true,
+    });
+    return {
+        settings: data ?? null,
+        isLoading,
+        error: error instanceof Error ? error.message : null,
+        refetch,
+    };
+}

package/dist/features/seller/hooks/useSellerStore.d.ts

@@ -0,0 +1,28 @@
+import type { SellerStore, SellerDashboardStats, SellerAnalytics } from "../types";
+export declare function useSellerStore(opts?: {
+    enabled?: boolean;
+    endpoint?: string;
+}): {
+    store: SellerStore | null;
+    isLoading: boolean;
+    error: string | null;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<SellerStore | null, Error>>;
+};
+export declare function useSellerDashboard(opts?: {
+    enabled?: boolean;
+    endpoint?: string;
+}): {
+    stats: SellerDashboardStats | null;
+    isLoading: boolean;
+    error: string | null;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<SellerDashboardStats, Error>>;
+};
+export declare function useSellerAnalytics(period?: string, opts?: {
+    enabled?: boolean;
+    endpoint?: string;
+}): {
+    analytics: SellerAnalytics | null;
+    isLoading: boolean;
+    error: string | null;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<SellerAnalytics, Error>>;
+};

package/dist/features/seller/hooks/useSellerStore.js

@@ -0,0 +1,47 @@
+import { useQuery } from "@tanstack/react-query";
+import { apiClient } from "../../../http";
+import { SELLER_ENDPOINTS } from "../../../constants/api-endpoints";
+export function useSellerStore(opts) {
+    const endpoint = opts?.endpoint ?? SELLER_ENDPOINTS.STORE;
+    const { data, isLoading, error, refetch } = useQuery({
+        queryKey: ["seller-store"],
+        queryFn: () => apiClient.get(endpoint),
+        enabled: opts?.enabled ?? true,
+    });
+    return {
+        store: data ?? null,
+        isLoading,
+        error: error instanceof Error ? error.message : null,
+        refetch,
+    };
+}
+export function useSellerDashboard(opts) {
+    const endpoint = opts?.endpoint ?? SELLER_ENDPOINTS.DASHBOARD;
+    const { data, isLoading, error, refetch } = useQuery({
+        queryKey: ["seller-dashboard"],
+        queryFn: () => apiClient.get(endpoint),
+        enabled: opts?.enabled ?? true,
+        staleTime: 60000,
+    });
+    return {
+        stats: data ?? null,
+        isLoading,
+        error: error instanceof Error ? error.message : null,
+        refetch,
+    };
+}
+export function useSellerAnalytics(period = "30d", opts) {
+    const endpoint = opts?.endpoint ?? SELLER_ENDPOINTS.ANALYTICS(period);
+    const { data, isLoading, error, refetch } = useQuery({
+        queryKey: ["seller-analytics", period],
+        queryFn: () => apiClient.get(endpoint),
+        enabled: opts?.enabled ?? true,
+        staleTime: 5 * 60000,
+    });
+    return {
+        analytics: data ?? null,
+        isLoading,
+        error: error instanceof Error ? error.message : null,
+        refetch,
+    };
+}

package/dist/features/seller/hooks/useSellerStorefront.d.ts

@@ -0,0 +1,16 @@
+import type { PublicUserProfile, SellerReviewsData, ProductsApiResponse } from "../../account/hooks/usePublicProfile";
+export { SellerReviewsData, ProductsApiResponse };
+export declare function useSellerStorefront(sellerId: string, options?: {
+    initialSeller?: PublicUserProfile;
+    profileEndpoint?: string;
+    productsEndpoint?: string;
+    reviewsEndpoint?: string;
+}): {
+    seller: PublicUserProfile | undefined;
+    loading: boolean;
+    profileError: string;
+    productsData: ProductsApiResponse | undefined;
+    productsLoading: boolean;
+    reviewsData: SellerReviewsData | undefined;
+    reviewsLoading: boolean;
+};

package/dist/features/seller/hooks/useSellerStorefront.js

@@ -0,0 +1,56 @@
+import { useQuery } from "@tanstack/react-query";
+import { apiClient } from "../../../http";
+import { ACCOUNT_ENDPOINTS, PROFILE_STATS_ENDPOINTS, } from "../../../constants/api-endpoints";
+export function useSellerStorefront(sellerId, options) {
+    const profileEndpoint = options?.profileEndpoint ?? ACCOUNT_ENDPOINTS.SELLER_PROFILE(sellerId);
+    const productsEndpoint = options?.productsEndpoint ?? PROFILE_STATS_ENDPOINTS.PRODUCTS(sellerId);
+    const reviewsEndpoint = options?.reviewsEndpoint ?? ACCOUNT_ENDPOINTS.SELLER_REVIEWS(sellerId);
+    const initialProfileData = options?.initialSeller ? { user: options.initialSeller } : undefined;
+    const { data: sellerData, isLoading: loading, error: fetchError, } = useQuery({
+        queryKey: ["seller-profile", sellerId],
+        queryFn: async () => {
+            const user = await apiClient.get(profileEndpoint);
+            return { user };
+        },
+        enabled: !!sellerId,
+        initialData: initialProfileData,
+    });
+    const seller = sellerData?.user;
+    const fetchErrorMsg = fetchError?.message ?? null;
+    const notSellerError = seller && seller.role !== "seller" && seller.role !== "admin"
+        ? "notFound"
+        : null;
+    const profileError = fetchErrorMsg ?? notSellerError;
+    const isReady = !!seller && !profileError && !!sellerId;
+    const { data: productsData, isLoading: productsLoading } = useQuery({
+        queryKey: ["storefront-products", sellerId],
+        queryFn: async () => {
+            const result = await apiClient.get(productsEndpoint);
+            return {
+                data: result.items,
+                meta: {
+                    total: result.total,
+                    page: result.page,
+                    pageSize: result.pageSize,
+                },
+            };
+        },
+        enabled: isReady,
+        staleTime: 60000,
+    });
+    const { data: reviewsData, isLoading: reviewsLoading } = useQuery({
+        queryKey: ["storefront-reviews", sellerId],
+        queryFn: () => apiClient.get(reviewsEndpoint),
+        enabled: isReady,
+        staleTime: 60000,
+    });
+    return {
+        seller,
+        loading,
+        profileError,
+        productsData,
+        productsLoading,
+        reviewsData,
+        reviewsLoading,
+    };
+}

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

@@ -0,0 +1,11 @@
+export * from "./types";
+export * from "./hooks/useBecomeSeller";
+export * from "./hooks/useSellerStore";
+export * from "./hooks/useSellerPayouts";
+export * from "./hooks/useSellerStorefront";
+export * from "./hooks/useSellerListingData";
+export * from "./components";
+export * from "./schemas";
+export * from "./columns";
+export { manifest } from "./manifest";
+export { SELLER_PAGE_PERMISSIONS } from "./permission-map";

package/dist/features/seller/index.js

@@ -0,0 +1,11 @@
+export * from "./types";
+export * from "./hooks/useBecomeSeller";
+export * from "./hooks/useSellerStore";
+export * from "./hooks/useSellerPayouts";
+export * from "./hooks/useSellerStorefront";
+export * from "./hooks/useSellerListingData";
+export * from "./components";
+export * from "./schemas";
+export * from "./columns";
+export { manifest } from "./manifest";
+export { SELLER_PAGE_PERMISSIONS } from "./permission-map";

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

@@ -0,0 +1,2 @@
+import type { FeatureManifest } from "../../contracts";
+export declare const manifest: FeatureManifest;

package/dist/features/seller/manifest.js

@@ -0,0 +1,74 @@
+export const manifest = {
+    name: "seller",
+    i18nNamespace: "seller",
+    envKeys: [],
+    routes: [
+        { segment: "[locale]/seller", exports: { default: "SellerDashboardView" } },
+        {
+            segment: "[locale]/seller/products",
+            exports: { default: "SellerProductsView" },
+        },
+        {
+            segment: "[locale]/seller/products/new",
+            exports: { default: "SellerCreateProductView" },
+        },
+        {
+            segment: "[locale]/seller/products/[id]",
+            exports: { default: "SellerEditProductView" },
+        },
+        {
+            segment: "[locale]/seller/orders",
+            exports: { default: "SellerOrdersView" },
+        },
+        {
+            segment: "[locale]/seller/payouts",
+            exports: { default: "SellerPayoutsView" },
+        },
+        {
+            segment: "[locale]/seller/store",
+            exports: { default: "SellerStoreSetupView" },
+        },
+        {
+            segment: "[locale]/seller/analytics",
+            exports: { default: "SellerAnalyticsView" },
+        },
+        {
+            segment: "[locale]/seller/coupons",
+            exports: { default: "SellerCouponsView" },
+        },
+        {
+            segment: "[locale]/seller/shipping",
+            exports: { default: "SellerShippingView" },
+        },
+        {
+            segment: "[locale]/seller/addresses",
+            exports: { default: "SellerAddressesView" },
+        },
+        {
+            segment: "[locale]/become-a-seller",
+            exports: { default: "SellerGuideView" },
+        },
+        { segment: "[locale]/sellers", exports: { default: "SellersListView" } },
+    ],
+    apiRoutes: [
+        { segment: "api/seller/dashboard", methods: ["GET"] },
+        { segment: "api/seller/products", methods: ["GET", "POST"] },
+        {
+            segment: "api/seller/products/[id]",
+            methods: ["GET", "PATCH", "DELETE"],
+        },
+        { segment: "api/seller/orders", methods: ["GET"] },
+        { segment: "api/seller/payouts", methods: ["GET", "POST"] },
+        { segment: "api/seller/store", methods: ["GET", "PATCH"] },
+        { segment: "api/seller/analytics", methods: ["GET"] },
+        { segment: "api/seller/coupons", methods: ["GET", "POST"] },
+        { segment: "api/seller/coupons/[id]", methods: ["PATCH", "DELETE"] },
+        { segment: "api/seller/shipping", methods: ["GET", "PATCH"] },
+        {
+            segment: "api/seller/addresses",
+            methods: ["GET", "POST", "PATCH", "DELETE"],
+        },
+        { segment: "api/sellers", methods: ["GET"] },
+        { segment: "api/sellers/[storeSlug]", methods: ["GET"] },
+    ],
+};

package/dist/features/seller/messages/en.json

@@ -0,0 +1,32 @@
+{
+  "storeStatus": {
+    "pending": "Pending",
+    "active": "Active",
+    "suspended": "Suspended",
+    "rejected": "Rejected"
+  },
+  "payoutStatus": {
+    "pending": "Pending",
+    "processing": "Processing",
+    "completed": "Completed",
+    "failed": "Failed"
+  },
+  "dashboard": {
+    "totalRevenue": "Total Revenue",
+    "pendingPayouts": "Pending Payouts",
+    "activeListings": "Active Listings",
+    "totalOrders": "Total Orders",
+    "pendingOrders": "Pending Orders"
+  },
+  "sidebar": {
+    "dashboard": "Dashboard",
+    "products": "Products",
+    "orders": "Orders",
+    "payouts": "Payouts",
+    "store": "My Store",
+    "analytics": "Analytics",
+    "coupons": "Coupons",
+    "shipping": "Shipping",
+    "addresses": "Addresses"
+  }
+}

package/dist/features/seller/permission-map.d.ts

@@ -0,0 +1,3 @@
+import type { Permission } from "../../security";
+/** Required permission for each seller route path */
+export declare const SELLER_PAGE_PERMISSIONS: Record<string, Permission>;

package/dist/features/seller/permission-map.js

@@ -0,0 +1,15 @@
+/** Required permission for each seller route path */
+export const SELLER_PAGE_PERMISSIONS = {
+    "/seller": "seller:access",
+    "/seller/dashboard": "seller:analytics",
+    "/seller/products": "seller:products:read",
+    "/seller/products/new": "seller:products:write",
+    "/seller/products/[id]": "seller:products:write",
+    "/seller/orders": "seller:orders:read",
+    "/seller/orders/[id]": "seller:orders:read",
+    "/seller/analytics": "seller:analytics",
+    "/seller/coupons": "seller:coupons",
+    "/seller/store": "seller:store",
+    "/seller/payouts": "seller:payouts:read",
+    "/seller/shipping": "seller:shipping",
+};

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

@@ -0,0 +1,66 @@
+/**
+ * Offer Repository
+ *
+ * Data access layer for the `offers` Firestore collection.
+ * Handles buyer make-an-offer, seller counter/accept/decline lifecycle.
+ */
+import { BaseRepository } from "../../../providers/db-firebase";
+import type { SieveModel, FirebaseSieveResult } from "../../../providers/db-firebase";
+import type { OfferDocument, OfferCreateInput, OfferUpdateInput } from "../schemas";
+declare class OfferRepository extends BaseRepository<OfferDocument> {
+    constructor();
+    /** Override mapDoc to auto-decrypt PII on every offer read */
+    protected mapDoc<D = OfferDocument>(snap: import("../../../providers/db-firebase").DocumentSnapshot): D;
+    static readonly SIEVE_FIELDS: {
+        readonly status: {
+            readonly canFilter: true;
+            readonly canSort: false;
+        };
+        readonly productId: {
+            readonly canFilter: true;
+            readonly canSort: false;
+        };
+        readonly buyerUid: {
+            readonly canFilter: true;
+            readonly canSort: false;
+        };
+        readonly sellerId: {
+            readonly canFilter: true;
+            readonly canSort: false;
+        };
+        readonly createdAt: {
+            readonly canFilter: false;
+            readonly canSort: true;
+        };
+    };
+    create(input: OfferCreateInput): Promise<OfferDocument>;
+    findByBuyer(buyerUid: string, model?: SieveModel): Promise<FirebaseSieveResult<OfferDocument>>;
+    findBySeller(sellerId: string, model?: SieveModel): Promise<FirebaseSieveResult<OfferDocument>>;
+    findPendingBySeller(sellerId: string): Promise<OfferDocument[]>;
+    /** Returns all pending or countered offers past their expiresAt — used by expiry sweep job */
+    findExpired(): Promise<OfferDocument[]>;
+    /**
+     * Returns true when the buyer already has an active (pending or countered) offer
+     * on this product.  Used to prevent duplicate parallel negotiations.
+     */
+    hasActiveOffer(buyerUid: string, productId: string): Promise<boolean>;
+    /**
+     * Count how many offer documents a buyer has created for a product since `since`.
+     * Used to enforce the 3-offer-per-product limit; resets automatically when
+     * `product.updatedAt` advances past the previously-created offer dates.
+     */
+    countByBuyerAndProduct(buyerUid: string, productId: string, since: Date): Promise<number>;
+    updateStatus(offerId: string, patch: OfferUpdateInput): Promise<OfferDocument>;
+    accept(offerId: string, lockedPrice: number, sellerNote?: string): Promise<OfferDocument>;
+    decline(offerId: string, sellerNote?: string): Promise<OfferDocument>;
+    counter(offerId: string, counterAmount: number, sellerNote?: string): Promise<OfferDocument>;
+    acceptCounter(offerId: string): Promise<OfferDocument>;
+    withdraw(offerId: string): Promise<OfferDocument>;
+    /**
+     * Cloud Functions compatibility: pending/countered offers already expired.
+     */
+    findExpiredActive(now: Date): Promise<OfferDocument[]>;
+    expireMany(offerIds: string[]): Promise<void>;
+}
+export declare const offerRepository: OfferRepository;
+export { OfferRepository };