@develit-services/bank 0.0.41 → 0.0.43

package/dist/export/worker.mjs

@@ -1,15 +1,15 @@
-import { uuidv4, develitWorker, createInternalError, first, RPCResponse, action, service } from '@develit-io/backend-sdk';
+import { uuidv4, bankAccountMetadataSchema, 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, F as FinbricksConnector, M as MockConnector, E as ErsteConnector, P as PAYMENT_TYPES, e as CONNECTOR_KEYS, B as BATCH_STATUSES, c as PAYMENT_STATUSES, d as PAYMENT_DIRECTIONS, q as getPaymentDirection } from '../shared/bank.HuMp6uP6.mjs';
+import { t as tables, F as FinbricksConnector, M as MockConnector, E as ErsteConnector, 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, v as getPaymentDirection } from '../shared/bank.BWcFhTu1.mjs';
 import 'jose';
 import { CURRENCY_CODES } from '@develit-io/general-codes';
 import { z } from 'zod';
 import { eq, inArray, and, sql, asc, desc, gte, lte } from 'drizzle-orm';
-import { M as MockCobsConnector } from '../shared/bank.E-nyO12E.mjs';
+import { M as MockCobsConnector } from '../shared/bank.6WoCPIFy.mjs';
 import 'drizzle-orm/sqlite-core';
-import 'drizzle-zod';
 import 'date-fns';
+import 'drizzle-zod';
 import 'drizzle-orm/relations';
 
 const upsertAccountCommand = (db, { account }) => {
@@ -345,20 +345,21 @@ const seperateSupportedPayments = (mappedPayments, accounts) => {
 };
 
 const sendPaymentInputSchema = z.object({
+  correlationId: z.string().min(1),
   refId: z.string(),
   amount: z.number().positive(),
   paymentType: z.enum(PAYMENT_TYPES),
+  chargeBearer: z.enum(CHARGE_BEARERS),
+  executionDate: z.string(),
+  instructionPriority: z.enum(INSTRUCTION_PRIORITIES),
   currency: z.enum(CURRENCY_CODES),
-  vs: z.string().nullable().optional(),
-  ss: z.string().nullable().optional(),
-  ks: z.string().nullable().optional(),
-  message: z.string().nullable().optional(),
-  creditorHolderName: z.string(),
-  creditorAccountNumberWithBankCode: z.string(),
-  creditorIban: z.string(),
-  debtorHolderName: z.string(),
-  debtorAccountNumberWithBankCode: z.string(),
-  debtorIban: z.string()
+  vs: z.string().optional(),
+  ss: z.string().optional(),
+  ks: z.string().optional(),
+  message: z.string().optional(),
+  creditor: bankAccountMetadataSchema,
+  debtor: bankAccountMetadataSchema,
+  purpose: z.string().optional()
 });
 
 const getAuthUriInputSchema = z.object({
@@ -377,10 +378,8 @@ const simulateDepositInputSchema = z.object({
   bankingSs: z.string().max(10).optional(),
   bankingKs: z.string().max(10).optional(),
   message: z.string(),
-  creditorIban: z.string().max(34),
-  creditorHolderName: z.string(),
-  debtorIban: z.string().max(34),
-  debtorHolderName: z.string(),
+  creditor: bankAccountMetadataSchema,
+  debtor: bankAccountMetadataSchema,
   connectorKey: z.enum(CONNECTOR_KEYS)
 });
 
@@ -389,11 +388,6 @@ const setLastSyncAtInputSchema = z.object({
   lastSyncedAt: z.coerce.date()
 });
 
-const initiateConnectorInputSchema = z.object({
-  connectorKey: z.enum(CONNECTOR_KEYS),
-  withAuth: z.boolean().default(true).optional()
-});
-
 const ALLOWED_BATCH_FILTERS = {
   ACCOUNT_ID: "filterBatchAccountId",
   STATUS: "filterBatchStatus"
@@ -443,6 +437,10 @@ const syncAccountInputSchema = z.object({
   accountId: z.uuid()
 });
 
+const updateAccountInputSchema = z.object({
+  account: accountInsertSchema
+});
+
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __decorateClass = (decorators, target, key, kind) => {
@@ -460,22 +458,124 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
     this.allowedProviders = config.allowedProviders;
     this.db = drizzle(this.env.BANK_D1, { schema: tables });
   }
-  getAllowedProviders() {
-    return this.allowedProviders;
-  }
-  async getAccounts() {
+  async _getAccounts() {
     return await getAllAccountsQuery(this.db);
   }
-  async getPayments(input) {
-    return this.handleAction(
-      { data: input, schema: getPaymentsInputSchema },
-      { successMessage: "Payments fetched successfully" },
-      async (pagination) => {
-        return await getPaymentsWithPaginationQuery(this.db, pagination);
+  async _saveOrUpdatePayments(accounts) {
+    const allFetchedPayments = [];
+    const connectorKeys = new Set(
+      accounts.map(({ connectorKey }) => connectorKey)
+    );
+    for (const connectorKey of connectorKeys) {
+      await this._initiateBankConnector({ connectorKey });
+      for (const account of accounts.filter(
+        (acc) => acc.connectorKey === connectorKey
+      )) {
+        const payments = await this.bankConnector.getAllAccountPayments({
+          db: this.db,
+          env: this.env.ENVIRONMENT,
+          account
+        });
+        if (!payments || payments.length === 0) continue;
+        this.log(payments);
+        payments.forEach((payment) => {
+          payment.direction = getPaymentDirection(payment, account.iban);
+        });
+        allFetchedPayments.push(...payments);
+      }
+    }
+    if (allFetchedPayments.length < 1) return;
+    const bankRefIds = allFetchedPayments.map((payment) => payment.bankRefId).filter(Boolean);
+    const alreadyExistingPayments = await getPaymentsByBankRefIdsQuery(
+      this.db,
+      {
+        ids: bankRefIds
       }
     );
+    const paymentsCommands = allFetchedPayments.map((payment) => {
+      const isAlreadyExisting = alreadyExistingPayments.some(
+        (existingPayment) => existingPayment.bankRefId === payment.bankRefId
+      );
+      if (isAlreadyExisting)
+        return updatePaymentCommand(this.db, { payment }).command;
+      return createPaymentCommand(this.db, { payment }).command;
+    });
+    await this.db.batch([paymentsCommands[0], ...paymentsCommands.slice(1)]);
+    console.log("FETCHEDPAYMANETS TO SYNC", allFetchedPayments.length);
+    for (const account of accounts) {
+      const paymentsForAccount = allFetchedPayments.filter(
+        (payment) => (payment.direction === "OUTGOING" ? payment.debtorIban : payment.creditorIban) === account.iban
+      );
+      let lastSyncPayment;
+      lastSyncPayment = paymentsForAccount.filter(({ status }) => status !== "COMPLETED").sort(
+        (a, b) => (a.createdAt?.getTime() || 0) - (b.createdAt?.getTime() || 0)
+      )[0];
+      if (!lastSyncPayment) {
+        lastSyncPayment = paymentsForAccount.sort(
+          (a, b) => (b.createdAt?.getTime() || 0) - (a.createdAt?.getTime() || 0)
+        )[0];
+      }
+      if (lastSyncPayment.createdAt) {
+        await updateAccountLastSyncCommand(this.db, {
+          accountId: account.id,
+          lastSyncedAt: lastSyncPayment.createdAt
+        }).command.execute();
+      }
+    }
+    await this.pushToQueue(
+      this.env.QUEUE_BUS_QUEUE,
+      allFetchedPayments.map((payment) => ({
+        eventType: "BANK_PAYMENT",
+        eventSignal: "created",
+        bankPayment: payment,
+        metadata: {
+          correlationId: uuidv4(),
+          timestamp: (/* @__PURE__ */ new Date()).toDateString()
+        }
+      }))
+    );
+  }
+  async _initiateBankConnector({
+    connectorKey,
+    withAuth
+  }) {
+    if (!this.allowedProviders.includes(connectorKey)) {
+      throw createInternalError(null, {
+        message: `Invalid connector key: ${connectorKey}`
+      });
+    }
+    const accounts = await this._getAccounts();
+    const accountsForConnector = accounts.filter(
+      (acc) => acc.connectorKey === connectorKey
+    );
+    const accountsWithCredentials = await Promise.all(
+      accountsForConnector.map(async (acc) => {
+        const credentials = await getCredentialsByAccountId(this.db, {
+          accountId: acc.id
+        });
+        if (!credentials) {
+          throw createInternalError(null, {
+            message: `No credentials found for account ${acc.id}`
+          });
+        }
+        return {
+          currency: acc.currency,
+          iban: acc.iban,
+          token: credentials.value,
+          id: acc.id,
+          connectorKey: acc.connectorKey
+        };
+      })
+    );
+    this.bankConnector = initiateConnector({
+      bank: connectorKey,
+      connectedAccounts: accountsWithCredentials,
+      env: this.env
+    });
+    if (!withAuth) return;
+    await this.bankConnector.authenticate();
   }
-  accountFetchInterval(connectorKey) {
+  _accountFetchInterval(connectorKey) {
     switch (connectorKey) {
       case "ERSTE":
         return ErsteConnector.FETCH_INTERVAL;
@@ -487,10 +587,19 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
         return 0;
     }
   }
+  async getPayments(input) {
+    return this.handleAction(
+      { data: input, schema: getPaymentsInputSchema },
+      { successMessage: "Payments fetched successfully" },
+      async (pagination) => {
+        return await getPaymentsWithPaginationQuery(this.db, pagination);
+      }
+    );
+  }
   async syncAccount(input) {
     return this.handleAction(
       { data: input, schema: syncAccountInputSchema },
-      { successMessage: "" },
+      { successMessage: "Account synchronized successfully" },
       async ({ accountId }) => {
         const account = await getAccountByIdQuery(this.db, {
           accountId
@@ -501,38 +610,40 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
             message: "Account not found",
             status: 404
           });
-        await this.syncAccounts({
-          accounts: [account]
-        });
+        await this._saveOrUpdatePayments([account]);
       }
     );
   }
   async syncAccounts(options) {
-    return this.handleAction(null, {}, async () => {
-      const accountsToSync = [];
-      let accounts = options?.accounts || [];
-      if (!accounts.length) {
-        accounts = await this.getAccounts();
-      }
-      for (const account of accounts.filter(
-        (acc) => !!!acc.connectorKey.includes("MOCK")
-      )) {
-        const accountFetchInterval = this.accountFetchInterval(
-          account.connectorKey
-        );
-        const now = Date.now();
-        const lastSyncTime = account.lastSyncedAt.getTime();
-        const intervalMs = accountFetchInterval * 1e3;
-        const shouldFetch = now - lastSyncTime >= intervalMs;
-        if (!shouldFetch) continue;
-        accountsToSync.push({
-          ...account
-        });
+    return this.handleAction(
+      null,
+      { successMessage: "Accounts synchronized successfully" },
+      async () => {
+        const accountsToSync = [];
+        let accounts = options?.accounts || [];
+        if (!accounts.length) {
+          accounts = await this._getAccounts();
+        }
+        for (const account of accounts.filter(
+          (acc) => !!!acc.connectorKey.includes("MOCK")
+        )) {
+          const accountFetchInterval = this._accountFetchInterval(
+            account.connectorKey
+          );
+          const now = Date.now();
+          const lastSyncTime = account.lastSyncedAt.getTime();
+          const intervalMs = accountFetchInterval * 1e3;
+          const shouldFetch = now - lastSyncTime >= intervalMs;
+          if (!shouldFetch) continue;
+          accountsToSync.push({
+            ...account
+          });
+        }
+        console.log("ACCS TO SYNC", accountsToSync.length);
+        if (accountsToSync.length <= 0) return;
+        await this._saveOrUpdatePayments(accounts);
       }
-      console.log("ACCS TO SYNC", accountsToSync.length);
-      if (accountsToSync.length <= 0) return;
-      await this.saveOrUpdatePayments(accountsToSync);
-    });
+    );
   }
   async scheduled(controller) {
     if (controller.cron === this.env.CRON_PAYMENTS_PROCESSING) {
@@ -547,7 +658,7 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
   async updateBatchStatuses() {
     const pendingBatches = await getAllPendingBatchesQuery(this.db);
     const uniqueConnectors = /* @__PURE__ */ new Set();
-    const accounts = await this.getAccounts();
+    const accounts = await this._getAccounts();
     for (const batch of pendingBatches) {
       const connectorKey = accounts.find(
         (acc) => acc.id === batch.accountId
@@ -588,53 +699,6 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
     ]);
     console.log("Batch update completed");
   }
-  // @action('initiate-bank-connector')
-  async initiateBankConnector(input) {
-    return this.handleAction(
-      { data: input, schema: initiateConnectorInputSchema },
-      { successMessage: "Bank connector initiated successfully" },
-      async ({ connectorKey, withAuth }) => {
-        if (!this.allowedProviders.includes(connectorKey)) {
-          throw createInternalError(null, {
-            message: `Invalid connector key: ${connectorKey}`
-          });
-        }
-        const accounts = await this.getAccounts();
-        const accountsForConnector = accounts.filter(
-          (acc) => acc.connectorKey === connectorKey
-        );
-        const accountsWithCredentials = await Promise.all(
-          accountsForConnector.map(async (acc) => {
-            const credentials = await getCredentialsByAccountId(this.db, {
-              accountId: acc.id
-            });
-            if (!credentials) {
-              throw createInternalError(null, {
-                message: `No credentials found for account ${acc.id}`
-              });
-            }
-            return {
-              currency: acc.currency,
-              iban: acc.iban,
-              token: credentials.value,
-              id: acc.id,
-              connectorKey: acc.connectorKey
-            };
-          })
-        );
-        this.bankConnector = initiateConnector({
-          bank: connectorKey,
-          connectedAccounts: accountsWithCredentials,
-          env: this.env
-        });
-        if (!withAuth) return;
-        await this.bankConnector.authenticate();
-      }
-    );
-  }
-  batchLimit(connectorKey) {
-    return 50;
-  }
   async addPaymentsToBatch({
     paymentsToBatch
   }) {
@@ -644,9 +708,8 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
         (payment) => {
           return {
             id: uuidv4(),
-            accountId: "",
+            correlationId: payment.correlationId,
             refId: payment.refId,
-            connectorKey: "MOCK",
             amount: payment.amount,
             direction: "OUTGOING",
             paymentType: payment.paymentType,
@@ -658,16 +721,14 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
             ss: payment.ss || null,
             ks: payment.ks || null,
             message: payment.message || null,
-            creditorHolderName: payment.creditorHolderName,
-            creditorAccountNumberWithBankCode: payment.creditorAccountNumberWithBankCode,
-            creditorIban: payment.creditorIban,
-            debtorHolderName: payment.debtorHolderName,
-            debtorAccountNumberWithBankCode: payment.debtorAccountNumberWithBankCode,
-            debtorIban: payment.debtorIban
+            creditor: payment.creditor,
+            creditorIban: payment.creditor.iban || null,
+            debtor: payment.debtor,
+            debtorIban: payment.debtor.iban || null
           };
         }
       );
-      const accounts = await this.getAccounts();
+      const accounts = await this._getAccounts();
       const { supportedPayments, unsupportedPayments } = seperateSupportedPayments(mappedPayments, accounts);
       if (unsupportedPayments.length > 0) {
         this.logError({ unsupportedPayments });
@@ -678,23 +739,17 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
             bankPayment: {
               ...unsupported,
               status: "FAILED",
-              statusReason: "UNSUPPORTED_ACCOUNT",
-              paymentType: unsupported.paymentType,
-              creditorAccountNumberWithBankCode: unsupported.creditorAccountNumberWithBankCode,
-              creditorIban: unsupported.creditorIban,
-              creditorHolderName: unsupported.creditorHolderName,
-              debtorAccountNumberWithBankCode: unsupported.debtorAccountNumberWithBankCode,
-              debtorIban: unsupported.debtorIban,
-              debtorHolderName: unsupported.debtorHolderName
+              statusReason: "UNSUPPORTED_ACCOUNT"
             },
+            eventSignal: "failed",
             metadata: {
-              correlationId: uuidv4(),
+              correlationId: unsupported.correlationId,
               timestamp: (/* @__PURE__ */ new Date()).toDateString()
             }
           }))
         );
       }
-      for (const acc of await this.getAccounts()) {
+      for (const acc of accounts) {
         const newPayments = supportedPayments.filter(
           (payment) => payment.debtorIban === acc.iban && payment.currency === acc.currency
         ).map((payment) => ({
@@ -712,7 +767,7 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
           accountId: acc.id
         });
         const availableBatch = openBatches.find(
-          (batch) => batch.payments.length >= this.batchLimit(acc.connectorKey)
+          (batch) => batch.payments.length >= acc.batchSizeLimit
         );
         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`
@@ -748,7 +803,7 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
             status: "PROCESSING"
           }
         }).command.execute();
-        await this.initiateBankConnector({ connectorKey });
+        await this._initiateBankConnector({ connectorKey });
         if (!this.bankConnector) {
           await upsertBatchCommand(this.db, {
             batch: {
@@ -877,7 +932,7 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
       { data: input, schema: getAuthUriInputSchema },
       { successMessage: "Auth URI obtained." },
       async ({ connectorKey }) => {
-        await this.initiateBankConnector({ connectorKey, withAuth: false });
+        await this._initiateBankConnector({ connectorKey, withAuth: false });
         const ott = uuidv4();
         const { command: createOneTimeToken } = createOneTimeTokenCommand(
           this.db,
@@ -915,14 +970,14 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
             status: 400
           });
         }
-        await this.initiateBankConnector({
+        await this._initiateBankConnector({
           connectorKey: ottRow.refId
         });
         const { credentials, accounts } = await this.bankConnector.authorizeAccount({
           urlParams
         });
         console.log("Bank connector initiated");
-        const alreadyExistingAccounts = (await this.getAccounts()).filter(
+        const alreadyExistingAccounts = (await this._getAccounts()).filter(
           (acc) => acc.connectorKey === ottRow.refId && accounts.map((item) => item.iban).includes(acc.iban)
         );
         const upsertAccounts = accounts.map(
@@ -949,7 +1004,7 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
           ...deleteCredentials,
           ...createAccountCredentials
         ]);
-        const fetchedAccounts = await this.getAccounts();
+        const fetchedAccounts = await this._getAccounts();
         if (!fetchedAccounts)
           throw createInternalError(null, {
             message: "Account not found",
@@ -962,79 +1017,6 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
       }
     );
   }
-  async saveOrUpdatePayments(accounts) {
-    return this.handleAction(null, {}, async () => {
-      const allFetchedPayments = [];
-      const connectorKeys = new Set(
-        accounts.map(({ connectorKey }) => connectorKey)
-      );
-      for (const connectorKey of connectorKeys) {
-        await this.initiateBankConnector({ connectorKey });
-        for (const account of accounts.filter(
-          (acc) => acc.connectorKey === connectorKey
-        )) {
-          const payments = await this.bankConnector.getAllAccountPayments({
-            db: this.db,
-            env: this.env.ENVIRONMENT,
-            account
-          });
-          if (!payments || payments.length === 0) continue;
-          this.log(payments);
-          payments.forEach((payment) => {
-            payment.direction = getPaymentDirection(payment, account.iban);
-          });
-          allFetchedPayments.push(...payments);
-        }
-      }
-      if (allFetchedPayments.length < 1) return;
-      const bankRefIds = allFetchedPayments.map((payment) => payment.bankRefId).filter(Boolean);
-      const alreadyExistingPayments = await getPaymentsByBankRefIdsQuery(
-        this.db,
-        { ids: bankRefIds }
-      );
-      const paymentsCommands = allFetchedPayments.map((payment) => {
-        const isAlreadyExisting = alreadyExistingPayments.some(
-          (existingPayment) => existingPayment.bankRefId === payment.bankRefId
-        );
-        if (isAlreadyExisting)
-          return updatePaymentCommand(this.db, { payment }).command;
-        return createPaymentCommand(this.db, { payment }).command;
-      });
-      await this.db.batch([paymentsCommands[0], ...paymentsCommands.slice(1)]);
-      console.log("FETCHEDPAYMANETS TO SYNC", allFetchedPayments.length);
-      for (const account of accounts) {
-        const paymentsForAccount = allFetchedPayments.filter(
-          (payment) => (payment.direction === "OUTGOING" ? payment.debtorIban : payment.creditorIban) === account.iban
-        );
-        let lastSyncPayment;
-        lastSyncPayment = paymentsForAccount.filter(({ status }) => status !== "COMPLETED").sort(
-          (a, b) => (a.createdAt?.getTime() || 0) - (b.createdAt?.getTime() || 0)
-        )[0];
-        if (!lastSyncPayment) {
-          lastSyncPayment = paymentsForAccount.sort(
-            (a, b) => (b.createdAt?.getTime() || 0) - (a.createdAt?.getTime() || 0)
-          )[0];
-        }
-        if (lastSyncPayment.createdAt) {
-          await updateAccountLastSyncCommand(this.db, {
-            accountId: account.id,
-            lastSyncedAt: lastSyncPayment.createdAt
-          }).command.execute();
-        }
-      }
-      await this.pushToQueue(
-        this.env.QUEUE_BUS_QUEUE,
-        allFetchedPayments.map((payment) => ({
-          eventType: "BANK_PAYMENT",
-          bankPayment: payment,
-          metadata: {
-            correlationId: uuidv4(),
-            timestamp: (/* @__PURE__ */ new Date()).toDateString()
-          }
-        }))
-      );
-    });
-  }
   async simulateDeposit(input) {
     return this.handleAction(
       { data: input, schema: simulateDepositInputSchema },
@@ -1046,14 +1028,12 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
         bankingSs,
         bankingKs,
         message,
-        creditorIban,
-        creditorHolderName,
-        debtorIban,
-        debtorHolderName,
+        creditor,
+        debtor,
         connectorKey
       }) => {
         const account = await getAccountByIbanQuery(this.db, {
-          iban: creditorIban
+          iban: debtor.iban
         });
         if (!account)
           throw createInternalError(null, {
@@ -1063,6 +1043,7 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
           });
         const payment = {
           id: uuidv4(),
+          correlationId: uuidv4(),
           amount,
           connectorKey,
           accountId: account.id,
@@ -1077,19 +1058,20 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
           ss: bankingSs,
           ks: bankingKs,
           message,
-          creditorIban,
-          creditorHolderName,
-          debtorIban,
-          debtorHolderName
+          creditor,
+          creditorIban: creditor.iban,
+          debtor,
+          debtorIban: debtor.iban
         };
         const { command } = createPaymentCommand(this.db, { payment });
         const createdPayment = await command.execute().then(first);
         this.logQueuePush({ payment, isPaymentExecuted: true });
         await this.pushToQueue(this.env.QUEUE_BUS_QUEUE, {
           eventType: "BANK_PAYMENT",
+          eventSignal: "completed",
           bankPayment: createdPayment,
           metadata: {
-            correlationId: createdPayment.id,
+            correlationId: createdPayment.correlationId,
             timestamp: (/* @__PURE__ */ new Date()).toDateString()
           }
         });
@@ -1115,7 +1097,6 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
           accountId: account.id,
           lastSyncedAt
         }).command.execute();
-        return {};
       }
     );
   }
@@ -1132,9 +1113,33 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
     );
   }
   async getBankAccounts() {
-    return RPCResponse.ok("Bank accounts retrieved successfully", {
-      data: await this.getAccounts()
-    });
+    return this.handleAction(
+      null,
+      { successMessage: "Bank accounts retrieved successfully" },
+      async () => await this._getAccounts()
+    );
+  }
+  async updateAccount(input) {
+    return this.handleAction(
+      {
+        data: input,
+        schema: updateAccountInputSchema
+      },
+      { successMessage: "Account updated successfully" },
+      async ({ account }) => {
+        const updatedAccount = await upsertAccountCommand(this.db, {
+          account
+        }).command.execute().then(first);
+        if (!updatedAccount) {
+          throw createInternalError(null, {
+            message: "Account not found",
+            code: "ACCOUNT_NOT_FOUND",
+            status: 404
+          });
+        }
+        return updatedAccount;
+      }
+    );
   }
   async getBatches(input) {
     return this.handleAction(
@@ -1176,9 +1181,6 @@ __decorateClass([
 __decorateClass([
   action("authorize-account")
 ], BankServiceBase.prototype, "authorizeAccount", 1);
-__decorateClass([
-  action("save-or-update-payments")
-], BankServiceBase.prototype, "saveOrUpdatePayments", 1);
 __decorateClass([
   action("simulate-deposit")
 ], BankServiceBase.prototype, "simulateDeposit", 1);
@@ -1191,6 +1193,9 @@ __decorateClass([
 __decorateClass([
   action("get-bank-accounts")
 ], BankServiceBase.prototype, "getBankAccounts", 1);
+__decorateClass([
+  action("update-account")
+], BankServiceBase.prototype, "updateAccount", 1);
 __decorateClass([
   action("getBatches")
 ], BankServiceBase.prototype, "getBatches", 1);

package/dist/shared/{bank.E-nyO12E.mjs → bank.6WoCPIFy.mjs}

@@ -1,4 +1,4 @@
-import { F as FinbricksConnector } from './bank.HuMp6uP6.mjs';
+import { F as FinbricksConnector } from './bank.BWcFhTu1.mjs';
 
 class MockCobsConnector extends FinbricksConnector {
   constructor(config) {