@develit-services/bank 0.3.60 → 0.4.0

package/dist/export/worker.mjs

@@ -1,17 +1,18 @@
 import { uuidv4, first, bankAccountMetadataSchema, workflowInstanceStatusSchema, develitWorker, createInternalError, action, service } from '@develit-io/backend-sdk';
 import { WorkerEntrypoint } from 'cloudflare:workers';
 import { drizzle } from 'drizzle-orm/d1';
-import { t as tables } from '../shared/bank.DgGcjhmM.mjs';
+import { t as tables, e as encrypt, i as importAesKey, b as getCredentialsByAccountId, u as upsertBatchCommand, g as getBatchByIdQuery, d as createPaymentCommand, a as getAccountByIdQuery } from '../shared/bank.B51e8oDT.mjs';
+import { i as initiateConnector, t as toIncomingPayment, d as assignAccount, e as toBatchedPayment } from '../shared/bank.DinCwx0P.mjs';
 import { z } from 'zod';
-import { I as INSTRUCTION_PRIORITIES, C as CHARGE_BEARERS, P as PAYMENT_TYPES, d as CONNECTOR_KEYS, B as BATCH_STATUSES, a as PAYMENT_STATUSES, b as PAYMENT_DIRECTIONS, f as accountInsertSchema } from '../shared/bank.BqGzJNC6.mjs';
+import { I as INSTRUCTION_PRIORITIES, C as CHARGE_BEARERS, P as PAYMENT_TYPES, d as CONNECTOR_KEYS, B as BATCH_STATUSES, a as PAYMENT_STATUSES, b as PAYMENT_DIRECTIONS, f as accountInsertSchema } from '../shared/bank.qc8ALZwm.mjs';
 import { CURRENCY_CODES } from '@develit-io/general-codes';
 import 'date-fns';
-import { eq, sql, inArray, and, asc, desc, gte, lte } from 'drizzle-orm';
 import 'jose';
+import { eq, sql, inArray, and, asc, desc, gte, lte } from 'drizzle-orm';
 import 'node:crypto';
-import { f as encrypt, i as importAesKey, a as getCredentialsByAccountId, b as initiateConnector, u as upsertBatchCommand, d as getBatchByIdQuery, c as createPaymentCommand, g as getAccountByIdQuery } from '../shared/bank.DSsVeR3F.mjs';
-import 'drizzle-orm/sqlite-core';
+import '../shared/bank.BUSlmr6r.mjs';
 import 'drizzle-orm/relations';
+import 'drizzle-orm/sqlite-core';
 import 'drizzle-zod';
 
 const upsertAccountCommand = (db, { account }) => {
@@ -234,8 +235,8 @@ const getOttQuery = async (db, { ott }) => {
   return await db.select().from(tables.ott).where(eq(tables.ott.oneTimeToken, ott)).get();
 };
 
-const seperateSupportedPayments = (mappedPayments, accounts) => {
-  const [supportedPayments, unsupportedPayments] = mappedPayments.reduce(
+const seperateSupportedPayments = (incomingPayments, accounts) => {
+  const [supportedPayments, unsupportedPayments] = incomingPayments.reduce(
     ([valid, invalid], payment) => {
       const isValid = accounts.some(
         (acc) => acc.iban === payment.debtorIban && acc.currency === payment.currency
@@ -270,7 +271,8 @@ const sendPaymentInputSchema = z.object({
   message: z.string().optional(),
   creditor: bankAccountMetadataSchema,
   debtor: bankAccountMetadataSchema,
-  purpose: z.string().optional()
+  purpose: z.string().optional(),
+  sendAsSinglePayment: z.boolean().optional()
 });
 
 const getAuthUriInputSchema = z.object({
@@ -673,32 +675,9 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
   }) {
     return this.handleAction(null, {}, async () => {
       this.logInput({ paymentsToBatch });
-      const mappedPayments = paymentsToBatch.map(
-        (payment) => {
-          return {
-            id: uuidv4(),
-            correlationId: payment.correlationId,
-            refId: payment.refId,
-            amount: payment.amount,
-            direction: "OUTGOING",
-            paymentType: payment.paymentType,
-            currency: payment.currency,
-            status: "CREATED",
-            initiatedAt: /* @__PURE__ */ new Date(),
-            processedAt: null,
-            vs: payment.vs || null,
-            ss: payment.ss || null,
-            ks: payment.ks || null,
-            message: payment.message || null,
-            creditor: payment.creditor,
-            creditorIban: payment.creditor.iban || null,
-            debtor: payment.debtor,
-            debtorIban: payment.debtor.iban || null
-          };
-        }
-      );
+      const incomingPayments = paymentsToBatch.map(toIncomingPayment);
       const accounts = await this._getAccounts();
-      const { supportedPayments, unsupportedPayments } = seperateSupportedPayments(mappedPayments, accounts);
+      const { supportedPayments, unsupportedPayments } = seperateSupportedPayments(incomingPayments, accounts);
       if (unsupportedPayments.length > 0) {
         this.logError({ unsupportedPayments });
         await this.pushToQueue(
@@ -720,45 +699,72 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
         );
       }
       for (const acc of accounts) {
-        const newPayments = supportedPayments.filter(
+        const accountAssignedPayments = supportedPayments.filter(
           (payment) => payment.debtorIban === acc.iban && payment.currency === acc.currency
-        ).map((payment) => ({
-          ...payment,
-          connectorKey: acc.connectorKey,
-          accountId: acc.id
-        }));
-        if (newPayments.length === 0) {
+        ).map((payment) => assignAccount(payment, acc));
+        if (accountAssignedPayments.length === 0) {
           continue;
         }
         this.log({
-          message: `\u{1F4B0} Processing ${newPayments.length} payments for account (${acc.iban}, ${acc.currency})`
-        });
-        const openBatches = await getAccountOpenBatchesQuery(this.db, {
-          accountId: acc.id
+          message: `\u{1F4B0} Processing ${accountAssignedPayments.length} payments for account (${acc.iban}, ${acc.currency})`
         });
-        const availableBatch = openBatches.find(
-          (batch) => batch.payments.length < acc.batchSizeLimit
+        const singlePayments = accountAssignedPayments.filter(
+          (p) => p.sendAsSinglePayment === true
         );
-        this.log({
-          message: availableBatch ? `\u{1F504} Found existing OPEN batches for account ${acc.id}, merging ${availableBatch.payments.length} existing + ${newPayments.length} new payments` : `\u2728 Creating new batch for account ${acc.id} with ${newPayments.length} payments`
-        });
-        const { command } = upsertBatchCommand(this.db, {
-          batch: availableBatch ? {
-            ...availableBatch,
-            payments: [...availableBatch.payments, ...newPayments]
-          } : {
-            id: uuidv4(),
-            authorizationUrls: [],
-            accountId: acc.id,
-            payments: newPayments,
-            status: "OPEN"
-          }
-        });
-        const upsertedBatch = await command.execute();
-        this.log({
-          message: `\u2705 Batch upserted successfully for account ${acc.id}`
-        });
-        return upsertedBatch;
+        const regularPayments = accountAssignedPayments.filter(
+          (p) => p.sendAsSinglePayment !== true
+        );
+        for (const singlePayment of singlePayments) {
+          const batchedPayment = toBatchedPayment(singlePayment);
+          const { command } = upsertBatchCommand(this.db, {
+            batch: {
+              id: uuidv4(),
+              authorizationUrls: [],
+              accountId: acc.id,
+              payments: [batchedPayment],
+              status: "OPEN",
+              metadata: {
+                sizeLimit: 1
+              }
+            }
+          });
+          await command.execute();
+          this.log({
+            message: `\u2728 Created single payment batch for account ${acc.id}`
+          });
+        }
+        if (regularPayments.length > 0) {
+          const openBatches = await getAccountOpenBatchesQuery(this.db, {
+            accountId: acc.id
+          });
+          const availableBatch = openBatches.find(
+            (batch) => batch.payments.length < (batch.metadata?.sizeLimit ?? acc.batchSizeLimit)
+          );
+          this.log({
+            message: availableBatch ? `\u{1F504} Found existing OPEN batch for account ${acc.id}, merging ${availableBatch.payments.length} existing + ${regularPayments.length} new payments` : `\u2728 Creating new batch for account ${acc.id} with ${regularPayments.length} payments`
+          });
+          const batchedPayments = regularPayments.map(toBatchedPayment);
+          const { command } = upsertBatchCommand(this.db, {
+            batch: availableBatch ? {
+              ...availableBatch,
+              payments: [...availableBatch.payments, ...batchedPayments]
+            } : {
+              id: uuidv4(),
+              authorizationUrls: [],
+              accountId: acc.id,
+              payments: batchedPayments,
+              status: "OPEN",
+              metadata: {
+                sizeLimit: acc.batchSizeLimit
+              }
+            }
+          });
+          const upsertedBatch = await command.execute();
+          this.log({
+            message: `\u2705 Batch upserted successfully for account ${acc.id}`
+          });
+          return upsertedBatch;
+        }
       }
     });
   }

package/dist/export/workflows.cjs

@@ -1,16 +1,18 @@
 'use strict';
 
+const backendSdk = require('@develit-io/backend-sdk');
 const cloudflare_workers = require('cloudflare:workers');
 const cloudflare_workflows = require('cloudflare:workflows');
 const d1 = require('drizzle-orm/d1');
-const drizzle = require('../shared/bank.CNEv3Rac.cjs');
-const backendSdk = require('@develit-io/backend-sdk');
-const encryption = require('../shared/bank.CXpc8168.cjs');
+const drizzle = require('../shared/bank.DEvSNsEs.cjs');
+const batchLifecycle = require('../shared/bank.Bg3Pdwm4.cjs');
+const mock_connector = require('../shared/bank.CfSZTfWS.cjs');
 const drizzleOrm = require('drizzle-orm');
-require('date-fns');
-require('../shared/bank.CMbfx0u7.cjs');
-require('drizzle-orm/sqlite-core');
+require('../shared/bank.c38V_FCq.cjs');
+require('../shared/bank.BeIpkWR-.cjs');
 require('drizzle-orm/relations');
+require('drizzle-orm/sqlite-core');
+require('date-fns');
 require('@develit-io/general-codes');
 require('jose');
 require('node:crypto');
@@ -39,6 +41,206 @@ function pushToQueue$1(queue, message) {
     }))
   );
 }
+class BankProcessBatch extends cloudflare_workers.WorkflowEntrypoint {
+  async run(event, step) {
+    const { batchId } = event.payload;
+    const db = d1.drizzle(this.env.BANK_D1, { schema: drizzle.tables });
+    const batch = await step.do("load batch", async () => {
+      const batch2 = await drizzle.getBatchByIdQuery(db, { batchId });
+      if (!batch2) {
+        throw new cloudflare_workflows.NonRetryableError(`Batch not found`);
+      }
+      if (batchLifecycle.isBatchSigned(batch2))
+        throw new cloudflare_workflows.NonRetryableError(`Batch already signed`);
+      return batch2;
+    });
+    await step.do("lock batch", async () => {
+      const paymentsChecksum = drizzle.checksum(batch.payments);
+      if (batch.paymentsChecksum && batch.paymentsChecksum !== paymentsChecksum)
+        throw new cloudflare_workflows.NonRetryableError(
+          `Batch payments have been modified externally, manual review needed`
+        );
+      if (batchLifecycle.isBatchFailed(batch))
+        throw new cloudflare_workflows.NonRetryableError(
+          `Batch is in FAILED status and cannot be processed, manual review needed`
+        );
+      if (batchLifecycle.isBatchOpen(batch)) {
+        const updatedBatch = await drizzle.upsertBatchCommand(db, {
+          batch: {
+            ...batch,
+            status: "PROCESSING",
+            paymentsChecksum
+          }
+        }).command.execute().then(backendSdk.first);
+        return { status: updatedBatch.status };
+      }
+      return { status: batch.status };
+    });
+    const batchResult = await step.do(
+      "initiate batch with payments",
+      {
+        retries: { limit: 5, delay: 2e3, backoff: "constant" },
+        timeout: "30 seconds"
+      },
+      async () => {
+        if (batch.batchPaymentInitiatedAt) {
+          return {
+            authorizationUrls: batch.authorizationUrls,
+            preparedPayments: batch.payments.map(
+              (p) => mock_connector.toPreparedPayment(p, void 0, batch.batchPaymentInitiatedAt)
+            ),
+            metadata: batch.metadata
+          };
+        }
+        const account = await drizzle.getAccountByIdQuery(db, {
+          accountId: batch.accountId
+        });
+        if (!account) {
+          throw new cloudflare_workflows.NonRetryableError(`Account not found: ${batch.accountId}`);
+        }
+        const encryptionKey = await drizzle.importAesKey(this.env.ENCRYPTION_KEY);
+        const credentials = await drizzle.getCredentialsByAccountId(db, encryptionKey, {
+          accountId: account.id
+        });
+        if (!credentials) {
+          throw new cloudflare_workflows.NonRetryableError(
+            `No credentials found for account: ${account.id}`
+          );
+        }
+        if (credentials.expiresAt < /* @__PURE__ */ new Date()) {
+          throw new cloudflare_workflows.NonRetryableError(
+            `Credentials have expired for account: ${account.id}`
+          );
+        }
+        const connector = mock_connector.initiateConnector({
+          env: this.env,
+          bank: account.connectorKey,
+          connectedAccounts: [
+            {
+              ...account,
+              iban: account.iban,
+              token: credentials.value
+            }
+          ]
+        });
+        const result = await connector.initiateBatch({
+          batchId: batch.id,
+          payments: batch.payments
+        });
+        const {
+          authorizationUrls,
+          payments: preparedPayments,
+          metadata
+        } = result;
+        if (!authorizationUrls || authorizationUrls.length === 0) {
+          throw new Error("Failed to retrieve authorization URLs");
+        }
+        return {
+          authorizationUrls,
+          preparedPayments,
+          metadata
+        };
+      }
+    );
+    await step.do("update batch to ready to sign", async () => {
+      const upsertBatch = drizzle.upsertBatchCommand(db, {
+        batch: {
+          ...batch,
+          authorizationUrls: batchResult.authorizationUrls,
+          metadata: batchResult.metadata,
+          status: "READY_TO_SIGN",
+          batchPaymentInitiatedAt: /* @__PURE__ */ new Date()
+        }
+      }).command;
+      await upsertBatch.execute();
+      return {
+        status: "READY_TO_SIGN",
+        paymentsPrepared: batchResult.preparedPayments.length
+      };
+    });
+    const isMockConnector = batchResult.preparedPayments.some(
+      (p) => p.connectorKey === "MOCK"
+    );
+    if (isMockConnector) {
+      await step.do(
+        "mock: create completed payments and update batch",
+        async () => {
+          const processedAt = /* @__PURE__ */ new Date();
+          const completedPayments = batchResult.preparedPayments.map(
+            (p) => mock_connector.toCompletedPayment(p, "COMPLETED", `MOCK-${backendSdk.uuidv4()}`, processedAt)
+          );
+          const createCommands = completedPayments.map(
+            (payment) => drizzle.createPaymentCommand(db, { payment }).command
+          );
+          const updateBatchCommand = drizzle.upsertBatchCommand(db, {
+            batch: {
+              ...batch,
+              status: "SIGNED",
+              authorizationUrls: batchResult.authorizationUrls,
+              metadata: batchResult.metadata,
+              batchPaymentInitiatedAt: /* @__PURE__ */ new Date()
+            }
+          }).command;
+          if (createCommands.length > 0) {
+            await db.batch([updateBatchCommand, ...createCommands]);
+          } else {
+            await updateBatchCommand.execute();
+          }
+          const eventsToEmit = completedPayments.map(
+            (payment) => ({
+              eventType: "BANK_PAYMENT",
+              eventSignal: "paymentCompleted",
+              bankPayment: payment,
+              metadata: {
+                correlationId: backendSdk.uuidv4(),
+                entityId: payment.id,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              }
+            })
+          );
+          await pushToQueue$1(
+            this.env.QUEUE_BUS_QUEUE,
+            eventsToEmit
+          );
+          return {
+            paymentsCreated: completedPayments.length,
+            eventsEmitted: completedPayments.length
+          };
+        }
+      );
+    }
+    if (!isMockConnector) {
+      await step.do("enqueue authorization email", async () => {
+        await pushToQueue$1(this.env.NOTIFICATIONS_QUEUE, {
+          type: "email",
+          payload: {
+            email: {
+              to: [this.env.BANK_AUTH_RECIPIENT],
+              subject: "Payment Authorization",
+              text: Array.isArray(batchResult.authorizationUrls) ? batchResult.authorizationUrls[0] || "No Authorization URL" : batchResult.authorizationUrls || "No Authorization URL"
+            }
+          },
+          metadata: {
+            initiator: {
+              service: "bank"
+            }
+          }
+        });
+        return { emailSent: true };
+      });
+    }
+  }
+}
+
+function pushToQueue(queue, message) {
+  if (!Array.isArray(message)) return queue.send(message, { contentType: "v8" });
+  return queue.sendBatch(
+    message.map((m) => ({
+      body: m,
+      contentType: "v8"
+    }))
+  );
+}
 class BankSyncAccountPayments extends cloudflare_workers.WorkflowEntrypoint {
   async run(event, step) {
     const { accountId } = event.payload;
@@ -46,7 +248,7 @@ class BankSyncAccountPayments extends cloudflare_workers.WorkflowEntrypoint {
     while (true) {
       const now = /* @__PURE__ */ new Date();
       const account = await step.do("load account", async () => {
-        const account2 = await encryption.getAccountByIdQuery(db, { accountId });
+        const account2 = await drizzle.getAccountByIdQuery(db, { accountId });
         if (!account2) {
           throw new cloudflare_workflows.NonRetryableError(`Bank account not found: ${accountId}`);
         }
@@ -63,8 +265,8 @@ class BankSyncAccountPayments extends cloudflare_workers.WorkflowEntrypoint {
           timeout: "30 seconds"
         },
         async () => {
-          const encryptionKey = await encryption.importAesKey(this.env.ENCRYPTION_KEY);
-          const credentials = await encryption.getCredentialsByAccountId(
+          const encryptionKey = await drizzle.importAesKey(this.env.ENCRYPTION_KEY);
+          const credentials = await drizzle.getCredentialsByAccountId(
             db,
             encryptionKey,
             { accountId }
@@ -79,7 +281,7 @@ class BankSyncAccountPayments extends cloudflare_workers.WorkflowEntrypoint {
               `Credentials have expired for account: ${accountId}`
             );
           }
-          const connector = encryption.initiateConnector({
+          const connector = mock_connector.initiateConnector({
             env: this.env,
             bank: account.connectorKey,
             connectedAccounts: [
@@ -91,15 +293,13 @@ class BankSyncAccountPayments extends cloudflare_workers.WorkflowEntrypoint {
             ]
           });
           return await connector.getAllAccountPayments({
-            environment: this.env.ENVIRONMENT,
-            db,
             account,
             filter: { dateFrom: account.lastSyncAt }
           });
         }
       );
       const paymentsToProcess = payments.filter(
-        (p) => p.parsed.status === "COMPLETED" || p.parsed.status === "FAILED"
+        (p) => batchLifecycle.isPaymentCompleted(p.parsed)
       );
       if (paymentsToProcess.length) {
         const lastSyncBankRefIds = account.lastSyncMetadata?.lastSyncBankRefIds || [];
@@ -111,7 +311,7 @@ class BankSyncAccountPayments extends cloudflare_workers.WorkflowEntrypoint {
           async () => {
             const eventsToEmit = [];
             const createCommands = paymentsToInsert.map(
-              (p) => encryption.createPaymentCommand(db, { payment: p.parsed }).command
+              (p) => drizzle.createPaymentCommand(db, { payment: p.parsed }).command
             );
             eventsToEmit.push(
               ...paymentsToInsert.map((p) => ({
@@ -144,7 +344,7 @@ class BankSyncAccountPayments extends cloudflare_workers.WorkflowEntrypoint {
               await db.batch(
                 backendSdk.asNonEmpty([updateLastSyncCommand, ...createCommands])
               );
-              await pushToQueue$1(
+              await pushToQueue(
                 this.env.QUEUE_BUS_QUEUE,
                 eventsToEmit
               );
@@ -164,201 +364,5 @@ class BankSyncAccountPayments extends cloudflare_workers.WorkflowEntrypoint {
   }
 }
 
-function pushToQueue(queue, message) {
-  if (!Array.isArray(message)) return queue.send(message, { contentType: "v8" });
-  return queue.sendBatch(
-    message.map((m) => ({
-      body: m,
-      contentType: "v8"
-    }))
-  );
-}
-class BankProcessBatch extends cloudflare_workers.WorkflowEntrypoint {
-  async run(event, step) {
-    const { batchId } = event.payload;
-    const db = d1.drizzle(this.env.BANK_D1, { schema: drizzle.tables });
-    const batch = await step.do("load batch", async () => {
-      const batch2 = await encryption.getBatchByIdQuery(db, { batchId });
-      if (!batch2) {
-        throw new cloudflare_workflows.NonRetryableError(`Batch not found`);
-      }
-      if (batch2.status === "SIGNED")
-        throw new cloudflare_workflows.NonRetryableError(`Batch already signed`);
-      return batch2;
-    });
-    await step.do("lock batch", async () => {
-      const paymentsChecksum = encryption.checksum(batch.payments);
-      if (batch.paymentsChecksum && batch.paymentsChecksum !== paymentsChecksum)
-        throw new cloudflare_workflows.NonRetryableError(
-          `Batch payments have been modified externally, manual review needed`
-        );
-      if (batch.status === "FAILED")
-        throw new cloudflare_workflows.NonRetryableError(
-          `Batch is in FAILED status and cannot be processed, manual review needed`
-        );
-      if (batch.status === "OPEN") {
-        const updatedBatch = await encryption.upsertBatchCommand(db, {
-          batch: {
-            ...batch,
-            status: "PROCESSING",
-            paymentsChecksum
-          }
-        }).command.execute().then(backendSdk.first);
-        return { status: updatedBatch.status };
-      }
-      return { status: batch.status };
-    });
-    const preparedPayments = await step.do(
-      "prepare payments",
-      {
-        retries: { limit: 5, delay: 2e3, backoff: "constant" },
-        timeout: "30 seconds"
-      },
-      async () => {
-        const account = await encryption.getAccountByIdQuery(db, {
-          accountId: batch.accountId
-        });
-        if (!account) {
-          throw new cloudflare_workflows.NonRetryableError(`Account not found: ${batch.accountId}`);
-        }
-        const encryptionKey = await encryption.importAesKey(this.env.ENCRYPTION_KEY);
-        const credentials = await encryption.getCredentialsByAccountId(db, encryptionKey, {
-          accountId: account.id
-        });
-        if (!credentials) {
-          throw new cloudflare_workflows.NonRetryableError(
-            `No credentials found for account: ${account.id}`
-          );
-        }
-        if (credentials.expiresAt < /* @__PURE__ */ new Date()) {
-          throw new cloudflare_workflows.NonRetryableError(
-            `Credentials have expired for account: ${account.id}`
-          );
-        }
-        const connector = encryption.initiateConnector({
-          env: this.env,
-          bank: account.connectorKey,
-          connectedAccounts: [
-            {
-              ...account,
-              iban: account.iban,
-              token: credentials.value
-            }
-          ]
-        });
-        const preparedPayments2 = [];
-        for (const payment of batch.payments) {
-          const prepared = await connector.preparePayment(payment);
-          if (prepared) {
-            preparedPayments2.push(prepared);
-          }
-        }
-        return preparedPayments2;
-      }
-    );
-    const batchResult = await step.do(
-      "initiate batch from payments",
-      {
-        retries: { limit: 5, delay: 2e3, backoff: "constant" },
-        timeout: "30 seconds"
-      },
-      async () => {
-        if (batch.batchPaymentInitiatedAt) {
-          return {
-            authorizationUrls: batch.authorizationUrls,
-            initializedPayments: preparedPayments.map((p) => ({
-              ...p,
-              status: "INITIALIZED"
-            })),
-            metadata: batch.metadata
-          };
-        }
-        const account = await encryption.getAccountByIdQuery(db, {
-          accountId: batch.accountId
-        });
-        if (!account) {
-          throw new cloudflare_workflows.NonRetryableError(`Account not found: ${batch.accountId}`);
-        }
-        const encryptionKey = await encryption.importAesKey(this.env.ENCRYPTION_KEY);
-        const credentials = await encryption.getCredentialsByAccountId(db, encryptionKey, {
-          accountId: account.id
-        });
-        if (!credentials) {
-          throw new cloudflare_workflows.NonRetryableError(
-            `No credentials found for account: ${account.id}`
-          );
-        }
-        if (credentials.expiresAt < /* @__PURE__ */ new Date()) {
-          throw new cloudflare_workflows.NonRetryableError(
-            `Credentials have expired for account: ${account.id}`
-          );
-        }
-        const connector = encryption.initiateConnector({
-          env: this.env,
-          bank: account.connectorKey,
-          connectedAccounts: [
-            {
-              ...account,
-              iban: account.iban,
-              token: credentials.value
-            }
-          ]
-        });
-        const result = await connector.initiateBatchFromPayments({
-          batchId: batch.id,
-          payments: preparedPayments
-        });
-        const {
-          authorizationUrls,
-          payments: initializedPayments,
-          metadata
-        } = result;
-        if (!authorizationUrls || authorizationUrls.length === 0) {
-          throw new Error("Failed to retrieve authorization URLs");
-        }
-        return {
-          authorizationUrls,
-          initializedPayments,
-          metadata
-        };
-      }
-    );
-    await step.do("update batch and payments to initialized", async () => {
-      const upsertBatch = encryption.upsertBatchCommand(db, {
-        batch: {
-          ...batch,
-          authorizationUrls: batchResult.authorizationUrls,
-          metadata: batchResult.metadata,
-          status: "READY_TO_SIGN",
-          batchPaymentInitiatedAt: /* @__PURE__ */ new Date()
-        }
-      }).command;
-      await upsertBatch.execute();
-      return {
-        status: "READY_TO_SIGN",
-        paymentsInitialized: batchResult.initializedPayments.length
-      };
-    });
-    await step.do("enqueue authorization email", async () => {
-      await pushToQueue(this.env.NOTIFICATIONS_QUEUE, {
-        type: "email",
-        payload: {
-          email: {
-            to: [this.env.BANK_AUTH_RECIPIENT],
-            subject: "Payment Authorization",
-            text: Array.isArray(batchResult.authorizationUrls) ? batchResult.authorizationUrls[0] || "No Authorization URL" : batchResult.authorizationUrls || "No Authorization URL"
-          }
-        },
-        metadata: {
-          initiator: {
-            service: "bank"
-          }
-        }
-      });
-      return { emailSent: true };
-    });
-  }
-}
-
 exports.BankProcessBatch = BankProcessBatch;
 exports.BankSyncAccountPayments = BankSyncAccountPayments;