@myrjfa/state 2.2.0 → 2.3.1

package/dist/lib/context/ChatContext.js

@@ -1,318 +1,426 @@
 "use client";
 import { jsx as _jsx } from "react/jsx-runtime";
-import { createContext, useContext, useEffect, useState, useCallback, useRef } from "react";
-import { getSocket } from "../actions/socket";
-import { chatApi } from "../actions/chat";
+import { createContext, useCallback, useContext, useEffect, useRef, useState, } from "react";
 import { useAtomValue } from "jotai";
+import { getSocket } from "../actions/socket";
+import { chatApi, normalizeChatMessage, } from "../actions/chat";
+import { chatActorKey, isSameChatActor, } from "../models/chat";
 import { userAtom } from "../userAtom";
-const ChatContext = createContext({
+const emptyContext = {
     socket: null,
     isConnected: false,
     conversations: [],
     activeConversation: null,
-    setActiveConversation: () => { },
+    setActiveConversation: () => undefined,
     messages: [],
-    setMessages: () => { },
+    setMessages: () => undefined,
     typingUsers: new Map(),
     onlineUsers: new Set(),
-    refreshConversations: async () => { },
-    sendMessage: async () => { },
-    createPoll: () => { },
-    votePoll: () => { },
-    editMessage: () => { },
-    toggleMessageReaction: () => { },
-    deleteMessage: () => { },
-    markRead: () => { },
+    refreshConversations: async () => undefined,
+    sendMessage: async () => undefined,
+    createPoll: () => undefined,
+    votePoll: async () => null,
+    updatePoll: async () => null,
+    editMessage: () => undefined,
+    toggleMessageReaction: () => undefined,
+    deleteMessage: () => undefined,
+    markRead: () => undefined,
     unreadNotificationCount: 0,
     notifications: [],
-    clearNotifications: () => { },
-});
-export function useChatContext() {
-    return useContext(ChatContext);
-}
+    clearNotifications: () => undefined,
+    eventRevision: 0,
+    paymentRevision: 0,
+};
+const ChatContext = createContext(emptyContext);
+export const useChatContext = () => useContext(ChatContext);
 export function ChatProvider({ children }) {
     const user = useAtomValue(userAtom);
+    const actorId = user?._id || user?.id || "";
+    const accountType = user?.accountType || user?.role;
+    const actorModel = accountType === "host" ? "HostProfile" : "User";
     const [isConnected, setIsConnected] = useState(false);
     const [conversations, setConversations] = useState([]);
-    const [activeConversation, _setActiveConversation] = useState(null);
+    const [activeConversation, setActiveConversationState] = useState(null);
     const activeConversationRef = useRef(null);
     const [messages, setMessages] = useState([]);
     const [typingUsers, setTypingUsers] = useState(new Map());
     const [onlineUsers, setOnlineUsers] = useState(new Set());
     const [unreadNotificationCount, setUnreadNotificationCount] = useState(0);
     const [notifications, setNotifications] = useState([]);
+    const [eventRevision, setEventRevision] = useState(0);
+    const [paymentRevision, setPaymentRevision] = useState(0);
     const socketRef = useRef(null);
-    const setActiveConversation = useCallback((conv) => {
-        _setActiveConversation(conv);
-        activeConversationRef.current = conv;
+    const conversationListParamsRef = useRef({ filter: "all" });
+    const setActiveConversation = useCallback((conversation) => {
+        setActiveConversationState(conversation);
+        activeConversationRef.current = conversation;
     }, []);
-    useEffect(() => {
-        activeConversationRef.current = activeConversation;
-    }, [activeConversation]);
-    const refreshConversations = useCallback(async () => {
-        try {
-            const data = await chatApi.getConversations();
-            setConversations(data);
+    const refreshConversations = useCallback(async (params) => {
+        if (params)
+            conversationListParamsRef.current = params;
+        const data = await chatApi.getConversations(params || conversationListParamsRef.current);
+        setConversations(data);
+        const activeId = activeConversationRef.current?._id;
+        if (activeId) {
+            const refreshed = data.find((conversation) => conversation._id === activeId);
+            if (refreshed)
+                setActiveConversation(refreshed);
         }
-        catch (err) {
-            console.error("Failed to fetch conversations:", err);
+    }, [setActiveConversation]);
+    const sendMessage = useCallback(async (conversationId, text, files, replyTo, options) => {
+        const trimmed = text.trim();
+        let media = [];
+        if (files?.length) {
+            const formData = new FormData();
+            files.forEach((file) => formData.append("files", file));
+            const upload = await chatApi.uploadFiles(formData);
+            media = upload?.data?.files || [];
+            if (!media.length)
+                throw new Error("Unable to upload attachments");
+            media = media.map((item, index) => {
+                const metadata = files[index]?.chatMediaMetadata;
+                return metadata ? { ...item, ...metadata } : item;
+            });
         }
-    }, []);
-    const sendMessage = useCallback(async (conversationId, text, files, replyTo) => {
-        let actualId = conversationId;
-        // If it's a draft conversation, create it first
-        if (conversationId.startsWith("draft_")) {
-            const otherUserId = conversationId.replace("draft_", "");
-            try {
-                const res = await chatApi.createConversation({
-                    type: "individual",
-                    otherUserId
+        if (!trimmed && !media.length)
+            return;
+        const socket = socketRef.current;
+        if (socket?.connected) {
+            await new Promise((resolve, reject) => {
+                socket.emit("message:send", {
+                    conversationId,
+                    text: trimmed,
+                    replyTo,
+                    media,
+                    type: options?.type || (media.length ? "media" : "text"),
+                    mentions: options?.mentions || [],
+                }, (result) => {
+                    if (result?.success)
+                        resolve();
+                    else
+                        reject(new Error(result?.error?.message || "Unable to send message"));
                 });
-                if (res._id) {
-                    actualId = res._id;
-                    // Update active conversation in state to point to the real one
-                    setActiveConversation(res);
-                    // Refresh to include in list
-                    await refreshConversations();
-                }
-                else {
-                    console.error("Failed to create conversation during lazy send");
-                    return;
-                }
-            }
-            catch (err) {
-                console.error("Failed to create conversation during lazy send:", err);
-                return;
-            }
-        }
-        if (!socketRef.current)
+            });
             return;
-        let media = [];
-        if (files && files.length > 0) {
-            // Upload files first
-            const formData = new FormData();
-            files.forEach(f => formData.append("chatFiles", f));
-            try {
-                // We need a dedicated upload endpoint.
-                // For now, let's assume /api/v1/chat/upload
-                const response = await chatApi.uploadFiles(formData);
-                if (response.error) {
-                    console.error("File upload failed:", response.error);
-                    return;
-                }
-                media = response.data.files.map((f) => ({
-                    type: f.mimetype.startsWith("audio") ? "audio" : (f.mimetype.startsWith("image") ? "image" : "file"),
-                    url: f.location,
-                    name: f.originalname
-                }));
-            }
-            catch (err) {
-                console.error("File upload failed:", err);
-            }
         }
-        socketRef.current.emit("message:send", {
-            conversationId: actualId,
-            content: { text, media },
-            type: media.length > 0 ? "media" : "text",
+        const message = await chatApi.sendMessage(conversationId, {
+            text: trimmed,
             replyTo,
+            media,
+            type: options?.type || (media.length ? "media" : "text"),
+            mentions: options?.mentions || [],
         });
-    }, [refreshConversations, setActiveConversation]);
-    const editMessage = useCallback((messageId, text) => {
-        if (!socketRef.current)
+        if (message) {
+            setMessages((current) => current.some((item) => item._id === message._id)
+                ? current
+                : [...current, message]);
+            await refreshConversations();
+        }
+    }, [refreshConversations]);
+    const editMessage = useCallback(async (messageId, text) => {
+        if (socketRef.current?.connected) {
+            socketRef.current.emit("message:edit", { messageId, text });
             return;
-        socketRef.current.emit("message:edit", { messageId, text });
+        }
+        const message = await chatApi.editMessage(messageId, text);
+        if (message) {
+            setMessages((current) => current.map((item) => (item._id === message._id ? message : item)));
+        }
     }, []);
-    const toggleMessageReaction = useCallback((messageId, reaction) => {
-        if (!socketRef.current)
-            return;
-        socketRef.current.emit("message:react", { messageId, reaction });
+    const createPoll = useCallback(async (conversationId, question, options, allowMultiple) => {
+        const response = await chatApi.createPoll(conversationId, { question, options, allowMultiple });
+        if (response.data) {
+            const message = normalizeChatMessage(response.data);
+            setMessages((current) => current.some((item) => item._id === message._id) ? current : [...current, message]);
+            await refreshConversations();
+        }
+    }, [refreshConversations]);
+    const votePoll = useCallback(async (pollId, optionIndex) => {
+        const response = await chatApi.votePoll(pollId, optionIndex);
+        return response.data || null;
     }, []);
-    const deleteMessage = useCallback((messageId) => {
-        if (!socketRef.current)
-            return;
-        socketRef.current.emit("message:delete", { messageId });
+    const updatePoll = useCallback(async (pollId, data) => {
+        const response = await chatApi.updatePoll(pollId, data);
+        return response.data || null;
     }, []);
-    const createPoll = useCallback((conversationId, question, options, allowMultiple) => {
-        if (!socketRef.current)
+    const toggleMessageReaction = useCallback(async (messageId, emoji) => {
+        if (socketRef.current?.connected) {
+            socketRef.current.emit("message:react", {
+                messageId,
+                emoji: emoji || "",
+            });
             return;
-        socketRef.current.emit("poll:create", { conversationId, question, options, allowMultiple });
+        }
+        const message = await chatApi.addReaction(messageId, emoji || "");
+        if (message) {
+            setMessages((current) => current.map((item) => (item._id === message._id ? message : item)));
+        }
     }, []);
-    const votePoll = useCallback((pollId, optionIndex) => {
-        if (!socketRef.current)
+    const deleteMessage = useCallback(async (messageId) => {
+        if (socketRef.current?.connected) {
+            socketRef.current.emit("message:delete", { messageId });
             return;
-        socketRef.current.emit("poll:vote", { pollId, optionIndex });
+        }
+        const message = await chatApi.deleteMessage(messageId);
+        if (message) {
+            setMessages((current) => current.map((item) => (item._id === message._id ? message : item)));
+        }
     }, []);
+    const markRead = useCallback(async (conversationId, messageIds) => {
+        if (!messageIds.length || !actorId)
+            return;
+        const readAt = new Date().toISOString();
+        setMessages((current) => current.map((message) => message.conversationId === conversationId && messageIds.includes(message._id) &&
+            !message.readBy.some((receipt) => isSameChatActor(receipt, { actorId, actorModel }))
+            ? {
+                ...message,
+                readBy: [
+                    ...message.readBy,
+                    { actorId, actorModel, readAt },
+                ],
+            }
+            : message));
+        setConversations((current) => current.map((conversation) => conversation._id === conversationId
+            ? {
+                ...conversation,
+                participants: conversation.participants.map((participant) => isSameChatActor(participant, { actorId, actorModel })
+                    ? {
+                        ...participant,
+                        unreadCount: Math.max(0, participant.unreadCount - messageIds.length),
+                    }
+                    : participant),
+                preference: {
+                    ...conversation.preference,
+                    markedUnreadAt: null,
+                },
+            }
+            : conversation));
+        if (socketRef.current?.connected) {
+            socketRef.current.emit("message:read", {
+                conversationId,
+                messageIds,
+            });
+            return;
+        }
+        await chatApi.markRead(conversationId, messageIds);
+        await refreshConversations();
+    }, [actorId, actorModel, refreshConversations]);
     const clearNotifications = useCallback(() => {
         setNotifications([]);
         setUnreadNotificationCount(0);
     }, []);
-    const markRead = useCallback((conversationId, unreadIds) => {
-        if (!socketRef.current)
+    useEffect(() => {
+        const socket = socketRef.current;
+        const conversationId = activeConversation?._id;
+        if (!socket || !conversationId || conversationId.startsWith("draft_")) {
             return;
-        socketRef.current.emit("message:read", { conversationId, unreadIds });
-    }, []);
+        }
+        socket.emit("conversation:join", { conversationId });
+        return () => {
+            socket.emit("conversation:leave", { conversationId });
+        };
+    }, [activeConversation?._id]);
     useEffect(() => {
-        if (!user) {
+        if (!user || !actorId || accountType === "staff") {
             setIsConnected(false);
             setConversations([]);
             return;
         }
         const socket = getSocket();
         socketRef.current = socket;
-        function onConnect() {
+        const onConnect = () => {
             setIsConnected(true);
-            refreshConversations();
-        }
-        function onDisconnect() {
+            void refreshConversations();
+            const activeId = activeConversationRef.current?._id;
+            if (activeId && !activeId.startsWith("draft_")) {
+                socket.emit("conversation:join", { conversationId: activeId });
+            }
+        };
+        const onDisconnect = () => {
             setIsConnected(false);
-        }
-        socket.on("connect", onConnect);
-        socket.on("disconnect", onDisconnect);
-        if (!socket.connected) {
-            socket.connect();
-        }
-        else {
-            // Include logic for if already connected
-            onConnect();
-        }
-        // New message
-        socket.on("message:new", ({ conversationId, message }) => {
-            setMessages((prev) => {
-                const currentActiveId = activeConversationRef.current?._id;
-                // If this message belongs to the active conversation, add it
-                if (currentActiveId === conversationId) {
-                    // Deduplicate
-                    if (prev.some((m) => m._id === message._id))
-                        return prev;
-                    return [...prev, message];
-                }
-                return prev;
-            });
-            // Update conversations last message
-            setConversations((prev) => prev
-                .map((c) => c._id === conversationId
+            setOnlineUsers(new Set());
+            setTypingUsers(new Map());
+        };
+        const onNewMessage = (payload) => {
+            const message = normalizeChatMessage(payload.message);
+            if (activeConversationRef.current?._id === payload.conversationId) {
+                setMessages((current) => current.some((item) => item._id === message._id)
+                    ? current
+                    : [...current, message]);
+            }
+            if (!isSameChatActor({ actorId: message.senderId, actorModel: message.senderModel }, { actorId, actorModel })) {
+                socketRef.current?.emit("message:delivered", { messageId: message._id });
+            }
+            void refreshConversations();
+        };
+        const onDelivered = ({ messageId, actorId: deliveredActorId, actorModel: deliveredActorModel, deliveredAt, }) => {
+            setMessages((current) => current.map((message) => message._id === messageId && !(message.deliveredTo || []).some((receipt) => isSameChatActor(receipt, {
+                actorId: deliveredActorId,
+                actorModel: deliveredActorModel,
+            }))
                 ? {
-                    ...c,
-                    lastMessage: {
-                        content: message.content?.text || `[${message.type}]`,
-                        senderId: message.senderId,
-                        sentAt: message.createdAt,
-                    },
-                    updatedAt: message.createdAt,
+                    ...message,
+                    deliveredTo: [
+                        ...(message.deliveredTo || []),
+                        {
+                            actorId: deliveredActorId,
+                            actorModel: deliveredActorModel,
+                            deliveredAt,
+                        },
+                    ],
                 }
-                : c)
-                .sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime()));
-        });
-        // Message updated
-        socket.on("message:updated", ({ message }) => {
-            setMessages((prev) => prev.map((m) => (m._id === message._id ? message : m)));
-        });
-        socket.on("message:readed", ({ conversationId, userId, unreadIds }) => {
-            setMessages((prev) => prev.map((m) => {
-                if (m.conversationId === conversationId && unreadIds.includes(m._id)) {
-                    return {
-                        ...m,
-                        isRead: true,
-                    };
+                : message));
+        };
+        const onUpdatedMessage = ({ message: rawMessage }) => {
+            const message = normalizeChatMessage(rawMessage);
+            setMessages((current) => current.map((item) => (item._id === message._id ? message : item)));
+        };
+        const onRead = ({ conversationId, actorId: readerId, actorModel: readerModel, messageIds, readAt, }) => {
+            const readMessageIds = new Set(messageIds);
+            setMessages((current) => current.map((message) => message.conversationId === conversationId &&
+                readMessageIds.has(message._id) &&
+                !message.readBy.some((receipt) => isSameChatActor(receipt, {
+                    actorId: readerId,
+                    actorModel: readerModel,
+                }))
+                ? {
+                    ...message,
+                    readBy: [
+                        ...message.readBy,
+                        { actorId: readerId, actorModel: readerModel, readAt },
+                    ],
+                    deliveredTo: (message.deliveredTo || []).some((receipt) => isSameChatActor(receipt, {
+                        actorId: readerId,
+                        actorModel: readerModel,
+                    }))
+                        ? message.deliveredTo
+                        : [
+                            ...(message.deliveredTo || []),
+                            {
+                                actorId: readerId,
+                                actorModel: readerModel,
+                                deliveredAt: readAt,
+                            },
+                        ],
                 }
-                return m;
-            }));
-            setConversations((prev) => {
-                return prev.map((c) => {
-                    if (c._id === conversationId) {
-                        return {
-                            ...c,
-                            participants: c.participants.map((p) => {
-                                if (p.userId === userId) {
-                                    return {
-                                        ...p,
-                                        unreadCounts: {
-                                            messages: 0,
-                                            mentions: 0,
-                                            milestones: 0,
-                                            expenses: 0,
-                                        }
-                                    };
-                                }
-                                return p;
-                            }),
-                        };
-                    }
-                    return c;
-                });
+                : message));
+        };
+        const onTypingStart = ({ conversationId, actorId: typingActorId, actorModel: typingActorModel, }) => {
+            const typingActorKey = chatActorKey({
+                actorId: typingActorId,
+                actorModel: typingActorModel,
             });
-        });
-        // // Poll created/updated (we treat them as messages that might trigger UI updates)
-        // socket.on("poll:created", ({ pollMessage }: { pollMessage: Message }) => {
-        //     setMessages((prev) => [...prev, pollMessage]);
-        // });
-        socket.on("poll:updated", ({ pollMessage }) => {
-            // Re-fetch messages or update a specific one if referenceId matches
-            setMessages(prev => prev.map(m => (m.type === "poll" && m._id === pollMessage._id)
-                ? pollMessage // Store poll detail in message temporarily for UI
-                : m));
-        });
-        // Message deleted
-        socket.on("message:deleted", ({ messageId }) => {
-            setMessages((prev) => prev.filter((m) => m._id !== messageId));
-        });
-        // Typing indicators
-        socket.on("typing:start", ({ conversationId, userId }) => {
-            setTypingUsers((prev) => {
-                const next = new Map(prev);
+            setTypingUsers((current) => {
+                const next = new Map(current);
                 const users = next.get(conversationId) || [];
-                if (!users.includes(userId)) {
-                    next.set(conversationId, [...users, userId]);
+                if (!users.includes(typingActorKey)) {
+                    next.set(conversationId, [...users, typingActorKey]);
                 }
                 return next;
             });
-        });
-        socket.on("typing:stop", ({ conversationId, userId }) => {
-            setTypingUsers((prev) => {
-                const next = new Map(prev);
-                const users = next.get(conversationId) || [];
-                next.set(conversationId, users.filter((u) => u !== userId));
+        };
+        const onTypingStop = ({ conversationId, actorId: typingActorId, actorModel: typingActorModel, }) => {
+            const typingActorKey = chatActorKey({
+                actorId: typingActorId,
+                actorModel: typingActorModel,
+            });
+            setTypingUsers((current) => {
+                const next = new Map(current);
+                next.set(conversationId, (next.get(conversationId) || []).filter((item) => item !== typingActorKey));
                 return next;
             });
-        });
-        // Online/offline
-        socket.on("presence:online", ({ userId }) => {
-            setOnlineUsers((prev) => new Set(prev).add(userId));
-        });
-        socket.on("presence:offline", ({ userId }) => {
-            setOnlineUsers((prev) => {
-                const next = new Set(prev);
-                next.delete(userId);
+        };
+        const onPresenceOnline = ({ actorId: onlineId, actorModel: onlineModel, }) => {
+            setOnlineUsers((current) => new Set(current).add(chatActorKey({
+                actorId: onlineId,
+                actorModel: onlineModel,
+            })));
+        };
+        const onPresenceOffline = ({ actorId: offlineId, actorModel: offlineModel, }) => {
+            setOnlineUsers((current) => {
+                const next = new Set(current);
+                next.delete(chatActorKey({
+                    actorId: offlineId,
+                    actorModel: offlineModel,
+                }));
                 return next;
             });
-        });
-        // Real-time notifications
-        socket.on("notification:new", (notification) => {
-            setNotifications((prev) => [notification, ...prev].slice(0, 50));
-            setUnreadNotificationCount((prev) => prev + 1);
-        });
+        };
+        const onNotification = (notification) => {
+            setNotifications((current) => [notification, ...current].slice(0, 50));
+            setUnreadNotificationCount((current) => current + 1);
+        };
+        const onPreferenceUpdated = ({ conversationId, preference, }) => {
+            setConversations((current) => current.map((conversation) => conversation._id === conversationId
+                ? { ...conversation, preference }
+                : conversation));
+            if (activeConversationRef.current?._id === conversationId) {
+                setActiveConversation({
+                    ...activeConversationRef.current,
+                    preference,
+                });
+            }
+        };
+        const onConversationMetadataChanged = () => {
+            void refreshConversations();
+        };
+        const onConversationEventChanged = () => {
+            setEventRevision((current) => current + 1);
+        };
+        const onParticipantsChanged = () => {
+            void refreshConversations();
+        };
+        const onPaymentChanged = () => {
+            setPaymentRevision((current) => current + 1);
+            void refreshConversations();
+        };
+        socket.on("connect", onConnect);
+        socket.on("disconnect", onDisconnect);
+        socket.on("message:new", onNewMessage);
+        socket.on("message:delivered", onDelivered);
+        socket.on("message:updated", onUpdatedMessage);
+        socket.on("message:read", onRead);
+        socket.on("typing:start", onTypingStart);
+        socket.on("typing:stop", onTypingStop);
+        socket.on("presence:online", onPresenceOnline);
+        socket.on("presence:offline", onPresenceOffline);
+        socket.on("notification", onNotification);
+        socket.on("conversation:preference.updated", onPreferenceUpdated);
+        socket.on("message:pinned", onConversationMetadataChanged);
+        socket.on("message:unpinned", onConversationMetadataChanged);
+        socket.on("conversation:event.created", onConversationEventChanged);
+        socket.on("conversation:event.updated", onConversationEventChanged);
+        socket.on("conversation:event.deleted", onConversationEventChanged);
+        socket.on("conversation:event.rsvp", onConversationEventChanged);
+        socket.on("conversation:participants.updated", onParticipantsChanged);
+        socket.on("conversation:payment.updated", onPaymentChanged);
+        if (!socket.connected)
+            socket.connect();
+        else
+            onConnect();
         return () => {
             socket.off("connect", onConnect);
             socket.off("disconnect", onDisconnect);
-            socket.off("message:new");
-            socket.off("message:updated");
-            socket.off("message:deleted");
-            socket.off("typing:start");
-            socket.off("typing:stop");
-            socket.off("presence:online");
-            socket.off("presence:offline");
-            socket.off("notification:new");
-            // Disconnect on unmount? Maybe not if shared across pages.
-            // But if specific to chat...
-            // For shared state lib, we might want to keep it open?
-            // If user navigates away from chat pages, maybe close it?
-            // The original logic disconnected on unmount.
-            // But if we want global notifications (unread count), we need it open.
-            // Let's keep it open but manage listeners.
-            // Actually, if we unmount the provider, we should disconnect or remove listeners.
-            // Assuming this Provider wraps only Chat pages.
+            socket.off("message:new", onNewMessage);
+            socket.off("message:delivered", onDelivered);
+            socket.off("message:updated", onUpdatedMessage);
+            socket.off("message:read", onRead);
+            socket.off("typing:start", onTypingStart);
+            socket.off("typing:stop", onTypingStop);
+            socket.off("presence:online", onPresenceOnline);
+            socket.off("presence:offline", onPresenceOffline);
+            socket.off("notification", onNotification);
+            socket.off("conversation:preference.updated", onPreferenceUpdated);
+            socket.off("message:pinned", onConversationMetadataChanged);
+            socket.off("message:unpinned", onConversationMetadataChanged);
+            socket.off("conversation:event.created", onConversationEventChanged);
+            socket.off("conversation:event.updated", onConversationEventChanged);
+            socket.off("conversation:event.deleted", onConversationEventChanged);
+            socket.off("conversation:event.rsvp", onConversationEventChanged);
+            socket.off("conversation:participants.updated", onParticipantsChanged);
+            socket.off("conversation:payment.updated", onPaymentChanged);
         };
-    }, [user, refreshConversations]);
+    }, [accountType, actorId, actorModel, refreshConversations]);
     return (_jsx(ChatContext.Provider, { value: {
             socket: socketRef.current,
             isConnected,
@@ -331,8 +439,11 @@ export function ChatProvider({ children }) {
             markRead,
             createPoll,
             votePoll,
+            updatePoll,
             unreadNotificationCount,
             notifications,
             clearNotifications,
+            eventRevision,
+            paymentRevision,
         }, children: children }));
 }