@fabriktor/fx 0.0.133 → 0.0.135

package/dist/src/core/multi-create.d.ts

@@ -48,6 +48,8 @@ export declare class MultiCreatePool {
 export type MultiCreateOptions<Input, Result> = {
     run: (input: Input, attempt: MultiCreateAttempt) => Promise<Result>;
     pool?: MultiCreatePool;
+    check?: (inputs: readonly Input[], signal: AbortSignal) => Promise<void>;
+    on_blocked?: (entry: MultiCreateEntry<Input, Result>) => void;
     retry_same_request?: boolean;
     before_request?: () => void;
     on_failed?: (entry: MultiCreateEntry<Input, Result>) => void;
@@ -73,6 +75,8 @@ export declare class MultiCreator<Input, Result> {
     whenIdle(): Promise<void>;
     cancel(): void;
     private run;
+    private reject;
+    private settle;
     private replace;
     private publish;
 }

package/dist/src/core/multi-create.js

@@ -3,6 +3,7 @@
 // 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 { isPreActionBlocked } from "./pre-action.js";
 import { createEvent, EventBus, notifyObserver, } from "./events.js";
 export const multiCreateMaximumEntries = 40;
 export const multiCreateConcurrency = 5;
@@ -138,6 +139,18 @@ export class MultiCreator {
     async run(pending) {
         const signal = this.controller.signal;
         const pool = this.opts.pool ?? sharedMultiCreatePool;
+        try {
+            signal.throwIfAborted();
+            this.opts.before_request?.();
+            await this.opts.check?.(pending.filter((entry) => !entry.created_id).map((entry) => entry.input), signal);
+            signal.throwIfAborted();
+        }
+        catch (error) {
+            for (const entry of pending)
+                this.reject(entry, error);
+            this.settle(pending);
+            return;
+        }
         await Promise.all(pending.map((entry) => pool.run(async () => {
             let current = {
                 ...entry,
@@ -175,11 +188,22 @@ export class MultiCreator {
                 });
             }
             catch (error) {
-                current = { ...current, status: MultiCreateStatus.Failed, error };
-                this.replace(current);
-                notifyObserver(() => this.opts.on_failed?.(current));
+                this.reject(current, error);
             }
         })));
+        this.settle(pending);
+    }
+    reject(entry, error) {
+        const blocked = isPreActionBlocked(error) && !entry.attempted && !entry.created_id;
+        const current = {
+            ...entry,
+            status: blocked ? MultiCreateStatus.Pending : MultiCreateStatus.Failed,
+            error,
+        };
+        this.replace(current);
+        notifyObserver(() => blocked ? this.opts.on_blocked?.(current) : this.opts.on_failed?.(current));
+    }
+    settle(pending) {
         this.running = false;
         this.publish();
         const ids = new Set(pending.map((entry) => entry.id));

package/dist/src/payments/payments.d.ts

@@ -3,6 +3,9 @@ import { type PaymentsOperator, type BillableOperator, type PayrollsOperator } f
 import { type SearchOptions, type OwnerSearchOptions, type SearchPage } from "../core/search.js";
 import { EventBus } from "../core/events.js";
 import type { MultiCreateAttempt, MultiCreateCheckpoint } from "../core/multi-create.js";
+export declare const PaymentsPreActionReason: {
+    readonly RecipientNotOnboarded: "recipient_not_onboarded";
+};
 type PurchaseCreditsPayload = Parameters<PaymentsOperator["purchaseCredits"]>[0];
 type OpenPublicSessionPayload = Parameters<PaymentsOperator["openPmtPublicSession"]>[0];
 type PaymentFromPublicSessionPayload = Parameters<PaymentsOperator["paymentFromPublicSession"]>[0];
@@ -192,6 +195,7 @@ export type PaymentsFXOptions = {
     events?: EventBus;
 };
 export interface PaymentsFXOperator {
+    checkEntityPaymentRecipients(entities: readonly ResolvePayableEntityOptions[], signal?: AbortSignal): Promise<void>;
     resolvePayableEntity(opts: ResolvePayableEntityOptions): Promise<PayableEntityBalance>;
     searchPayableEntities(opts: SearchPayableEntitiesOptions): Promise<SearchPage<PayableEntityBalance>>;
     createEntityPayment(opts: CreateEntityPaymentOptions, attempt: MultiCreateAttempt): Promise<Payment>;
@@ -244,6 +248,9 @@ export declare class PaymentsFX implements PaymentsFXOperator {
     resolveEntityPayments(opts: ResolveEntityPaymentsOptions): Promise<EntityPayments[]>;
     searchPayableEntities(opts: SearchPayableEntitiesOptions): Promise<SearchPage<PayableEntityBalance>>;
     resolvePayableEntity(opts: ResolvePayableEntityOptions): Promise<PayableEntityBalance>;
+    private findPayableEntity;
+    checkEntityPaymentRecipients(entities: readonly ResolvePayableEntityOptions[], signal?: AbortSignal): Promise<void>;
+    private checkPaymentRecipient;
     createEntityPayment(opts: CreateEntityPaymentOptions, attempt: MultiCreateAttempt): Promise<Payment>;
     createPayment(opts: CreatePaymentOptions): Promise<Payment>;
     replacePayment(opts: ReplacePaymentOptions): Promise<Payment>;

package/dist/src/payments/payments.js

@@ -5,10 +5,14 @@
 // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
 import { CreditLedgerSourceAndroidIAP, CreditLedgerSourceAppleIAP, CreditLedgerSourceStripe, ZeroID, PaymentKindMain, PaymentEntityTypeBill, PaymentEntityTypePayroll, PSPActionableStatusSucceeded, PSPActionableStatusFailed, PSPActionableStatusCanceled, PSPPaymentStatusPending, PSPPaymentStatusPartial, PSPPaymentStatusFull, } from "@fabriktor/schema";
 import { queryParams, } from "@fabriktor/client";
+import { runPreActionCheck } from "../core/pre-action.js";
 import { errResolveFailed, errValidation } from "../core/err.js";
 import { normalizeIDs, requiredOperationID, resolvedID } from "../core/id.js";
 import { runOwnerSearch, runSearch, } from "../core/search.js";
 import { createEvent, EventBus } from "../core/events.js";
+export const PaymentsPreActionReason = {
+    RecipientNotOnboarded: "recipient_not_onboarded",
+};
 const entityPaymentQuerySize = 30;
 const publicAmountPattern = /^\d+$/;
 const resourcePayment = "payment";
@@ -307,6 +311,21 @@ export class PaymentsFX {
         }
     }
     async resolvePayableEntity(opts) {
+        const entity = await this.findPayableEntity(opts);
+        const [balance] = await this.resolveEntityPayments({
+            owner_id: opts.owner_id,
+            type: opts.type,
+            entities: [entity],
+            signal: opts.signal,
+        });
+        if (!balance)
+            throw errResolveFailed({
+                resource: resourcePayment,
+                msg: msgPaymentHistoryIncomplete,
+            });
+        return { ...balance, entity };
+    }
+    async findPayableEntity(opts) {
         opts.signal?.throwIfAborted();
         const record = opts.type === PaymentEntityTypeBill
             ? (await this.billable?.findOneBill({
@@ -324,19 +343,35 @@ export class PaymentsFX {
                 resource: resourcePayment,
                 msg: msgPaymentMissing,
             });
-        const entity = payableEntity(record, opts.type, opts.owner_id);
-        const [balance] = await this.resolveEntityPayments({
-            owner_id: opts.owner_id,
-            type: opts.type,
-            entities: [entity],
-            signal: opts.signal,
+        return payableEntity(record, opts.type, opts.owner_id);
+    }
+    // Check the whole selection before starting a batch; never retain readiness across actions.
+    async checkEntityPaymentRecipients(entities, signal) {
+        const recipients = new Set();
+        for (const opts of entities) {
+            signal?.throwIfAborted();
+            const entity = await this.findPayableEntity({ ...opts, signal });
+            recipients.add(entity.recipient_id);
+        }
+        for (const recipient_id of recipients)
+            await this.checkPaymentRecipient(recipient_id, signal);
+    }
+    async checkPaymentRecipient(recipient_id, signal) {
+        if (!resolvedID(recipient_id))
+            throw errValidation({ msg: msgPaymentEntityInvalid });
+        await runPreActionCheck({
+            reason: PaymentsPreActionReason.RecipientNotOnboarded,
+            allowed: async () => {
+                signal?.throwIfAborted();
+                const out = await this.payments.onboardingStatus({ recipient_id, signal });
+                if (typeof out.value !== "boolean")
+                    throw errResolveFailed({
+                        resource: resourcePmtAccount,
+                        msg: msgPmtAccountMissing,
+                    });
+                return out.value;
+            },
         });
-        if (!balance)
-            throw errResolveFailed({
-                resource: resourcePayment,
-                msg: msgPaymentHistoryIncomplete,
-            });
-        return { ...balance, entity };
     }
     async createEntityPayment(opts, attempt) {
         if (attempt.created_id)
@@ -386,6 +421,11 @@ export class PaymentsFX {
         if (opts.created_id)
             return this.findPayment(opts.created_id, opts.signal);
         opts.signal?.throwIfAborted();
+        if (!opts.in.is_manual &&
+            (opts.in.type === PaymentEntityTypeBill ||
+                opts.in.type === PaymentEntityTypePayroll))
+            await this.checkPaymentRecipient(opts.in.recipient_id, opts.signal);
+        opts.signal?.throwIfAborted();
         opts.before_request?.();
         const out = await this.payments.insertOnePayment(opts);
         const id = requiredOperationID(out, msgCreatedPaymentIDMissing);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fabriktor/fx",
-  "version": "0.0.133",
+  "version": "0.0.135",
   "description": "![Fabriktor Logo](./img/fabriktor-character.gif)",
   "type": "module",
   "exports": {
@@ -17,7 +17,7 @@
     "typescript": "^6.0.3"
   },
   "dependencies": {
-    "@fabriktor/client": "0.0.93",
+    "@fabriktor/client": "0.0.94",
     "@fabriktor/fx": "0.0.94",
     "@fabriktor/schema": "0.0.66"
   }