@develit-services/bank 0.3.43 → 0.3.45

package/dist/export/worker.mjs

@@ -1,19 +1,18 @@
 import { uuidv4, bankAccountMetadataSchema, workflowInstanceStatusSchema, develitWorker, createInternalError, first, action, service } from '@develit-io/backend-sdk';
 import { WorkerEntrypoint } from 'cloudflare:workers';
 import { drizzle } from 'drizzle-orm/d1';
-import { t as tables, c as INSTRUCTION_PRIORITIES, C as CHARGE_BEARERS, P as PAYMENT_TYPES, g as CONNECTOR_KEYS, B as BATCH_STATUSES, d as PAYMENT_STATUSES, e as PAYMENT_DIRECTIONS, i as accountInsertSchema, M as MockConnector, F as FinbricksConnector, E as ErsteConnector } from '../shared/bank.YiArmBW2.mjs';
-import 'jose';
-import { CURRENCY_CODES } from '@develit-io/general-codes';
+import { t as tables } from '../shared/bank.B1Gpn3ht.mjs';
 import { z } from 'zod';
-import { e as encrypt, P as PROCESS_BATCH_WORKFLOW_EVENTS, i as importAesKey, a as getCredentialsByAccountId, b as initiateConnector, u as upsertBatchCommand, c as createPaymentCommand, g as getAccountByIdQuery } from '../shared/bank.CUU0Daxj.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.D-3fzX63.mjs';
+import { CURRENCY_CODES } from '@develit-io/general-codes';
+import 'date-fns';
 import { eq, inArray, and, sql, asc, desc, gte, lte } from 'drizzle-orm';
+import 'jose';
+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.BUEmFxS8.mjs';
 import 'drizzle-orm/sqlite-core';
-import 'date-fns';
-import 'drizzle-zod';
 import 'drizzle-orm/relations';
-import 'node:crypto';
-import 'cloudflare:workflows';
-import '../shared/bank.CNtiZSem.mjs';
+import 'drizzle-zod';
 
 const upsertAccountCommand = (db, { account }) => {
   const id = account.id || uuidv4();
@@ -313,22 +312,6 @@ z.object({
   details: workflowInstanceStatusSchema
 });
 
-const batchAuthorizedEventPayloadSchema = z.object({
-  authorized: z.boolean()
-});
-const processBatchEventInputSchema = z.discriminatedUnion("eventType", [
-  z.object({
-    batchId: z.uuid(),
-    eventType: z.literal(PROCESS_BATCH_WORKFLOW_EVENTS.batchAuthorized),
-    payload: batchAuthorizedEventPayloadSchema
-  })
-  // Future event types can be added here as new objects in the array
-]);
-z.object({
-  success: z.boolean(),
-  message: z.string()
-});
-
 const ALLOWED_PAYMENT_FILTERS = {
   ACCOUNT_ID: "filterPaymentAccountId",
   AMOUNT: "filterPaymentAmount",
@@ -414,9 +397,13 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
   async _getAccounts() {
     return await getAllAccountsQuery(this.db);
   }
+  async _getConnectedAccounts() {
+    const accounts = await this._getAccounts();
+    return accounts.filter((acc) => acc.status !== "DISABLED");
+  }
   async _initiateBankConnector({
     connectorKey,
-    withAuth
+    skipAccounts
   }) {
     if (!this.allowedProviders.includes(connectorKey)) {
       throw createInternalError(null, {
@@ -425,55 +412,45 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
         status: 400
       });
     }
-    const accounts = await this._getAccounts();
-    const accountsForConnector = accounts.filter(
-      (acc) => acc.connectorKey === connectorKey && acc.status !== "DISABLED"
-    );
-    const encryptionKey = await importAesKey(this.env.ENCRYPTION_KEY);
-    const accountsWithCredentials = await Promise.all(
-      accountsForConnector.map(async (acc) => {
-        const credentials = await getCredentialsByAccountId(
-          this.db,
-          encryptionKey,
-          {
-            accountId: acc.id
+    let connectedAccounts = [];
+    if (!skipAccounts) {
+      const encryptionKey = await importAesKey(this.env.ENCRYPTION_KEY);
+      const accounts = await this._getConnectedAccounts();
+      const accountsForConnector = accounts.filter(
+        (acc) => acc.connectorKey === connectorKey
+      );
+      connectedAccounts = await Promise.all(
+        accountsForConnector.map(async (acc) => {
+          const credentials = await getCredentialsByAccountId(
+            this.db,
+            encryptionKey,
+            {
+              accountId: acc.id
+            }
+          );
+          if (!credentials) {
+            throw createInternalError(null, {
+              message: `No credentials found for account ${acc.id}`,
+              code: "DB-B-001",
+              status: 404
+            });
           }
-        );
-        if (!credentials) {
-          throw createInternalError(null, {
-            message: `No credentials found for account ${acc.id}`,
-            code: "DB-B-001",
-            status: 404
-          });
-        }
-        return {
-          currency: acc.currency,
-          iban: acc.iban,
-          token: credentials.value,
-          id: acc.id,
-          connectorKey: acc.connectorKey
-        };
-      })
-    );
-    this.bankConnector = initiateConnector({
+          return {
+            currency: acc.currency,
+            iban: acc.iban,
+            token: credentials.value,
+            id: acc.id,
+            connectorKey: acc.connectorKey
+          };
+        })
+      );
+    }
+    const connector = initiateConnector({
       bank: connectorKey,
-      connectedAccounts: accountsWithCredentials,
+      connectedAccounts,
       env: this.env
     });
-    if (!withAuth) return;
-    await this.bankConnector.authenticate();
-  }
-  _accountFetchInterval(connectorKey) {
-    switch (connectorKey) {
-      case "ERSTE":
-        return ErsteConnector.FETCH_INTERVAL;
-      case "FINBRICKS":
-        return FinbricksConnector.FETCH_INTERVAL;
-      case "MOCK":
-        return MockConnector.FETCH_INTERVAL;
-      default:
-        return 0;
-    }
+    return connector;
   }
   async getPayments(input) {
     return this.handleAction(
@@ -561,65 +538,85 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
       await this.updateBatchStatuses();
     }
   }
-  async updateBatchStatuses() {
-    const pendingBatches = await getAllPendingBatchesQuery(this.db);
-    const uniqueConnectors = /* @__PURE__ */ new Set();
-    const accounts = await this._getAccounts();
-    for (const batch of pendingBatches) {
-      const connectorKey = accounts.find(
-        (acc) => acc.id === batch.accountId
-      ).connectorKey;
-      if (!uniqueConnectors.has(connectorKey)) {
-        uniqueConnectors.add(connectorKey);
+  async _resolveSingleBatch(batch, connector) {
+    const previousStatus = batch.status;
+    const currentStatus = await connector.getBatchStatus({
+      batchId: batch.id
+    });
+    let statusChanged = false;
+    if (previousStatus !== currentStatus) {
+      await upsertBatchCommand(this.db, {
+        batch: {
+          ...batch,
+          status: currentStatus
+        }
+      }).command.execute();
+      statusChanged = true;
+    }
+    return {
+      batchId: batch.id,
+      previousStatus,
+      currentStatus,
+      statusChanged
+      // eventSent,
+    };
+  }
+  async updateBatchStatuses(input) {
+    let pendingBatches;
+    if (input?.batchId) {
+      const batch = await getBatchByIdQuery(this.db, { batchId: input.batchId });
+      if (!batch) {
+        throw createInternalError(null, {
+          message: `Batch not found: ${input.batchId}`,
+          code: "DB-B-007",
+          status: 404
+        });
       }
+      pendingBatches = [batch];
+    } else {
+      pendingBatches = await getAllPendingBatchesQuery(this.db);
     }
-    const finalBatches = [];
-    for (const connectorKey of uniqueConnectors) {
-      const accs = accounts.filter((acc) => acc.connectorKey === connectorKey);
-      const updatedBatches = await Promise.all(
-        accs.map(async (account) => {
-          const batch = pendingBatches.find((acc) => acc.id === account.id);
-          const newStatus = await this.bankConnector.getBatchStatus({
-            batchId: batch.id
-          });
-          return {
+    const accounts = await this._getConnectedAccounts();
+    console.log(`Processing ${pendingBatches.length} pending batche(s)`);
+    const batchesByConnector = /* @__PURE__ */ new Map();
+    for (const batch of pendingBatches) {
+      const account = accounts.find((acc) => acc.id === batch.accountId);
+      if (!account) {
+        this.logError({
+          message: `Account not found for batch ${batch.id}, skipping`
+        });
+        await upsertBatchCommand(this.db, {
+          batch: {
             ...batch,
-            status: newStatus
-          };
-        })
-      );
-      finalBatches.push(...updatedBatches);
+            status: "FAILED",
+            statusReason: "ACCOUNT_NOT_FOUND"
+          }
+        }).command.execute();
+        continue;
+      }
+      const batches = batchesByConnector.get(account.connectorKey) || [];
+      batches.push(batch);
+      batchesByConnector.set(account.connectorKey, batches);
     }
-    const updateBatchesCommands = finalBatches.map((batch) => {
-      const { command } = upsertBatchCommand(this.db, {
-        batch: {
-          ...batch
-        }
+    const allResults = [];
+    for (const [connectorKey, batches] of batchesByConnector) {
+      console.log(
+        `Initializing ${connectorKey} connector for ${batches.length} batches`
+      );
+      const connector = await this._initiateBankConnector({
+        connectorKey
       });
-      return command;
-    });
-    await this.db.batch([
-      updateBatchesCommands[0],
-      ...updateBatchesCommands.slice(1)
-    ]);
-    for (const batch of finalBatches) {
-      try {
-        const instance = await this.env.PROCESS_BATCH_WORKFLOW.get(batch.id);
-        if (batch.status === "SIGNED" || batch.status === "SIGNATURE_FAILED") {
-          instance.sendEvent({
-            type: PROCESS_BATCH_WORKFLOW_EVENTS.batchAuthorized,
-            payload: {
-              authorized: batch.status === "SIGNED"
-            }
-          });
+      for (const batch of batches) {
+        const result = await this._resolveSingleBatch(batch, connector);
+        if (result) {
+          allResults.push(result);
         }
-      } catch (_) {
-        console.log(
-          `No workflow instance found for batch ${batch.id}, skipping.`
-        );
       }
     }
-    console.log("Batch update completed");
+    const changedCount = allResults.filter((r) => r.statusChanged).length;
+    console.log(
+      `Batch update completed: ${changedCount} status change(s) detected.`
+    );
   }
   async addPaymentsToBatch({
     paymentsToBatch
@@ -762,23 +759,6 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
       }
     );
   }
-  async processBatchEvent(input) {
-    return this.handleAction(
-      { data: input, schema: processBatchEventInputSchema },
-      { successMessage: "Event sent to batch processing workflow" },
-      async ({ batchId, eventType, payload }) => {
-        const instance = await this.env.PROCESS_BATCH_WORKFLOW.get(batchId);
-        await instance.sendEvent({
-          type: eventType,
-          payload
-        });
-        return {
-          success: true,
-          message: `Event '${eventType}' sent to workflow instance ${batchId}`
-        };
-      }
-    );
-  }
   async queue(b) {
     await this.handleAction(
       null,
@@ -797,7 +777,10 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
       { data: input, schema: getAuthUriInputSchema },
       { successMessage: "Auth URI obtained." },
       async ({ connectorKey }) => {
-        await this._initiateBankConnector({ connectorKey, withAuth: false });
+        const connector = await this._initiateBankConnector({
+          connectorKey,
+          skipAccounts: true
+        });
         const ott = uuidv4();
         const { command: createOneTimeToken } = createOneTimeTokenCommand(
           this.db,
@@ -808,7 +791,7 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
           }
         );
         await createOneTimeToken.execute();
-        const uri = await this.bankConnector.getAuthUri({ ott });
+        const uri = await connector.getAuthUri({ ott });
         return { uri };
       }
     );
@@ -835,10 +818,10 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
             status: 400
           });
         }
-        await this._initiateBankConnector({
+        const connector = await this._initiateBankConnector({
           connectorKey: ottRow.refId
         });
-        const { credentials, accounts } = await this.bankConnector.authorizeAccount({
+        const { credentials, accounts } = await connector.authorizeAccount({
           urlParams
         });
         console.log("Bank connector initiated");

package/dist/export/workflows.cjs

@@ -3,34 +3,34 @@
 const cloudflare_workers = require('cloudflare:workers');
 const cloudflare_workflows = require('cloudflare:workflows');
 const d1 = require('drizzle-orm/d1');
-const database_schema = require('../shared/bank.CLF9wee9.cjs');
+const drizzle = require('../shared/bank.CPYfE-Ei.cjs');
 const backendSdk = require('@develit-io/backend-sdk');
-const processBatch_workflow = require('../shared/bank.ChffLgyT.cjs');
+const encryption = require('../shared/bank.D0a-MZon.cjs');
 const drizzleOrm = require('drizzle-orm');
-require('drizzle-orm/sqlite-core');
 require('date-fns');
-require('jose');
-require('@develit-io/general-codes');
-require('drizzle-zod');
+require('../shared/bank.CpwLFudl.cjs');
+require('drizzle-orm/sqlite-core');
 require('drizzle-orm/relations');
+require('@develit-io/general-codes');
+require('jose');
 require('node:crypto');
-require('../shared/bank.DfE0M5H3.cjs');
+require('drizzle-zod');
 
 const updateAccountLastSyncCommand = (db, {
   lastSyncAt,
   accountId,
   lastSyncMetadata
 }) => {
-  const command = db.update(database_schema.tables.account).set({
+  const command = db.update(drizzle.tables.account).set({
     lastSyncAt,
     lastSyncMetadata
-  }).where(drizzleOrm.eq(database_schema.tables.account.id, accountId)).returning();
+  }).where(drizzleOrm.eq(drizzle.tables.account.id, accountId)).returning();
   return {
     command
   };
 };
 
-function pushToQueue(queue, message) {
+function pushToQueue$1(queue, message) {
   if (!Array.isArray(message)) return queue.send(message, { contentType: "v8" });
   return queue.sendBatch(
     message.map((m) => ({
@@ -42,11 +42,11 @@ function pushToQueue(queue, message) {
 class BankSyncAccountPayments extends cloudflare_workers.WorkflowEntrypoint {
   async run(event, step) {
     const { accountId } = event.payload;
-    const db = d1.drizzle(this.env.BANK_D1, { schema: database_schema.tables });
+    const db = d1.drizzle(this.env.BANK_D1, { schema: drizzle.tables });
     while (true) {
       const now = /* @__PURE__ */ new Date();
       const account = await step.do("load account", async () => {
-        const account2 = await processBatch_workflow.getAccountByIdQuery(db, { accountId });
+        const account2 = await encryption.getAccountByIdQuery(db, { accountId });
         if (!account2) {
           throw new cloudflare_workflows.NonRetryableError(`Bank account not found: ${accountId}`);
         }
@@ -63,8 +63,8 @@ class BankSyncAccountPayments extends cloudflare_workers.WorkflowEntrypoint {
           timeout: "30 seconds"
         },
         async () => {
-          const encryptionKey = await processBatch_workflow.importAesKey(this.env.ENCRYPTION_KEY);
-          const credentials = await processBatch_workflow.getCredentialsByAccountId(
+          const encryptionKey = await encryption.importAesKey(this.env.ENCRYPTION_KEY);
+          const credentials = await encryption.getCredentialsByAccountId(
             db,
             encryptionKey,
             { accountId }
@@ -79,7 +79,7 @@ class BankSyncAccountPayments extends cloudflare_workers.WorkflowEntrypoint {
               `Credentials have expired for account: ${accountId}`
             );
           }
-          const connector = processBatch_workflow.initiateConnector({
+          const connector = encryption.initiateConnector({
             env: this.env,
             bank: account.connectorKey,
             connectedAccounts: [
@@ -111,7 +111,7 @@ class BankSyncAccountPayments extends cloudflare_workers.WorkflowEntrypoint {
           async () => {
             const eventsToEmit = [];
             const createCommands = paymentsToInsert.map(
-              (p) => processBatch_workflow.createPaymentCommand(db, { payment: p.parsed }).command
+              (p) => encryption.createPaymentCommand(db, { payment: p.parsed }).command
             );
             eventsToEmit.push(
               ...paymentsToInsert.map((p) => ({
@@ -144,7 +144,7 @@ class BankSyncAccountPayments extends cloudflare_workers.WorkflowEntrypoint {
               await db.batch(
                 backendSdk.asNonEmpty([updateLastSyncCommand, ...createCommands])
               );
-              await pushToQueue(
+              await pushToQueue$1(
                 this.env.QUEUE_BUS_QUEUE,
                 eventsToEmit
               );
@@ -164,5 +164,201 @@ class BankSyncAccountPayments extends cloudflare_workers.WorkflowEntrypoint {
   }
 }
 
-exports.BankProcessBatch = processBatch_workflow.BankProcessBatch;
+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" || batch.status === "FULL") {
+        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;