@fabriktor/fx 0.0.32 → 0.0.33

package/dist/src/feed/feed.js

@@ -0,0 +1,642 @@
+// 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 { All, ColStorageFeed, PullTypeKeepAlive, ZeroID, } from "@fabriktor/schema";
+import { errResolveFailed, errValidation } from "../core/err.js";
+import { newPullSession, } from "../core/pull.js";
+import { StorageUploadModeration, } from "../storage/storage.js";
+const newFeedSessionToken = "";
+const resourceFeedSessionToken = "feed_session_token";
+const resourceFeedPostID = "feed_post_id";
+const resourceFeedObject = "feed_object";
+const msgKeepAliveIntervalInvalid = "Keep-alive interval must be a finite number greater than zero.";
+const msgFeedSessionClosed = "Feed session is closed.";
+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 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.";
+const msgFeedFavoriteAlreadyExists = "A favorite already exists for this post.";
+const msgFeedFavoriteMissing = "No favorite exists for this post.";
+const msgFeedReplyAlreadyExists = "A reply already exists for this post.";
+const msgFeedReplyMissing = "No reply exists for this post.";
+const msgFeedReferenceAlreadyExists = "A reference already exists for this post.";
+const msgFeedReferenceMissing = "No reference exists for this post.";
+const msgFeedObjectsMissing = "Storage download did not return any feed objects.";
+const msgFeedObjectURLMissing = "Storage object does not contain a permanent signed URL.";
+const msgFeedObjectMIMEMissing = "Storage object does not contain a MIME prefix.";
+const msgFeedObjectCaptionMissing = "Storage object does not contain a caption embedding.";
+export const FeedAction = {
+    Reaction: "reaction",
+    Favorite: "favorite",
+    Reply: "reply",
+    Reference: "reference",
+};
+export const FeedMediaPostStatus = {
+    Complete: "complete",
+    CreateUnresolved: "create_unresolved",
+    UploadFailed: "upload_failed",
+    AllForbidden: "all_forbidden",
+    DownloadFailed: "download_failed",
+    ResolveFailed: "resolve_failed",
+    PatchFailed: "patch_failed",
+};
+export class FeedFX {
+    feed;
+    storage_fx;
+    keep_alive_interval_ms;
+    running_actions;
+    completed_actions;
+    removed_actions;
+    action_ids;
+    constructor(opts) {
+        validateFeedFXOptions(opts);
+        this.feed = opts.feed;
+        this.storage_fx = opts.storage_fx;
+        this.keep_alive_interval_ms = opts.keep_alive_interval_ms;
+        this.running_actions = new Map();
+        this.completed_actions = new Map();
+        this.removed_actions = new Map();
+        this.action_ids = new Map();
+    }
+    async startSession(opts) {
+        const { on_error, ...context } = opts;
+        const initial = await this.feed.pull({
+            ...context,
+            session_token: newFeedSessionToken,
+            is_new_session: true,
+        });
+        const session_token = feedSessionToken(initial);
+        return newPullSession({
+            initial,
+            session_token,
+            keep_alive_interval_ms: this.keep_alive_interval_ms,
+            pull_next: async (token) => {
+                return await this.feed.pull({
+                    ...context,
+                    session_token: token,
+                    is_new_session: false,
+                });
+            },
+            keep_alive: async (token) => {
+                return await this.feed.pull({
+                    contact_ids: [],
+                    session_token: token,
+                    is_new_session: false,
+                    pull_type: PullTypeKeepAlive,
+                    entity_id: "",
+                    research: "",
+                });
+            },
+            resolve_session_token: feedSessionToken,
+            closed_error: () => errValidation({
+                msg: msgFeedSessionClosed,
+            }),
+            pull_in_progress_error: () => errValidation({
+                msg: msgFeedPullInProgress,
+            }),
+            on_error,
+        });
+    }
+    async addReaction(opts) {
+        const post_id = feedPostID(opts.post);
+        if (this.hasAction(opts.post, FeedAction.Reaction)) {
+            throw errValidation({
+                field: "post",
+                msg: msgFeedReactionAlreadyExists,
+            });
+        }
+        return await this.runAction(post_id, FeedAction.Reaction, async () => {
+            const out = await this.feed.insertOneFeedReaction({
+                in: {
+                    post_id,
+                    reaction_type: opts.reaction_type,
+                },
+            });
+            this.markAction(post_id, FeedAction.Reaction, operationID(out));
+            return out;
+        });
+    }
+    async removeReaction(opts) {
+        const post_id = feedPostID(opts.post);
+        const id = this.actionID(opts.post, FeedAction.Reaction);
+        if (id === undefined) {
+            throw errValidation({
+                field: "post",
+                msg: msgFeedReactionMissing,
+            });
+        }
+        return await this.runAction(post_id, FeedAction.Reaction, async () => {
+            const out = await this.feed.deleteOneFeedReaction({
+                id,
+            });
+            this.markActionRemoved(post_id, FeedAction.Reaction);
+            return out;
+        });
+    }
+    async addFavorite(opts) {
+        const post_id = feedPostID(opts.post);
+        if (this.hasAction(opts.post, FeedAction.Favorite)) {
+            throw errValidation({
+                field: "post",
+                msg: msgFeedFavoriteAlreadyExists,
+            });
+        }
+        return await this.runAction(post_id, FeedAction.Favorite, async () => {
+            const out = await this.feed.insertOneFeedFavorite({
+                in: {
+                    post_id,
+                },
+            });
+            this.markAction(post_id, FeedAction.Favorite, operationID(out));
+            return out;
+        });
+    }
+    async removeFavorite(opts) {
+        const post_id = feedPostID(opts.post);
+        const id = this.actionID(opts.post, FeedAction.Favorite);
+        if (id === undefined) {
+            throw errValidation({
+                field: "post",
+                msg: msgFeedFavoriteMissing,
+            });
+        }
+        return await this.runAction(post_id, FeedAction.Favorite, async () => {
+            const out = await this.feed.deleteOneFeedFavorite({
+                id,
+            });
+            this.markActionRemoved(post_id, FeedAction.Favorite);
+            return out;
+        });
+    }
+    async createReply(opts) {
+        const post_id = feedPostID(opts.post);
+        if (this.hasAction(opts.post, FeedAction.Reply)) {
+            throw errValidation({
+                field: "post",
+                msg: msgFeedReplyAlreadyExists,
+            });
+        }
+        return await this.runAction(post_id, FeedAction.Reply, async () => {
+            const out = await this.feed.insertOneFeedPost({
+                in: {
+                    objects: [],
+                    text: opts.in.text,
+                    is_uploading: false,
+                    has_media: false,
+                    visibility: All,
+                    referenced_post_id: ZeroID,
+                    reply_to_post_id: post_id,
+                },
+            });
+            this.markAction(post_id, FeedAction.Reply, operationID(out));
+            return out;
+        });
+    }
+    async removeReply(opts) {
+        const post_id = feedPostID(opts.post);
+        const id = this.actionID(opts.post, FeedAction.Reply);
+        if (id === undefined) {
+            throw errValidation({
+                field: "post",
+                msg: msgFeedReplyMissing,
+            });
+        }
+        return await this.runAction(post_id, FeedAction.Reply, async () => {
+            const out = await this.feed.deleteOneFeedPost({
+                id,
+            });
+            this.markActionRemoved(post_id, FeedAction.Reply);
+            return out;
+        });
+    }
+    async createReference(opts) {
+        const post_id = feedPostID(opts.post);
+        if (this.hasAction(opts.post, FeedAction.Reference)) {
+            throw errValidation({
+                field: "post",
+                msg: msgFeedReferenceAlreadyExists,
+            });
+        }
+        return await this.runAction(post_id, FeedAction.Reference, async () => {
+            const out = await this.feed.insertOneFeedPost({
+                in: {
+                    objects: [],
+                    text: opts.in.text,
+                    is_uploading: false,
+                    has_media: false,
+                    visibility: All,
+                    referenced_post_id: post_id,
+                    reply_to_post_id: ZeroID,
+                },
+            });
+            this.markAction(post_id, FeedAction.Reference, operationID(out));
+            return out;
+        });
+    }
+    async removeReference(opts) {
+        const post_id = feedPostID(opts.post);
+        const id = this.actionID(opts.post, FeedAction.Reference);
+        if (id === undefined) {
+            throw errValidation({
+                field: "post",
+                msg: msgFeedReferenceMissing,
+            });
+        }
+        return await this.runAction(post_id, FeedAction.Reference, async () => {
+            const out = await this.feed.deleteOneFeedPost({
+                id,
+            });
+            this.markActionRemoved(post_id, FeedAction.Reference);
+            return out;
+        });
+    }
+    async createPostWithMedia(opts) {
+        return await this.createMediaPost({
+            in: {
+                objects: [],
+                text: opts.in.text,
+                is_uploading: true,
+                has_media: true,
+                visibility: opts.in.visibility,
+                referenced_post_id: ZeroID,
+                reply_to_post_id: ZeroID,
+            },
+            user_id: opts.user_id,
+            uploader_id: opts.uploader_id,
+            full_quality: opts.full_quality,
+            files: opts.files,
+            save_to_personal_box: opts.save_to_personal_box,
+        });
+    }
+    async createReplyWithMedia(opts) {
+        const post_id = feedPostID(opts.post);
+        if (this.hasAction(opts.post, FeedAction.Reply)) {
+            throw errValidation({
+                field: "post",
+                msg: msgFeedReplyAlreadyExists,
+            });
+        }
+        return await this.runAction(post_id, FeedAction.Reply, async () => {
+            const out = await this.createMediaPost({
+                in: {
+                    objects: [],
+                    text: opts.in.text,
+                    is_uploading: true,
+                    has_media: true,
+                    visibility: All,
+                    referenced_post_id: ZeroID,
+                    reply_to_post_id: post_id,
+                },
+                user_id: opts.user_id,
+                uploader_id: opts.uploader_id,
+                full_quality: opts.full_quality,
+                files: opts.files,
+                save_to_personal_box: opts.save_to_personal_box,
+            });
+            const id = completedMediaPostID(out);
+            if (id !== undefined) {
+                this.markAction(post_id, FeedAction.Reply, id);
+            }
+            return out;
+        });
+    }
+    async createReferenceWithMedia(opts) {
+        const post_id = feedPostID(opts.post);
+        if (this.hasAction(opts.post, FeedAction.Reference)) {
+            throw errValidation({
+                field: "post",
+                msg: msgFeedReferenceAlreadyExists,
+            });
+        }
+        return await this.runAction(post_id, FeedAction.Reference, async () => {
+            const out = await this.createMediaPost({
+                in: {
+                    objects: [],
+                    text: opts.in.text,
+                    is_uploading: true,
+                    has_media: true,
+                    visibility: All,
+                    referenced_post_id: post_id,
+                    reply_to_post_id: ZeroID,
+                },
+                user_id: opts.user_id,
+                uploader_id: opts.uploader_id,
+                full_quality: opts.full_quality,
+                files: opts.files,
+                save_to_personal_box: opts.save_to_personal_box,
+            });
+            const id = completedMediaPostID(out);
+            if (id !== undefined) {
+                this.markAction(post_id, FeedAction.Reference, id);
+            }
+            return out;
+        });
+    }
+    async createMediaPost(opts) {
+        const create = await this.feed.insertOneFeedPost({
+            in: opts.in,
+        });
+        const post_id = operationID(create);
+        if (post_id === undefined) {
+            return {
+                status: FeedMediaPostStatus.CreateUnresolved,
+                create,
+                error: errResolveFailed({
+                    resource: resourceFeedPostID,
+                    msg: msgFeedCreatedPostIDMissing,
+                }),
+            };
+        }
+        let upload;
+        try {
+            upload = await this.storage_fx.uploadObjectsWithPersonalBox({
+                col: ColStorageFeed,
+                owner_id: post_id,
+                user_id: opts.user_id,
+                uploader_id: opts.uploader_id,
+                full_quality: opts.full_quality,
+                files: opts.files,
+                save_to_personal_box: opts.save_to_personal_box,
+            });
+        }
+        catch (err) {
+            return {
+                status: FeedMediaPostStatus.UploadFailed,
+                post_id,
+                error: err,
+            };
+        }
+        if (upload.primary.moderation === StorageUploadModeration.AllForbidden) {
+            return {
+                status: FeedMediaPostStatus.AllForbidden,
+                post_id,
+                upload,
+            };
+        }
+        let stored;
+        try {
+            stored = await this.storage_fx.downloadObjects({
+                col: ColStorageFeed,
+                owner_id: post_id,
+                expire: false,
+            });
+        }
+        catch (err) {
+            return {
+                status: FeedMediaPostStatus.DownloadFailed,
+                post_id,
+                upload,
+                error: err,
+            };
+        }
+        let objects;
+        try {
+            objects = feedObjects(stored.value ?? []);
+        }
+        catch (err) {
+            return {
+                status: FeedMediaPostStatus.ResolveFailed,
+                post_id,
+                upload,
+                error: err,
+            };
+        }
+        try {
+            await this.feed.replaceOneFeedPost({
+                id: post_id,
+                in: {
+                    ...opts.in,
+                    objects,
+                    is_uploading: false,
+                },
+            });
+        }
+        catch (err) {
+            return {
+                status: FeedMediaPostStatus.PatchFailed,
+                post_id,
+                upload,
+                objects,
+                error: err,
+            };
+        }
+        return {
+            status: FeedMediaPostStatus.Complete,
+            post_id,
+            upload,
+            objects,
+        };
+    }
+    async runAction(post_id, action, fn) {
+        if (this.isActionRunning(post_id, action)) {
+            throw errValidation({
+                msg: msgFeedActionInProgress,
+            });
+        }
+        this.setActionRunning(post_id, action, true);
+        try {
+            return await fn();
+        }
+        finally {
+            this.setActionRunning(post_id, action, false);
+        }
+    }
+    hasAction(post, action) {
+        const post_id = feedPostID(post);
+        if (this.isActionCompleted(post_id, action)) {
+            return true;
+        }
+        if (this.isActionRemoved(post_id, action)) {
+            return false;
+        }
+        return selfActionID(post, action) !== undefined;
+    }
+    actionID(post, action) {
+        const post_id = feedPostID(post);
+        if (this.isActionCompleted(post_id, action)) {
+            return this.action_ids.get(post_id)?.get(action);
+        }
+        if (this.isActionRemoved(post_id, action)) {
+            return undefined;
+        }
+        return selfActionID(post, action);
+    }
+    markAction(post_id, action, id) {
+        this.clearActionRemoved(post_id, action);
+        let completed = this.completed_actions.get(post_id);
+        if (completed === undefined) {
+            completed = new Set();
+            this.completed_actions.set(post_id, completed);
+        }
+        completed.add(action);
+        if (id === undefined) {
+            return;
+        }
+        let ids = this.action_ids.get(post_id);
+        if (ids === undefined) {
+            ids = new Map();
+            this.action_ids.set(post_id, ids);
+        }
+        ids.set(action, id);
+    }
+    markActionRemoved(post_id, action) {
+        const completed = this.completed_actions.get(post_id);
+        completed?.delete(action);
+        if (completed?.size === 0) {
+            this.completed_actions.delete(post_id);
+        }
+        const ids = this.action_ids.get(post_id);
+        ids?.delete(action);
+        if (ids?.size === 0) {
+            this.action_ids.delete(post_id);
+        }
+        let removed = this.removed_actions.get(post_id);
+        if (removed === undefined) {
+            removed = new Set();
+            this.removed_actions.set(post_id, removed);
+        }
+        removed.add(action);
+    }
+    clearActionRemoved(post_id, action) {
+        const removed = this.removed_actions.get(post_id);
+        removed?.delete(action);
+        if (removed?.size === 0) {
+            this.removed_actions.delete(post_id);
+        }
+    }
+    isActionCompleted(post_id, action) {
+        return this.completed_actions.get(post_id)?.has(action) ?? false;
+    }
+    isActionRemoved(post_id, action) {
+        return this.removed_actions.get(post_id)?.has(action) ?? false;
+    }
+    isActionRunning(post_id, action) {
+        return this.running_actions.get(post_id)?.has(action) ?? false;
+    }
+    setActionRunning(post_id, action, running) {
+        if (running) {
+            let actions = this.running_actions.get(post_id);
+            if (actions === undefined) {
+                actions = new Set();
+                this.running_actions.set(post_id, actions);
+            }
+            actions.add(action);
+            return;
+        }
+        const actions = this.running_actions.get(post_id);
+        actions?.delete(action);
+        if (actions?.size === 0) {
+            this.running_actions.delete(post_id);
+        }
+    }
+}
+export function newFeedFX(opts) {
+    return new FeedFX(opts);
+}
+function validateFeedFXOptions(opts) {
+    if (!Number.isFinite(opts.keep_alive_interval_ms) ||
+        opts.keep_alive_interval_ms <= 0) {
+        throw errValidation({
+            field: "keep_alive_interval_ms",
+            msg: msgKeepAliveIntervalInvalid,
+        });
+    }
+}
+function feedSessionToken(out) {
+    const token = resolvedValue(out.value?.session_token);
+    if (token === undefined) {
+        throw errResolveFailed({
+            resource: resourceFeedSessionToken,
+            msg: msgFeedSessionTokenMissing,
+        });
+    }
+    return token;
+}
+function feedPostID(post) {
+    const id = resolvedID(post.id);
+    if (id === undefined) {
+        throw errValidation({
+            field: "id",
+            msg: msgFeedPostIDMissing,
+        });
+    }
+    return id;
+}
+function operationID(out) {
+    return resolvedID(out.id);
+}
+function selfActionID(post, action) {
+    switch (action) {
+        case FeedAction.Reaction:
+            return resolvedID(post.self?.reaction_id);
+        case FeedAction.Favorite:
+            return resolvedID(post.self?.favorite_id);
+        case FeedAction.Reply:
+            return resolvedID(post.self?.reply_id);
+        case FeedAction.Reference:
+            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) {
+        return undefined;
+    }
+    return out;
+}
+function completedMediaPostID(out) {
+    if (out.status !== FeedMediaPostStatus.Complete) {
+        return undefined;
+    }
+    return out.post_id;
+}
+function feedObjects(objects) {
+    if (objects.length === 0) {
+        throw errResolveFailed({
+            resource: resourceFeedObject,
+            msg: msgFeedObjectsMissing,
+        });
+    }
+    const out = [];
+    for (const object of objects) {
+        const signed_url = resolvedValue(object.signed_url);
+        if (signed_url === undefined) {
+            throw errResolveFailed({
+                resource: resourceFeedObject,
+                msg: msgFeedObjectURLMissing,
+            });
+        }
+        const mime_prefix = resolvedValue(object.mime_prefix);
+        if (mime_prefix === undefined) {
+            throw errResolveFailed({
+                resource: resourceFeedObject,
+                msg: msgFeedObjectMIMEMissing,
+            });
+        }
+        const embedding = object.caption;
+        if (embedding === undefined) {
+            throw errResolveFailed({
+                resource: resourceFeedObject,
+                msg: msgFeedObjectCaptionMissing,
+            });
+        }
+        out.push({
+            signed_url,
+            mime_prefix,
+            embedding,
+        });
+    }
+    return out;
+}