@mohasinac/appkit 3.4.7 → 3.5.0

package/dist/features/catalogue/components/AdminCatalogueApprovalsView.js

@@ -0,0 +1,53 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import React from "react";
+import { sortBy } from "@mohasinac/appkit";
+import { useQueryClient } from "@tanstack/react-query";
+import { useApiMutation } from "@mohasinac/appkit/client";
+import { Button, Modal, Row, Stack, Text, Textarea } from "../../../ui";
+import { ADMIN_ENDPOINTS } from "../../../constants/api-endpoints";
+import { apiClient } from "../../../http";
+import { toRecordArray, toRelativeDate, toStringValue, } from "../../admin/hooks/useAdminListingData";
+import { DataListingView } from "../../admin/components/DataListingView";
+export function AdminCatalogueApprovalsView() {
+    const queryClient = useQueryClient();
+    const [rejectTarget, setRejectTarget] = React.useState(null);
+    const [rejectReason, setRejectReason] = React.useState("");
+    const invalidate = () => queryClient.invalidateQueries({ queryKey: ["admin", "catalogue-approvals"] });
+    const approveMutation = useApiMutation({
+        successMessage: "Approved and listed",
+        mutationFn: (id) => apiClient.post(ADMIN_ENDPOINTS.CATALOGUE_APPROVE(id)),
+        onSuccess: invalidate,
+    });
+    const rejectMutation = useApiMutation({
+        successMessage: "Rejected",
+        mutationFn: () => apiClient.post(ADMIN_ENDPOINTS.CATALOGUE_REJECT(rejectTarget), { reason: rejectReason }),
+        onSuccess: () => {
+            setRejectTarget(null);
+            setRejectReason("");
+            invalidate();
+        },
+    });
+    const config = {
+        portal: "admin",
+        title: "Catalogue Approvals",
+        searchPlaceholder: "Search by title",
+        emptyLabel: "No pending catalogue requests",
+        filterKeys: [],
+        defaultSort: sortBy("createdAt", "DESC"),
+        queryKey: ["admin", "catalogue-approvals", "listing"],
+        endpoint: ADMIN_ENDPOINTS.CATALOGUE_APPROVALS,
+        sortOptions: [{ value: sortBy("createdAt", "DESC"), label: "Newest" }],
+        mapRows: (response) => toRecordArray(response.items).map((item, index) => ({
+            id: toStringValue(item.id, `catalogue-${index}`),
+            primary: toStringValue(item.title, "Untitled item"),
+            secondary: toStringValue(item.ownerId, ""),
+            status: toStringValue(item.listingStatus, "pending_admin_approval"),
+            updatedAt: toRelativeDate(item.submittedForApprovalAt ?? item.createdAt),
+        })),
+        getTotal: (response, mappedRows) => (typeof response.meta?.total === "number" ? response.meta.total : mappedRows.length),
+        buildFilters: () => undefined,
+        renderRowActions: (row) => (_jsxs(Row, { gap: "sm", children: [_jsx(Button, { size: "sm", isLoading: approveMutation.isPending, onClick: () => approveMutation.mutate(row.id), children: "Approve" }), _jsx(Button, { size: "sm", variant: "danger", onClick: () => setRejectTarget(row.id), children: "Reject" })] })),
+    };
+    return (_jsxs(_Fragment, { children: [_jsx(DataListingView, { config: config }), _jsx(Modal, { isOpen: !!rejectTarget, onClose: () => setRejectTarget(null), title: "Reject this catalogue listing?", size: "sm", children: _jsxs(Stack, { gap: "md", children: [_jsx(Text, { variant: "secondary", children: "The owner will see this reason." }), _jsx(Textarea, { value: rejectReason, onChange: (e) => setRejectReason(e.target.value), rows: 3, placeholder: "Reason for rejection" }), _jsx(Button, { isLoading: rejectMutation.isPending, disabled: !rejectReason.trim(), variant: "danger", onClick: () => rejectMutation.mutate(), children: "Reject" })] }) })] }));
+}

package/dist/features/catalogue/components/CatalogueItemEditorView.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+import type { CatalogueItemDocument } from "../schemas/firestore";
+export interface CatalogueItemEditorViewProps {
+    item?: CatalogueItemDocument;
+    onSaved?: (id: string) => void;
+}
+export declare function CatalogueItemEditorView({ item, onSaved }: CatalogueItemEditorViewProps): React.JSX.Element;

package/dist/features/catalogue/components/CatalogueItemEditorView.js

@@ -0,0 +1,79 @@
+"use client";
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import React from "react";
+import { useQueryClient } from "@tanstack/react-query";
+import { useApiMutation } from "@mohasinac/appkit/client";
+import { Alert, Button, FieldInput, FieldSelect, FieldTextarea, Form, Grid, Row, Span, Stack, Toggle } from "../../../ui";
+import { MediaUploadList } from "../../media/upload/MediaUploadList";
+import { useMediaUpload } from "../../media";
+import { apiClient } from "../../../http";
+import { ACCOUNT_ENDPOINTS } from "../../../constants/api-endpoints";
+import { createCatalogueItemSchema } from "../schemas/validation";
+const CONDITION_OPTIONS = [
+    { label: "New", value: "new" },
+    { label: "Like new", value: "like_new" },
+    { label: "Good", value: "good" },
+    { label: "Fair", value: "fair" },
+    { label: "Poor", value: "poor" },
+    { label: "Used", value: "used" },
+    { label: "Refurbished", value: "refurbished" },
+];
+export function CatalogueItemEditorView({ item, onSaved }) {
+    const isCreate = !item;
+    const queryClient = useQueryClient();
+    const { upload } = useMediaUpload();
+    const uploadIndexRef = React.useRef(0);
+    const [title, setTitle] = React.useState(item?.title ?? "");
+    const [description, setDescription] = React.useState(item?.description ?? "");
+    const [condition, setCondition] = React.useState(item?.condition ?? "");
+    const [price, setPrice] = React.useState(item?.price ? String(item.price / 100) : "0");
+    const [quantity, setQuantity] = React.useState(String(item?.quantity ?? 1));
+    const [visibility, setVisibility] = React.useState(item?.visibility ?? "public");
+    const [images, setImages] = React.useState(item?.images ?? []);
+    const galleryFields = images.map((url) => ({ url, type: "image" }));
+    const handleUpload = async (file) => {
+        uploadIndexRef.current += 1;
+        return upload(file, "catalogue", true, {
+            type: "catalogue-image",
+            item: title || "item",
+            index: uploadIndexRef.current,
+        });
+    };
+    const saveMutation = useApiMutation({
+        successMessage: isCreate ? "Added to your catalogue" : "Catalogue item updated",
+        mutationFn: async () => {
+            const payload = {
+                title,
+                description: description || undefined,
+                condition: condition || undefined,
+                price: Math.round(Number(price) * 100),
+                quantity: Number(quantity),
+                visibility,
+                images,
+                mainImage: images[0],
+            };
+            if (isCreate)
+                return apiClient.post(ACCOUNT_ENDPOINTS.CATALOGUE, payload);
+            return apiClient.patch(ACCOUNT_ENDPOINTS.CATALOGUE_BY_ID(item.id), payload);
+        },
+        onSuccess: (saved) => {
+            queryClient.invalidateQueries({ queryKey: ["user", "catalogue"] });
+            onSaved?.(saved.id);
+        },
+    });
+    return (_jsx(Form, { schema: createCatalogueItemSchema, spacing: "md", children: ({ setFieldError }) => (_jsxs(Stack, { gap: "md", children: [item?.listingStatus && item.listingStatus !== "not_listed" && (_jsxs(Alert, { variant: "info", children: ["This item is ", item.listingStatus.replace(/_/g, " "), item.listingStatus === "rejected" && item.rejectionReason ? `: ${item.rejectionReason}` : "."] })), _jsxs(Grid, { cols: 2, gap: "md", children: [_jsx(FieldInput, { name: "title", label: "Title", required: true, value: title, onChange: setTitle }), _jsx(FieldSelect, { name: "condition", label: "Condition", value: condition, onChange: setCondition, options: CONDITION_OPTIONS }), _jsx(FieldInput, { name: "price", label: "Estimated resale price (\u20B9)", type: "number", min: "0", value: price, onChange: setPrice }), _jsx(FieldInput, { name: "quantity", label: "Quantity", type: "number", min: "1", value: quantity, onChange: setQuantity })] }), _jsx(FieldTextarea, { name: "description", label: "Description", value: description, onChange: setDescription, rows: 3 }), _jsx(MediaUploadList, { label: "Photos", value: galleryFields, onChange: (fields) => setImages(fields.map((f) => f.url)), onUpload: handleUpload, accept: "image/*", maxItems: 8, helperText: "Photos older than 30 days must be refreshed before this item can be listed." }), _jsxs(Row, { gap: "sm", align: "center", children: [_jsx(Toggle, { checked: visibility === "public", onChange: (checked) => setVisibility(checked ? "public" : "private"), size: "sm" }), _jsx(Span, { children: visibility === "public" ? "Public — visible on your profile" : "Private — only you can see it" })] }), _jsx(Button, { type: "button", isLoading: saveMutation.isPending, onClick: () => {
+                        const parsed = createCatalogueItemSchema.safeParse({
+                            title,
+                            images,
+                            price: Math.round(Number(price) * 100),
+                            quantity: Number(quantity),
+                            visibility,
+                        });
+                        if (!parsed.success) {
+                            for (const issue of parsed.error.issues)
+                                setFieldError(String(issue.path[0]), issue.message);
+                            return;
+                        }
+                        saveMutation.mutate();
+                    }, children: isCreate ? "Add to Catalogue" : "Save Changes" })] })) }));
+}

package/dist/features/catalogue/components/PublicCatalogueView.d.ts

@@ -0,0 +1,5 @@
+import React from "react";
+export interface PublicCatalogueViewProps {
+    ownerSlug: string;
+}
+export declare function PublicCatalogueView({ ownerSlug }: PublicCatalogueViewProps): React.JSX.Element;

package/dist/features/catalogue/components/PublicCatalogueView.js

@@ -0,0 +1,22 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useQuery } from "@tanstack/react-query";
+import { Div, Grid, Heading, Skeleton, Text } from "../../../ui";
+import { MediaImage } from "../../media/MediaImage";
+import { apiClient } from "../../../http";
+import { ACCOUNT_ENDPOINTS } from "../../../constants/api-endpoints";
+import { formatPaise } from "../../../utils/number.formatter";
+export function PublicCatalogueView({ ownerSlug }) {
+    const { data, isLoading } = useQuery({
+        queryKey: ["catalogue", "public", ownerSlug],
+        queryFn: () => apiClient.get(ACCOUNT_ENDPOINTS.PUBLIC_CATALOGUE(ownerSlug)),
+    });
+    if (isLoading) {
+        return (_jsx(Grid, { cols: 4, gap: "md", children: [1, 2, 3, 4].map((n) => (_jsx(Skeleton, { variant: "rectangular", height: 200 }, n))) }));
+    }
+    const items = data?.items ?? [];
+    if (items.length === 0) {
+        return _jsx(Text, { variant: "secondary", children: "Nothing public here yet." });
+    }
+    return (_jsx(Grid, { cols: 4, gap: "md", children: items.map((item) => (_jsxs(Div, { rounded: "xl", border: "default", padding: "md", surface: "card", children: [_jsx(MediaImage, { src: item.mainImage || item.images[0] || "", alt: item.title, size: "card" }), _jsx(Div, { padding: "t-sm", children: _jsx(Heading, { level: 4, size: "sm", children: item.title }) }), typeof item.price === "number" && item.price > 0 && (_jsx(Text, { size: "sm", color: "muted", children: formatPaise(item.price) }))] }, item.id))) }));
+}

package/dist/features/catalogue/components/UserCatalogueView.d.ts

@@ -0,0 +1,12 @@
+import React from "react";
+export interface UserCatalogueViewProps {
+    /**
+     * True for sellers AND admins — both can list a catalogue item directly
+     * (no approval queue). Sellers list under their own store; admins list
+     * under the platform's consignment store, since admins have no personal
+     * seller store and approving their own "Request to sell" would be a
+     * pointless round trip. Ordinary buyers get "Request to sell" instead.
+     */
+    canListDirectly: boolean;
+}
+export declare function UserCatalogueView({ canListDirectly }: UserCatalogueViewProps): React.JSX.Element;

package/dist/features/catalogue/components/UserCatalogueView.js

@@ -0,0 +1,51 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from "react";
+import { useQuery, useQueryClient } from "@tanstack/react-query";
+import { useApiMutation } from "@mohasinac/appkit/client";
+import { Badge, Button, Div, Grid, Heading, Row, SideDrawer, Skeleton, Stack, Text } from "../../../ui";
+import { MediaImage } from "../../media/MediaImage";
+import { apiClient } from "../../../http";
+import { ACCOUNT_ENDPOINTS } from "../../../constants/api-endpoints";
+import { CatalogueItemEditorView } from "./CatalogueItemEditorView";
+const STATUS_VARIANT = {
+    not_listed: "secondary",
+    pending_admin_approval: "warning",
+    listed: "success",
+    rejected: "default",
+};
+export function UserCatalogueView({ canListDirectly }) {
+    const queryClient = useQueryClient();
+    const { data, isLoading } = useQuery({
+        queryKey: ["user", "catalogue"],
+        queryFn: () => apiClient.get(ACCOUNT_ENDPOINTS.CATALOGUE),
+    });
+    const items = data?.items ?? [];
+    const [editingId, setEditingId] = React.useState(null);
+    const [creating, setCreating] = React.useState(false);
+    const invalidate = () => queryClient.invalidateQueries({ queryKey: ["user", "catalogue"] });
+    const toggleVisibilityMutation = useApiMutation({
+        successMessage: "Visibility updated",
+        mutationFn: (item) => apiClient.patch(ACCOUNT_ENDPOINTS.CATALOGUE_BY_ID(item.id), {
+            visibility: item.visibility === "public" ? "private" : "public",
+        }),
+        onSuccess: invalidate,
+    });
+    const deleteMutation = useApiMutation({
+        successMessage: "Removed from catalogue",
+        mutationFn: (id) => apiClient.delete(ACCOUNT_ENDPOINTS.CATALOGUE_BY_ID(id)),
+        onSuccess: invalidate,
+    });
+    const listMutation = useApiMutation({
+        successMessage: "Listed",
+        mutationFn: (id) => apiClient.post(ACCOUNT_ENDPOINTS.CATALOGUE_LIST(id)),
+        onSuccess: invalidate,
+    });
+    const submitMutation = useApiMutation({
+        successMessage: "Requested — an admin will review it",
+        mutationFn: (id) => apiClient.post(ACCOUNT_ENDPOINTS.CATALOGUE_SUBMIT(id)),
+        onSuccess: invalidate,
+    });
+    const editingItem = items.find((i) => i.id === editingId);
+    return (_jsxs(Stack, { gap: "md", children: [_jsxs(Row, { align: "center", justify: "between", children: [_jsx(Heading, { level: 2, children: "My Catalogue" }), _jsx(Button, { onClick: () => setCreating(true), children: "+ Add Item" })] }), isLoading ? (_jsx(Grid, { cols: 3, gap: "md", children: [1, 2, 3].map((n) => (_jsx(Skeleton, { variant: "rectangular", height: 220 }, n))) })) : items.length === 0 ? (_jsx(Text, { variant: "secondary", children: "Nothing in your catalogue yet." })) : (_jsx(Grid, { cols: 3, gap: "md", children: items.map((item) => (_jsxs(Div, { rounded: "xl", border: "default", padding: "md", surface: "card", children: [_jsx(MediaImage, { src: item.mainImage || item.images[0] || "", alt: item.title, size: "card" }), _jsxs(Stack, { gap: "xs", padding: "t-sm", children: [_jsx(Text, { weight: "medium", children: item.title }), _jsxs(Row, { gap: "sm", align: "center", children: [_jsx(Badge, { variant: STATUS_VARIANT[item.listingStatus], children: item.listingStatus.replace(/_/g, " ") }), _jsx(Badge, { variant: "secondary", children: item.visibility })] }), _jsxs(Row, { gap: "sm", wrap: true, children: [_jsx(Button, { size: "sm", variant: "ghost", onClick: () => setEditingId(item.id), children: "Edit" }), _jsx(Button, { size: "sm", variant: "ghost", onClick: () => toggleVisibilityMutation.mutate(item), children: item.visibility === "public" ? "Make private" : "Make public" }), item.listingStatus === "not_listed" && (canListDirectly ? (_jsx(Button, { size: "sm", isLoading: listMutation.isPending, onClick: () => listMutation.mutate(item.id), children: "List" })) : (_jsx(Button, { size: "sm", isLoading: submitMutation.isPending, onClick: () => submitMutation.mutate(item.id), children: "Request to sell" }))), item.listingStatus === "not_listed" && (_jsx(Button, { size: "sm", variant: "ghost", isLoading: deleteMutation.isPending, onClick: () => deleteMutation.mutate(item.id), children: "Delete" }))] })] })] }, item.id))) })), _jsx(SideDrawer, { isOpen: creating, onClose: () => setCreating(false), title: "Add to Catalogue", children: _jsx(CatalogueItemEditorView, { onSaved: () => { setCreating(false); invalidate(); } }) }), _jsx(SideDrawer, { isOpen: !!editingItem, onClose: () => setEditingId(null), title: "Edit Catalogue Item", children: editingItem && (_jsx(CatalogueItemEditorView, { item: editingItem, onSaved: () => { setEditingId(null); invalidate(); } })) })] }));
+}

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

@@ -0,0 +1,12 @@
+export * from "./schemas";
+export * from "./utils/freshness";
+export { listFromCatalogueAction } from "./actions/list-from-catalogue";
+export { submitCatalogueItemForApprovalAction } from "./actions/submit-for-approval";
+export { approveCatalogueListingAction, rejectCatalogueListingAction, } from "./actions/approve-catalogue-listing";
+export { UserCatalogueView } from "./components/UserCatalogueView";
+export type { UserCatalogueViewProps } from "./components/UserCatalogueView";
+export { CatalogueItemEditorView } from "./components/CatalogueItemEditorView";
+export type { CatalogueItemEditorViewProps } from "./components/CatalogueItemEditorView";
+export { PublicCatalogueView } from "./components/PublicCatalogueView";
+export type { PublicCatalogueViewProps } from "./components/PublicCatalogueView";
+export { AdminCatalogueApprovalsView } from "./components/AdminCatalogueApprovalsView";

package/dist/features/catalogue/index.js

@@ -0,0 +1,9 @@
+export * from "./schemas";
+export * from "./utils/freshness";
+export { listFromCatalogueAction } from "./actions/list-from-catalogue";
+export { submitCatalogueItemForApprovalAction } from "./actions/submit-for-approval";
+export { approveCatalogueListingAction, rejectCatalogueListingAction, } from "./actions/approve-catalogue-listing";
+export { UserCatalogueView } from "./components/UserCatalogueView";
+export { CatalogueItemEditorView } from "./components/CatalogueItemEditorView";
+export { PublicCatalogueView } from "./components/PublicCatalogueView";
+export { AdminCatalogueApprovalsView } from "./components/AdminCatalogueApprovalsView";

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

@@ -0,0 +1,39 @@
+/**
+ * Personal Catalogue Repository (Feature B).
+ */
+import { BaseRepository, type SieveModel, type FirebaseSieveResult } from "../../../providers/db-firebase";
+import { type CatalogueItemDocument, type CatalogueItemCreateInput, type CatalogueItemUpdateInput } from "../schemas/firestore";
+export declare class CatalogueRepository extends BaseRepository<CatalogueItemDocument> {
+    constructor();
+    create(input: CatalogueItemCreateInput): Promise<CatalogueItemDocument>;
+    /** Stamps lastImageUpdateAt whenever `images` changes — the single field the freshness gate checks. */
+    update(itemId: string, input: CatalogueItemUpdateInput): Promise<CatalogueItemDocument>;
+    listPublicByOwner(ownerId: string): Promise<CatalogueItemDocument[]>;
+    listByOwner(ownerId: string): Promise<CatalogueItemDocument[]>;
+    listPendingApproval(model: SieveModel): Promise<FirebaseSieveResult<CatalogueItemDocument>>;
+    static readonly SIEVE_FIELDS: {
+        id: {
+            canFilter: boolean;
+            canSort: boolean;
+        };
+        ownerId: {
+            canFilter: boolean;
+            canSort: boolean;
+        };
+        visibility: {
+            canFilter: boolean;
+            canSort: boolean;
+        };
+        listingStatus: {
+            canFilter: boolean;
+            canSort: boolean;
+        };
+        createdAt: {
+            canFilter: boolean;
+            canSort: boolean;
+        };
+    };
+    /** Bounded scan for the staleness-reminder Function — images older than N days, not yet reminded for this update. */
+    listStale(olderThanDate: Date, limit?: number): Promise<CatalogueItemDocument[]>;
+}
+export declare const catalogueRepository: CatalogueRepository;

package/dist/features/catalogue/repository/catalogue.repository.js

@@ -0,0 +1,68 @@
+/**
+ * Personal Catalogue Repository (Feature B).
+ */
+import { BaseRepository, prepareForFirestore, } from "../../../providers/db-firebase";
+import { CATALOGUE_COLLECTION, CATALOGUE_FIELDS, createCatalogueItemId, } from "../schemas/firestore";
+export class CatalogueRepository extends BaseRepository {
+    constructor() {
+        super(CATALOGUE_COLLECTION);
+    }
+    async create(input) {
+        const id = createCatalogueItemId({ ownerSlug: input.ownerId, title: input.title });
+        const now = new Date();
+        const data = {
+            ...input,
+            listingStatus: "not_listed",
+            lastImageUpdateAt: now,
+            createdAt: now,
+            updatedAt: now,
+        };
+        await this.getCollection().doc(id).set(prepareForFirestore(data));
+        return { id, ...data };
+    }
+    /** Stamps lastImageUpdateAt whenever `images` changes — the single field the freshness gate checks. */
+    async update(itemId, input) {
+        const patch = { ...input };
+        if (input.images !== undefined) {
+            patch.lastImageUpdateAt = new Date();
+        }
+        return super.update(itemId, patch);
+    }
+    async listPublicByOwner(ownerId) {
+        const snap = await this.getCollection()
+            .where(CATALOGUE_FIELDS.OWNER_ID, "==", ownerId)
+            .where(CATALOGUE_FIELDS.VISIBILITY, "==", "public")
+            .orderBy(CATALOGUE_FIELDS.CREATED_AT, "desc")
+            .get();
+        return snap.docs.map((doc) => this.mapDoc(doc));
+    }
+    async listByOwner(ownerId) {
+        const snap = await this.getCollection()
+            .where(CATALOGUE_FIELDS.OWNER_ID, "==", ownerId)
+            .orderBy(CATALOGUE_FIELDS.CREATED_AT, "desc")
+            .get();
+        return snap.docs.map((doc) => this.mapDoc(doc));
+    }
+    async listPendingApproval(model) {
+        return this.sieveQuery(model, CatalogueRepository.SIEVE_FIELDS, {
+            defaultPageSize: 25,
+            maxPageSize: 100,
+        });
+    }
+    /** Bounded scan for the staleness-reminder Function — images older than N days, not yet reminded for this update. */
+    async listStale(olderThanDate, limit = 200) {
+        const snap = await this.getCollection()
+            .where(CATALOGUE_FIELDS.LAST_IMAGE_UPDATE_AT, "<", olderThanDate)
+            .limit(limit)
+            .get();
+        return snap.docs.map((doc) => this.mapDoc(doc));
+    }
+}
+CatalogueRepository.SIEVE_FIELDS = {
+    id: { canFilter: true, canSort: false },
+    ownerId: { canFilter: true, canSort: false },
+    visibility: { canFilter: true, canSort: false },
+    listingStatus: { canFilter: true, canSort: false },
+    createdAt: { canFilter: true, canSort: true },
+};
+export const catalogueRepository = new CatalogueRepository();

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

@@ -0,0 +1,47 @@
+/**
+ * Personal Catalogue (Feature B) Firestore Document Types & Constants.
+ *
+ * Naming note: this is unrelated to `CatalogProductDocument` (SB-UNI-L, the
+ * shared master-catalog sellers create offers against) — "Catalogue" here is
+ * a user's personal photo inventory of items they own, slug-prefixed
+ * `mycatalog-` to stay visually distinct from `catalog-`.
+ */
+import { type GenerateCatalogueItemIdInput } from "../../../utils/id-generators";
+import type { BaseDocument } from "../../../_internal/shared/types/base-document";
+import type { ProductDraftFields } from "../../shipments/schemas/firestore";
+export declare const CATALOGUE_COLLECTION: "catalogueItems";
+export type CatalogueVisibility = "public" | "private";
+export type CatalogueOwnerRole = "user" | "seller" | "admin";
+export type CatalogueListingStatus = "not_listed" | "pending_admin_approval" | "listed" | "rejected";
+export interface CatalogueItemDocument extends BaseDocument, Partial<Omit<ProductDraftFields, "title" | "images" | "mainImage">> {
+    ownerId: string;
+    ownerRole: CatalogueOwnerRole;
+    title: string;
+    description?: string;
+    images: string[];
+    mainImage?: string;
+    quantity: number;
+    visibility: CatalogueVisibility;
+    watermarkOverride?: {
+        text?: string;
+    };
+    lastImageUpdateAt: Date;
+    staleReminderSentAt?: Date;
+    listingStatus: CatalogueListingStatus;
+    submittedForApprovalAt?: Date;
+    rejectionReason?: string;
+    linkedProductId?: string;
+    linkedProductSlug?: string;
+}
+export declare const CATALOGUE_IMAGE_FRESHNESS_DAYS: 30;
+export declare const CATALOGUE_FIELDS: {
+    readonly ID: "id";
+    readonly OWNER_ID: "ownerId";
+    readonly VISIBILITY: "visibility";
+    readonly LISTING_STATUS: "listingStatus";
+    readonly LAST_IMAGE_UPDATE_AT: "lastImageUpdateAt";
+    readonly CREATED_AT: "createdAt";
+};
+export type CatalogueItemCreateInput = Omit<CatalogueItemDocument, "id" | "createdAt" | "updatedAt" | "lastImageUpdateAt" | "listingStatus">;
+export type CatalogueItemUpdateInput = Partial<Omit<CatalogueItemDocument, "id" | "createdAt" | "ownerId">>;
+export declare function createCatalogueItemId(input: GenerateCatalogueItemIdInput): string;

package/dist/features/catalogue/schemas/firestore.js

@@ -0,0 +1,22 @@
+/**
+ * Personal Catalogue (Feature B) Firestore Document Types & Constants.
+ *
+ * Naming note: this is unrelated to `CatalogProductDocument` (SB-UNI-L, the
+ * shared master-catalog sellers create offers against) — "Catalogue" here is
+ * a user's personal photo inventory of items they own, slug-prefixed
+ * `mycatalog-` to stay visually distinct from `catalog-`.
+ */
+import { generateCatalogueItemId, } from "../../../utils/id-generators";
+export const CATALOGUE_COLLECTION = "catalogueItems";
+export const CATALOGUE_IMAGE_FRESHNESS_DAYS = 30;
+export const CATALOGUE_FIELDS = {
+    ID: "id",
+    OWNER_ID: "ownerId",
+    VISIBILITY: "visibility",
+    LISTING_STATUS: "listingStatus",
+    LAST_IMAGE_UPDATE_AT: "lastImageUpdateAt",
+    CREATED_AT: "createdAt",
+};
+export function createCatalogueItemId(input) {
+    return generateCatalogueItemId(input);
+}

package/dist/features/catalogue/schemas/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./firestore";
+export * from "./validation";

package/dist/features/catalogue/schemas/index.js

@@ -0,0 +1,2 @@
+export * from "./firestore";
+export * from "./validation";

package/dist/features/catalogue/schemas/validation.d.ts

@@ -0,0 +1,71 @@
+import { z } from "zod";
+export declare const createCatalogueItemSchema: z.ZodObject<{
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    images: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    mainImage: z.ZodOptional<z.ZodString>;
+    condition: z.ZodOptional<z.ZodEnum<["new", "like_new", "good", "fair", "poor", "used", "refurbished", "broken", "graded"]>>;
+    categorySlugs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    brandSlug: z.ZodOptional<z.ZodString>;
+    price: z.ZodOptional<z.ZodNumber>;
+    quantity: z.ZodDefault<z.ZodNumber>;
+    visibility: z.ZodDefault<z.ZodEnum<["public", "private"]>>;
+}, "strip", z.ZodTypeAny, {
+    title: string;
+    images: string[];
+    visibility: "public" | "private";
+    quantity: number;
+    description?: string | undefined;
+    categorySlugs?: string[] | undefined;
+    brandSlug?: string | undefined;
+    price?: number | undefined;
+    mainImage?: string | undefined;
+    condition?: "new" | "used" | "refurbished" | "like_new" | "good" | "fair" | "poor" | "broken" | "graded" | undefined;
+}, {
+    title: string;
+    description?: string | undefined;
+    categorySlugs?: string[] | undefined;
+    brandSlug?: string | undefined;
+    price?: number | undefined;
+    mainImage?: string | undefined;
+    images?: string[] | undefined;
+    condition?: "new" | "used" | "refurbished" | "like_new" | "good" | "fair" | "poor" | "broken" | "graded" | undefined;
+    visibility?: "public" | "private" | undefined;
+    quantity?: number | undefined;
+}>;
+export declare const updateCatalogueItemSchema: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    images: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString, "many">>>;
+    mainImage: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    condition: z.ZodOptional<z.ZodOptional<z.ZodEnum<["new", "like_new", "good", "fair", "poor", "used", "refurbished", "broken", "graded"]>>>;
+    categorySlugs: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    brandSlug: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    price: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    quantity: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+    visibility: z.ZodOptional<z.ZodDefault<z.ZodEnum<["public", "private"]>>>;
+}, "strip", z.ZodTypeAny, {
+    title?: string | undefined;
+    description?: string | undefined;
+    categorySlugs?: string[] | undefined;
+    brandSlug?: string | undefined;
+    price?: number | undefined;
+    mainImage?: string | undefined;
+    images?: string[] | undefined;
+    condition?: "new" | "used" | "refurbished" | "like_new" | "good" | "fair" | "poor" | "broken" | "graded" | undefined;
+    visibility?: "public" | "private" | undefined;
+    quantity?: number | undefined;
+}, {
+    title?: string | undefined;
+    description?: string | undefined;
+    categorySlugs?: string[] | undefined;
+    brandSlug?: string | undefined;
+    price?: number | undefined;
+    mainImage?: string | undefined;
+    images?: string[] | undefined;
+    condition?: "new" | "used" | "refurbished" | "like_new" | "good" | "fair" | "poor" | "broken" | "graded" | undefined;
+    visibility?: "public" | "private" | undefined;
+    quantity?: number | undefined;
+}>;
+export type CreateCatalogueItemInput = z.infer<typeof createCatalogueItemSchema>;
+export type UpdateCatalogueItemInput = z.infer<typeof updateCatalogueItemSchema>;

package/dist/features/catalogue/schemas/validation.js

@@ -0,0 +1,25 @@
+import { z } from "zod";
+const productConditionSchema = z.enum([
+    "new",
+    "like_new",
+    "good",
+    "fair",
+    "poor",
+    "used",
+    "refurbished",
+    "broken",
+    "graded",
+]);
+export const createCatalogueItemSchema = z.object({
+    title: z.string().min(1, "Title is required"),
+    description: z.string().optional(),
+    images: z.array(z.string()).default([]),
+    mainImage: z.string().optional(),
+    condition: productConditionSchema.optional(),
+    categorySlugs: z.array(z.string()).optional(),
+    brandSlug: z.string().optional(),
+    price: z.number().int().min(0).optional(),
+    quantity: z.number().int().min(1).default(1),
+    visibility: z.enum(["public", "private"]).default("public"),
+});
+export const updateCatalogueItemSchema = createCatalogueItemSchema.partial();

package/dist/features/catalogue/utils/freshness.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Shared gate for both the seller "List" action and the buyer "Request to
+ * sell" action — photos older than CATALOGUE_IMAGE_FRESHNESS_DAYS (30) must
+ * be refreshed before a catalogue item can become a real listing. Checked
+ * once at write time against the repository-stamped `lastImageUpdateAt`, not
+ * re-derived per image at read time.
+ */
+export declare function assertCatalogueImagesFresh(item: {
+    lastImageUpdateAt: Date;
+}): void;

package/dist/features/catalogue/utils/freshness.js

@@ -0,0 +1,15 @@
+import { CATALOGUE_IMAGE_FRESHNESS_DAYS } from "../schemas/firestore";
+import { ValidationError } from "../../../errors";
+/**
+ * Shared gate for both the seller "List" action and the buyer "Request to
+ * sell" action — photos older than CATALOGUE_IMAGE_FRESHNESS_DAYS (30) must
+ * be refreshed before a catalogue item can become a real listing. Checked
+ * once at write time against the repository-stamped `lastImageUpdateAt`, not
+ * re-derived per image at read time.
+ */
+export function assertCatalogueImagesFresh(item) {
+    const ageDays = (Date.now() - new Date(item.lastImageUpdateAt).getTime()) / 86400000;
+    if (ageDays > CATALOGUE_IMAGE_FRESHNESS_DAYS) {
+        throw new ValidationError(`Photos for this item are ${Math.floor(ageDays)} days old — upload fresh photos (within ${CATALOGUE_IMAGE_FRESHNESS_DAYS} days) before listing it.`);
+    }
+}

package/dist/features/catalogue/utils/product-from-item.d.ts

@@ -0,0 +1,15 @@
+import type { CatalogueItemDocument } from "../schemas/firestore";
+import type { ProductDocument } from "../../products/schemas/firestore";
+/** The platform's own consignment store — used whenever a catalogue item is
+ * listed by someone with no personal seller store of their own (buyer
+ * approval path, admin direct-list path). */
+export declare const CONSIGNMENT_STORE_ID = "store-letitrip-official";
+/**
+ * Shared field mapping from a catalogue item to a new product — used by
+ * both the direct-listing path (seller/admin) and the admin-approval path
+ * (buyer). Reuses `ProductDraftFields`-shaped fields already on the
+ * catalogue item (title/images/price/condition/categorySlugs/brandSlug) as
+ * a near-literal copy; only `storeId` and the `sourceCatalogueItemId`/
+ * `sourceCatalogueOwnerId` back-reference differ per caller.
+ */
+export declare function createProductFromCatalogueItem(item: CatalogueItemDocument, storeId: string): Promise<ProductDocument>;

package/dist/features/catalogue/utils/product-from-item.js

@@ -0,0 +1,34 @@
+import { productRepository } from "../../../repositories";
+/** The platform's own consignment store — used whenever a catalogue item is
+ * listed by someone with no personal seller store of their own (buyer
+ * approval path, admin direct-list path). */
+export const CONSIGNMENT_STORE_ID = "store-letitrip-official";
+/**
+ * Shared field mapping from a catalogue item to a new product — used by
+ * both the direct-listing path (seller/admin) and the admin-approval path
+ * (buyer). Reuses `ProductDraftFields`-shaped fields already on the
+ * catalogue item (title/images/price/condition/categorySlugs/brandSlug) as
+ * a near-literal copy; only `storeId` and the `sourceCatalogueItemId`/
+ * `sourceCatalogueOwnerId` back-reference differ per caller.
+ */
+export async function createProductFromCatalogueItem(item, storeId) {
+    return productRepository.create({
+        title: item.title,
+        description: item.description || "Listed via LetItRip's personal catalogue.",
+        categorySlugs: item.categorySlugs ?? [],
+        brandSlug: item.brandSlug,
+        price: item.price ?? 0,
+        currency: "INR",
+        stockQuantity: item.quantity,
+        mainImage: item.mainImage ?? item.images[0] ?? "",
+        images: item.images,
+        status: "published",
+        storeId,
+        featured: false,
+        tags: [],
+        condition: item.condition,
+        listingType: "standard",
+        sourceCatalogueItemId: item.id,
+        sourceCatalogueOwnerId: item.ownerId,
+    });
+}