@develit-services/bank 4.1.0 → 4.2.1

package/dist/export/worker.mjs

@@ -1,5 +1,5 @@
 import { bankAccountMetadataSchema, structuredAddressSchema, uuidv4, first, buildMultiFilterConditions as buildMultiFilterConditions$1, workflowInstanceStatusSchema, develitWorker, createInternalError, action, service } from '@develit-io/backend-sdk';
-import { B as tables, g as accountInsertSchema, G as relations, H as initiateConnector, o as isProcessedStatus, p as isTerminalStatus, J as getNonTerminalPaymentRequestsQuery, x as toIncomingPayment, j as assignAccount, u as toBatchedPayment, y as toPaymentRequestInsert, a as FinbricksClient, F as FINBRICKS_ENDPOINTS } from '../shared/bank.BxZARqNE.mjs';
+import { G as tables, g as accountInsertSchema, H as relations, J as initiateConnector, o as isProcessedStatus, p as isTerminalStatus, L as getNonTerminalPaymentRequestsQuery, x as toIncomingPayment, j as assignAccount, u as toBatchedPayment, y as toPaymentRequestInsert, a as FinbricksClient, F as FINBRICKS_ENDPOINTS } from '../shared/bank.BOMobxtA.mjs';
 import { eq, sql, and, like, asc, desc, inArray, gte, lte, isNull, count } from 'drizzle-orm';
 import { WorkerEntrypoint } from 'cloudflare:workers';
 import { drizzle } from 'drizzle-orm/d1';
@@ -9,10 +9,69 @@ import { I as INSTRUCTION_PRIORITIES, C as CHARGE_BEARERS, g as PAYMENT_TYPES, b
 import { CURRENCY_CODES } from '@develit-io/general-codes';
 import 'date-fns';
 import 'node:crypto';
-import { h as encrypt, d as createCredentialsResolver, e as updatePaymentRequestStatusCommand, a as getPaymentRequestsByBatchIdQuery, g as getBatchByIdQuery, u as upsertBatchCommand, i as importAesKey, f as createPaymentCommand, b as getAccountByIdQuery } from '../shared/bank.BScD3GXI.mjs';
+import { h as encrypt, d as createCredentialsResolver, e as updatePaymentRequestStatusCommand, a as getPaymentRequestsByBatchIdQuery, g as getBatchByIdQuery, u as upsertBatchCommand, i as importAesKey, f as createPaymentCommand, b as getAccountByIdQuery } from '../shared/bank.BELDXSDV.mjs';
 import 'drizzle-orm/zod';
 import 'drizzle-orm/sqlite-core';
 
+const SYNC_WORKFLOW_HEARTBEAT_CRON = "0 */8 * * *";
+const DEAD_STATUSES = /* @__PURE__ */ new Set([
+  "complete",
+  "terminated",
+  "errored",
+  "unknown"
+]);
+async function heartbeatSyncWorkflows({
+  entities,
+  resetAfterIterations,
+  getInstance,
+  createInstance,
+  logger
+}) {
+  await Promise.all(
+    entities.map(async ({ id, iterationCount }) => {
+      try {
+        const instance = await getInstance(id);
+        const { status } = await instance.status();
+        if (DEAD_STATUSES.has(status)) {
+          await instance.restart();
+          logger.info("sync-workflow.heartbeat.zombie-recovery", {
+            id,
+            previousStatus: status
+          });
+          return;
+        }
+        if (iterationCount == null) {
+          logger.warn("sync-workflow.heartbeat.iteration-count-missing", {
+            id,
+            status
+          });
+          return;
+        }
+        if (iterationCount >= resetAfterIterations) {
+          await instance.restart();
+          logger.info("sync-workflow.heartbeat.scheduled-reset", {
+            id,
+            iterationCount
+          });
+        }
+      } catch (err) {
+        try {
+          await createInstance(id);
+          logger.info("sync-workflow.heartbeat.created-missing-instance", {
+            id
+          });
+        } catch (createErr) {
+          logger.error("sync-workflow.heartbeat.failed", {
+            id,
+            error: err instanceof Error ? err.message : String(err),
+            createError: createErr instanceof Error ? createErr.message : String(createErr)
+          });
+        }
+      }
+    })
+  );
+}
+
 const sendPaymentInputSchema = z.object({
   correlationId: z.string().min(1),
   refId: z.string().optional(),
@@ -755,6 +814,7 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
     const byConnector = Map.groupBy(allPRs, (pr) => pr.connectorKey);
     let processed = 0;
     let statusChanged = 0;
+    let skippedNoBankRefId = 0;
     const eventsToEmit = [];
     for (const [connectorKey, requests] of byConnector) {
       let connector;
@@ -767,10 +827,30 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
         continue;
       }
       for (const pr of requests) {
+        if (!pr.bankRefId && pr.connectorKey === "DBU") {
+          skippedNoBankRefId++;
+          console.warn(
+            "[_resolvePaymentRequestStatuses] Skipping DBU PR without bankRefId",
+            {
+              prId: pr.id,
+              status: pr.status,
+              connectorKey: pr.connectorKey,
+              createdAt: pr.createdAt
+            }
+          );
+          continue;
+        }
         try {
           const paymentId = pr.bankRefId ?? pr.id;
           const newStatus = await connector.getPaymentStatus({ paymentId });
           if (newStatus !== pr.status) {
+            console.log("[_resolvePaymentRequestStatuses] Status changed", {
+              prId: pr.id,
+              connectorKey: pr.connectorKey,
+              bankRefId: pr.bankRefId,
+              oldStatus: pr.status,
+              newStatus
+            });
             await updatePaymentRequestStatusCommand(this.db, {
               id: pr.id,
               status: newStatus,
@@ -783,17 +863,34 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
           }
           processed++;
         } catch (err) {
-          this.logError({
-            message: `Failed to resolve status for PR ${pr.id}: ${err}`
-          });
+          console.error(
+            "[_resolvePaymentRequestStatuses] Failed to get payment status",
+            {
+              prId: pr.id,
+              connectorKey: pr.connectorKey,
+              status: pr.status,
+              bankRefId: pr.bankRefId,
+              error: err instanceof Error ? err.message : String(err)
+            }
+          );
         }
       }
     }
     if (eventsToEmit.length > 0) {
-      await this.pushToQueue(
-        this.env.QUEUE_BUS_QUEUE,
-        eventsToEmit
-      );
+      try {
+        await this.pushToQueue(
+          this.env.QUEUE_BUS_QUEUE,
+          eventsToEmit
+        );
+      } catch (err) {
+        console.error(
+          "[_resolvePaymentRequestStatuses] Failed to push events to queue",
+          {
+            eventCount: eventsToEmit.length,
+            error: err instanceof Error ? err.message : String(err)
+          }
+        );
+      }
     }
     const affectedBatchIds = [
       ...new Set(
@@ -801,7 +898,32 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
       )
     ];
     for (const batchId of affectedBatchIds) {
-      await this._deriveBatchStatus(batchId);
+      try {
+        await this._deriveBatchStatus(batchId);
+      } catch (err) {
+        console.error(
+          "[_resolvePaymentRequestStatuses] Failed to derive batch status",
+          {
+            batchId,
+            error: err instanceof Error ? err.message : String(err)
+          }
+        );
+      }
+    }
+    console.log("[_resolvePaymentRequestStatuses] Summary", {
+      total: allPRs.length,
+      processed,
+      statusChanged,
+      skippedNoBankRefId
+    });
+    if (skippedNoBankRefId > 5) {
+      console.warn(
+        "[_resolvePaymentRequestStatuses] HIGH NUMBER of PRs without bankRefId",
+        {
+          count: skippedNoBankRefId,
+          note: "These PRs may be orphaned - payment sent but bankRefId not saved"
+        }
+      );
     }
     return { processed, statusChanged };
   }
@@ -816,8 +938,9 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
     if (!batch || batch.status === "COMPLETED" || batch.status === "FAILED")
       return;
     if (allPRs.length === 0) return;
+    const connectorKey = allPRs[0]?.connectorKey;
     const allTerminal = allPRs.every(
-      (pr) => isTerminalStatus(pr.status)
+      (pr) => isTerminalStatus(pr.status, connectorKey)
     );
     const allAuthorizedOrHigher = allPRs.every((pr) => pr.status !== "OPENED");
     if (allTerminal) {
@@ -838,16 +961,49 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
       null,
       { successMessage: "Payment request statuses updated" },
       async () => {
+        const startTime = Date.now();
+        console.log("[updatePaymentRequestStatuses] Starting", {
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
         const nonTerminalPRs = await getNonTerminalPaymentRequestsQuery(this.db);
         if (nonTerminalPRs.length === 0) {
+          console.log(
+            "[updatePaymentRequestStatuses] No non-terminal PRs found",
+            {
+              duration: `${Date.now() - startTime}ms`
+            }
+          );
           return { processed: 0, statusChanged: 0 };
         }
+        const byConnector = nonTerminalPRs.reduce(
+          (acc, pr) => {
+            const key = pr.connectorKey || "unknown";
+            acc[key] = (acc[key] || 0) + 1;
+            return acc;
+          },
+          {}
+        );
+        console.log("[updatePaymentRequestStatuses] By connector", byConnector);
         const now = Date.now();
         const pollableIds = [];
         for (const pr of nonTerminalPRs) {
           const status = pr.status;
+          if (isTerminalStatus(status, pr.connectorKey)) {
+            continue;
+          }
           if (status === "OPENED" || status === "AUTHORIZED") {
             if (pr.createdAt != null && now - pr.createdAt.getTime() > this.POLLING_TIMEOUT_MS) {
+              console.warn(
+                "[updatePaymentRequestStatuses] Closing PR due to timeout",
+                {
+                  prId: pr.id,
+                  status: pr.status,
+                  connectorKey: pr.connectorKey,
+                  createdAt: pr.createdAt,
+                  bankRefId: pr.bankRefId,
+                  age: `${Math.floor((now - pr.createdAt.getTime()) / (24 * 60 * 60 * 1e3))} days`
+                }
+              );
               await updatePaymentRequestStatusCommand(this.db, {
                 id: pr.id,
                 status: "CLOSED",
@@ -857,14 +1013,20 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
               continue;
             }
             pollableIds.push(pr.id);
-          } else if (status === "COMPLETED" || status === "BOOKED") {
-            if (pr.processedAt != null && now - pr.processedAt.getTime() > this.COMPLETED_POLLING_WINDOW_MS) {
-              continue;
-            }
-            pollableIds.push(pr.id);
           }
         }
-        return this._resolvePaymentRequestStatuses(pollableIds);
+        const result = await this._resolvePaymentRequestStatuses(pollableIds);
+        const duration = Date.now() - startTime;
+        console.log("[updatePaymentRequestStatuses] Completed", {
+          duration: `${duration}ms`,
+          metrics: {
+            total: nonTerminalPRs.length,
+            polled: pollableIds.length,
+            processed: result.processed,
+            statusChanged: result.statusChanged
+          }
+        });
+        return result;
       }
     );
   }
@@ -872,8 +1034,46 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
     if (controller.cron === this.env.CRON_PAYMENT_STATUSES) {
       console.log("Scheduled CRON payment request statuses");
       await this.updatePaymentRequestStatuses();
+      return;
+    }
+    if (controller.cron === SYNC_WORKFLOW_HEARTBEAT_CRON) {
+      console.log("Scheduled CRON sync workflow heartbeat");
+      await this.heartbeatSyncWorkflows();
     }
   }
+  async heartbeatSyncWorkflows() {
+    const accounts = await this.db.select({
+      id: tables.account.id,
+      lastSyncMetadata: tables.account.lastSyncMetadata
+    }).from(tables.account).where(eq(tables.account.status, "AUTHORIZED")).all();
+    const resetAfterIterations = Number(
+      this.env.SYNC_WORKFLOW_RESET_AFTER_ITERATIONS
+    );
+    if (!Number.isFinite(resetAfterIterations) || resetAfterIterations <= 0) {
+      console.error(
+        "Invalid SYNC_WORKFLOW_RESET_AFTER_ITERATIONS, skipping heartbeat",
+        { value: this.env.SYNC_WORKFLOW_RESET_AFTER_ITERATIONS }
+      );
+      return;
+    }
+    await heartbeatSyncWorkflows({
+      entities: accounts.map((a) => ({
+        id: a.id,
+        iterationCount: a.lastSyncMetadata?.iterationCount
+      })),
+      resetAfterIterations,
+      getInstance: (id) => this.env.SYNC_ACCOUNT_PAYMENTS_WORKFLOW.get(id),
+      createInstance: (id) => this.env.SYNC_ACCOUNT_PAYMENTS_WORKFLOW.create({
+        id,
+        params: { accountId: id }
+      }),
+      logger: {
+        info: (event, data) => console.log(JSON.stringify({ level: "info", event, ...data })),
+        warn: (event, data) => console.warn(JSON.stringify({ level: "warn", event, ...data })),
+        error: (event, data) => console.error(JSON.stringify({ level: "error", event, ...data }))
+      }
+    });
+  }
   async handleAuthorizationCallback(input) {
     return this.handleAction(
       { data: input, schema: handleAuthorizationCallbackInputSchema },

package/dist/export/workflows.cjs

@@ -1,10 +1,10 @@
 'use strict';
 
 const backendSdk = require('@develit-io/backend-sdk');
-const ott_zod = require('../shared/bank.xrNekjj9.cjs');
+const ott_zod = require('../shared/bank.DiJmJkDt.cjs');
 const batchLifecycle = require('../shared/bank.NF8bZBy0.cjs');
 const drizzleOrm = require('drizzle-orm');
-const credentialsResolver = require('../shared/bank.DNFep60v.cjs');
+const credentialsResolver = require('../shared/bank.CioJeFzf.cjs');
 const cloudflare_workers = require('cloudflare:workers');
 const cloudflare_workflows = require('cloudflare:workflows');
 const d1 = require('drizzle-orm/d1');
@@ -305,6 +305,10 @@ function createWorkflowLogger(instanceId) {
   };
 }
 
+function getStepCount(ctx) {
+  return ctx.step?.count ?? 0;
+}
+
 async function pushToQueue(queue, message) {
   if (!Array.isArray(message)) {
     await queue.send(message, { contentType: "v8" });
@@ -325,6 +329,10 @@ class BankSyncAccountPayments extends cloudflare_workers.WorkflowEntrypoint {
     if (!accountId) {
       throw new cloudflare_workflows.NonRetryableError(`Haven't obtained accountId to load.`);
     }
+    const workflowStartedAt = await step.do(
+      "capture workflow start time",
+      async () => Date.now()
+    );
     while (true) {
       const now = /* @__PURE__ */ new Date();
       const account = await step.do("load account", async () => {
@@ -390,99 +398,106 @@ class BankSyncAccountPayments extends cloudflare_workers.WorkflowEntrypoint {
       const paymentsToProcess = payments.filter(
         (p) => ott_zod.isPaymentCompleted(p.parsed)
       );
-      if (paymentsToProcess.length) {
-        const lastSyncBankRefIds = account.lastSyncMetadata?.lastSyncBankRefIds || [];
-        const paymentsToInsert = paymentsToProcess.filter(
-          (p) => !lastSyncBankRefIds.includes(p.parsed.bankRefId)
-        );
-        await step.do(
-          "process new payments and update lastSyncAt",
-          async () => {
-            const eventsToEmit = [];
-            const bankRefIds = paymentsToInsert.map((p) => p.parsed.bankRefId).filter((id) => id != null);
-            const matchingRequests = bankRefIds.length > 0 ? await db.select().from(ott_zod.tables.paymentRequest).where(
+      const lastSyncBankRefIds = account.lastSyncMetadata?.lastSyncBankRefIds || [];
+      const paymentsToInsert = paymentsToProcess.filter(
+        (p) => !lastSyncBankRefIds.includes(p.parsed.bankRefId)
+      );
+      await step.do(
+        "process new payments and update lastSyncAt",
+        async (ctx) => {
+          const eventsToEmit = [];
+          const bankRefIds = paymentsToInsert.map((p) => p.parsed.bankRefId).filter((id) => id != null);
+          const BANK_REF_ID_CHUNK_SIZE = 90;
+          const matchingRequests = [];
+          for (let i = 0; i < bankRefIds.length; i += BANK_REF_ID_CHUNK_SIZE) {
+            const chunkIds = bankRefIds.slice(i, i + BANK_REF_ID_CHUNK_SIZE);
+            const rows = await db.select().from(ott_zod.tables.paymentRequest).where(
               drizzleOrm.and(
-                drizzleOrm.inArray(ott_zod.tables.paymentRequest.bankRefId, bankRefIds),
+                drizzleOrm.inArray(ott_zod.tables.paymentRequest.bankRefId, chunkIds),
                 drizzleOrm.eq(ott_zod.tables.paymentRequest.accountId, account.id),
-                drizzleOrm.eq(
-                  ott_zod.tables.paymentRequest.connectorKey,
-                  account.connectorKey
-                )
+                drizzleOrm.eq(ott_zod.tables.paymentRequest.connectorKey, account.connectorKey)
               )
-            ) : [];
-            const requestByBankRefId = Object.fromEntries(
-              matchingRequests.map((r) => [r.bankRefId, r])
             );
-            const enrichedPayments = paymentsToInsert.map((p) => {
-              const req = p.parsed.bankRefId && requestByBankRefId[p.parsed.bankRefId] || null;
-              if (!req) return p;
-              return {
-                ...p,
-                parsed: {
-                  ...p.parsed,
-                  // queue-bus: transaction matching (DBU doesn't echo these in statements)
-                  vs: p.parsed.vs ?? req.vs,
-                  ss: p.parsed.ss ?? req.ss,
-                  ks: p.parsed.ks ?? req.ks,
-                  message: p.parsed.message ?? req.message,
-                  // queue-bus: party creation
-                  creditor: {
-                    ...p.parsed.creditor,
-                    holderName: p.parsed.creditor?.holderName ?? req.creditor?.holderName
-                  },
-                  debtor: {
-                    ...p.parsed.debtor,
-                    holderName: p.parsed.debtor?.holderName ?? req.debtor?.holderName
-                  }
-                  // NOT enriched: chargeBearer, instructionPriority, refId, batchId,
-                  //               createdAt, address, swiftBic — no downstream consumer in payment table
+            matchingRequests.push(...rows);
+          }
+          const requestByBankRefId = Object.fromEntries(
+            matchingRequests.map((r) => [r.bankRefId, r])
+          );
+          const enrichedPayments = paymentsToInsert.map((p) => {
+            const req = p.parsed.bankRefId && requestByBankRefId[p.parsed.bankRefId] || null;
+            if (!req) return p;
+            return {
+              ...p,
+              parsed: {
+                ...p.parsed,
+                // queue-bus: transaction matching (DBU doesn't echo these in statements)
+                vs: p.parsed.vs ?? req.vs,
+                ss: p.parsed.ss ?? req.ss,
+                ks: p.parsed.ks ?? req.ks,
+                message: p.parsed.message ?? req.message,
+                // queue-bus: party creation
+                creditor: {
+                  ...p.parsed.creditor,
+                  holderName: p.parsed.creditor?.holderName ?? req.creditor?.holderName
+                },
+                debtor: {
+                  ...p.parsed.debtor,
+                  holderName: p.parsed.debtor?.holderName ?? req.debtor?.holderName
                 }
-              };
-            });
-            const createCommands = enrichedPayments.map(
-              (p) => credentialsResolver.createPaymentCommand(db, { payment: p.parsed }).command
+                // NOT enriched: chargeBearer, instructionPriority, refId, batchId,
+                //               createdAt, address, swiftBic — no downstream consumer in payment table
+              }
+            };
+          });
+          const createCommands = enrichedPayments.map(
+            (p) => credentialsResolver.createPaymentCommand(db, { payment: p.parsed }).command
+          );
+          eventsToEmit.push(
+            ...enrichedPayments.map((p) => ({
+              eventType: "BANK_PAYMENT",
+              eventSignal: "paymentFetched",
+              bankPayment: p.parsed,
+              metadata: {
+                correlationId: p.parsed.correlationId,
+                entityId: p.parsed.id,
+                timestamp: /* @__PURE__ */ new Date()
+              }
+            }))
+          );
+          const lastSyncMetadata = {
+            payments: payments.length,
+            paymentsToProcess: paymentsToProcess.length,
+            paymentsInserted: paymentsToInsert.length,
+            lastSyncBankRefIds: paymentsToProcess.filter((p) => p.parsed.status === "BOOKED").map((p) => p.parsed.bankRefId),
+            lastSyncPayments: lastSyncBankRefIds.length,
+            eventsEmitted: eventsToEmit.length,
+            iterationCount: getStepCount(ctx),
+            workflowStartedAt
+          };
+          const updateLastSyncCommand = updateAccountLastSyncCommand(db, {
+            accountId: account.id,
+            lastSyncAt: now,
+            lastSyncMetadata
+          }).command;
+          if (createCommands.length) {
+            await db.batch(
+              backendSdk.asNonEmpty([updateLastSyncCommand, ...createCommands])
             );
-            eventsToEmit.push(
-              ...enrichedPayments.map((p) => ({
-                eventType: "BANK_PAYMENT",
-                eventSignal: "paymentFetched",
-                bankPayment: p.parsed,
-                metadata: {
-                  correlationId: p.parsed.correlationId,
-                  entityId: p.parsed.id,
-                  timestamp: /* @__PURE__ */ new Date()
-                }
-              }))
+          } else {
+            await updateLastSyncCommand;
+          }
+          if (eventsToEmit.length) {
+            await pushToQueue(
+              this.env.QUEUE_BUS_QUEUE,
+              eventsToEmit
             );
-            const lastSyncMetadata = {
-              payments: payments.length,
-              paymentsToProcess: paymentsToProcess.length,
-              paymentsInserted: paymentsToInsert.length,
-              lastSyncBankRefIds: paymentsToProcess.filter((p) => p.parsed.status === "BOOKED").map((p) => p.parsed.bankRefId),
-              lastSyncPayments: lastSyncBankRefIds.length,
-              eventsEmitted: eventsToEmit.length
-            };
-            const updateLastSyncCommand = updateAccountLastSyncCommand(db, {
-              accountId: account.id,
-              lastSyncAt: now,
-              lastSyncMetadata
-            }).command;
-            if (eventsToEmit.length) {
-              await db.batch(
-                backendSdk.asNonEmpty([updateLastSyncCommand, ...createCommands])
-              );
-              await pushToQueue(
-                this.env.QUEUE_BUS_QUEUE,
-                eventsToEmit
-              );
-            }
-            return {
-              ...lastSyncMetadata,
-              newLastSyncAt: now
-            };
           }
-        );
-      }
+          return {
+            ...lastSyncMetadata,
+            newLastSyncAt: now
+          };
+        }
+      );
       await step.sleep(
         "Sleep for next sync",
         `${account.syncIntervalS} seconds`