@fabriktor/fx 0.0.38 → 0.0.39

package/dist/src/chat/chat.d.ts

@@ -1,5 +1,8 @@
 import type { ChatOperator, WSCloseHandler, WSConnection, WSErrorHandler, WSMessageHandler } from "@fabriktor/client";
-import type { Chat, ChatRoom, ChatRoomMember } from "@fabriktor/schema";
+import { type Chat, type ChatRoom, type ChatRoomMember } from "@fabriktor/schema";
+import { type SearchPage } from "../core/search.js";
+type ChatInsertOptions = Parameters<ChatOperator["insertOneChat"]>[0];
+export type CreateChatOptions = ChatInsertOptions;
 export type ReactChatOptions = Parameters<ChatOperator["reactChat"]>[0];
 export type ChatFXOptions = {
     chat: ChatOperator;
@@ -27,6 +30,13 @@ export type LatestChatsPage = {
     has_more: boolean;
     next_cursor: LatestChatsCursor;
 };
+export type SearchChatRoomMembersOptions = {
+    chat_room_id: string;
+    q?: string;
+    page?: number;
+    per_page?: number;
+};
+export type SearchChatRoomMembersPage = SearchPage<ChatRoomMember>;
 export type ChatRoomMembersOptions = {
     chat_room_id: string;
 };
@@ -53,22 +63,24 @@ export type ReactUploadedChatOptions = {
     reaction: ReactChatOptions;
 };
 export type ChatRoomSession = {
-    latest: LatestChatsPage;
     chats_ws: WSConnection;
     chat_room_ws: WSConnection;
+    latest: LatestChatsPage;
     closeNormal(reason?: string): void;
     closeLeavingPage(reason?: string): void;
 };
 export type GlobalChatRoomsSession = {
-    members: ChatRoomMember[];
     chat_rooms_ws: WSConnection;
+    members: ChatRoomMember[];
     closeNormal(reason?: string): void;
     closeLeavingPage(reason?: string): void;
 };
 export interface ChatFXOperator {
+    createChat(opts: CreateChatOptions): Promise<Chat>;
     newLatestChatsCursor(opts: LatestChatsOptions): LatestChatsCursor;
     latestChats(opts: LatestChatsOptions): Promise<LatestChatsPage>;
     nextLatestChats(opts: NextLatestChatsOptions): Promise<LatestChatsPage>;
+    searchChatRoomMembers(opts: SearchChatRoomMembersOptions): Promise<SearchChatRoomMembersPage>;
     chatRoomMembers(opts: ChatRoomMembersOptions): Promise<ChatRoomMember[]>;
     myChatRoomMembers(opts: MyChatRoomMembersOptions): Promise<ChatRoomMember[]>;
     openChatRoom(opts: OpenChatRoomOptions): Promise<ChatRoomSession>;
@@ -78,13 +90,19 @@ export interface ChatFXOperator {
 export declare class ChatFX implements ChatFXOperator {
     private chat;
     constructor(opts: ChatFXOptions);
+    createChat(opts: CreateChatOptions): Promise<Chat>;
     newLatestChatsCursor(opts: LatestChatsOptions): LatestChatsCursor;
     latestChats(opts: LatestChatsOptions): Promise<LatestChatsPage>;
     nextLatestChats(opts: NextLatestChatsOptions): Promise<LatestChatsPage>;
+    searchChatRoomMembers(opts: SearchChatRoomMembersOptions): Promise<SearchChatRoomMembersPage>;
     chatRoomMembers(opts: ChatRoomMembersOptions): Promise<ChatRoomMember[]>;
     myChatRoomMembers(opts: MyChatRoomMembersOptions): Promise<ChatRoomMember[]>;
     openChatRoom(opts: OpenChatRoomOptions): Promise<ChatRoomSession>;
     openGlobalChatRooms(opts: OpenGlobalChatRoomsOptions): Promise<GlobalChatRoomsSession>;
     reactUploadedChat(opts: ReactUploadedChatOptions): Promise<void>;
+    private openChatRoomConnections;
+    private openGlobalChatRoomsConnection;
+    private findChat;
 }
 export declare function newChatFX(opts: ChatFXOptions): ChatFX;
+export {};

package/dist/src/chat/chat.js

@@ -3,16 +3,31 @@
 // Licensed under the Apache License, Version 2.0 (the "License"); you may
 // not use this file except in compliance with the License. You may obtain
 // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-import { errValidation } from "../core/err.js";
+import { ZeroID, } from "@fabriktor/schema";
+import { errResolveFailed, errValidation } from "../core/err.js";
 import { normalizeSearchPage, normalizeSearchPerPage, runSearch, } from "../core/search.js";
 const closeCodeNormal = 1000;
 const closeCodeLeavingPage = 1001;
+const wsRefreshMilliseconds = 40 * 60 * 1000;
+const wsRefreshRetryMilliseconds = 30 * 1000;
+const resourceChatID = "chat_id";
+const resourceChat = "chat";
+const msgCreatedChatIDMissing = "Created chat response did not contain an ID.";
+const msgChatMissing = "Chat could not be resolved after the mutation.";
 const msgChatObjectsUploading = "Cannot react to a chat while objects are still uploading.";
 export class ChatFX {
     chat;
     constructor(opts) {
         this.chat = opts.chat;
     }
+    async createChat(opts) {
+        const out = await this.chat.insertOneChat(opts);
+        const id = requiredOperationID(out, {
+            resource: resourceChatID,
+            msg: msgCreatedChatIDMissing,
+        });
+        return await this.findChat(id);
+    }
     newLatestChatsCursor(opts) {
         return {
             chat_room_id: opts.chat_room_id,
@@ -45,6 +60,17 @@ export class ChatFX {
             per_page: opts.cursor.per_page,
         });
     }
+    async searchChatRoomMembers(opts) {
+        return await runSearch({
+            search: (searchOpts) => this.chat.searchManyChatRoomMembers(searchOpts),
+            query: {
+                chat_room_id: opts.chat_room_id,
+            },
+            q: opts.q,
+            page: opts.page,
+            per_page: opts.per_page,
+        });
+    }
     async chatRoomMembers(opts) {
         const out = await this.chat.queryChatRoomMembers({
             query: {
@@ -66,28 +92,66 @@ export class ChatFX {
             chat_room_id: opts.chat_room_id,
             per_page: opts.per_page,
         });
-        const chats_ws = await this.chat.wsChats({
-            owner_id: opts.owner_id,
-            chat_room_id: opts.chat_room_id,
-            on_message: opts.on_chat,
-            on_error: opts.on_error,
-            on_close: opts.on_close,
-        });
-        const chat_room_ws = await this.chat.wsChatRoom({
-            id: opts.chat_room_id,
-            on_message: opts.on_chat_room,
-            on_error: opts.on_error,
-            on_close: opts.on_close,
-        });
+        const fx = this;
+        let current = await fx.openChatRoomConnections(opts);
+        let refresh_timer = null;
+        let closed = false;
+        current.activate();
+        scheduleRefresh();
+        async function refresh() {
+            refresh_timer = null;
+            if (closed) {
+                return;
+            }
+            try {
+                const next = await fx.openChatRoomConnections(opts);
+                if (closed) {
+                    next.close(closeCodeNormal);
+                    return;
+                }
+                const previous = current;
+                previous.deactivate();
+                current = next;
+                current.activate();
+                previous.close(closeCodeNormal);
+                scheduleRefresh();
+            }
+            catch {
+                scheduleRefresh(wsRefreshRetryMilliseconds);
+            }
+        }
+        function scheduleRefresh(delay = wsRefreshMilliseconds) {
+            if (closed) {
+                return;
+            }
+            refresh_timer = setTimeout(() => {
+                void refresh();
+            }, delay);
+        }
+        function closeSession(code, reason) {
+            if (closed) {
+                return;
+            }
+            closed = true;
+            if (refresh_timer !== null) {
+                clearTimeout(refresh_timer);
+                refresh_timer = null;
+            }
+            current.close(code, reason);
+        }
         return {
             latest,
-            chats_ws,
-            chat_room_ws,
+            get chats_ws() {
+                return current.chats_ws;
+            },
+            get chat_room_ws() {
+                return current.chat_room_ws;
+            },
             closeNormal(reason) {
-                closeWS([chats_ws, chat_room_ws], closeCodeNormal, reason);
+                closeSession(closeCodeNormal, reason);
             },
             closeLeavingPage(reason) {
-                closeWS([chats_ws, chat_room_ws], closeCodeLeavingPage, reason);
+                closeSession(closeCodeLeavingPage, reason);
             },
         };
     }
@@ -95,20 +159,63 @@ export class ChatFX {
         const members = await this.myChatRoomMembers({
             owner_id: opts.owner_id,
         });
-        const chat_rooms_ws = await this.chat.wsMineChatRooms({
-            owner_id: opts.owner_id,
-            on_message: opts.on_chat_room,
-            on_error: opts.on_error,
-            on_close: opts.on_close,
-        });
+        const fx = this;
+        let current = await fx.openGlobalChatRoomsConnection(opts);
+        let refresh_timer = null;
+        let closed = false;
+        current.activate();
+        scheduleRefresh();
+        async function refresh() {
+            refresh_timer = null;
+            if (closed) {
+                return;
+            }
+            try {
+                const next = await fx.openGlobalChatRoomsConnection(opts);
+                if (closed) {
+                    next.close(closeCodeNormal);
+                    return;
+                }
+                const previous = current;
+                previous.deactivate();
+                current = next;
+                current.activate();
+                previous.close(closeCodeNormal);
+                scheduleRefresh();
+            }
+            catch {
+                scheduleRefresh(wsRefreshRetryMilliseconds);
+            }
+        }
+        function scheduleRefresh(delay = wsRefreshMilliseconds) {
+            if (closed) {
+                return;
+            }
+            refresh_timer = setTimeout(() => {
+                void refresh();
+            }, delay);
+        }
+        function closeSession(code, reason) {
+            if (closed) {
+                return;
+            }
+            closed = true;
+            if (refresh_timer !== null) {
+                clearTimeout(refresh_timer);
+                refresh_timer = null;
+            }
+            current.close(code, reason);
+        }
         return {
             members,
-            chat_rooms_ws,
+            get chat_rooms_ws() {
+                return current.chat_rooms_ws;
+            },
             closeNormal(reason) {
-                closeWS([chat_rooms_ws], closeCodeNormal, reason);
+                closeSession(closeCodeNormal, reason);
             },
             closeLeavingPage(reason) {
-                closeWS([chat_rooms_ws], closeCodeLeavingPage, reason);
+                closeSession(closeCodeLeavingPage, reason);
             },
         };
     }
@@ -121,6 +228,139 @@ export class ChatFX {
         }
         await this.chat.reactChat(opts.reaction);
     }
+    async openChatRoomConnections(opts) {
+        let active = false;
+        const chats_ws = await this.chat.wsChats({
+            owner_id: opts.owner_id,
+            chat_room_id: opts.chat_room_id,
+            on_message(v, ev) {
+                if (active) {
+                    opts.on_chat(v, ev);
+                }
+            },
+            on_error: opts.on_error === undefined
+                ? undefined
+                : (ev) => {
+                    if (active) {
+                        opts.on_error?.(ev);
+                    }
+                },
+            on_close: opts.on_close === undefined
+                ? undefined
+                : (ev) => {
+                    if (active) {
+                        opts.on_close?.(ev);
+                    }
+                },
+        });
+        let chat_room_ws;
+        try {
+            chat_room_ws = await this.chat.wsChatRoom({
+                id: opts.chat_room_id,
+                on_message(v, ev) {
+                    if (active) {
+                        opts.on_chat_room(v, ev);
+                    }
+                },
+                on_error: opts.on_error === undefined
+                    ? undefined
+                    : (ev) => {
+                        if (active) {
+                            opts.on_error?.(ev);
+                        }
+                    },
+                on_close: opts.on_close === undefined
+                    ? undefined
+                    : (ev) => {
+                        if (active) {
+                            opts.on_close?.(ev);
+                        }
+                    },
+            });
+        }
+        catch (cause) {
+            chats_ws.close(closeCodeNormal);
+            await Promise.allSettled([chats_ws.opened]);
+            throw cause;
+        }
+        try {
+            await Promise.all([chats_ws.opened, chat_room_ws.opened]);
+        }
+        catch (cause) {
+            closeWS([chats_ws, chat_room_ws], closeCodeNormal);
+            throw cause;
+        }
+        return {
+            chats_ws,
+            chat_room_ws,
+            activate() {
+                active = true;
+            },
+            deactivate() {
+                active = false;
+            },
+            close(code, reason) {
+                closeWS([chats_ws, chat_room_ws], code, reason);
+            },
+        };
+    }
+    async openGlobalChatRoomsConnection(opts) {
+        let active = false;
+        const chat_rooms_ws = await this.chat.wsMineChatRooms({
+            owner_id: opts.owner_id,
+            on_message(v, ev) {
+                if (active) {
+                    opts.on_chat_room(v, ev);
+                }
+            },
+            on_error: opts.on_error === undefined
+                ? undefined
+                : (ev) => {
+                    if (active) {
+                        opts.on_error?.(ev);
+                    }
+                },
+            on_close: opts.on_close === undefined
+                ? undefined
+                : (ev) => {
+                    if (active) {
+                        opts.on_close?.(ev);
+                    }
+                },
+        });
+        try {
+            await chat_rooms_ws.opened;
+        }
+        catch (cause) {
+            chat_rooms_ws.close(closeCodeNormal);
+            throw cause;
+        }
+        return {
+            chat_rooms_ws,
+            activate() {
+                active = true;
+            },
+            deactivate() {
+                active = false;
+            },
+            close(code, reason) {
+                chat_rooms_ws.close(code, reason);
+            },
+        };
+    }
+    async findChat(id) {
+        const out = await this.chat.findOneChat({
+            id,
+        });
+        const chat = out.value;
+        if (chat === undefined) {
+            throw errResolveFailed({
+                resource: resourceChat,
+                msg: msgChatMissing,
+            });
+        }
+        return chat;
+    }
 }
 export function newChatFX(opts) {
     return new ChatFX(opts);
@@ -155,3 +395,20 @@ function closeWS(conns, code, reason) {
         conn.close(code, reason);
     }
 }
+function requiredOperationID(out, opts) {
+    const id = resolvedID(out.id);
+    if (id === undefined) {
+        throw errResolveFailed({
+            resource: opts.resource,
+            msg: opts.msg,
+        });
+    }
+    return id;
+}
+function resolvedID(value) {
+    const id = value?.trim();
+    if (id === undefined || id === "" || id === ZeroID) {
+        return undefined;
+    }
+    return id;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fabriktor/fx",
-  "version": "0.0.38",
+  "version": "0.0.39",
   "description": "![Fabriktor Logo](./img/fabriktor-character.gif)",
   "type": "module",
   "exports": {
@@ -17,7 +17,7 @@
     "typescript": "^6.0.3"
   },
   "dependencies": {
-    "@fabriktor/client": "0.0.44",
+    "@fabriktor/client": "0.0.45",
     "@fabriktor/schema": "0.0.32"
   }
 }