@fabriktor/fx 0.0.38 → 0.0.40

package/dist/src/calls/calls.js

@@ -4,7 +4,11 @@
 // 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 { errResolveFailed } from "../core/err.js";
+import { requiredOperationID } from "../core/id.js";
+const resourceEvent = "event";
 const resourceVideoToken = "video_token";
+const msgCreatedEventIDMissing = "Created event response did not contain an ID.";
+const msgEventMissing = "Event could not be resolved after the mutation.";
 const msgUnableToMintVideoToken = "Unable to mint video token.";
 export class CallsFX {
     calls;
@@ -13,6 +17,15 @@ export class CallsFX {
         this.calls = opts.calls;
         this.notifications = opts.notifications;
     }
+    async createEvent(opts) {
+        const out = await this.calls.insertOneEvent(opts);
+        const id = requiredOperationID(out, msgCreatedEventIDMissing);
+        return await this.findEvent(id);
+    }
+    async replaceEvent(opts) {
+        await this.calls.replaceOneEvent(opts);
+        return await this.findEvent(opts.id);
+    }
     async startCall(opts) {
         const token = await this.requireVideoToken(opts.mint);
         await this.notifications.relayNotification(opts.notification);
@@ -26,6 +39,19 @@ export class CallsFX {
     async cancelCall(opts) {
         await this.notifications.relayNotification(opts.notification);
     }
+    async findEvent(id) {
+        const out = await this.calls.findOneEvent({
+            id,
+        });
+        const event = out.value;
+        if (event === undefined) {
+            throw errResolveFailed({
+                resource: resourceEvent,
+                msg: msgEventMissing,
+            });
+        }
+        return event;
+    }
     async requireVideoToken(opts) {
         const out = await this.calls.mintVideoToken(opts);
         const token = out.value?.trim();

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

@@ -1,9 +1,29 @@
 import type { ChatOperator, WSCloseHandler, WSConnection, WSErrorHandler, WSMessageHandler } from "@fabriktor/client";
 import type { Chat, ChatRoom, ChatRoomMember } from "@fabriktor/schema";
+import { type SearchPage } from "../core/search.js";
+type ChatInsertOptions = Parameters<ChatOperator["insertOneChat"]>[0];
+type ChatReplaceOptions = Parameters<ChatOperator["replaceOneChat"]>[0];
+export type CreateChatOptions = ChatInsertOptions;
+export type MarkChatObjectsUploadedOptions = {
+    id: ChatReplaceOptions["id"];
+};
 export type ReactChatOptions = Parameters<ChatOperator["reactChat"]>[0];
 export type ChatFXOptions = {
     chat: ChatOperator;
 };
+type SearchChatsScope = {
+    chat_room_id: string;
+    owner_id?: string;
+} | {
+    chat_room_id?: string;
+    owner_id: string;
+};
+export type SearchChatsOptions = SearchChatsScope & {
+    q: string;
+    page?: number;
+    per_page?: number;
+};
+export type SearchChatsPage = SearchPage<Chat>;
 export type LatestChatsOptions = {
     chat_room_id: string;
     page?: number;
@@ -27,6 +47,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 +80,26 @@ 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>;
+    markChatObjectsUploaded(opts: MarkChatObjectsUploadedOptions): Promise<Chat>;
+    searchChats(opts: SearchChatsOptions): Promise<SearchChatsPage>;
     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 +109,21 @@ export interface ChatFXOperator {
 export declare class ChatFX implements ChatFXOperator {
     private chat;
     constructor(opts: ChatFXOptions);
+    createChat(opts: CreateChatOptions): Promise<Chat>;
+    markChatObjectsUploaded(opts: MarkChatObjectsUploadedOptions): Promise<Chat>;
+    searchChats(opts: SearchChatsOptions): Promise<SearchChatsPage>;
     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,56 @@
 // 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 { normalizeSearchPage, normalizeSearchPerPage, runSearch, } from "../core/search.js";
+import { errRequired, errResolveFailed, errValidation } from "../core/err.js";
+import { requiredOperationID } from "../core/id.js";
+import { normalizeSearchPage, normalizeSearchPerPage, normalizeSearchQuery, runSearch, } from "../core/search.js";
 const closeCodeNormal = 1000;
 const closeCodeLeavingPage = 1001;
+const wsRefreshMilliseconds = 40 * 60 * 1000;
+const wsRefreshRetryMilliseconds = 30 * 1000;
+const resourceChat = "chat";
+const msgCreatedChatIDMissing = "Created chat response did not contain an ID.";
+const msgChatMissing = "Chat could not be resolved after the mutation.";
+const msgSearchQueryRequired = "Search query is required.";
 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, msgCreatedChatIDMissing);
+        return await this.findChat(id);
+    }
+    async markChatObjectsUploaded(opts) {
+        await this.chat.replaceOneChat({
+            id: opts.id,
+            in: {
+                objects_uploaded: true,
+            },
+        });
+        return await this.findChat(opts.id);
+    }
+    async searchChats(opts) {
+        const q = normalizeSearchQuery(opts.q);
+        if (q === undefined) {
+            throw errRequired({
+                field: "q",
+                msg: msgSearchQueryRequired,
+            });
+        }
+        return await runSearch({
+            search: (searchOpts) => this.chat.searchManyChats(searchOpts),
+            query: {
+                chat_room_id: opts.chat_room_id,
+                owner_id: opts.owner_id,
+            },
+            q,
+            page: opts.page,
+            per_page: opts.per_page,
+        });
+    }
     newLatestChatsCursor(opts) {
         return {
             chat_room_id: opts.chat_room_id,
@@ -45,6 +85,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 +117,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 +184,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 +253,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);

package/dist/src/contacts/contacts.d.ts

@@ -1,5 +1,9 @@
-import { Friend, Hired, Manager, Na, OldHire, type Contact, type ID, type OperationResult } from "@fabriktor/schema";
 import type { ContactsOperator } from "@fabriktor/client";
+import { Friend, Hired, Manager, Na, OldHire, type Contact, type ID, type OperationResult } from "@fabriktor/schema";
+type ContactInsertOptions = Parameters<ContactsOperator["insertOneContact"]>[0];
+type ContactReplaceOptions = Parameters<ContactsOperator["replaceOneContact"]>[0];
+export type CreateContactOptions = ContactInsertOptions;
+export type ReplaceContactOptions = ContactReplaceOptions;
 export type ContactRelation = typeof Na | typeof Friend | typeof OldHire | typeof Hired | typeof Manager;
 export type ActiveContactRelation = typeof Friend | typeof Hired | typeof Manager;
 export type ContactsFXOptions = {
@@ -42,6 +46,8 @@ export type EndHireRelationOptions = {
     contact: Contact;
 };
 export interface ContactsFXOperator {
+    createContact(opts: CreateContactOptions): Promise<Contact>;
+    replaceContact(opts: ReplaceContactOptions): Promise<Contact>;
     loadContactIndex(opts: LoadContactIndexOptions): Promise<ContactIndex>;
     startPresence(opts: StartPresenceOptions): Promise<PresenceSession>;
     sendFriendRequest(opts: SendFriendRequestOptions): Promise<OperationResult>;
@@ -54,6 +60,8 @@ export interface ContactsFXOperator {
 export declare class ContactsFX implements ContactsFXOperator {
     private contacts;
     constructor(opts: ContactsFXOptions);
+    createContact(opts: CreateContactOptions): Promise<Contact>;
+    replaceContact(opts: ReplaceContactOptions): Promise<Contact>;
     loadContactIndex(opts: LoadContactIndexOptions): Promise<ContactIndex>;
     startPresence(opts: StartPresenceOptions): Promise<PresenceSession>;
     sendFriendRequest(opts: SendFriendRequestOptions): Promise<OperationResult>;
@@ -62,6 +70,8 @@ export declare class ContactsFX implements ContactsFXOperator {
     acceptContactRequest(opts: AcceptContactRequestOptions): Promise<OperationResult>;
     rejectContactRequest(opts: RejectContactRequestOptions): Promise<OperationResult>;
     endHireRelation(opts: EndHireRelationOptions): Promise<OperationResult>;
-    private replaceContact;
+    private replaceContactResult;
+    private findContact;
 }
 export declare function newContactsFX(opts: ContactsFXOptions): ContactsFX;
+export {};

package/dist/src/contacts/contacts.js

@@ -4,8 +4,12 @@
 // 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 { Friend, Na, OldHire, } from "@fabriktor/schema";
-import { errRequired, errValidation } from "../core/err.js";
+import { errRequired, errResolveFailed, errValidation } from "../core/err.js";
+import { requiredOperationID } from "../core/id.js";
 const presenceIntervalMS = 120_000;
+const resourceContact = "contact";
+const msgCreatedContactIDMissing = "Created contact response did not contain an ID.";
+const msgContactMissing = "Contact could not be resolved after the mutation.";
 const msgOwnerIDRequired = "Owner ID is required.";
 const msgContactIDRequired = "Contact ID is required.";
 const msgRelationUpgradeInvalid = "Requested relation must be higher than the current relation.";
@@ -16,6 +20,15 @@ export class ContactsFX {
     constructor(opts) {
         this.contacts = opts.contacts;
     }
+    async createContact(opts) {
+        const out = await this.contacts.insertOneContact(opts);
+        const id = requiredOperationID(out, msgCreatedContactIDMissing);
+        return await this.findContact(id);
+    }
+    async replaceContact(opts) {
+        await this.contacts.replaceOneContact(opts);
+        return await this.findContact(opts.id);
+    }
     async loadContactIndex(opts) {
         const owner_id = opts.owner_id.trim();
         if (owner_id === "") {
@@ -101,7 +114,7 @@ export class ContactsFX {
                 msg: msgRelationUpgradeInvalid,
             });
         }
-        return await this.replaceContact(opts.contact, {
+        return await this.replaceContactResult(opts.contact, {
             is_pending: true,
             relation: opts.contact.relation,
             requested_relation: opts.requested_relation,
@@ -115,7 +128,7 @@ export class ContactsFX {
                 msg: msgRelationDowngradeInvalid,
             });
         }
-        return await this.replaceContact(opts.contact, {
+        return await this.replaceContactResult(opts.contact, {
             is_pending: false,
             relation: opts.relation,
             requested_relation: Na,
@@ -129,7 +142,7 @@ export class ContactsFX {
                 msg: msgPendingRelationRequired,
             });
         }
-        return await this.replaceContact(opts.contact, {
+        return await this.replaceContactResult(opts.contact, {
             is_pending: false,
             relation: opts.contact.requested_relation,
             requested_relation: Na,
@@ -137,19 +150,19 @@ export class ContactsFX {
         });
     }
     async rejectContactRequest(opts) {
-        return await this.replaceContact(opts.contact, {
+        return await this.replaceContactResult(opts.contact, {
             is_archived: true,
         });
     }
     async endHireRelation(opts) {
-        return await this.replaceContact(opts.contact, {
+        return await this.replaceContactResult(opts.contact, {
             is_pending: false,
             relation: OldHire,
             requested_relation: Na,
             is_archived: false,
         });
     }
-    async replaceContact(contact, overrides) {
+    async replaceContactResult(contact, overrides) {
         return await this.contacts.replaceOneContact({
             id: contact.id,
             in: {
@@ -162,6 +175,19 @@ export class ContactsFX {
             },
         });
     }
+    async findContact(id) {
+        const out = await this.contacts.findOneContact({
+            id,
+        });
+        const contact = out.value;
+        if (contact === undefined) {
+            throw errResolveFailed({
+                resource: resourceContact,
+                msg: msgContactMissing,
+            });
+        }
+        return contact;
+    }
 }
 export function newContactsFX(opts) {
     return new ContactsFX(opts);

package/dist/src/core/id.d.ts

@@ -0,0 +1,3 @@
+import { type OperationResult } from "@fabriktor/schema";
+export declare function requiredOperationID(out: OperationResult, msg: string): string;
+export declare function resolvedID(value?: string): string | undefined;

package/dist/src/core/id.js

@@ -0,0 +1,24 @@
+// Copyright (C) Fabriktor, Inc. 2025-present.
+//
+// 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 { IDKey, ZeroID } from "@fabriktor/schema";
+import { errResolveFailed } from "./err.js";
+export function requiredOperationID(out, msg) {
+    const id = resolvedID(out.id);
+    if (id === undefined) {
+        throw errResolveFailed({
+            resource: IDKey,
+            msg,
+        });
+    }
+    return id;
+}
+export function resolvedID(value) {
+    const id = value?.trim();
+    if (id === undefined || id === "" || id === ZeroID) {
+        return undefined;
+    }
+    return id;
+}