@fabriktor/fx 0.0.30 → 0.0.32

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

@@ -0,0 +1,50 @@
+import type { InBill, OperationResult, PLBillablePeriodsFromDates, PLBillableSetItemQuantity, PLBillableVendorInvoiceFromBill, PLBillableYearSpan, RPBillablePeriodsFromDates, YearSpan } from "@fabriktor/schema";
+import type { BillableOperator, OperationResultOf } from "@fabriktor/client";
+export type BillableFXOptions = {
+    billable: BillableOperator;
+};
+export type GenerateFixedEstimateOptions = {
+    in: InBill;
+};
+export type AcceptFixedEstimateOptions = {
+    in: InBill;
+};
+export type GenerateDynamicEstimateOptions = {
+    in: InBill;
+};
+export type GenerateDynamicBillOptions = {
+    in: InBill;
+    exclude_billed?: boolean;
+};
+export type MarkLocationAchievedOptions = {
+    in: InBill;
+};
+export type YearSpanOptions = PLBillableYearSpan;
+export type PeriodsFromDatesOptions = PLBillablePeriodsFromDates;
+export type VendorInvoiceFromBillOptions = PLBillableVendorInvoiceFromBill;
+export type SetItemQuantityOptions = PLBillableSetItemQuantity;
+export interface BillableFXOperator {
+    generateFixedEstimate(opts: GenerateFixedEstimateOptions): Promise<OperationResult>;
+    acceptFixedEstimate(opts: AcceptFixedEstimateOptions): Promise<OperationResult>;
+    generateDynamicEstimate(opts: GenerateDynamicEstimateOptions): Promise<OperationResult>;
+    generateDynamicBill(opts: GenerateDynamicBillOptions): Promise<OperationResult>;
+    markLocationAchieved(opts: MarkLocationAchievedOptions): Promise<OperationResult>;
+    yearSpan(opts: YearSpanOptions): Promise<OperationResultOf<YearSpan>>;
+    periodsFromDates(opts: PeriodsFromDatesOptions): Promise<OperationResultOf<RPBillablePeriodsFromDates>>;
+    vendorInvoiceFromBill(opts: VendorInvoiceFromBillOptions): Promise<OperationResult>;
+    setItemQuantity(opts: SetItemQuantityOptions): Promise<void>;
+}
+export declare class BillableFX implements BillableFXOperator {
+    private billable;
+    constructor(opts: BillableFXOptions);
+    generateFixedEstimate(opts: GenerateFixedEstimateOptions): Promise<OperationResult>;
+    acceptFixedEstimate(opts: AcceptFixedEstimateOptions): Promise<OperationResult>;
+    generateDynamicEstimate(opts: GenerateDynamicEstimateOptions): Promise<OperationResult>;
+    generateDynamicBill(opts: GenerateDynamicBillOptions): Promise<OperationResult>;
+    markLocationAchieved(opts: MarkLocationAchievedOptions): Promise<OperationResult>;
+    yearSpan(opts: YearSpanOptions): Promise<OperationResultOf<YearSpan>>;
+    periodsFromDates(opts: PeriodsFromDatesOptions): Promise<OperationResultOf<RPBillablePeriodsFromDates>>;
+    vendorInvoiceFromBill(opts: VendorInvoiceFromBillOptions): Promise<OperationResult>;
+    setItemQuantity(opts: SetItemQuantityOptions): Promise<void>;
+}
+export declare function newBillableFX(opts: BillableFXOptions): BillableFX;

package/dist/src/billable/billable.js

@@ -0,0 +1,74 @@
+// 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
+const billTypeFixed = "fixed";
+const billTypeDynamic = "dynamic";
+export class BillableFX {
+    billable;
+    constructor(opts) {
+        this.billable = opts.billable;
+    }
+    async generateFixedEstimate(opts) {
+        return await this.billable.generateBill(billWith(opts.in, {
+            type: billTypeFixed,
+            is_estimate: true,
+        }));
+    }
+    async acceptFixedEstimate(opts) {
+        return await this.billable.generateBill(billWith(opts.in, {
+            type: billTypeFixed,
+            is_estimate: false,
+        }));
+    }
+    async generateDynamicEstimate(opts) {
+        return await this.billable.generateBill(billWith(opts.in, {
+            type: billTypeDynamic,
+            is_estimate: true,
+        }));
+    }
+    async generateDynamicBill(opts) {
+        return await this.billable.generateBill(billWith(opts.in, {
+            type: billTypeDynamic,
+            is_estimate: false,
+            exclude_billed: opts.exclude_billed,
+        }));
+    }
+    async markLocationAchieved(opts) {
+        return await this.billable.generateBill(billWith(opts.in, {
+            is_location_achieved: true,
+        }));
+    }
+    async yearSpan(opts) {
+        return await this.billable.yearSpan(opts);
+    }
+    async periodsFromDates(opts) {
+        return await this.billable.periodsFromDates(opts);
+    }
+    async vendorInvoiceFromBill(opts) {
+        return await this.billable.vendorInvoiceFromBill(opts);
+    }
+    async setItemQuantity(opts) {
+        await this.billable.setItemQuantity(opts);
+    }
+}
+export function newBillableFX(opts) {
+    return new BillableFX(opts);
+}
+function billWith(x, overrides) {
+    const out = {
+        ...x,
+        ...defined(overrides),
+    };
+    return out;
+}
+function defined(x) {
+    const out = {};
+    for (const [k, v] of Object.entries(x)) {
+        if (v !== undefined) {
+            out[k] = v;
+        }
+    }
+    return out;
+}

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

@@ -0,0 +1,33 @@
+import type { PLCallsMintVideoToken, PLNotificationsRelay } from "@fabriktor/schema";
+import type { CallsOperator, NotificationsOperator } from "@fabriktor/client";
+export type MintVideoTokenOptions = PLCallsMintVideoToken;
+export type StartCallOptions = {
+    mint: MintVideoTokenOptions;
+    notification: PLNotificationsRelay;
+};
+export type AnswerCallOptions = {
+    mint: MintVideoTokenOptions;
+    self_notification: PLNotificationsRelay;
+};
+export type CancelCallOptions = {
+    notification: PLNotificationsRelay;
+};
+export type CallsFXOptions = {
+    calls: CallsOperator;
+    notifications: NotificationsOperator;
+};
+export interface CallsFXOperator {
+    startCall(opts: StartCallOptions): Promise<string>;
+    answerCall(opts: AnswerCallOptions): Promise<string>;
+    cancelCall(opts: CancelCallOptions): Promise<void>;
+}
+export declare class CallsFX implements CallsFXOperator {
+    private calls;
+    private notifications;
+    constructor(opts: CallsFXOptions);
+    startCall(opts: StartCallOptions): Promise<string>;
+    answerCall(opts: AnswerCallOptions): Promise<string>;
+    cancelCall(opts: CancelCallOptions): Promise<void>;
+    private requireVideoToken;
+}
+export declare function newCallsFX(opts: CallsFXOptions): CallsFX;

package/dist/src/calls/calls.js

@@ -0,0 +1,43 @@
+// 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 { errResolveFailed } from "../core/err.js";
+const resourceVideoToken = "video_token";
+const msgUnableToMintVideoToken = "Unable to mint video token.";
+export class CallsFX {
+    calls;
+    notifications;
+    constructor(opts) {
+        this.calls = opts.calls;
+        this.notifications = opts.notifications;
+    }
+    async startCall(opts) {
+        const token = await this.requireVideoToken(opts.mint);
+        await this.notifications.relayNotification(opts.notification);
+        return token;
+    }
+    async answerCall(opts) {
+        const token = await this.requireVideoToken(opts.mint);
+        await this.notifications.relayNotification(opts.self_notification);
+        return token;
+    }
+    async cancelCall(opts) {
+        await this.notifications.relayNotification(opts.notification);
+    }
+    async requireVideoToken(opts) {
+        const out = await this.calls.mintVideoToken(opts);
+        const token = out.value?.trim();
+        if (token === undefined || token === "") {
+            throw errResolveFailed({
+                resource: resourceVideoToken,
+                msg: msgUnableToMintVideoToken,
+            });
+        }
+        return token;
+    }
+}
+export function newCallsFX(opts) {
+    return new CallsFX(opts);
+}

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

@@ -0,0 +1,89 @@
+import { type Chat, type ChatRoom, type ChatRoomMember, type PLChatReact } from "@fabriktor/schema";
+import type { ChatOperator, WSCloseHandler, WSConnection, WSErrorHandler, WSMessageHandler } from "@fabriktor/client";
+export type ChatFXOptions = {
+    chat: ChatOperator;
+};
+export type LatestChatsOptions = {
+    chat_room_id: string;
+    page?: number;
+    per_page?: number;
+};
+export type LatestChatsCursor = {
+    chat_room_id: string;
+    next_page: number;
+    per_page: number;
+    done: boolean;
+};
+export type NextLatestChatsOptions = {
+    cursor: LatestChatsCursor;
+};
+export type LatestChatsPage = {
+    chats: Chat[];
+    page: number;
+    per_page: number;
+    total_count?: number;
+    last_page?: number;
+    has_more: boolean;
+    next_cursor: LatestChatsCursor;
+};
+export type ChatRoomMembersOptions = {
+    chat_room_id: string;
+};
+export type MyChatRoomMembersOptions = {
+    owner_id: string;
+};
+export type OpenChatRoomOptions = {
+    owner_id: string;
+    chat_room_id: string;
+    per_page?: number;
+    on_chat: WSMessageHandler<Chat>;
+    on_chat_room: WSMessageHandler<ChatRoom>;
+    on_error?: WSErrorHandler;
+    on_close?: WSCloseHandler;
+};
+export type OpenGlobalChatRoomsOptions = {
+    owner_id: string;
+    on_chat_room: WSMessageHandler<ChatRoom>;
+    on_error?: WSErrorHandler;
+    on_close?: WSCloseHandler;
+};
+export type ReactUploadedChatOptions = {
+    chat: Chat;
+    reaction: PLChatReact;
+};
+export type ChatRoomSession = {
+    latest: LatestChatsPage;
+    chats_ws: WSConnection;
+    chat_room_ws: WSConnection;
+    closeNormal(reason?: string): void;
+    closeLeavingPage(reason?: string): void;
+};
+export type GlobalChatRoomsSession = {
+    members: ChatRoomMember[];
+    chat_rooms_ws: WSConnection;
+    closeNormal(reason?: string): void;
+    closeLeavingPage(reason?: string): void;
+};
+export interface ChatFXOperator {
+    newLatestChatsCursor(opts: LatestChatsOptions): LatestChatsCursor;
+    latestChats(opts: LatestChatsOptions): Promise<LatestChatsPage>;
+    nextLatestChats(opts: NextLatestChatsOptions): Promise<LatestChatsPage>;
+    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>;
+}
+export declare class ChatFX implements ChatFXOperator {
+    private chat;
+    constructor(opts: ChatFXOptions);
+    newLatestChatsCursor(opts: LatestChatsOptions): LatestChatsCursor;
+    latestChats(opts: LatestChatsOptions): Promise<LatestChatsPage>;
+    nextLatestChats(opts: NextLatestChatsOptions): Promise<LatestChatsPage>;
+    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>;
+}
+export declare function newChatFX(opts: ChatFXOptions): ChatFX;

package/dist/src/chat/chat.js

@@ -0,0 +1,194 @@
+// 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, SearchResultResultsKey, } from "@fabriktor/schema";
+import { errValidation } from "../core/err.js";
+const firstPage = 1;
+const defaultPerPage = 30;
+const closeCodeNormal = 1000;
+const closeCodeLeavingPage = 1001;
+const msgChatObjectsUploading = "Cannot react to a chat while objects are still uploading.";
+export class ChatFX {
+    chat;
+    constructor(opts) {
+        this.chat = opts.chat;
+    }
+    newLatestChatsCursor(opts) {
+        return {
+            chat_room_id: opts.chat_room_id,
+            next_page: normalizePage(opts.page),
+            per_page: normalizePerPage(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({
+            query: {
+                chat_room_id: opts.chat_room_id,
+                [SearchPageKey]: page,
+                [SearchPerPageKey]: per_page,
+            },
+        });
+        return latestChatsPage({
+            chat_room_id: opts.chat_room_id,
+            page,
+            per_page,
+            raw,
+        });
+    }
+    async nextLatestChats(opts) {
+        if (opts.cursor.done) {
+            return emptyLatestChatsPage(opts.cursor);
+        }
+        return await this.latestChats({
+            chat_room_id: opts.cursor.chat_room_id,
+            page: opts.cursor.next_page,
+            per_page: opts.cursor.per_page,
+        });
+    }
+    async chatRoomMembers(opts) {
+        const out = await this.chat.queryChatRoomMembers({
+            query: {
+                chat_room_id: opts.chat_room_id,
+            },
+        });
+        return out.value ?? [];
+    }
+    async myChatRoomMembers(opts) {
+        const out = await this.chat.queryChatRoomMembers({
+            query: {
+                owner_id: opts.owner_id,
+            },
+        });
+        return out.value ?? [];
+    }
+    async openChatRoom(opts) {
+        const latest = await this.latestChats({
+            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,
+        });
+        return {
+            latest,
+            chats_ws,
+            chat_room_ws,
+            closeNormal(reason) {
+                closeWS([chats_ws, chat_room_ws], closeCodeNormal, reason);
+            },
+            closeLeavingPage(reason) {
+                closeWS([chats_ws, chat_room_ws], closeCodeLeavingPage, reason);
+            },
+        };
+    }
+    async openGlobalChatRooms(opts) {
+        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,
+        });
+        return {
+            members,
+            chat_rooms_ws,
+            closeNormal(reason) {
+                closeWS([chat_rooms_ws], closeCodeNormal, reason);
+            },
+            closeLeavingPage(reason) {
+                closeWS([chat_rooms_ws], closeCodeLeavingPage, reason);
+            },
+        };
+    }
+    async reactUploadedChat(opts) {
+        if (opts.chat.has_objects && !opts.chat.objects_uploaded) {
+            throw errValidation({
+                field: "chat_id",
+                msg: msgChatObjectsUploading,
+            });
+        }
+        await this.chat.reactChat(opts.reaction);
+    }
+}
+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,
+        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,
+        },
+    };
+}
+function emptyLatestChatsPage(cursor) {
+    return {
+        chats: [],
+        page: cursor.next_page,
+        per_page: cursor.per_page,
+        has_more: false,
+        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;
+    }
+    return Math.max(firstPage, Math.trunc(v));
+}
+function normalizePerPage(v) {
+    if (v === undefined || !Number.isFinite(v)) {
+        return defaultPerPage;
+    }
+    return Math.max(1, Math.trunc(v));
+}

package/dist/src/contacts/contacts.d.ts

@@ -0,0 +1,67 @@
+import { Friend, Hired, Manager, Na, OldHire, type Contact, type ID, type OperationResult } from "@fabriktor/schema";
+import type { ContactsOperator } from "@fabriktor/client";
+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 = {
+    contacts: ContactsOperator;
+};
+export type LoadContactIndexOptions = {
+    owner_id: string;
+};
+export type ContactIndex = {
+    contacts: Contact[];
+    peer_ids: Set<string>;
+};
+export type PresenceActiveHandler = (active_ids: ID[]) => void;
+export type PresenceErrorHandler = (err: unknown) => void;
+export type StartPresenceOptions = {
+    on_active: PresenceActiveHandler;
+    on_error?: PresenceErrorHandler;
+};
+export type PresenceSession = {
+    stop(): void;
+};
+export type SendFriendRequestOptions = {
+    contact_id: string;
+};
+export type RequestRelationUpgradeOptions = {
+    contact: Contact;
+    requested_relation: ActiveContactRelation;
+};
+export type DowngradeRelationOptions = {
+    contact: Contact;
+    relation: ActiveContactRelation;
+};
+export type AcceptContactRequestOptions = {
+    contact: Contact;
+};
+export type RejectContactRequestOptions = {
+    contact: Contact;
+};
+export type EndHireRelationOptions = {
+    contact: Contact;
+};
+export interface ContactsFXOperator {
+    loadContactIndex(opts: LoadContactIndexOptions): Promise<ContactIndex>;
+    startPresence(opts: StartPresenceOptions): Promise<PresenceSession>;
+    sendFriendRequest(opts: SendFriendRequestOptions): Promise<OperationResult>;
+    requestRelationUpgrade(opts: RequestRelationUpgradeOptions): Promise<OperationResult>;
+    downgradeRelation(opts: DowngradeRelationOptions): Promise<OperationResult>;
+    acceptContactRequest(opts: AcceptContactRequestOptions): Promise<OperationResult>;
+    rejectContactRequest(opts: RejectContactRequestOptions): Promise<OperationResult>;
+    endHireRelation(opts: EndHireRelationOptions): Promise<OperationResult>;
+}
+export declare class ContactsFX implements ContactsFXOperator {
+    private contacts;
+    constructor(opts: ContactsFXOptions);
+    loadContactIndex(opts: LoadContactIndexOptions): Promise<ContactIndex>;
+    startPresence(opts: StartPresenceOptions): Promise<PresenceSession>;
+    sendFriendRequest(opts: SendFriendRequestOptions): Promise<OperationResult>;
+    requestRelationUpgrade(opts: RequestRelationUpgradeOptions): Promise<OperationResult>;
+    downgradeRelation(opts: DowngradeRelationOptions): Promise<OperationResult>;
+    acceptContactRequest(opts: AcceptContactRequestOptions): Promise<OperationResult>;
+    rejectContactRequest(opts: RejectContactRequestOptions): Promise<OperationResult>;
+    endHireRelation(opts: EndHireRelationOptions): Promise<OperationResult>;
+    private replaceContact;
+}
+export declare function newContactsFX(opts: ContactsFXOptions): ContactsFX;