@fabriktor/fx 0.0.31 → 0.0.33

package/dist/src/core/err.js

@@ -4,12 +4,6 @@
 // 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
 const msgUnknownFXErr = "Unknown FX error.";
-const msgUnableToResolveUsername = "Unable to resolve username.";
-const msgUnableToMintVideoToken = "Unable to mint video token.";
-const msgPhoneRequired = "Phone number is required.";
-const msgPhoneCodeRequired = "Verification code is required.";
-const resourceUsername = "username";
-const resourceVideoToken = "video_token";
 export const FXErrKind = {
     Required: "required",
     Validation: "validation",
@@ -64,38 +58,6 @@ export function errResolveFailed(opts) {
         cause: opts.cause,
     });
 }
-export function errUsernameResolveFailed(field) {
-    return errResolveFailed({
-        resource: resourceUsername,
-        field,
-        msg: msgUnableToResolveUsername,
-    });
-}
-export function errVideoTokenMintFailed() {
-    return errResolveFailed({
-        resource: resourceVideoToken,
-        msg: msgUnableToMintVideoToken,
-    });
-}
-export function errUsernameInvalid(opts) {
-    return errValidation({
-        field: opts.field,
-        msg: opts.msg,
-        cause: opts.cause,
-    });
-}
-export function errPhoneRequired(field) {
-    return errRequired({
-        field,
-        msg: msgPhoneRequired,
-    });
-}
-export function errPhoneCodeRequired(field) {
-    return errRequired({
-        field,
-        msg: msgPhoneCodeRequired,
-    });
-}
 export function errUnknown(cause) {
     if (isFXErr(cause)) {
         return cause;

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

@@ -0,0 +1,39 @@
+export type PullSessionErrorHandler = (err: unknown) => void;
+export interface PullSession<TResult> {
+    readonly initial: TResult;
+    readonly sessionToken: string;
+    pullNext(): Promise<TResult>;
+    close(): void;
+}
+export type PullSessionOptions<TResult> = {
+    initial: TResult;
+    session_token: string;
+    keep_alive_interval_ms: number;
+    pull_next: (session_token: string) => Promise<TResult>;
+    keep_alive: (session_token: string) => Promise<TResult>;
+    resolve_session_token: (out: TResult) => string;
+    closed_error: () => Error;
+    pull_in_progress_error: () => Error;
+    on_error?: PullSessionErrorHandler;
+};
+export declare class DefaultPullSession<TResult> implements PullSession<TResult> {
+    readonly initial: TResult;
+    private token;
+    private closed;
+    private pulling;
+    private timer;
+    private keepAliveTask?;
+    private pullNextFn;
+    private keepAliveFn;
+    private resolveSessionToken;
+    private closedError;
+    private pullInProgressError;
+    private onError?;
+    constructor(opts: PullSessionOptions<TResult>);
+    get sessionToken(): string;
+    pullNext(): Promise<TResult>;
+    close(): void;
+    private keepAlive;
+    private runKeepAlive;
+}
+export declare function newPullSession<TResult>(opts: PullSessionOptions<TResult>): DefaultPullSession<TResult>;

package/dist/src/core/pull.js

@@ -0,0 +1,101 @@
+// 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
+export class DefaultPullSession {
+    initial;
+    token;
+    closed;
+    pulling;
+    timer;
+    keepAliveTask;
+    pullNextFn;
+    keepAliveFn;
+    resolveSessionToken;
+    closedError;
+    pullInProgressError;
+    onError;
+    constructor(opts) {
+        this.initial = opts.initial;
+        this.token = opts.session_token;
+        this.closed = false;
+        this.pulling = false;
+        this.pullNextFn = opts.pull_next;
+        this.keepAliveFn = opts.keep_alive;
+        this.resolveSessionToken = opts.resolve_session_token;
+        this.closedError = opts.closed_error;
+        this.pullInProgressError = opts.pull_in_progress_error;
+        this.onError = opts.on_error;
+        this.timer = globalThis.setInterval(() => {
+            void this.keepAlive();
+        }, opts.keep_alive_interval_ms);
+    }
+    get sessionToken() {
+        return this.token;
+    }
+    async pullNext() {
+        if (this.closed) {
+            throw this.closedError();
+        }
+        if (this.pulling) {
+            throw this.pullInProgressError();
+        }
+        this.pulling = true;
+        try {
+            const keepAliveTask = this.keepAliveTask;
+            if (keepAliveTask !== undefined) {
+                await keepAliveTask;
+            }
+            if (this.closed) {
+                throw this.closedError();
+            }
+            const out = await this.pullNextFn(this.token);
+            if (!this.closed) {
+                this.token = this.resolveSessionToken(out);
+            }
+            return out;
+        }
+        finally {
+            this.pulling = false;
+        }
+    }
+    close() {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        globalThis.clearInterval(this.timer);
+    }
+    async keepAlive() {
+        if (this.closed || this.pulling || this.keepAliveTask !== undefined) {
+            return;
+        }
+        const task = this.runKeepAlive();
+        this.keepAliveTask = task;
+        try {
+            await task;
+        }
+        finally {
+            if (this.keepAliveTask === task) {
+                this.keepAliveTask = undefined;
+            }
+        }
+    }
+    async runKeepAlive() {
+        try {
+            const out = await this.keepAliveFn(this.token);
+            if (!this.closed) {
+                this.token = this.resolveSessionToken(out);
+            }
+        }
+        catch (err) {
+            if (!this.closed) {
+                this.onError?.(err);
+            }
+        }
+    }
+}
+export function newPullSession(opts) {
+    return new DefaultPullSession(opts);
+}

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

@@ -0,0 +1,167 @@
+import { type FeedObject, type FeedPost, 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 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"];
+export declare const FeedAction: {
+    readonly Reaction: "reaction";
+    readonly Favorite: "favorite";
+    readonly Reply: "reply";
+    readonly Reference: "reference";
+};
+export type FeedAction = (typeof FeedAction)[keyof typeof FeedAction];
+export declare const FeedMediaPostStatus: {
+    readonly Complete: "complete";
+    readonly CreateUnresolved: "create_unresolved";
+    readonly UploadFailed: "upload_failed";
+    readonly AllForbidden: "all_forbidden";
+    readonly DownloadFailed: "download_failed";
+    readonly ResolveFailed: "resolve_failed";
+    readonly PatchFailed: "patch_failed";
+};
+export type FeedMediaPostStatus = (typeof FeedMediaPostStatus)[keyof typeof FeedMediaPostStatus];
+export type FeedReactionType = FeedReactionInsert["reaction_type"];
+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">;
+export type FeedPullResult = OperationResultOf<RPFeedPull>;
+export type FeedSession = PullSession<FeedPullResult>;
+export type FeedSessionErrorHandler = PullSessionErrorHandler;
+export type FeedFXOptions = {
+    feed: FeedOperator;
+    storage_fx: StorageFXOperator;
+    keep_alive_interval_ms: number;
+};
+export type StartFeedSessionOptions = FeedPullContext & {
+    on_error?: FeedSessionErrorHandler;
+};
+export type AddFeedReactionOptions = {
+    post: FeedPost;
+    reaction_type: FeedReactionType;
+};
+export type RemoveFeedReactionOptions = {
+    post: FeedPost;
+};
+export type AddFeedFavoriteOptions = {
+    post: FeedPost;
+};
+export type RemoveFeedFavoriteOptions = {
+    post: FeedPost;
+};
+export type CreateFeedReplyOptions = {
+    post: FeedPost;
+    in: FeedTextPostContent;
+};
+export type RemoveFeedReplyOptions = {
+    post: FeedPost;
+};
+export type CreateFeedReferenceOptions = {
+    post: FeedPost;
+    in: FeedTextPostContent;
+};
+export type RemoveFeedReferenceOptions = {
+    post: FeedPost;
+};
+export type FeedMediaUploadOptions = {
+    user_id?: string;
+    uploader_id?: string;
+    full_quality?: boolean;
+    files: StorageUploadFile[];
+    save_to_personal_box?: boolean;
+};
+export type CreateFeedPostWithMediaOptions = FeedMediaUploadOptions & {
+    in: FeedMediaPostInput;
+};
+export type CreateFeedReplyWithMediaOptions = FeedMediaUploadOptions & {
+    post: FeedPost;
+    in: FeedTextPostContent;
+};
+export type CreateFeedReferenceWithMediaOptions = FeedMediaUploadOptions & {
+    post: FeedPost;
+    in: FeedTextPostContent;
+};
+export type CreateFeedPostWithMediaResult = {
+    status: typeof FeedMediaPostStatus.Complete;
+    post_id: string;
+    upload: StoragePersonalBoxUploadResult;
+    objects: FeedObject[];
+} | {
+    status: typeof FeedMediaPostStatus.CreateUnresolved;
+    create: OperationResult;
+    error: unknown;
+} | {
+    status: typeof FeedMediaPostStatus.UploadFailed;
+    post_id: string;
+    error: unknown;
+} | {
+    status: typeof FeedMediaPostStatus.AllForbidden;
+    post_id: string;
+    upload: StoragePersonalBoxUploadResult;
+} | {
+    status: typeof FeedMediaPostStatus.DownloadFailed;
+    post_id: string;
+    upload: StoragePersonalBoxUploadResult;
+    error: unknown;
+} | {
+    status: typeof FeedMediaPostStatus.ResolveFailed;
+    post_id: string;
+    upload: StoragePersonalBoxUploadResult;
+    error: unknown;
+} | {
+    status: typeof FeedMediaPostStatus.PatchFailed;
+    post_id: string;
+    upload: StoragePersonalBoxUploadResult;
+    objects: FeedObject[];
+    error: unknown;
+};
+export interface FeedFXOperator {
+    startSession(opts: StartFeedSessionOptions): Promise<FeedSession>;
+    addReaction(opts: AddFeedReactionOptions): Promise<OperationResult>;
+    removeReaction(opts: RemoveFeedReactionOptions): Promise<OperationResult>;
+    addFavorite(opts: AddFeedFavoriteOptions): Promise<OperationResult>;
+    removeFavorite(opts: RemoveFeedFavoriteOptions): Promise<OperationResult>;
+    createReply(opts: CreateFeedReplyOptions): Promise<OperationResult>;
+    removeReply(opts: RemoveFeedReplyOptions): Promise<OperationResult>;
+    createReference(opts: CreateFeedReferenceOptions): Promise<OperationResult>;
+    removeReference(opts: RemoveFeedReferenceOptions): Promise<OperationResult>;
+    createPostWithMedia(opts: CreateFeedPostWithMediaOptions): Promise<CreateFeedPostWithMediaResult>;
+    createReplyWithMedia(opts: CreateFeedReplyWithMediaOptions): Promise<CreateFeedPostWithMediaResult>;
+    createReferenceWithMedia(opts: CreateFeedReferenceWithMediaOptions): Promise<CreateFeedPostWithMediaResult>;
+}
+export declare class FeedFX implements FeedFXOperator {
+    private feed;
+    private storage_fx;
+    private keep_alive_interval_ms;
+    private running_actions;
+    private completed_actions;
+    private removed_actions;
+    private action_ids;
+    constructor(opts: FeedFXOptions);
+    startSession(opts: StartFeedSessionOptions): Promise<FeedSession>;
+    addReaction(opts: AddFeedReactionOptions): Promise<OperationResult>;
+    removeReaction(opts: RemoveFeedReactionOptions): Promise<OperationResult>;
+    addFavorite(opts: AddFeedFavoriteOptions): Promise<OperationResult>;
+    removeFavorite(opts: RemoveFeedFavoriteOptions): Promise<OperationResult>;
+    createReply(opts: CreateFeedReplyOptions): Promise<OperationResult>;
+    removeReply(opts: RemoveFeedReplyOptions): Promise<OperationResult>;
+    createReference(opts: CreateFeedReferenceOptions): Promise<OperationResult>;
+    removeReference(opts: RemoveFeedReferenceOptions): Promise<OperationResult>;
+    createPostWithMedia(opts: CreateFeedPostWithMediaOptions): Promise<CreateFeedPostWithMediaResult>;
+    createReplyWithMedia(opts: CreateFeedReplyWithMediaOptions): Promise<CreateFeedPostWithMediaResult>;
+    createReferenceWithMedia(opts: CreateFeedReferenceWithMediaOptions): Promise<CreateFeedPostWithMediaResult>;
+    private createMediaPost;
+    private runAction;
+    private hasAction;
+    private actionID;
+    private markAction;
+    private markActionRemoved;
+    private clearActionRemoved;
+    private isActionCompleted;
+    private isActionRemoved;
+    private isActionRunning;
+    private setActionRunning;
+}
+export declare function newFeedFX(opts: FeedFXOptions): FeedFX;
+export {};