@mohasinac/appkit 2.4.10 → 2.5.0

package/dist/features/media/upload/MediaUploadField.js

@@ -22,6 +22,16 @@ function isVideo(url) {
 function isImage(url) {
     return /\.(jpe?g|png|gif|webp|svg)(\?|$)/i.test(url);
 }
+function isPdf(url) {
+    return /\.pdf(\?|$)/i.test(url);
+}
+function isPdfAccept(accept) {
+    return accept
+        .toLowerCase()
+        .split(",")
+        .map((s) => s.trim())
+        .some((s) => s === "application/pdf" || s === ".pdf");
+}
 function filenameFromUrl(url) {
     try {
         const parts = new URL(url).pathname.split("/");
@@ -58,6 +68,10 @@ export function MediaUploadField({ label, value, onChange, onChangeField, onUplo
     const [extInput, setExtInput] = useState("");
     const [extError, setExtError] = useState("");
     const hasAlternateSources = showYoutube || showExternal;
+    // PDF mode: derived from the `accept` prop. Hides camera capture + alternate
+    // URL tabs (YouTube/External never make sense for invoice/payout-doc fields)
+    // and trim/thumbnail flow.
+    const pdfMode = isPdfAccept(accept);
     function handleYtApply() {
         const id = extractYouTubeId(ytInput);
         if (!id) {
@@ -131,10 +145,12 @@ export function MediaUploadField({ label, value, onChange, onChangeField, onUplo
     const tUpload = useTranslations("upload");
     const tMediaEditor = useTranslations("mediaEditor");
     const { isSupported: isCameraSupported } = useCamera();
-    const showCamera = captureSource === "camera-only" ||
-        (captureSource === "both" && inputMode === "camera");
-    const showFileInput = captureSource === "file-only" ||
-        (captureSource === "both" && inputMode === "file");
+    // PDF uploads never come from a camera capture — force file-only in pdfMode.
+    const effectiveCaptureSource = pdfMode ? "file-only" : captureSource;
+    const showCamera = effectiveCaptureSource === "camera-only" ||
+        (effectiveCaptureSource === "both" && inputMode === "camera");
+    const showFileInput = effectiveCaptureSource === "file-only" ||
+        (effectiveCaptureSource === "both" && inputMode === "file");
     const captureModeAccept = captureMode === "video"
         ? "video/*"
         : captureMode === "both"
@@ -247,7 +263,7 @@ export function MediaUploadField({ label, value, onChange, onChangeField, onUplo
     return (_jsxs(Div, { className: "space-y-2", children: [_jsx(Label, { className: "block text-sm font-medium text-zinc-600 dark:text-zinc-400", children: label }), hasAlternateSources && !disabled && (_jsx(Row, { gap: "none", className: "appkit-media-upload__source-tabs", children: ["upload", ...(showYoutube ? ["youtube"] : []), ...(showExternal ? ["external"] : [])].map((tab) => (_jsx("button", { type: "button", onClick: () => setSourceTab(tab), className: [
                         "appkit-media-upload__source-tab",
                         sourceTab === tab ? "appkit-media-upload__source-tab--active" : "",
-                    ].filter(Boolean).join(" "), children: tab === "upload" ? "Upload" : tab === "youtube" ? "YouTube" : "External URL" }, tab))) })), hasAlternateSources && sourceTab === "youtube" && !disabled && (_jsxs(Div, { className: "space-y-2", children: [_jsxs(Row, { gap: "sm", children: [_jsx("input", { type: "text", value: ytInput, onChange: (e) => { setYtInput(e.target.value); setYtError(""); }, placeholder: "YouTube video ID or URL", className: "appkit-input flex-1" }), _jsx(Button, { type: "button", variant: "primary", size: "sm", onClick: handleYtApply, children: "Apply" })] }), ytError && _jsx(Alert, { variant: "error", children: ytError }), value?.includes("youtube.com") && (_jsxs(Text, { size: "xs", variant: "secondary", children: ["YouTube embed: ", value] }))] })), hasAlternateSources && sourceTab === "external" && !disabled && (_jsxs(Div, { className: "space-y-2", children: [_jsxs(Row, { gap: "sm", children: [_jsx("input", { type: "url", value: extInput, onChange: (e) => { setExtInput(e.target.value); setExtError(""); }, placeholder: "https://example.com/image.jpg", className: "appkit-input flex-1" }), _jsx(Button, { type: "button", variant: "primary", size: "sm", onClick: handleExtApply, children: "Apply" })] }), extError && _jsx(Alert, { variant: "error", children: extError }), _jsx(Text, { size: "xs", variant: "secondary", children: "External URLs are stored as-is and are not watermarked." })] })), (!hasAlternateSources || sourceTab === "upload") && value && !isLoading && (_jsxs(Div, { className: "rounded-lg border border-zinc-200 dark:border-zinc-700 bg-zinc-50 dark:bg-zinc-900 p-3", children: [isVideo(value) ? (_jsx(Div, { className: "relative aspect-video overflow-hidden rounded-lg", children: _jsx(MediaVideo, { src: value, alt: label, controls: true, objectFit: "contain" }) })) : isImage(value) ? (_jsx(Div, { className: "relative aspect-video overflow-hidden rounded-lg", children: _jsx(MediaImage, { src: value, alt: label, size: "card", objectFit: "contain" }) })) : (_jsx("a", { href: value, target: "_blank", rel: "noopener noreferrer", className: "text-sm underline break-all text-blue-600 dark:text-blue-400", children: filenameFromUrl(value) })), !disabled && (_jsxs(Row, { wrap: true, gap: "sm", className: "mt-2", children: [isVideo(value) && (enableTrim || enableThumbnail) && (_jsx(Button, { type: "button", onClick: () => {
+                    ].filter(Boolean).join(" "), children: tab === "upload" ? "Upload" : tab === "youtube" ? "YouTube" : "External URL" }, tab))) })), hasAlternateSources && sourceTab === "youtube" && !disabled && (_jsxs(Div, { className: "space-y-2", children: [_jsxs(Row, { gap: "sm", children: [_jsx("input", { type: "text", value: ytInput, onChange: (e) => { setYtInput(e.target.value); setYtError(""); }, placeholder: "YouTube video ID or URL", className: "appkit-input flex-1" }), _jsx(Button, { type: "button", variant: "primary", size: "sm", onClick: handleYtApply, children: "Apply" })] }), ytError && _jsx(Alert, { variant: "error", children: ytError }), value?.includes("youtube.com") && (_jsxs(Text, { size: "xs", variant: "secondary", children: ["YouTube embed: ", value] }))] })), hasAlternateSources && sourceTab === "external" && !disabled && (_jsxs(Div, { className: "space-y-2", children: [_jsxs(Row, { gap: "sm", children: [_jsx("input", { type: "url", value: extInput, onChange: (e) => { setExtInput(e.target.value); setExtError(""); }, placeholder: "https://example.com/image.jpg", className: "appkit-input flex-1" }), _jsx(Button, { type: "button", variant: "primary", size: "sm", onClick: handleExtApply, children: "Apply" })] }), extError && _jsx(Alert, { variant: "error", children: extError }), _jsx(Text, { size: "xs", variant: "secondary", children: "External URLs are stored as-is and are not watermarked." })] })), (!hasAlternateSources || sourceTab === "upload") && value && !isLoading && (_jsxs(Div, { className: "rounded-lg border border-zinc-200 dark:border-zinc-700 bg-zinc-50 dark:bg-zinc-900 p-3", children: [isVideo(value) ? (_jsx(Div, { className: "relative aspect-video overflow-hidden rounded-lg", children: _jsx(MediaVideo, { src: value, alt: label, controls: true, objectFit: "contain" }) })) : isImage(value) ? (_jsx(Div, { className: "relative aspect-video overflow-hidden rounded-lg", children: _jsx(MediaImage, { src: value, alt: label, size: "card", objectFit: "contain" }) })) : isPdf(value) ? (_jsxs(Row, { gap: "md", align: "center", children: [_jsx(Div, { "aria-hidden": true, className: "flex h-12 w-12 shrink-0 items-center justify-center rounded-lg bg-rose-100 text-rose-700 dark:bg-rose-900/40 dark:text-rose-300", children: _jsx("span", { className: "text-xs font-bold", children: "PDF" }) }), _jsx("a", { href: value, target: "_blank", rel: "noopener noreferrer", className: "text-sm font-medium text-blue-600 underline break-all dark:text-blue-400", children: filenameFromUrl(value) })] })) : (_jsx("a", { href: value, target: "_blank", rel: "noopener noreferrer", className: "text-sm underline break-all text-blue-600 dark:text-blue-400", children: filenameFromUrl(value) })), !disabled && (_jsxs(Row, { wrap: true, gap: "sm", className: "mt-2", children: [isVideo(value) && (enableTrim || enableThumbnail) && (_jsx(Button, { type: "button", onClick: () => {
                                     setPendingVideoUrl(value);
                                     if (enableTrim)
                                         setShowTrimModal(true);

package/dist/features/messages/actions/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./messages-actions";
+export * from "./ping-rtdb";

package/dist/features/messages/actions/index.js

@@ -0,0 +1,2 @@
+export * from "./messages-actions";
+export * from "./ping-rtdb";

package/dist/features/messages/actions/messages-actions.d.ts

@@ -0,0 +1,15 @@
+import { type ConversationsRepository } from "../repository/conversations.repository";
+import type { ConversationDocument, ConversationMessage } from "../schemas/firestore";
+export declare const MESSAGE_MAX_LENGTH = 2000;
+export declare function listConversationsForBuyer(buyerId: string): Promise<ConversationDocument[]>;
+export declare function listConversationsForStore(storeId: string): Promise<ConversationDocument[]>;
+export declare function getConversation(conversationId: string): Promise<ConversationDocument | null>;
+export interface SendMessageInput {
+    conversationId: string;
+    senderId: string;
+    senderRole: "buyer" | "seller";
+    body: string;
+}
+export declare function sendMessage(input: SendMessageInput): Promise<ConversationDocument>;
+export declare function markConversationRead(conversationId: string, role: "buyer" | "seller"): Promise<void>;
+export type { ConversationsRepository, ConversationDocument, ConversationMessage };

package/dist/features/messages/actions/messages-actions.js

@@ -0,0 +1,33 @@
+/**
+ * Messages domain actions — pure business functions; auth/rate-limit is the
+ * caller's responsibility.
+ */
+import { ValidationError } from "../../../errors";
+import { ERROR_MESSAGES } from "../../../errors/messages";
+import { conversationsRepository, } from "../repository/conversations.repository";
+export const MESSAGE_MAX_LENGTH = 2000;
+export async function listConversationsForBuyer(buyerId) {
+    return conversationsRepository.listByBuyer(buyerId);
+}
+export async function listConversationsForStore(storeId) {
+    return conversationsRepository.listByStore(storeId);
+}
+export async function getConversation(conversationId) {
+    return conversationsRepository.findById(conversationId);
+}
+export async function sendMessage(input) {
+    const body = input.body?.trim();
+    if (!body)
+        throw new ValidationError(ERROR_MESSAGES.CONVERSATIONS.BODY_REQUIRED);
+    if (body.length > MESSAGE_MAX_LENGTH) {
+        throw new ValidationError(`${ERROR_MESSAGES.CONVERSATIONS.BODY_TOO_LONG} (max ${MESSAGE_MAX_LENGTH} characters)`);
+    }
+    return conversationsRepository.appendMessage(input.conversationId, {
+        senderId: input.senderId,
+        senderRole: input.senderRole,
+        body,
+    });
+}
+export async function markConversationRead(conversationId, role) {
+    await conversationsRepository.markRead(conversationId, role);
+}

package/dist/features/messages/actions/ping-rtdb.d.ts

@@ -0,0 +1,2 @@
+import { type ConversationPingTargets } from "../realtime";
+export declare function pingConversationRtdb(targets: ConversationPingTargets): Promise<void>;

package/dist/features/messages/actions/ping-rtdb.js

@@ -0,0 +1,24 @@
+/**
+ * pingConversationRtdb — server-side fan-out for conversation updates.
+ *
+ * Writes `Date.now()` to each ping path so RTDB-subscribed clients refetch.
+ * Best-effort: failures are logged and swallowed (clients fall back to focus /
+ * explicit refetch).
+ */
+import { getAdminRealtimeDb } from "../../../providers/db-firebase";
+import { serverLogger } from "../../../monitoring";
+import { buildConversationPingPaths, } from "../realtime";
+export async function pingConversationRtdb(targets) {
+    const paths = buildConversationPingPaths(targets);
+    try {
+        const db = getAdminRealtimeDb();
+        const now = Date.now();
+        await Promise.all(paths.filter(Boolean).map((p) => db.ref(p).set(now)));
+    }
+    catch (err) {
+        serverLogger.warn("conversations: RTDB ping failed", {
+            paths,
+            error: err instanceof Error ? err.message : String(err),
+        });
+    }
+}

package/dist/features/messages/hooks/useConversation.d.ts

@@ -0,0 +1,22 @@
+import { conversationPingPath, userConversationsPingPath } from "../realtime";
+import type { ConversationDocument } from "../schemas/firestore";
+/**
+ * @deprecated Re-exported for backwards compat — import `conversationPingPath`
+ * from `@mohasinac/appkit` instead.
+ */
+export declare const CONVERSATIONS_PING_PATH: typeof conversationPingPath;
+/**
+ * @deprecated Re-exported for backwards compat — import
+ * `userConversationsPingPath` from `@mohasinac/appkit` instead.
+ */
+export declare const CONVERSATIONS_PING_USER_PATH: typeof userConversationsPingPath;
+export interface UseConversationReturn {
+    conversation: ConversationDocument | null;
+    isLoading: boolean;
+    error: Error | null;
+    isConnected: boolean;
+    sendMessage: (body: string) => Promise<void>;
+    markRead: () => Promise<void>;
+    refetch: () => Promise<void>;
+}
+export declare function useConversation(conversationId: string | null): UseConversationReturn;

package/dist/features/messages/hooks/useConversation.js

@@ -0,0 +1,125 @@
+"use client";
+/**
+ * useConversation — load + subscribe to a single conversation.
+ *
+ * Strategy: Firestore is the canonical store; messages live embedded in the
+ * conversation document. The realtime layer is a single RTDB "ping" path
+ * (`chats/{conversationId}/lastUpdate`) that the send/mark-read API routes
+ * bump on every write. This hook subscribes to that ping and re-fetches the
+ * doc through the API on each tick. Zero RTDB schema duplication and the
+ * canonical Firestore message ordering wins.
+ */
+import { useCallback, useEffect, useState } from "react";
+import { getClientRealtimeProvider } from "../../../contracts/client-realtime";
+import { conversationPingPath, userConversationsPingPath, } from "../realtime";
+/**
+ * @deprecated Re-exported for backwards compat — import `conversationPingPath`
+ * from `@mohasinac/appkit` instead.
+ */
+export const CONVERSATIONS_PING_PATH = conversationPingPath;
+/**
+ * @deprecated Re-exported for backwards compat — import
+ * `userConversationsPingPath` from `@mohasinac/appkit` instead.
+ */
+export const CONVERSATIONS_PING_USER_PATH = userConversationsPingPath;
+const DETAIL_ENDPOINT = (id) => `/api/user/conversations/${encodeURIComponent(id)}`;
+const SEND_ENDPOINT = (id) => `/api/user/conversations/${encodeURIComponent(id)}/messages`;
+const READ_ENDPOINT = (id) => `/api/user/conversations/${encodeURIComponent(id)}/read`;
+async function fetchDetail(id) {
+    const res = await fetch(DETAIL_ENDPOINT(id), { credentials: "include" });
+    if (res.status === 404)
+        return null;
+    if (!res.ok)
+        throw new Error(`Failed to load conversation (${res.status})`);
+    const json = (await res.json());
+    return json.data ?? null;
+}
+export function useConversation(conversationId) {
+    const [conversation, setConversation] = useState(null);
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const [isConnected, setIsConnected] = useState(false);
+    const refetch = useCallback(async () => {
+        if (!conversationId) {
+            setConversation(null);
+            return;
+        }
+        setIsLoading(true);
+        setError(null);
+        try {
+            setConversation(await fetchDetail(conversationId));
+        }
+        catch (e) {
+            setError(e instanceof Error ? e : new Error(String(e)));
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [conversationId]);
+    useEffect(() => {
+        void refetch();
+    }, [refetch]);
+    useEffect(() => {
+        if (!conversationId) {
+            setIsConnected(false);
+            return;
+        }
+        try {
+            const unsubscribe = getClientRealtimeProvider().subscribe(conversationPingPath(conversationId), () => {
+                setIsConnected(true);
+                void refetch();
+            }, () => setIsConnected(false));
+            return () => {
+                setIsConnected(false);
+                unsubscribe();
+            };
+        }
+        catch {
+            // Realtime provider not registered — falls back to one-shot fetch above.
+            setIsConnected(false);
+            return undefined;
+        }
+    }, [conversationId, refetch]);
+    const sendMessage = useCallback(async (body) => {
+        if (!conversationId)
+            return;
+        const trimmed = body.trim();
+        if (!trimmed)
+            return;
+        const res = await fetch(SEND_ENDPOINT(conversationId), {
+            method: "POST",
+            credentials: "include",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ body: trimmed }),
+        });
+        if (!res.ok) {
+            throw new Error(`Failed to send message (${res.status})`);
+        }
+        // RTDB ping will trigger refetch — but kick off one immediately in case
+        // the ping path isn't subscribed (e.g. provider not registered).
+        await refetch();
+    }, [conversationId, refetch]);
+    const markRead = useCallback(async () => {
+        if (!conversationId)
+            return;
+        try {
+            await fetch(READ_ENDPOINT(conversationId), {
+                method: "POST",
+                credentials: "include",
+            });
+            await refetch();
+        }
+        catch {
+            // best-effort
+        }
+    }, [conversationId, refetch]);
+    return {
+        conversation,
+        isLoading,
+        error,
+        isConnected,
+        sendMessage,
+        markRead,
+        refetch,
+    };
+}

package/dist/features/messages/hooks/useConversations.d.ts

@@ -0,0 +1,9 @@
+import type { ConversationDocument } from "../schemas/firestore";
+export interface UseConversationsReturn {
+    conversations: ConversationDocument[];
+    isLoading: boolean;
+    error: Error | null;
+    totalUnread: number;
+    refetch: () => Promise<void>;
+}
+export declare function useConversations(userId: string | null | undefined): UseConversationsReturn;

package/dist/features/messages/hooks/useConversations.js

@@ -0,0 +1,62 @@
+"use client";
+/**
+ * useConversations — list the current buyer's conversations. Subscribes to a
+ * single RTDB ping path so the list refreshes whenever any of the user's
+ * conversations gets a new message.
+ */
+import { useCallback, useEffect, useState } from "react";
+import { getClientRealtimeProvider } from "../../../contracts/client-realtime";
+import { userConversationsPingPath } from "../realtime";
+const LIST_ENDPOINT = "/api/user/conversations";
+async function fetchList() {
+    const res = await fetch(LIST_ENDPOINT, { credentials: "include" });
+    if (!res.ok)
+        throw new Error(`Failed to load conversations (${res.status})`);
+    const json = (await res.json());
+    return json.data?.items ?? [];
+}
+export function useConversations(userId) {
+    const [conversations, setConversations] = useState([]);
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const refetch = useCallback(async () => {
+        if (!userId) {
+            setConversations([]);
+            return;
+        }
+        setIsLoading(true);
+        setError(null);
+        try {
+            setConversations(await fetchList());
+        }
+        catch (e) {
+            setError(e instanceof Error ? e : new Error(String(e)));
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [userId]);
+    useEffect(() => {
+        void refetch();
+    }, [refetch]);
+    // Subscribe to the per-user ping path — any send/mark-read in any of the
+    // user's conversations bumps this and triggers a fresh list fetch.
+    useEffect(() => {
+        if (!userId)
+            return;
+        try {
+            const unsubscribe = getClientRealtimeProvider().subscribe(userConversationsPingPath(userId), () => {
+                void refetch();
+            }, () => {
+                // ignore — list will refresh on next focus / explicit refetch
+            });
+            return unsubscribe;
+        }
+        catch {
+            // Realtime provider not registered — non-fatal; list still works.
+            return undefined;
+        }
+    }, [userId, refetch]);
+    const totalUnread = conversations.reduce((sum, c) => sum + (c.unreadBuyer ?? 0), 0);
+    return { conversations, isLoading, error, totalUnread, refetch };
+}

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

@@ -0,0 +1,6 @@
+export * from "./hooks/useConversations";
+export * from "./hooks/useConversation";
+export type { ConversationDocument, ConversationMessage, } from "./schemas/firestore";
+export { CONVERSATIONS_COLLECTION, CONVERSATIONS_INDEXED_FIELDS, } from "./schemas/firestore";
+export { conversationPingPath, userConversationsPingPath, buildConversationPingPaths, } from "./realtime";
+export type { ConversationPingTargets } from "./realtime";

package/dist/features/messages/index.js

@@ -0,0 +1,4 @@
+export * from "./hooks/useConversations";
+export * from "./hooks/useConversation";
+export { CONVERSATIONS_COLLECTION, CONVERSATIONS_INDEXED_FIELDS, } from "./schemas/firestore";
+export { conversationPingPath, userConversationsPingPath, buildConversationPingPaths, } from "./realtime";

package/dist/features/messages/realtime.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Conversations realtime channel — shared between client hooks and server
+ * routes. Lives in a non-`"use client"` module so server route handlers can
+ * import the path builders without dragging the React hooks into a server
+ * bundle.
+ *
+ * Strategy (D5 + VC7):
+ *   - Firestore = canonical store; messages embedded in `conversations/{id}`.
+ *   - RTDB = "ping" channel only — server writes Date.now() to two paths on
+ *     every mutation, clients subscribe and refetch.
+ *
+ *     chats/{id}/lastUpdate              — single-conversation ping
+ *     chats/user/{userId}/lastUpdate     — per-user fan-out ping
+ *
+ * Both ends import these constants instead of inlining the path strings.
+ */
+/** RTDB path bumped on every write to a single conversation. */
+export declare function conversationPingPath(conversationId: string): string;
+/**
+ * RTDB path bumped on every write across all of a user's conversations.
+ * Subscribing to this is how the chat list / nav bell refresh without
+ * subscribing to every individual conversation.
+ */
+export declare function userConversationsPingPath(userId: string): string;
+/** All ping paths to bump on a single conversation write. */
+export interface ConversationPingTargets {
+    conversationId: string;
+    buyerId: string;
+    /** Resolved store-owner UID for the seller side; null when not known. */
+    sellerOwnerId: string | null;
+}
+export declare function buildConversationPingPaths(targets: ConversationPingTargets): string[];

package/dist/features/messages/realtime.js

@@ -0,0 +1,39 @@
+/**
+ * Conversations realtime channel — shared between client hooks and server
+ * routes. Lives in a non-`"use client"` module so server route handlers can
+ * import the path builders without dragging the React hooks into a server
+ * bundle.
+ *
+ * Strategy (D5 + VC7):
+ *   - Firestore = canonical store; messages embedded in `conversations/{id}`.
+ *   - RTDB = "ping" channel only — server writes Date.now() to two paths on
+ *     every mutation, clients subscribe and refetch.
+ *
+ *     chats/{id}/lastUpdate              — single-conversation ping
+ *     chats/user/{userId}/lastUpdate     — per-user fan-out ping
+ *
+ * Both ends import these constants instead of inlining the path strings.
+ */
+const PING_KEY = "lastUpdate";
+/** RTDB path bumped on every write to a single conversation. */
+export function conversationPingPath(conversationId) {
+    return `chats/${conversationId}/${PING_KEY}`;
+}
+/**
+ * RTDB path bumped on every write across all of a user's conversations.
+ * Subscribing to this is how the chat list / nav bell refresh without
+ * subscribing to every individual conversation.
+ */
+export function userConversationsPingPath(userId) {
+    return `chats/user/${userId}/${PING_KEY}`;
+}
+export function buildConversationPingPaths(targets) {
+    const paths = [
+        conversationPingPath(targets.conversationId),
+        userConversationsPingPath(targets.buyerId),
+    ];
+    if (targets.sellerOwnerId) {
+        paths.push(userConversationsPingPath(targets.sellerOwnerId));
+    }
+    return paths;
+}

package/dist/features/messages/repository/conversations.repository.d.ts

@@ -0,0 +1,35 @@
+/**
+ * ConversationsRepository — buyer↔seller messaging.
+ *
+ * One document per buyer×storeId×productId tuple. Messages are embedded in
+ * the document as an array (good up to ~200 entries; migrate to subcollection
+ * later if threads explode).
+ *
+ * All mutations are transactional so concurrent writes don't drop messages
+ * or unread counters.
+ */
+import { type ConversationDocument, type ConversationMessage } from "../schemas/firestore";
+export declare class ConversationFullError extends Error {
+    readonly code: "CONVERSATION_FULL";
+}
+export declare class ConversationsRepository {
+    private collection;
+    findById(id: string): Promise<ConversationDocument | null>;
+    listByBuyer(buyerId: string): Promise<ConversationDocument[]>;
+    listByStore(storeId: string): Promise<ConversationDocument[]>;
+    /**
+     * Append a message to a conversation in a transaction. Bumps the counterparty
+     * unread counter; updates lastMessage / lastMessageAt / updatedAt.
+     */
+    appendMessage(conversationId: string, msg: Omit<ConversationMessage, "id" | "sentAt" | "isRead"> & {
+        id?: string;
+        sentAt?: Date;
+    }): Promise<ConversationDocument>;
+    /**
+     * Zero out the unread counter for one party. Also flips `isRead` on the
+     * embedded messages sent by the other party so the seller side can see what
+     * the buyer has already read.
+     */
+    markRead(conversationId: string, role: "buyer" | "seller"): Promise<void>;
+}
+export declare const conversationsRepository: ConversationsRepository;