@develit-services/bank 0.3.44 → 0.3.46

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.DFRS9oN5.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.Cj-oB02_.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.DhPfZ6b_.mjs';
+import 'drizzle-zod';
 
 const upsertAccountCommand = (db, { account }) => {
   const id = account.id || uuidv4();
@@ -259,7 +258,9 @@ const getAuthUriInputSchema = z.object({
 
 const authorizeAccountInputSchema = z.object({
   ott: z.string(),
-  urlParams: z.string()
+  urlParams: z.string(),
+  syncIntervalS: z.number().int().positive().optional(),
+  startSync: z.boolean().optional()
 });
 
 const simulateDepositInputSchema = z.object({
@@ -313,20 +314,12 @@ 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
-]);
+const updateBatchStatusesInputSchema = z.object({
+  batchId: z.uuid().optional()
+}).optional();
 z.object({
-  success: z.boolean(),
-  message: z.string()
+  processed: z.number(),
+  statusChanged: z.number()
 });
 
 const ALLOWED_PAYMENT_FILTERS = {
@@ -414,9 +407,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 +422,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 +548,97 @@ 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;
     }
-    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 {
+      batchId: batch.id,
+      previousStatus,
+      currentStatus,
+      statusChanged
+      // eventSent,
+    };
+  }
+  async updateBatchStatuses(input) {
+    return this.handleAction(
+      { data: input, schema: updateBatchStatusesInputSchema },
+      { successMessage: "Batch statuses updated" },
+      async (validatedInput) => {
+        let pendingBatches;
+        if (validatedInput?.batchId) {
+          const batch = await getBatchByIdQuery(this.db, {
+            batchId: validatedInput.batchId
           });
-          return {
-            ...batch,
-            status: newStatus
-          };
-        })
-      );
-      finalBatches.push(...updatedBatches);
-    }
-    const updateBatchesCommands = finalBatches.map((batch) => {
-      const { command } = upsertBatchCommand(this.db, {
-        batch: {
-          ...batch
+          if (!batch) {
+            throw createInternalError(null, {
+              message: `Batch not found: ${validatedInput.batchId}`,
+              code: "DB-B-007",
+              status: 404
+            });
+          }
+          pendingBatches = [batch];
+        } else {
+          pendingBatches = await getAllPendingBatchesQuery(this.db);
         }
-      });
-      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"
-            }
+        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: "FAILED",
+                statusReason: "ACCOUNT_NOT_FOUND"
+              }
+            }).command.execute();
+            continue;
+          }
+          const batches = batchesByConnector.get(account.connectorKey) || [];
+          batches.push(batch);
+          batchesByConnector.set(account.connectorKey, batches);
+        }
+        const allResults = [];
+        for (const [connectorKey, batches] of batchesByConnector) {
+          console.log(
+            `Initializing ${connectorKey} connector for ${batches.length} batches`
+          );
+          const connector = await this._initiateBankConnector({
+            connectorKey
           });
+          for (const batch of batches) {
+            const result = await this._resolveSingleBatch(batch, connector);
+            if (result) {
+              allResults.push(result);
+            }
+          }
         }
-      } catch (_) {
+        const changedCount = allResults.filter((r) => r.statusChanged).length;
         console.log(
-          `No workflow instance found for batch ${batch.id}, skipping.`
+          `Batch update completed: ${changedCount} status change(s) detected`
         );
+        return {
+          processed: allResults.length,
+          statusChanged: changedCount
+        };
       }
-    }
-    console.log("Batch update completed");
+    );
   }
   async addPaymentsToBatch({
     paymentsToBatch
@@ -762,23 +781,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 +799,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 +813,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 };
       }
     );
@@ -817,7 +822,7 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
     return this.handleAction(
       { data: input, schema: authorizeAccountInputSchema },
       { successMessage: "Erste code saved." },
-      async ({ ott, urlParams }) => {
+      async ({ ott, urlParams, syncIntervalS, startSync }) => {
         const ottRow = await getOttQuery(this.db, {
           ott
         });
@@ -835,10 +840,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");
@@ -847,7 +852,7 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
         );
         const upsertAccounts = accounts.map(
           (acc) => upsertAccountCommand(this.db, {
-            account: acc
+            account: syncIntervalS ? { ...acc, syncIntervalS } : acc
           }).command
         );
         const deleteCredentials = alreadyExistingAccounts.map(
@@ -879,6 +884,19 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
             code: "DB-B-003",
             status: 404
           });
+        if (startSync) {
+          for (const account of fetchedAccounts) {
+            const { error } = await this.syncAccount({
+              accountId: account.id
+            });
+            if (error) {
+              this.logError({
+                message: `Failed to auto-start sync workflow for account ${account.id}`,
+                error
+              });
+            }
+          }
+        }
         return {
           accounts: fetchedAccounts
         };