@webinex/chatify 2.0.0-build4 → 2.0.0-build7

package/src/core/api/chatApi.ts

@@ -1,7 +1,11 @@
-import { __baseApi, __settings } from './baseApi';
+import { BaseApiEndpointBuilder, __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,14 +1,13 @@
-import { __baseApi, __settings } from './baseApi';
+import { BaseApiEndpointBuilder, __settings } from './baseApi';
 import { unsubscribe } from '../client';
 import { ChatListItem } from '../types';
-import { useSelector } from 'react-redux';
 
-const chatListApi = __baseApi.injectEndpoints({
-  endpoints: (builder) => ({
+export function chatListEndpoints(builder: BaseApiEndpointBuilder) {
+  return {
     getChatList: builder.query<ChatListItem[], void>({
       queryFn: async () => ({ data: await __settings.client.chats() }),
       providesTags: ['chat', 'account'],
-      onCacheEntryAdded: async (_, { dispatch, cacheEntryRemoved, cacheDataLoaded, updateCachedData }) => {
+      onCacheEntryAdded: async (_, { cacheEntryRemoved, cacheDataLoaded, updateCachedData }) => {
         await cacheDataLoaded;
 
         unsubscribe(
@@ -131,17 +130,5 @@ const chatListApi = __baseApi.injectEndpoints({
         ).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 { __baseApi, __settings } from './baseApi';
+import { BaseApiEndpointBuilder, __settings } from './baseApi';
 
-export const __chatMemberApi = __baseApi.injectEndpoints({
-  endpoints: (builder) => ({
+export function chatMemberEndpoints(builder: BaseApiEndpointBuilder) {
+  return {
     removeChatMember: builder.mutation<void, RemoveChatMemberRequest>({
       queryFn: async (args) => {
         await __settings.client.removeChatMember(args);
@@ -16,5 +16,5 @@ export const __chatMemberApi = __baseApi.injectEndpoints({
         return { data: null! };
       },
     }),
-  }),
-});
+  };
+}

package/src/core/api/chatMessageApi.ts

@@ -1,147 +1,12 @@
 import { unsubscribe } from '../client';
 import { Debounce, DebounceValue } from '../debounce';
 import { ChatMessage, chatId } from '../types';
-import { DEFAULT_MESSAGE_LIST_TAKE, __baseApi, __settings } from './baseApi';
+import { BaseApiEndpointBuilder, DEFAULT_MESSAGE_LIST_TAKE, __baseApi, __settings } from './baseApi';
 
-export interface ChatMessageListResult {
-  messages: ChatMessage[];
-  hasMore: boolean;
+export function chatMessageEndpoints(builder: BaseApiEndpointBuilder) {
+  return {};
 }
 
-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) => ({
-    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);
-      },
-    }),
-  }),
+  endpoints: (builder) => ({}),
 });

package/src/core/api/threadApi.ts

@@ -4,121 +4,5 @@ import { unsubscribe } from '../client';
 import { useMemo } from 'react';
 
 export const __threadApi = __baseApi.injectEndpoints({
-  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! };
-      },
-    }),
-  }),
+  endpoints: (builder) => ({}),
 });
-
-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,103 +16,5 @@ const THREAD_MESSAGE_READ_QUEUE = new Debounce<string>({
 });
 
 export const __threadMessageApi = __baseApi.injectEndpoints({
-  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);
-      },
-    }),
-  }),
+  endpoints: (builder) => ({}),
 });

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

@@ -0,0 +1,5 @@
+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">;
+};