@fabriktor/fx 0.0.39 → 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,12 +1,29 @@
 import type { ChatOperator, WSCloseHandler, WSConnection, WSErrorHandler, WSMessageHandler } from "@fabriktor/client";
-import { type Chat, type ChatRoom, type ChatRoomMember } from "@fabriktor/schema";
+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;
@@ -77,6 +94,8 @@ export type GlobalChatRoomsSession = {
 };
 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>;
@@ -91,6 +110,8 @@ 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>;

package/dist/src/chat/chat.js

@@ -3,17 +3,17 @@
 // 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 { errResolveFailed, 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 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 msgSearchQueryRequired = "Search query is required.";
 const msgChatObjectsUploading = "Cannot react to a chat while objects are still uploading.";
 export class ChatFX {
     chat;
@@ -22,12 +22,37 @@ export class ChatFX {
     }
     async createChat(opts) {
         const out = await this.chat.insertOneChat(opts);
-        const id = requiredOperationID(out, {
-            resource: resourceChatID,
-            msg: msgCreatedChatIDMissing,
-        });
+        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,
@@ -395,20 +420,3 @@ 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/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;
+}

package/dist/src/feed/feed.d.ts

@@ -1,10 +1,17 @@
-import { type FeedObject, type FeedPost, type OperationResult, type RPFeedPull } from "@fabriktor/schema";
+import { type FeedFavorite, type FeedObject, type FeedPost, type FeedReaction, type OperationResult, type RPFeedPull } from "@fabriktor/schema";
 import type { FeedOperator, OperationResultOf, StorageUploadFile } from "@fabriktor/client";
 import { type PullSession, type PullSessionErrorHandler } from "../core/pull.js";
+import { type SearchPage } from "../core/search.js";
 import { type StorageFXOperator, type StoragePersonalBoxUploadResult } from "../storage/storage.js";
 type FeedPullOptions = Parameters<FeedOperator["pull"]>[0];
-type FeedPostInsert = Parameters<FeedOperator["insertOneFeedPost"]>[0]["in"];
-type FeedReactionInsert = Parameters<FeedOperator["insertOneFeedReaction"]>[0]["in"];
+type FeedPostInsertOptions = Parameters<FeedOperator["insertOneFeedPost"]>[0];
+type FeedPostReplaceOptions = Parameters<FeedOperator["replaceOneFeedPost"]>[0];
+type FeedReactionInsertOptions = Parameters<FeedOperator["insertOneFeedReaction"]>[0];
+type FeedReactionReplaceOptions = Parameters<FeedOperator["replaceOneFeedReaction"]>[0];
+type FeedFavoriteInsertOptions = Parameters<FeedOperator["insertOneFeedFavorite"]>[0];
+type FeedFavoriteReplaceOptions = Parameters<FeedOperator["replaceOneFeedFavorite"]>[0];
+type FeedPostInsert = FeedPostInsertOptions["in"];
+type FeedReactionInsert = FeedReactionInsertOptions["in"];
 export declare const FeedAction: {
     readonly Reaction: "reaction";
     readonly Favorite: "favorite";
@@ -23,6 +30,18 @@ export declare const FeedMediaPostStatus: {
 };
 export type FeedMediaPostStatus = (typeof FeedMediaPostStatus)[keyof typeof FeedMediaPostStatus];
 export type FeedReactionType = FeedReactionInsert["reaction_type"];
+export type CreateFeedPostOptions = FeedPostInsertOptions;
+export type ReplaceFeedPostOptions = FeedPostReplaceOptions;
+export type CreateFeedReactionOptions = FeedReactionInsertOptions;
+export type ReplaceFeedReactionOptions = FeedReactionReplaceOptions;
+export type CreateFeedFavoriteOptions = FeedFavoriteInsertOptions;
+export type ReplaceFeedFavoriteOptions = FeedFavoriteReplaceOptions;
+export type SearchFeedPostsOptions = {
+    q?: string;
+    page?: number;
+    per_page?: number;
+};
+export type SearchFeedPostsPage = SearchPage<FeedPost>;
 export type FeedPullContext = Pick<FeedPullOptions, "contact_ids" | "pull_type" | "entity_id" | "research">;
 export type FeedTextPostContent = Pick<FeedPostInsert, "text">;
 export type FeedMediaPostInput = Pick<FeedPostInsert, "text" | "visibility">;
@@ -117,6 +136,13 @@ export type CreateFeedPostWithMediaResult = {
     error: unknown;
 };
 export interface FeedFXOperator {
+    createFeedPost(opts: CreateFeedPostOptions): Promise<FeedPost>;
+    replaceFeedPost(opts: ReplaceFeedPostOptions): Promise<FeedPost>;
+    searchFeedPosts(opts: SearchFeedPostsOptions): Promise<SearchFeedPostsPage>;
+    createFeedReaction(opts: CreateFeedReactionOptions): Promise<FeedReaction>;
+    replaceFeedReaction(opts: ReplaceFeedReactionOptions): Promise<FeedReaction>;
+    createFeedFavorite(opts: CreateFeedFavoriteOptions): Promise<FeedFavorite>;
+    replaceFeedFavorite(opts: ReplaceFeedFavoriteOptions): Promise<FeedFavorite>;
     startSession(opts: StartFeedSessionOptions): Promise<FeedSession>;
     addReaction(opts: AddFeedReactionOptions): Promise<OperationResult>;
     removeReaction(opts: RemoveFeedReactionOptions): Promise<OperationResult>;
@@ -139,6 +165,13 @@ export declare class FeedFX implements FeedFXOperator {
     private removed_actions;
     private action_ids;
     constructor(opts: FeedFXOptions);
+    createFeedPost(opts: CreateFeedPostOptions): Promise<FeedPost>;
+    replaceFeedPost(opts: ReplaceFeedPostOptions): Promise<FeedPost>;
+    searchFeedPosts(opts: SearchFeedPostsOptions): Promise<SearchFeedPostsPage>;
+    createFeedReaction(opts: CreateFeedReactionOptions): Promise<FeedReaction>;
+    replaceFeedReaction(opts: ReplaceFeedReactionOptions): Promise<FeedReaction>;
+    createFeedFavorite(opts: CreateFeedFavoriteOptions): Promise<FeedFavorite>;
+    replaceFeedFavorite(opts: ReplaceFeedFavoriteOptions): Promise<FeedFavorite>;
     startSession(opts: StartFeedSessionOptions): Promise<FeedSession>;
     addReaction(opts: AddFeedReactionOptions): Promise<OperationResult>;
     removeReaction(opts: RemoveFeedReactionOptions): Promise<OperationResult>;
@@ -152,6 +185,9 @@ export declare class FeedFX implements FeedFXOperator {
     createReplyWithMedia(opts: CreateFeedReplyWithMediaOptions): Promise<CreateFeedPostWithMediaResult>;
     createReferenceWithMedia(opts: CreateFeedReferenceWithMediaOptions): Promise<CreateFeedPostWithMediaResult>;
     private createMediaPost;
+    private findFeedPost;
+    private findFeedReaction;
+    private findFeedFavorite;
     private runAction;
     private hasAction;
     private actionID;

package/dist/src/feed/feed.js

@@ -5,11 +5,16 @@
 // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
 import { All, ColStorageFeed, PullTypeKeepAlive, ZeroID, } from "@fabriktor/schema";
 import { errResolveFailed, errValidation } from "../core/err.js";
+import { requiredOperationID, resolvedID } from "../core/id.js";
 import { newPullSession, } from "../core/pull.js";
+import { runSearch } from "../core/search.js";
 import { StorageUploadModeration, } from "../storage/storage.js";
 const newFeedSessionToken = "";
 const resourceFeedSessionToken = "feed_session_token";
 const resourceFeedPostID = "feed_post_id";
+const resourceFeedPost = "feed_post";
+const resourceFeedReaction = "feed_reaction";
+const resourceFeedFavorite = "feed_favorite";
 const resourceFeedObject = "feed_object";
 const msgKeepAliveIntervalInvalid = "Keep-alive interval must be a finite number greater than zero.";
 const msgFeedSessionClosed = "Feed session is closed.";
@@ -17,6 +22,11 @@ const msgFeedPullInProgress = "A feed pull is already in progress.";
 const msgFeedSessionTokenMissing = "Feed pull response did not contain a session token.";
 const msgFeedPostIDMissing = "Feed post does not contain an ID.";
 const msgFeedCreatedPostIDMissing = "Created feed post response did not contain an ID.";
+const msgFeedPostMissing = "Feed post could not be resolved after the mutation.";
+const msgCreatedFeedReactionIDMissing = "Created feed reaction response did not contain an ID.";
+const msgFeedReactionResolveMissing = "Feed reaction could not be resolved after the mutation.";
+const msgCreatedFeedFavoriteIDMissing = "Created feed favorite response did not contain an ID.";
+const msgFeedFavoriteResolveMissing = "Feed favorite could not be resolved after the mutation.";
 const msgFeedActionInProgress = "This feed action is already in progress for the post.";
 const msgFeedReactionAlreadyExists = "A reaction already exists for this post.";
 const msgFeedReactionMissing = "No reaction exists for this post.";
@@ -63,6 +73,42 @@ export class FeedFX {
         this.removed_actions = new Map();
         this.action_ids = new Map();
     }
+    async createFeedPost(opts) {
+        const out = await this.feed.insertOneFeedPost(opts);
+        const id = requiredOperationID(out, msgFeedCreatedPostIDMissing);
+        return await this.findFeedPost(id);
+    }
+    async replaceFeedPost(opts) {
+        await this.feed.replaceOneFeedPost(opts);
+        return await this.findFeedPost(opts.id);
+    }
+    async searchFeedPosts(opts) {
+        return await runSearch({
+            search: (searchOpts) => this.feed.searchManyFeedPosts(searchOpts),
+            query: {},
+            q: opts.q,
+            page: opts.page,
+            per_page: opts.per_page,
+        });
+    }
+    async createFeedReaction(opts) {
+        const out = await this.feed.insertOneFeedReaction(opts);
+        const id = requiredOperationID(out, msgCreatedFeedReactionIDMissing);
+        return await this.findFeedReaction(id);
+    }
+    async replaceFeedReaction(opts) {
+        await this.feed.replaceOneFeedReaction(opts);
+        return await this.findFeedReaction(opts.id);
+    }
+    async createFeedFavorite(opts) {
+        const out = await this.feed.insertOneFeedFavorite(opts);
+        const id = requiredOperationID(out, msgCreatedFeedFavoriteIDMissing);
+        return await this.findFeedFavorite(id);
+    }
+    async replaceFeedFavorite(opts) {
+        await this.feed.replaceOneFeedFavorite(opts);
+        return await this.findFeedFavorite(opts.id);
+    }
     async startSession(opts) {
         const { on_error, ...context } = opts;
         const initial = await this.feed.pull({
@@ -432,6 +478,45 @@ export class FeedFX {
             objects,
         };
     }
+    async findFeedPost(id) {
+        const out = await this.feed.findOneFeedPost({
+            id,
+        });
+        const post = out.value;
+        if (post === undefined) {
+            throw errResolveFailed({
+                resource: resourceFeedPost,
+                msg: msgFeedPostMissing,
+            });
+        }
+        return post;
+    }
+    async findFeedReaction(id) {
+        const out = await this.feed.findOneFeedReaction({
+            id,
+        });
+        const reaction = out.value;
+        if (reaction === undefined) {
+            throw errResolveFailed({
+                resource: resourceFeedReaction,
+                msg: msgFeedReactionResolveMissing,
+            });
+        }
+        return reaction;
+    }
+    async findFeedFavorite(id) {
+        const out = await this.feed.findOneFeedFavorite({
+            id,
+        });
+        const favorite = out.value;
+        if (favorite === undefined) {
+            throw errResolveFailed({
+                resource: resourceFeedFavorite,
+                msg: msgFeedFavoriteResolveMissing,
+            });
+        }
+        return favorite;
+    }
     async runAction(post_id, action, fn) {
         if (this.isActionRunning(post_id, action)) {
             throw errValidation({
@@ -582,13 +667,6 @@ function selfActionID(post, action) {
             return resolvedID(post.self?.reference_id);
     }
 }
-function resolvedID(v) {
-    const out = resolvedValue(v);
-    if (out === undefined || out === ZeroID) {
-        return undefined;
-    }
-    return out;
-}
 function resolvedValue(v) {
     const out = v?.trim();
     if (out === undefined || out.length === 0) {

package/dist/src/fulfillments/fulfillments.d.ts

@@ -0,0 +1,32 @@
+import type { FulfillmentsOperator } from "@fabriktor/client";
+import { type FulfillOrder } from "@fabriktor/schema";
+import { type SearchPage } from "../core/search.js";
+type FulfillOrderInsertOptions = Parameters<FulfillmentsOperator["insertOneFulfillOrder"]>[0];
+type FulfillOrderReplaceOptions = Parameters<FulfillmentsOperator["replaceOneFulfillOrder"]>[0];
+export type CreateFulfillOrderOptions = FulfillOrderInsertOptions;
+export type ReplaceFulfillOrderOptions = FulfillOrderReplaceOptions;
+export type SearchFulfillOrdersOptions = {
+    owner_id: string;
+    q?: string;
+    page?: number;
+    per_page?: number;
+};
+export type SearchFulfillOrdersPage = SearchPage<FulfillOrder>;
+export type FulfillmentsFXOptions = {
+    fulfillments: FulfillmentsOperator;
+};
+export interface FulfillmentsFXOperator {
+    createFulfillOrder(opts: CreateFulfillOrderOptions): Promise<FulfillOrder>;
+    replaceFulfillOrder(opts: ReplaceFulfillOrderOptions): Promise<FulfillOrder>;
+    searchFulfillOrders(opts: SearchFulfillOrdersOptions): Promise<SearchFulfillOrdersPage>;
+}
+export declare class FulfillmentsFX implements FulfillmentsFXOperator {
+    private fulfillments;
+    constructor(opts: FulfillmentsFXOptions);
+    createFulfillOrder(opts: CreateFulfillOrderOptions): Promise<FulfillOrder>;
+    replaceFulfillOrder(opts: ReplaceFulfillOrderOptions): Promise<FulfillOrder>;
+    searchFulfillOrders(opts: SearchFulfillOrdersOptions): Promise<SearchFulfillOrdersPage>;
+    private findFulfillOrder;
+}
+export declare function newFulfillmentsFX(opts: FulfillmentsFXOptions): FulfillmentsFX;
+export {};

package/dist/src/fulfillments/fulfillments.js

@@ -0,0 +1,54 @@
+// 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 { OwnerIDKey } from "@fabriktor/schema";
+import { errResolveFailed } from "../core/err.js";
+import { requiredOperationID } from "../core/id.js";
+import { runSearch } from "../core/search.js";
+const resourceFulfillOrder = "fulfill_order";
+const msgCreatedFulfillOrderIDMissing = "Created fulfill order response did not contain an ID.";
+const msgFulfillOrderMissing = "Fulfill order could not be resolved after the mutation.";
+export class FulfillmentsFX {
+    fulfillments;
+    constructor(opts) {
+        this.fulfillments = opts.fulfillments;
+    }
+    async createFulfillOrder(opts) {
+        const out = await this.fulfillments.insertOneFulfillOrder(opts);
+        const id = requiredOperationID(out, msgCreatedFulfillOrderIDMissing);
+        return await this.findFulfillOrder(id);
+    }
+    async replaceFulfillOrder(opts) {
+        await this.fulfillments.replaceOneFulfillOrder(opts);
+        return await this.findFulfillOrder(opts.id);
+    }
+    async searchFulfillOrders(opts) {
+        return await runSearch({
+            search: (searchOpts) => this.fulfillments.searchManyFulfillOrders(searchOpts),
+            query: {
+                [OwnerIDKey]: opts.owner_id,
+            },
+            q: opts.q,
+            page: opts.page,
+            per_page: opts.per_page,
+        });
+    }
+    async findFulfillOrder(id) {
+        const out = await this.fulfillments.findOneFulfillOrder({
+            id,
+        });
+        const fulfill_order = out.value;
+        if (fulfill_order === undefined) {
+            throw errResolveFailed({
+                resource: resourceFulfillOrder,
+                msg: msgFulfillOrderMissing,
+            });
+        }
+        return fulfill_order;
+    }
+}
+export function newFulfillmentsFX(opts) {
+    return new FulfillmentsFX(opts);
+}