@webinex/chatify 2.0.0-build10 → 2.0.0-build3

package/src/core/api/chatApi.ts

@@ -1,11 +1,7 @@
-import { BaseApiEndpointBuilder, __baseApi, __settings } from './baseApi';
+import { __baseApi, __settings } from './baseApi';
 import { unsubscribe } from '../client';
 import { Chat } from '../types';
 
-export function chatEndpoints(builder: BaseApiEndpointBuilder) {
-  return {};
-}
-
 const chatApi = __baseApi.injectEndpoints({
   endpoints: (builder) => ({
     getChat: builder.query<Chat, { id: string }>({

package/src/core/api/chatListApi.ts

@@ -1,13 +1,14 @@
-import { BaseApiEndpointBuilder, __settings } from './baseApi';
+import { __baseApi, __settings } from './baseApi';
 import { unsubscribe } from '../client';
 import { ChatListItem } from '../types';
+import { useSelector } from 'react-redux';
 
-export function chatListEndpoints(builder: BaseApiEndpointBuilder) {
-  return {
+const chatListApi = __baseApi.injectEndpoints({
+  endpoints: (builder) => ({
     getChatList: builder.query<ChatListItem[], void>({
       queryFn: async () => ({ data: await __settings.client.chats() }),
       providesTags: ['chat', 'account'],
-      onCacheEntryAdded: async (_, { cacheEntryRemoved, cacheDataLoaded, updateCachedData }) => {
+      onCacheEntryAdded: async (_, { dispatch, cacheEntryRemoved, cacheDataLoaded, updateCachedData }) => {
         await cacheDataLoaded;
 
         unsubscribe(
@@ -130,5 +131,17 @@ export function chatListEndpoints(builder: BaseApiEndpointBuilder) {
         ).when(cacheEntryRemoved);
       },
     }),
-  };
+  }),
+});
+
+export function useChatListItem(id: string | null) {
+  return useSelector((state: any) =>
+    id != null
+      ? chatListApi.endpoints.getChatList
+          .select()(state)
+          .data?.find((x) => x.id === id)
+      : null,
+  );
 }
+
+export const __chatListApi = chatListApi;

package/src/core/api/chatMemberApi.ts

@@ -1,8 +1,8 @@
 import { AddChatMemberRequest, RemoveChatMemberRequest } from '../types';
-import { BaseApiEndpointBuilder, __settings } from './baseApi';
+import { __baseApi, __settings } from './baseApi';
 
-export function chatMemberEndpoints(builder: BaseApiEndpointBuilder) {
-  return {
+export const __chatMemberApi = __baseApi.injectEndpoints({
+  endpoints: (builder) => ({
     removeChatMember: builder.mutation<void, RemoveChatMemberRequest>({
       queryFn: async (args) => {
         await __settings.client.removeChatMember(args);
@@ -16,5 +16,5 @@ export function chatMemberEndpoints(builder: BaseApiEndpointBuilder) {
         return { data: null! };
       },
     }),
-  };
-}
+  }),
+});

package/src/core/api/chatMessageApi.ts

@@ -1,12 +1,147 @@
 import { unsubscribe } from '../client';
 import { Debounce, DebounceValue } from '../debounce';
 import { ChatMessage, chatId } from '../types';
-import { BaseApiEndpointBuilder, DEFAULT_MESSAGE_LIST_TAKE, __baseApi, __settings } from './baseApi';
+import { DEFAULT_MESSAGE_LIST_TAKE, __baseApi, __settings } from './baseApi';
 
-export function chatMessageEndpoints(builder: BaseApiEndpointBuilder) {
-  return {};
+export interface ChatMessageListResult {
+  messages: ChatMessage[];
+  hasMore: boolean;
 }
 
+const CHAT_MESSAGE_READ_QUEUE = new Debounce<string>({
+  callback: (id) => __settings.client.readChatMessage({ id }),
+  compare: (a, b) => -a.localeCompare(b),
+  groupBy: (id) => chatId(id),
+  timeout: 500,
+});
+
 export const __chatMessageApi = __baseApi.injectEndpoints({
-  endpoints: (builder) => ({}),
+  endpoints: (builder) => ({
+    getChatMessageList: builder.query<ChatMessageListResult, { chatId: string }>({
+      queryFn: async ({ chatId }) => {
+        const messages = await __settings.client.chatMessages({
+          chatId,
+          skip: 0,
+          take: DEFAULT_MESSAGE_LIST_TAKE + 1,
+        });
+        return {
+          data: {
+            messages: messages.slice(0, DEFAULT_MESSAGE_LIST_TAKE),
+            hasMore: messages.length === DEFAULT_MESSAGE_LIST_TAKE + 1,
+          },
+        };
+      },
+      providesTags: ['message', 'chat', 'account'],
+      onCacheEntryAdded: async ({ chatId }, { dispatch, cacheEntryRemoved, cacheDataLoaded }) => {
+        await cacheDataLoaded;
+
+        unsubscribe(
+          __settings.client.subscribe('chatify://chat-new-message', ([message]) => {
+            message.chatId === chatId &&
+              dispatch(
+                __chatMessageApi.util.updateQueryData('getChatMessageList', { chatId }, (draft) => {
+                  draft.messages.unshift(message);
+                }),
+              );
+          }),
+
+          __settings.client.subscribe('chatify://chat-member-added', ([eventChatId, , , message]) => {
+            eventChatId === chatId &&
+              dispatch(
+                __chatMessageApi.util.updateQueryData('getChatMessageList', { chatId }, (draft) => {
+                  draft.messages.unshift(message);
+                }),
+              );
+          }),
+
+          __settings.client.subscribe('chatify://chat-member-removed', ([eventChatId, , , message]) => {
+            eventChatId === chatId &&
+              dispatch(
+                __chatMessageApi.util.updateQueryData('getChatMessageList', { chatId }, (draft) => {
+                  draft.messages.unshift(message);
+                }),
+              );
+          }),
+
+          __settings.client.subscribe('chatify://chat-name-changed', ([eventChatId, , message]) => {
+            eventChatId === chatId &&
+              dispatch(
+                __chatMessageApi.util.updateQueryData('getChatMessageList', { chatId }, (draft) => {
+                  draft.messages.unshift(message);
+                }),
+              );
+          }),
+        ).when(cacheEntryRemoved);
+      },
+    }),
+
+    fetchNextChatMessageList: builder.mutation<void, { chatId: string }>({
+      queryFn: async ({ chatId }, { getState }) => {
+        const current = __chatMessageApi.endpoints.getChatMessageList.select({ chatId })(getState() as any);
+        const messages = await __settings.client.chatMessages({
+          chatId,
+          skip: current.data!.messages.length,
+          take: DEFAULT_MESSAGE_LIST_TAKE + 1,
+        });
+        return {
+          data: null!,
+          meta: {
+            messages: messages.slice(0, DEFAULT_MESSAGE_LIST_TAKE),
+            hasMore: messages.length === DEFAULT_MESSAGE_LIST_TAKE + 1,
+          },
+        };
+      },
+      onQueryStarted: async ({ chatId }, { dispatch, queryFulfilled }) => {
+        const result = await queryFulfilled;
+        const meta: ChatMessageListResult = result.meta! as any;
+
+        dispatch(
+          __chatMessageApi.util.updateQueryData('getChatMessageList', { chatId }, (draft) => {
+            draft.hasMore = meta.hasMore;
+            draft.messages.push(...meta!.messages);
+          }),
+        );
+      },
+    }),
+
+    sendChatMessage: builder.mutation<void, { chatId: string; text: string }>({
+      queryFn: async ({ chatId, text }) => {
+        const requestId = new Date().getTime().toString();
+
+        await __settings.client.sendChatMessage({
+          chatId,
+          text,
+          files: [],
+          requestId,
+        });
+
+        return { data: null!, meta: { requestId } };
+      },
+    }),
+
+    readChatMessage: builder.mutation<void, { id: string }>({
+      queryFn: async () => {
+        return { data: null! };
+      },
+      onQueryStarted: async ({ id }, { dispatch }) => {
+        CHAT_MESSAGE_READ_QUEUE.push(id);
+        dispatch(
+          __chatMessageApi.endpoints.getChatMessageReadQueue.initiate(undefined, { forceRefetch: true }),
+        );
+      },
+    }),
+
+    getChatMessageReadQueue: builder.query<DebounceValue<string>[], void>({
+      queryFn: async () => ({ data: CHAT_MESSAGE_READ_QUEUE.units }),
+      onCacheEntryAdded: async (_, { dispatch, cacheEntryRemoved }) => {
+        unsubscribe(
+          CHAT_MESSAGE_READ_QUEUE.subscribe((value) => {
+            dispatch(
+              __chatMessageApi.util.updateQueryData('getChatMessageReadQueue', undefined, () => value.units),
+            );
+          }),
+        ).when(cacheEntryRemoved);
+      },
+    }),
+  }),
 });

package/src/core/api/threadApi.ts

@@ -4,5 +4,121 @@ import { unsubscribe } from '../client';
 import { useMemo } from 'react';
 
 export const __threadApi = __baseApi.injectEndpoints({
-  endpoints: (builder) => ({}),
+  endpoints: (builder) => ({
+    getWatchThreadList: builder.query<ThreadWatchListItem[], void>({
+      queryFn: async () => {
+        const threads = await __settings.client.watchThreads();
+        return { data: threads };
+      },
+      providesTags: ['account', 'thread'],
+      onCacheEntryAdded: async (_, { dispatch, cacheEntryRemoved, cacheDataLoaded, updateCachedData }) => {
+        await cacheDataLoaded;
+
+        unsubscribe(
+          __settings.client.subscribe(
+            'chatify://thread-created',
+            ([thread, watch]) =>
+              watch &&
+              updateCachedData((threads) => {
+                threads.push(thread);
+              }),
+          ),
+          __settings.client.subscribe('chatify://thread-message-new', ([threadId, message, readForId]) =>
+            updateCachedData((threads) => {
+              const thread = threads.find((x) => x.id === threadId);
+              if (!thread) return;
+
+              thread.lastMessage = message;
+
+              if (readForId === __settings.me()) {
+                thread.lastReadMessageId = message.id;
+              }
+            }),
+          ),
+          __settings.client.subscribe('chatify://thread-message-read', ([threadId, messageId]) =>
+            updateCachedData((threads) => {
+              const thread = threads.find((x) => x.id === threadId);
+              if (!thread) return;
+
+              thread.lastReadMessageId = messageId;
+            }),
+          ),
+          __settings.client.subscribe('chatify://thread-watch-added', ([thread]) =>
+            updateCachedData((threads) => {
+              threads.push(thread);
+            }),
+          ),
+          __settings.client.subscribe('chatify://thread-watch-removed', ([id]) =>
+            updateCachedData((threads) => {
+              const index = threads.findIndex((x) => x.id === id);
+              if (index !== -1) threads.splice(index, 1);
+            }),
+          ),
+        ).when(cacheEntryRemoved);
+      },
+    }),
+
+    getThread: builder.query<Thread, { id: string }>({
+      queryFn: async ({ id }) => {
+        const threads = await __settings.client.thread(id);
+        return { data: threads };
+      },
+      providesTags: ['account', 'thread'],
+      onCacheEntryAdded: async ({ id }, { cacheEntryRemoved, cacheDataLoaded, updateCachedData }) => {
+        await cacheDataLoaded;
+
+        unsubscribe(
+          __settings.client.subscribe(
+            'chatify://thread-message-read',
+            ([threadId, messageId]) =>
+              id === threadId &&
+              updateCachedData((t) => {
+                t.lastReadMessageId = messageId;
+              }),
+          ),
+          __settings.client.subscribe(
+            'chatify://thread-message-new',
+            ([threadId, message, readForId]) =>
+              id === threadId &&
+              updateCachedData((thread) => {
+                thread.lastMessageId = message.id;
+                thread.lastReadMessageId =
+                  readForId === __settings.me() ? message.id : thread.lastReadMessageId;
+              }),
+          ),
+          __settings.client.subscribe(
+            'chatify://thread-watch-added',
+            ([threadListItem]) =>
+              id === threadListItem.id &&
+              updateCachedData((thread) => {
+                thread.watch = true;
+                thread.lastMessageId = threadListItem.lastMessage?.id ?? null;
+                thread.lastReadMessageId = threadListItem.lastReadMessageId ?? null;
+              }),
+          ),
+          __settings.client.subscribe(
+            'chatify://thread-watch-removed',
+            ([threadId]) =>
+              id === threadId &&
+              updateCachedData((thread) => {
+                thread.watch = false;
+              }),
+          ),
+        ).when(cacheEntryRemoved);
+      },
+    }),
+
+    watchThread: builder.mutation<void, { id: string; watch: boolean }>({
+      queryFn: async ({ id, watch }) => {
+        await __settings.client.watchThread(id, watch);
+        return { data: null! };
+      },
+    }),
+  }),
 });
+
+export function useUnreadThreadMessageCount() {
+  const { data: threads, ...state } = __threadApi.useGetWatchThreadListQuery();
+  const count = useMemo(() => (threads != null ? calcThreadListUnreadCount(threads) : null), [threads]);
+  return [count, state] as const;
+}

package/src/core/api/threadMessageApi.ts

@@ -16,5 +16,103 @@ const THREAD_MESSAGE_READ_QUEUE = new Debounce<string>({
 });
 
 export const __threadMessageApi = __baseApi.injectEndpoints({
-  endpoints: (builder) => ({}),
+  endpoints: (builder) => ({
+    getThreadMessageList: builder.query<ThreadMessageList, { threadId: string }>({
+      queryFn: async (args) => {
+        const requestArgs = {
+          skip: 0,
+          take: DEFAULT_MESSAGE_LIST_TAKE + 1,
+          ...args,
+        };
+        const messages = await __settings.client.threadMessages(requestArgs);
+        return {
+          data: {
+            messages: messages.slice(0, DEFAULT_MESSAGE_LIST_TAKE),
+            hasMore: messages.length === DEFAULT_MESSAGE_LIST_TAKE + 1,
+          },
+        };
+      },
+      providesTags: ['account', 'thread', 'thread-message'],
+      onCacheEntryAdded: async ({ threadId }, { cacheEntryRemoved, cacheDataLoaded, updateCachedData }) => {
+        await cacheDataLoaded;
+
+        unsubscribe(
+          __settings.client.subscribe('chatify://thread-message-new', ([_threadId, message]) => {
+            threadId === _threadId &&
+              updateCachedData((messageList) => {
+                !messageList.messages.some((x) => x.id === message.id) &&
+                  messageList.messages.unshift(message);
+              });
+          }),
+        ).when(cacheEntryRemoved);
+      },
+    }),
+
+    fetchNextThreadMessageList: builder.mutation<void, { threadId: string }>({
+      queryFn: async ({ threadId }, { getState }) => {
+        const current = __threadMessageApi.endpoints.getThreadMessageList.select({ threadId })(
+          getState() as any,
+        );
+        const messages = await __settings.client.threadMessages({
+          threadId,
+          skip: current.data!.messages.length,
+          take: DEFAULT_MESSAGE_LIST_TAKE + 1,
+        });
+        return {
+          data: null!,
+          meta: {
+            messages: messages.slice(0, DEFAULT_MESSAGE_LIST_TAKE),
+            hasMore: messages.length === DEFAULT_MESSAGE_LIST_TAKE + 1,
+          },
+        };
+      },
+      onQueryStarted: async ({ threadId }, { dispatch, queryFulfilled }) => {
+        const result = await queryFulfilled;
+        const meta: ThreadMessageList = result.meta! as any;
+
+        dispatch(
+          __threadMessageApi.util.updateQueryData('getThreadMessageList', { threadId }, (draft) => {
+            draft.hasMore = meta.hasMore;
+            draft.messages.push(...meta!.messages);
+          }),
+        );
+      },
+    }),
+
+    sendThreadMessage: builder.mutation<string, SendThreadMessageRequest>({
+      queryFn: async (args) => {
+        const id = await __settings.client.sendThreadMessage(args);
+        return { data: id };
+      },
+    }),
+
+    readThreadMessage: builder.mutation<void, { id: string }>({
+      queryFn: async () => {
+        return { data: null! };
+      },
+      onQueryStarted: async ({ id }, { dispatch }) => {
+        THREAD_MESSAGE_READ_QUEUE.push(id);
+        dispatch(
+          __threadMessageApi.endpoints.getThreadMessageReadQueue.initiate(undefined, { forceRefetch: true }),
+        );
+      },
+    }),
+
+    getThreadMessageReadQueue: builder.query<DebounceValue<string>[], void>({
+      queryFn: async () => ({ data: THREAD_MESSAGE_READ_QUEUE.units }),
+      onCacheEntryAdded: async (_, { dispatch, cacheEntryRemoved }) => {
+        unsubscribe(
+          THREAD_MESSAGE_READ_QUEUE.subscribe((value) => {
+            dispatch(
+              __threadMessageApi.util.updateQueryData(
+                'getThreadMessageReadQueue',
+                undefined,
+                () => value.units,
+              ),
+            );
+          }),
+        ).when(cacheEntryRemoved);
+      },
+    }),
+  }),
 });

package/src/ui/Conversation/NextObserver/NextMessagesObserver.tsx

@@ -10,13 +10,13 @@ export function NextMessagesObserver(props: NextMessagesObserverProps) {
   const { onLoad, loading } = props;
   const [intersecting, setIntersecting] = useState(false);
   const ref = useRef<HTMLDivElement | null>(null);
-  const timerRef = useRef<number>();
+  const timerRef = useRef<NodeJS.Timer>();
 
   const observer = useMemo(
     () =>
       new IntersectionObserver(([entry]) => {
         if (entry.isIntersecting) {
-          timerRef.current = window.setTimeout(() => setIntersecting(true), 200);
+          timerRef.current = setTimeout(() => setIntersecting(true), 200);
         } else {
           clearTimeout(timerRef.current!);
         }

package/src/types/core/api/accountApi.d.ts

@@ -1,5 +0,0 @@
-import { BaseApiEndpointBuilder } from './baseApi';
-import { Account } from '../types';
-export declare function accountEndpoints(builder: BaseApiEndpointBuilder): {
-    getAccountList: import("@reduxjs/toolkit/query").QueryDefinition<void, import("@reduxjs/toolkit/query").BaseQueryFn, "chat" | "account" | "message" | "thread" | "thread-message", Account[], "chatify">;
-};