@fabriktor/fx 0.0.37 → 0.0.39

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

@@ -1,5 +1,8 @@
-import { type Chat, type ChatRoom, type ChatRoomMember } from "@fabriktor/schema";
 import type { ChatOperator, WSCloseHandler, WSConnection, WSErrorHandler, WSMessageHandler } from "@fabriktor/client";
+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,40 +3,50 @@
 // 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 { SearchPageKey, SearchPerPageKey, SearchResultResultsKey, } from "@fabriktor/schema";
-import { errValidation } from "../core/err.js";
-const firstPage = 1;
-const defaultPerPage = 30;
+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,
-            next_page: normalizePage(opts.page),
-            per_page: normalizePerPage(opts.per_page),
+            next_page: normalizeSearchPage(opts.page),
+            per_page: normalizeSearchPerPage(opts.per_page),
             done: false,
         };
     }
     async latestChats(opts) {
-        const page = normalizePage(opts.page);
-        const per_page = normalizePerPage(opts.per_page);
-        const raw = await this.chat.searchManyChats({
+        const raw = await runSearch({
+            search: (searchOpts) => this.chat.searchManyChats(searchOpts),
             query: {
                 chat_room_id: opts.chat_room_id,
-                [SearchPageKey]: page,
-                [SearchPerPageKey]: per_page,
             },
+            page: opts.page,
+            per_page: opts.per_page,
         });
         return latestChatsPage({
             chat_room_id: opts.chat_room_id,
-            page,
-            per_page,
             raw,
         });
     }
@@ -50,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: {
@@ -71,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);
             },
         };
     }
@@ -100,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);
             },
         };
     }
@@ -126,34 +228,156 @@ 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);
 }
 function latestChatsPage(opts) {
-    const value = opts.raw.value;
-    const chats = value?.[SearchResultResultsKey] ?? [];
-    const total_count = value?.total_count;
-    const last_page = value?.last_page;
-    const has_more = hasMoreChats({
-        chats,
-        page: opts.page,
-        per_page: opts.per_page,
-        total_count,
-        last_page,
-    });
     return {
-        chats,
-        page: opts.page,
-        per_page: opts.per_page,
-        total_count,
-        last_page,
-        has_more,
+        chats: opts.raw.results,
+        page: opts.raw.page,
+        per_page: opts.raw.per_page,
+        total_count: opts.raw.total_count,
+        last_page: opts.raw.last_page,
+        has_more: opts.raw.has_more,
         next_cursor: {
             chat_room_id: opts.chat_room_id,
-            next_page: has_more ? opts.page + 1 : opts.page,
-            per_page: opts.per_page,
-            done: !has_more,
+            next_page: opts.raw.next_page,
+            per_page: opts.raw.per_page,
+            done: opts.raw.done,
         },
     };
 }
@@ -166,29 +390,25 @@ function emptyLatestChatsPage(cursor) {
         next_cursor: cursor,
     };
 }
-function hasMoreChats(opts) {
-    if (opts.last_page !== undefined) {
-        return opts.page < opts.last_page;
-    }
-    if (opts.total_count !== undefined) {
-        return opts.page * opts.per_page < opts.total_count;
-    }
-    return opts.chats.length >= opts.per_page;
-}
 function closeWS(conns, code, reason) {
     for (const conn of conns) {
         conn.close(code, reason);
     }
 }
-function normalizePage(v) {
-    if (v === undefined || !Number.isFinite(v)) {
-        return firstPage;
+function requiredOperationID(out, opts) {
+    const id = resolvedID(out.id);
+    if (id === undefined) {
+        throw errResolveFailed({
+            resource: opts.resource,
+            msg: opts.msg,
+        });
     }
-    return Math.max(firstPage, Math.trunc(v));
+    return id;
 }
-function normalizePerPage(v) {
-    if (v === undefined || !Number.isFinite(v)) {
-        return defaultPerPage;
+function resolvedID(value) {
+    const id = value?.trim();
+    if (id === undefined || id === "" || id === ZeroID) {
+        return undefined;
     }
-    return Math.max(1, Math.trunc(v));
+    return id;
 }

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

@@ -0,0 +1,24 @@
+import type { OperationResultOf, SearchManyOptionsCRUD, SearchResultOf } from "@fabriktor/client";
+export type SearchQuery = NonNullable<SearchManyOptionsCRUD["query"]>;
+export type SearchCall<T> = (opts: SearchManyOptionsCRUD) => Promise<OperationResultOf<SearchResultOf<T>>>;
+export type RunSearchOptions<T> = {
+    search: SearchCall<T>;
+    query?: SearchQuery;
+    q?: string;
+    page?: number;
+    per_page?: number;
+};
+export type SearchPage<T> = {
+    results: T[];
+    page: number;
+    per_page: number;
+    total_count?: number;
+    last_page?: number;
+    has_more: boolean;
+    next_page: number;
+    done: boolean;
+};
+export declare function runSearch<T>(opts: RunSearchOptions<T>): Promise<SearchPage<T>>;
+export declare function normalizeSearchPage(value?: number): number;
+export declare function normalizeSearchPerPage(value?: number): number;
+export declare function normalizeSearchQuery(value?: string): string | undefined;

package/dist/src/core/search.js

@@ -0,0 +1,84 @@
+// 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 { SearchPageKey, SearchPerPageKey, SearchQueryKey, SearchResultResultsKey, } from "@fabriktor/schema";
+const firstSearchPage = 1;
+const defaultSearchPerPage = 30;
+export async function runSearch(opts) {
+    const page = normalizeSearchPage(opts.page);
+    const per_page = normalizeSearchPerPage(opts.per_page);
+    const q = normalizeSearchQuery(opts.q);
+    const query = q === undefined
+        ? {
+            ...opts.query,
+            [SearchPageKey]: page,
+            [SearchPerPageKey]: per_page,
+        }
+        : {
+            ...opts.query,
+            [SearchPageKey]: page,
+            [SearchPerPageKey]: per_page,
+            [SearchQueryKey]: q,
+        };
+    const raw = await opts.search({
+        query,
+    });
+    return resolveSearchPage({
+        raw,
+        page,
+        per_page,
+    });
+}
+export function normalizeSearchPage(value) {
+    if (value === undefined || !Number.isFinite(value)) {
+        return firstSearchPage;
+    }
+    return Math.max(firstSearchPage, Math.trunc(value));
+}
+export function normalizeSearchPerPage(value) {
+    if (value === undefined || !Number.isFinite(value)) {
+        return defaultSearchPerPage;
+    }
+    return Math.max(1, Math.trunc(value));
+}
+export function normalizeSearchQuery(value) {
+    const query = value?.trim();
+    if (!query) {
+        return undefined;
+    }
+    return query;
+}
+function resolveSearchPage(opts) {
+    const value = opts.raw.value;
+    const results = value?.[SearchResultResultsKey] ?? [];
+    const total_count = value?.total_count;
+    const last_page = value?.last_page;
+    const has_more = hasMoreSearchResults({
+        result_count: results.length,
+        page: opts.page,
+        per_page: opts.per_page,
+        total_count,
+        last_page,
+    });
+    return {
+        results,
+        page: opts.page,
+        per_page: opts.per_page,
+        total_count,
+        last_page,
+        has_more,
+        next_page: has_more ? opts.page + 1 : opts.page,
+        done: !has_more,
+    };
+}
+function hasMoreSearchResults(opts) {
+    if (opts.last_page !== undefined) {
+        return opts.page < opts.last_page;
+    }
+    if (opts.total_count !== undefined) {
+        return opts.page * opts.per_page < opts.total_count;
+    }
+    return opts.result_count >= opts.per_page;
+}

package/dist/src/index.d.ts

@@ -5,6 +5,7 @@ export * from "./chat/chat.js";
 export * from "./contacts/contacts.js";
 export * from "./core/err.js";
 export * from "./core/pull.js";
+export * from "./core/search.js";
 export * from "./feed/feed.js";
 export * from "./fx.js";
 export * from "./jobs/jobs.js";

package/dist/src/index.js

@@ -5,6 +5,7 @@ export * from "./chat/chat.js";
 export * from "./contacts/contacts.js";
 export * from "./core/err.js";
 export * from "./core/pull.js";
+export * from "./core/search.js";
 export * from "./feed/feed.js";
 export * from "./fx.js";
 export * from "./jobs/jobs.js";

package/dist/src/memos/memos.d.ts

@@ -1,5 +1,6 @@
 import type { MemosOperator } from "@fabriktor/client";
 import { type Memo, type MemoFolder } from "@fabriktor/schema";
+import { type SearchPage } from "../core/search.js";
 type MemoInsertOptions = Parameters<MemosOperator["insertOneMemo"]>[0];
 type MemoReplaceOptions = Parameters<MemosOperator["replaceOneMemo"]>[0];
 type MemoFolderInsertOptions = Parameters<MemosOperator["insertOneMemoFolder"]>[0];
@@ -8,11 +9,27 @@ export type CreateMemoOptions = MemoInsertOptions;
 export type ReplaceMemoOptions = MemoReplaceOptions;
 export type CreateMemoFolderOptions = MemoFolderInsertOptions;
 export type ReplaceMemoFolderOptions = MemoFolderReplaceOptions;
+export type SearchMemosOptions = {
+    owner_id: string;
+    q?: string;
+    page?: number;
+    per_page?: number;
+};
+export type SearchMemoFoldersOptions = {
+    owner_id: string;
+    q?: string;
+    page?: number;
+    per_page?: number;
+};
+export type SearchMemosPage = SearchPage<Memo>;
+export type SearchMemoFoldersPage = SearchPage<MemoFolder>;
 export interface MemosFXOperator {
     createMemo(opts: CreateMemoOptions): Promise<Memo>;
     replaceMemo(opts: ReplaceMemoOptions): Promise<Memo>;
     createMemoFolder(opts: CreateMemoFolderOptions): Promise<MemoFolder>;
     replaceMemoFolder(opts: ReplaceMemoFolderOptions): Promise<MemoFolder>;
+    searchMemos(opts: SearchMemosOptions): Promise<SearchMemosPage>;
+    searchMemoFolders(opts: SearchMemoFoldersOptions): Promise<SearchMemoFoldersPage>;
 }
 export type MemosFXOptions = {
     memos: MemosOperator;
@@ -24,6 +41,8 @@ export declare class MemosFX implements MemosFXOperator {
     replaceMemo(opts: ReplaceMemoOptions): Promise<Memo>;
     createMemoFolder(opts: CreateMemoFolderOptions): Promise<MemoFolder>;
     replaceMemoFolder(opts: ReplaceMemoFolderOptions): Promise<MemoFolder>;
+    searchMemos(opts: SearchMemosOptions): Promise<SearchMemosPage>;
+    searchMemoFolders(opts: SearchMemoFoldersOptions): Promise<SearchMemoFoldersPage>;
     private findMemo;
     private findMemoFolder;
 }

package/dist/src/memos/memos.js

@@ -3,8 +3,9 @@
 // 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 { ZeroID, } from "@fabriktor/schema";
+import { OwnerIDKey, ZeroID, } from "@fabriktor/schema";
 import { errResolveFailed } from "../core/err.js";
+import { runSearch } from "../core/search.js";
 const resourceMemoID = "memo_id";
 const resourceMemo = "memo";
 const resourceMemoFolderID = "memo_folder_id";
@@ -42,6 +43,28 @@ export class MemosFX {
         await this.memos.replaceOneMemoFolder(opts);
         return await this.findMemoFolder(opts.id);
     }
+    async searchMemos(opts) {
+        return await runSearch({
+            search: (searchOpts) => this.memos.searchManyMemos(searchOpts),
+            query: {
+                [OwnerIDKey]: opts.owner_id,
+            },
+            q: opts.q,
+            page: opts.page,
+            per_page: opts.per_page,
+        });
+    }
+    async searchMemoFolders(opts) {
+        return await runSearch({
+            search: (searchOpts) => this.memos.searchManyMemoFolders(searchOpts),
+            query: {
+                [OwnerIDKey]: opts.owner_id,
+            },
+            q: opts.q,
+            page: opts.page,
+            per_page: opts.per_page,
+        });
+    }
     async findMemo(id) {
         const out = await this.memos.findOneMemo({
             id,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fabriktor/fx",
-  "version": "0.0.37",
+  "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.43",
-    "@fabriktor/schema": "0.0.31"
+    "@fabriktor/client": "0.0.45",
+    "@fabriktor/schema": "0.0.32"
   }
 }