@fabriktor/fx 0.0.32 → 0.0.33

package/dist/src/billable/billable.d.ts

@@ -1,28 +1,29 @@
-import type { InBill, OperationResult, PLBillablePeriodsFromDates, PLBillableSetItemQuantity, PLBillableVendorInvoiceFromBill, PLBillableYearSpan, RPBillablePeriodsFromDates, YearSpan } from "@fabriktor/schema";
+import type { OperationResult, RPBillablePeriodsFromDates, YearSpan } from "@fabriktor/schema";
 import type { BillableOperator, OperationResultOf } from "@fabriktor/client";
+type GenerateBillPayload = Parameters<BillableOperator["generateBill"]>[0];
 export type BillableFXOptions = {
     billable: BillableOperator;
 };
 export type GenerateFixedEstimateOptions = {
-    in: InBill;
+    in: GenerateBillPayload;
 };
 export type AcceptFixedEstimateOptions = {
-    in: InBill;
+    in: GenerateBillPayload;
 };
 export type GenerateDynamicEstimateOptions = {
-    in: InBill;
+    in: GenerateBillPayload;
 };
 export type GenerateDynamicBillOptions = {
-    in: InBill;
+    in: GenerateBillPayload;
     exclude_billed?: boolean;
 };
 export type MarkLocationAchievedOptions = {
-    in: InBill;
+    in: GenerateBillPayload;
 };
-export type YearSpanOptions = PLBillableYearSpan;
-export type PeriodsFromDatesOptions = PLBillablePeriodsFromDates;
-export type VendorInvoiceFromBillOptions = PLBillableVendorInvoiceFromBill;
-export type SetItemQuantityOptions = PLBillableSetItemQuantity;
+export type YearSpanOptions = Parameters<BillableOperator["yearSpan"]>[0];
+export type PeriodsFromDatesOptions = Parameters<BillableOperator["periodsFromDates"]>[0];
+export type VendorInvoiceFromBillOptions = Parameters<BillableOperator["vendorInvoiceFromBill"]>[0];
+export type SetItemQuantityOptions = Parameters<BillableOperator["setItemQuantity"]>[0];
 export interface BillableFXOperator {
     generateFixedEstimate(opts: GenerateFixedEstimateOptions): Promise<OperationResult>;
     acceptFixedEstimate(opts: AcceptFixedEstimateOptions): Promise<OperationResult>;
@@ -48,3 +49,4 @@ export declare class BillableFX implements BillableFXOperator {
     setItemQuantity(opts: SetItemQuantityOptions): Promise<void>;
 }
 export declare function newBillableFX(opts: BillableFXOptions): BillableFX;
+export {};

package/dist/src/billable/billable.js

@@ -57,11 +57,10 @@ export function newBillableFX(opts) {
     return new BillableFX(opts);
 }
 function billWith(x, overrides) {
-    const out = {
+    return {
         ...x,
         ...defined(overrides),
     };
-    return out;
 }
 function defined(x) {
     const out = {};

package/dist/src/calls/calls.d.ts

@@ -1,16 +1,16 @@
-import type { PLCallsMintVideoToken, PLNotificationsRelay } from "@fabriktor/schema";
 import type { CallsOperator, NotificationsOperator } from "@fabriktor/client";
-export type MintVideoTokenOptions = PLCallsMintVideoToken;
+export type MintVideoTokenOptions = Parameters<CallsOperator["mintVideoToken"]>[0];
+export type RelayNotificationOptions = Parameters<NotificationsOperator["relayNotification"]>[0];
 export type StartCallOptions = {
     mint: MintVideoTokenOptions;
-    notification: PLNotificationsRelay;
+    notification: RelayNotificationOptions;
 };
 export type AnswerCallOptions = {
     mint: MintVideoTokenOptions;
-    self_notification: PLNotificationsRelay;
+    self_notification: RelayNotificationOptions;
 };
 export type CancelCallOptions = {
-    notification: PLNotificationsRelay;
+    notification: RelayNotificationOptions;
 };
 export type CallsFXOptions = {
     calls: CallsOperator;

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

@@ -1,5 +1,6 @@
-import { type Chat, type ChatRoom, type ChatRoomMember, type PLChatReact } from "@fabriktor/schema";
+import { type Chat, type ChatRoom, type ChatRoomMember } from "@fabriktor/schema";
 import type { ChatOperator, WSCloseHandler, WSConnection, WSErrorHandler, WSMessageHandler } from "@fabriktor/client";
+export type ReactChatOptions = Parameters<ChatOperator["reactChat"]>[0];
 export type ChatFXOptions = {
     chat: ChatOperator;
 };
@@ -49,7 +50,7 @@ export type OpenGlobalChatRoomsOptions = {
 };
 export type ReactUploadedChatOptions = {
     chat: Chat;
-    reaction: PLChatReact;
+    reaction: ReactChatOptions;
 };
 export type ChatRoomSession = {
     latest: LatestChatsPage;

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 {};