@fabriktor/fx 0.0.31 → 0.0.33

package/dist/src/payments/payments.js

@@ -0,0 +1,266 @@
+// 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 { CreditLedgerSourceAndroidIAP, CreditLedgerSourceAppleIAP, CreditLedgerSourceStripe, ZeroID, } from "@fabriktor/schema";
+import { errResolveFailed, errValidation } from "../core/err.js";
+const publicAmountPattern = /^\d+$/;
+const resourceStripeCreditPayment = "stripe credit payment";
+const resourcePublicPaymentSession = "public payment session";
+const msgStripeCreditPaymentIDMissing = "Stripe credit payment ID could not be resolved.";
+const msgStripeCreditPaymentMissing = "Stripe credit payment could not be resolved.";
+const msgStripeCreditPaymentAlreadyConfirmed = "Stripe credit payment is already confirmed.";
+const msgPublicSessionMissing = "Public payment session could not be resolved.";
+const msgPublicSessionInternal = "Internal clients cannot use the public payment flow.";
+const msgPublicSessionConsumed = "Public payment session has already been consumed.";
+const msgPublicAmountInvalid = "Public payment amount must be a positive integer.";
+const msgPublicBalanceInvalid = "Public payment session balance is invalid.";
+const msgPublicAmountExceedsBalance = "Public payment amount cannot exceed the session balance.";
+export const PublicPaymentSessionStatus = {
+    NotFound: "not_found",
+    Ready: "ready",
+    InternalClient: "internal_client",
+    Consumed: "consumed",
+};
+export class PaymentsFX {
+    payments;
+    submittedPublicSessionIDs;
+    constructor(opts) {
+        this.payments = opts.payments;
+        this.submittedPublicSessionIDs = new Set();
+    }
+    async purchaseAppleCredits(opts) {
+        await this.payments.purchaseCredits({
+            src: CreditLedgerSourceAppleIAP,
+            pkg: opts.pkg,
+            iap_apple: opts.iap_apple,
+            iap_google: zeroGoogleIAP(),
+            payer_payment_method_psp_id: ZeroID,
+            return_url: "",
+        });
+    }
+    async purchaseGoogleCredits(opts) {
+        await this.payments.purchaseCredits({
+            src: CreditLedgerSourceAndroidIAP,
+            pkg: opts.pkg,
+            iap_apple: zeroAppleIAP(),
+            iap_google: opts.iap_google,
+            payer_payment_method_psp_id: ZeroID,
+            return_url: "",
+        });
+    }
+    async prepareStripeCreditPurchase(opts) {
+        const out = await this.payments.purchaseCredits({
+            src: CreditLedgerSourceStripe,
+            pkg: opts.pkg,
+            iap_apple: zeroAppleIAP(),
+            iap_google: zeroGoogleIAP(),
+            payer_payment_method_psp_id: opts.payer_payment_method_psp_id,
+            return_url: opts.return_url,
+        });
+        const id = operationID(out);
+        if (id === undefined) {
+            throw errResolveFailed({
+                resource: resourceStripeCreditPayment,
+                msg: msgStripeCreditPaymentIDMissing,
+            });
+        }
+        const payment = await this.payments.findOnePayment({
+            id,
+        });
+        if (payment.value === undefined) {
+            throw errResolveFailed({
+                resource: resourceStripeCreditPayment,
+                msg: msgStripeCreditPaymentMissing,
+            });
+        }
+        return payment.value;
+    }
+    async confirmStripeCreditPurchase(opts) {
+        const id = resolvedID(opts.payment.id);
+        if (id === undefined) {
+            throw errValidation({
+                field: "payment",
+                msg: msgStripeCreditPaymentIDMissing,
+            });
+        }
+        if (opts.payment.psp_confirm) {
+            throw errValidation({
+                field: "payment",
+                msg: msgStripeCreditPaymentAlreadyConfirmed,
+            });
+        }
+        const input = {
+            id,
+            in: {
+                psp_confirm: true,
+            },
+        };
+        return await this.payments.replaceOnePayment(input);
+    }
+    async openDirectPublicPaymentSession(opts) {
+        return await this.openPublicPaymentSession({
+            is_direct: true,
+            entity_id: opts.entity_id,
+            username: "",
+            type: opts.type,
+            entity_number: "",
+            amount: "",
+        });
+    }
+    async openLookupPublicPaymentSession(opts) {
+        return await this.openPublicPaymentSession({
+            is_direct: false,
+            entity_id: ZeroID,
+            username: opts.username,
+            type: opts.type,
+            entity_number: opts.entity_number,
+            amount: opts.amount,
+        });
+    }
+    async payPublicSession(opts) {
+        validatePublicSession(opts);
+        const id = publicSessionID(opts.session);
+        if (this.submittedPublicSessionIDs.has(id)) {
+            throw errValidation({
+                field: "session",
+                msg: msgPublicSessionConsumed,
+            });
+        }
+        const input = {
+            pmt_public_session_id: id,
+            amount: publicPaymentAmount(opts),
+            payment_method_psp_id: opts.payment_method_psp_id,
+            payer_email: opts.payer_email,
+            payer_name: opts.payer_name,
+            return_url: opts.return_url,
+        };
+        this.submittedPublicSessionIDs.add(id);
+        try {
+            return await this.payments.paymentFromPublicSession(input);
+        }
+        catch (err) {
+            this.submittedPublicSessionIDs.delete(id);
+            throw err;
+        }
+    }
+    async openPublicPaymentSession(input) {
+        const out = await this.payments.openPmtPublicSession(input);
+        if (out === undefined) {
+            return {
+                status: PublicPaymentSessionStatus.NotFound,
+            };
+        }
+        const session = out.value;
+        if (session === undefined) {
+            throw errResolveFailed({
+                resource: resourcePublicPaymentSession,
+                msg: msgPublicSessionMissing,
+            });
+        }
+        if (session.is_internal_client) {
+            return {
+                status: PublicPaymentSessionStatus.InternalClient,
+                session,
+            };
+        }
+        const id = publicSessionID(session);
+        if (session.is_consumed || this.submittedPublicSessionIDs.has(id)) {
+            return {
+                status: PublicPaymentSessionStatus.Consumed,
+                session,
+            };
+        }
+        return {
+            status: PublicPaymentSessionStatus.Ready,
+            session,
+        };
+    }
+}
+export function newPaymentsFX(opts) {
+    return new PaymentsFX(opts);
+}
+function validatePublicSession(opts) {
+    if (opts.session.is_internal_client) {
+        throw errValidation({
+            field: "session",
+            msg: msgPublicSessionInternal,
+        });
+    }
+    if (opts.session.is_consumed) {
+        throw errValidation({
+            field: "session",
+            msg: msgPublicSessionConsumed,
+        });
+    }
+}
+function publicPaymentAmount(opts) {
+    const raw = opts.amount.trim();
+    if (!publicAmountPattern.test(raw)) {
+        throw errValidation({
+            field: "amount",
+            msg: msgPublicAmountInvalid,
+        });
+    }
+    const amount = Number(raw);
+    if (!Number.isSafeInteger(amount) || amount <= 0) {
+        throw errValidation({
+            field: "amount",
+            msg: msgPublicAmountInvalid,
+        });
+    }
+    const balance = opts.session.balance_amount;
+    if (!Number.isSafeInteger(balance) || balance < 0) {
+        throw errValidation({
+            field: "session",
+            msg: msgPublicBalanceInvalid,
+        });
+    }
+    if (amount > balance) {
+        throw errValidation({
+            field: "amount",
+            msg: msgPublicAmountExceedsBalance,
+        });
+    }
+    return amount.toString();
+}
+function publicSessionID(session) {
+    const id = resolvedID(session.id);
+    if (id === undefined) {
+        throw errResolveFailed({
+            resource: resourcePublicPaymentSession,
+            msg: msgPublicSessionMissing,
+        });
+    }
+    return id;
+}
+function operationID(out) {
+    return resolvedID(out.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 zeroAppleIAP() {
+    return {
+        transaction_id: "",
+    };
+}
+function zeroGoogleIAP() {
+    return {
+        product_id: "",
+        purchase_token: "",
+        kind: "",
+    };
+}

package/dist/src/payrolls/payrolls.d.ts

@@ -0,0 +1,52 @@
+import type { PayrollsOperator } from "@fabriktor/client";
+type AdjustmentReplaceOptions = Parameters<PayrollsOperator["replaceOneAdjustment"]>[0];
+type AdjustmentFolderReplaceOptions = Parameters<PayrollsOperator["replaceOneAdjustmentFolder"]>[0];
+type PayConfigReplaceOptions = Parameters<PayrollsOperator["replaceOnePayConfig"]>[0];
+type EmployeePayConfigReplaceOptions = Parameters<PayrollsOperator["replaceOneEmployeePayConfig"]>[0];
+type PayrollProgramReplaceOptions = Parameters<PayrollsOperator["replaceOnePayrollProgram"]>[0];
+export type SetAdjustmentArchivedOptions = {
+    id: AdjustmentReplaceOptions["id"];
+    is_archived: NonNullable<AdjustmentReplaceOptions["in"]["is_archived"]>;
+};
+export type SetAdjustmentFolderArchivedOptions = {
+    id: AdjustmentFolderReplaceOptions["id"];
+    is_archived: NonNullable<AdjustmentFolderReplaceOptions["in"]["is_archived"]>;
+};
+export type SetPayConfigArchivedOptions = {
+    id: PayConfigReplaceOptions["id"];
+    is_archived: NonNullable<PayConfigReplaceOptions["in"]["is_archived"]>;
+};
+export type SetEmployeePayConfigArchivedOptions = {
+    id: EmployeePayConfigReplaceOptions["id"];
+    is_archived: NonNullable<EmployeePayConfigReplaceOptions["in"]["is_archived"]>;
+};
+export type SetPayrollProgramEnabledOptions = {
+    id: PayrollProgramReplaceOptions["id"];
+    is_enabled: NonNullable<PayrollProgramReplaceOptions["in"]["is_enabled"]>;
+};
+export type SetAdjustmentArchivedResult = Awaited<ReturnType<PayrollsOperator["replaceOneAdjustment"]>>;
+export type SetAdjustmentFolderArchivedResult = Awaited<ReturnType<PayrollsOperator["replaceOneAdjustmentFolder"]>>;
+export type SetPayConfigArchivedResult = Awaited<ReturnType<PayrollsOperator["replaceOnePayConfig"]>>;
+export type SetEmployeePayConfigArchivedResult = Awaited<ReturnType<PayrollsOperator["replaceOneEmployeePayConfig"]>>;
+export type SetPayrollProgramEnabledResult = Awaited<ReturnType<PayrollsOperator["replaceOnePayrollProgram"]>>;
+export type PayrollsFXOptions = {
+    payrolls: PayrollsOperator;
+};
+export interface PayrollsFXOperator {
+    setAdjustmentArchived(opts: SetAdjustmentArchivedOptions): Promise<SetAdjustmentArchivedResult>;
+    setAdjustmentFolderArchived(opts: SetAdjustmentFolderArchivedOptions): Promise<SetAdjustmentFolderArchivedResult>;
+    setPayConfigArchived(opts: SetPayConfigArchivedOptions): Promise<SetPayConfigArchivedResult>;
+    setEmployeePayConfigArchived(opts: SetEmployeePayConfigArchivedOptions): Promise<SetEmployeePayConfigArchivedResult>;
+    setPayrollProgramEnabled(opts: SetPayrollProgramEnabledOptions): Promise<SetPayrollProgramEnabledResult>;
+}
+export declare class PayrollsFX implements PayrollsFXOperator {
+    private payrolls;
+    constructor(opts: PayrollsFXOptions);
+    setAdjustmentArchived(opts: SetAdjustmentArchivedOptions): Promise<SetAdjustmentArchivedResult>;
+    setAdjustmentFolderArchived(opts: SetAdjustmentFolderArchivedOptions): Promise<SetAdjustmentFolderArchivedResult>;
+    setPayConfigArchived(opts: SetPayConfigArchivedOptions): Promise<SetPayConfigArchivedResult>;
+    setEmployeePayConfigArchived(opts: SetEmployeePayConfigArchivedOptions): Promise<SetEmployeePayConfigArchivedResult>;
+    setPayrollProgramEnabled(opts: SetPayrollProgramEnabledOptions): Promise<SetPayrollProgramEnabledResult>;
+}
+export declare function newPayrollsFX(opts: PayrollsFXOptions): PayrollsFX;
+export {};

package/dist/src/payrolls/payrolls.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
+export class PayrollsFX {
+    payrolls;
+    constructor(opts) {
+        this.payrolls = opts.payrolls;
+    }
+    async setAdjustmentArchived(opts) {
+        return await this.payrolls.replaceOneAdjustment({
+            id: opts.id,
+            in: {
+                is_archived: opts.is_archived,
+            },
+        });
+    }
+    async setAdjustmentFolderArchived(opts) {
+        return await this.payrolls.replaceOneAdjustmentFolder({
+            id: opts.id,
+            in: {
+                is_archived: opts.is_archived,
+            },
+        });
+    }
+    async setPayConfigArchived(opts) {
+        return await this.payrolls.replaceOnePayConfig({
+            id: opts.id,
+            in: {
+                is_archived: opts.is_archived,
+            },
+        });
+    }
+    async setEmployeePayConfigArchived(opts) {
+        return await this.payrolls.replaceOneEmployeePayConfig({
+            id: opts.id,
+            in: {
+                is_archived: opts.is_archived,
+            },
+        });
+    }
+    async setPayrollProgramEnabled(opts) {
+        return await this.payrolls.replaceOnePayrollProgram({
+            id: opts.id,
+            in: {
+                is_enabled: opts.is_enabled,
+            },
+        });
+    }
+}
+export function newPayrollsFX(opts) {
+    return new PayrollsFX(opts);
+}

package/dist/src/privacy/privacy.d.ts

@@ -0,0 +1,21 @@
+import { type AccountLock } from "@fabriktor/schema";
+import type { PrivacyOperator } from "@fabriktor/client";
+export type PrivacyFXOptions = {
+    privacy: PrivacyOperator;
+};
+export type WatchAccountLockOptions = {
+    owner_id: string;
+    on_lock: (lock: AccountLock) => void;
+    on_error?: (err: unknown) => void;
+};
+export type StopAccountLockWatch = () => void;
+export interface PrivacyFXOperator {
+    watchAccountLock(opts: WatchAccountLockOptions): Promise<StopAccountLockWatch>;
+}
+export declare class PrivacyFX implements PrivacyFXOperator {
+    private privacy;
+    constructor(opts: PrivacyFXOptions);
+    watchAccountLock(opts: WatchAccountLockOptions): Promise<StopAccountLockWatch>;
+    private findAccountLock;
+}
+export declare function newPrivacyFX(opts: PrivacyFXOptions): PrivacyFX;

package/dist/src/privacy/privacy.js

@@ -0,0 +1,78 @@
+// 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 { ZeroID } from "@fabriktor/schema";
+import { errRequired } from "../core/err.js";
+const accountLockIntervalMs = 60 * 60 * 1000;
+const msgOwnerIDRequired = "Owner ID is required.";
+export class PrivacyFX {
+    privacy;
+    constructor(opts) {
+        this.privacy = opts.privacy;
+    }
+    async watchAccountLock(opts) {
+        const owner_id = opts.owner_id.trim();
+        if (owner_id === "" || owner_id === ZeroID) {
+            throw errRequired({
+                field: "owner_id",
+                msg: msgOwnerIDRequired,
+            });
+        }
+        const initial_lock = await this.findAccountLock(owner_id);
+        if (initial_lock !== undefined) {
+            opts.on_lock(initial_lock);
+            return () => { };
+        }
+        let stopped = false;
+        let timer;
+        const schedule = () => {
+            timer = globalThis.setTimeout(() => {
+                void check();
+            }, accountLockIntervalMs);
+        };
+        const check = async () => {
+            if (stopped) {
+                return;
+            }
+            try {
+                const lock = await this.findAccountLock(owner_id);
+                if (stopped) {
+                    return;
+                }
+                if (lock !== undefined) {
+                    stopped = true;
+                    opts.on_lock(lock);
+                    return;
+                }
+            }
+            catch (err) {
+                if (!stopped) {
+                    opts.on_error?.(err);
+                }
+            }
+            if (!stopped) {
+                schedule();
+            }
+        };
+        schedule();
+        return () => {
+            stopped = true;
+            if (timer !== undefined) {
+                globalThis.clearTimeout(timer);
+            }
+        };
+    }
+    async findAccountLock(owner_id) {
+        const out = await this.privacy.queryAccountLocks({
+            query: {
+                owner_id,
+            },
+        });
+        return out.value?.[0];
+    }
+}
+export function newPrivacyFX(opts) {
+    return new PrivacyFX(opts);
+}

package/dist/src/routes/routes.d.ts

@@ -0,0 +1,22 @@
+import type { RoutesOperator } from "@fabriktor/client";
+type RouteInsertOptions = Parameters<RoutesOperator["insertOneRoute"]>[0];
+type RouteInsert = RouteInsertOptions["in"];
+type RouteAvailability = NonNullable<Awaited<ReturnType<RoutesOperator["getAvailability"]>>["value"]>;
+export type CreateRouteOptions = {
+    in: RouteInsert;
+    availability: RouteAvailability;
+};
+export type CreateRouteResult = Awaited<ReturnType<RoutesOperator["insertOneRoute"]>>;
+export type RoutesFXOptions = {
+    routes: RoutesOperator;
+};
+export interface RoutesFXOperator {
+    createRoute(opts: CreateRouteOptions): Promise<CreateRouteResult>;
+}
+export declare class RoutesFX implements RoutesFXOperator {
+    private routes;
+    constructor(opts: RoutesFXOptions);
+    createRoute(opts: CreateRouteOptions): Promise<CreateRouteResult>;
+}
+export declare function newRoutesFX(opts: RoutesFXOptions): RoutesFX;
+export {};

package/dist/src/routes/routes.js

@@ -0,0 +1,134 @@
+// 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 { errValidation } from "../core/err.js";
+const maxHour = 23;
+const maxMinute = 59;
+const maxMinuteOfDay = 1440;
+const msgGlobalWindowSameDay = "The global route window must stay within one calendar day.";
+const msgGlobalWindowInvalid = "The global route window is invalid.";
+const msgEmployeeDuplicate = "An employee cannot be selected in more than one vehicle.";
+const msgEmployeeUnavailable = "A selected employee is not available for this route.";
+const msgLocationDuplicate = "A location cannot be selected more than once.";
+const msgLocationUnavailable = "A selected location is not available for this route.";
+const msgDestinationWindowInvalid = "A destination time window is invalid.";
+const msgDestinationWindowOutsideGlobal = "A destination time window must stay within the global route window.";
+export class RoutesFX {
+    routes;
+    constructor(opts) {
+        this.routes = opts.routes;
+    }
+    async createRoute(opts) {
+        validateRoute(opts.in, opts.availability);
+        return await this.routes.insertOneRoute({
+            in: opts.in,
+        });
+    }
+}
+export function newRoutesFX(opts) {
+    return new RoutesFX(opts);
+}
+function validateRoute(input, availability) {
+    if (!sameDay(input.from, input.to)) {
+        throw errValidation({
+            field: "to",
+            msg: msgGlobalWindowSameDay,
+        });
+    }
+    const fromMinute = minuteOfDay(input.from);
+    const toMinute = minuteOfDay(input.to);
+    if (fromMinute === undefined ||
+        toMinute === undefined ||
+        fromMinute >= toMinute) {
+        throw errValidation({
+            field: "to",
+            msg: msgGlobalWindowInvalid,
+        });
+    }
+    validateVehicles(input, availability);
+    validateDestinations(input, availability, fromMinute, toMinute);
+}
+function validateVehicles(input, availability) {
+    const availableEmployeeIDs = new Set(availability.availables.employees.map((id) => id.trim()));
+    const employeeIDs = new Set();
+    for (const vehicle of input.vehicles) {
+        for (const rawEmployeeID of vehicle.employee_ids) {
+            const employeeID = rawEmployeeID.trim();
+            if (employeeID === "") {
+                continue;
+            }
+            if (employeeIDs.has(employeeID)) {
+                throw errValidation({
+                    field: "vehicles",
+                    msg: msgEmployeeDuplicate,
+                });
+            }
+            if (!availableEmployeeIDs.has(employeeID)) {
+                throw errValidation({
+                    field: "vehicles",
+                    msg: msgEmployeeUnavailable,
+                });
+            }
+            employeeIDs.add(employeeID);
+        }
+    }
+}
+function validateDestinations(input, availability, fromMinute, toMinute) {
+    const availableLocationIDs = new Set(availability.availables.locations.map((id) => id.trim()));
+    const locationIDs = new Set();
+    for (const destination of input.destinations) {
+        const locationID = destination.location_id.trim();
+        if (locationID !== "") {
+            if (locationIDs.has(locationID)) {
+                throw errValidation({
+                    field: "destinations",
+                    msg: msgLocationDuplicate,
+                });
+            }
+            if (!availableLocationIDs.has(locationID)) {
+                throw errValidation({
+                    field: "destinations",
+                    msg: msgLocationUnavailable,
+                });
+            }
+            locationIDs.add(locationID);
+        }
+        if (!destination.use_time_window) {
+            continue;
+        }
+        const start = destination.time_window_start_hour_in_minutes;
+        const end = destination.time_window_end_hour_in_minutes;
+        if (!Number.isInteger(start) ||
+            !Number.isInteger(end) ||
+            start < 0 ||
+            end > maxMinuteOfDay ||
+            start >= end) {
+            throw errValidation({
+                field: "destinations",
+                msg: msgDestinationWindowInvalid,
+            });
+        }
+        if (start < fromMinute || end > toMinute) {
+            throw errValidation({
+                field: "destinations",
+                msg: msgDestinationWindowOutsideGlobal,
+            });
+        }
+    }
+}
+function sameDay(a, b) {
+    return a.y === b.y && a.m === b.m && a.d === b.d;
+}
+function minuteOfDay(v) {
+    if (!Number.isInteger(v.h) ||
+        !Number.isInteger(v.min) ||
+        v.h < 0 ||
+        v.h > maxHour ||
+        v.min < 0 ||
+        v.min > maxMinute) {
+        return undefined;
+    }
+    return v.h * 60 + v.min;
+}