@develit-services/bank 0.0.41 → 0.0.42

package/dist/database/schema.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-const database_schema = require('../shared/bank.C2tmTjwq.cjs');
+const database_schema = require('../shared/bank.Cw5xzUgM.cjs');
 require('@develit-io/backend-sdk');
 require('drizzle-orm/sqlite-core');
 require('drizzle-orm');

package/dist/database/schema.d.cts

@@ -1,4 +1,5 @@
-export { f as account, g as accountCredentials, c as batch, o as ott, d as payment, e as paymentRelations } from '../shared/bank.e_XSg9KV.cjs';
+export { f as account, g as accountCredentials, c as batch, o as ott, d as payment, e as paymentRelations } from '../shared/bank.PvYf5Bqd.cjs';
 import 'drizzle-orm/sqlite-core';
 import 'drizzle-orm';
 import 'zod';
+import '@develit-io/backend-sdk';

package/dist/database/schema.d.mts

@@ -1,4 +1,5 @@
-export { f as account, g as accountCredentials, c as batch, o as ott, d as payment, e as paymentRelations } from '../shared/bank.e_XSg9KV.mjs';
+export { f as account, g as accountCredentials, c as batch, o as ott, d as payment, e as paymentRelations } from '../shared/bank.PvYf5Bqd.mjs';
 import 'drizzle-orm/sqlite-core';
 import 'drizzle-orm';
 import 'zod';
+import '@develit-io/backend-sdk';

package/dist/database/schema.d.ts

@@ -1,4 +1,5 @@
-export { f as account, g as accountCredentials, c as batch, o as ott, d as payment, e as paymentRelations } from '../shared/bank.e_XSg9KV.js';
+export { f as account, g as accountCredentials, c as batch, o as ott, d as payment, e as paymentRelations } from '../shared/bank.PvYf5Bqd.js';
 import 'drizzle-orm/sqlite-core';
 import 'drizzle-orm';
 import 'zod';
+import '@develit-io/backend-sdk';

package/dist/database/schema.mjs

@@ -1,4 +1,4 @@
-export { y as account, z as accountCredentials, r as batch, x as ott, v as payment, w as paymentRelations } from '../shared/bank.HuMp6uP6.mjs';
+export { D as account, G as accountCredentials, w as batch, z as ott, x as payment, y as paymentRelations } from '../shared/bank.C4RJkRzZ.mjs';
 import '@develit-io/backend-sdk';
 import 'drizzle-orm/sqlite-core';
 import 'drizzle-orm';

package/dist/export/worker.cjs

@@ -5,12 +5,12 @@ Object.defineProperty(exports, '__esModule', { value: true });
 const backendSdk = require('@develit-io/backend-sdk');
 const cloudflare_workers = require('cloudflare:workers');
 const d1 = require('drizzle-orm/d1');
-const database_schema = require('../shared/bank.C2tmTjwq.cjs');
+const database_schema = require('../shared/bank.Cw5xzUgM.cjs');
 require('jose');
 const generalCodes = require('@develit-io/general-codes');
 const zod = require('zod');
 const drizzleOrm = require('drizzle-orm');
-const mockCobs_connector = require('../shared/bank.DBgpADhg.cjs');
+const mockCobs_connector = require('../shared/bank.DSXZph4D.cjs');
 require('drizzle-orm/sqlite-core');
 require('drizzle-zod');
 require('date-fns');
@@ -349,20 +349,21 @@ const seperateSupportedPayments = (mappedPayments, accounts) => {
 };
 
 const sendPaymentInputSchema = zod.z.object({
+  correlationId: zod.z.string().min(1),
   refId: zod.z.string(),
   amount: zod.z.number().positive(),
   paymentType: zod.z.enum(database_schema.PAYMENT_TYPES),
+  chargeBearer: zod.z.enum(database_schema.CHARGE_BEARERS),
+  executionDate: zod.z.string(),
+  instructionPriority: zod.z.enum(database_schema.INSTRUCTION_PRIORITIES),
   currency: zod.z.enum(generalCodes.CURRENCY_CODES),
-  vs: zod.z.string().nullable().optional(),
-  ss: zod.z.string().nullable().optional(),
-  ks: zod.z.string().nullable().optional(),
-  message: zod.z.string().nullable().optional(),
-  creditorHolderName: zod.z.string(),
-  creditorAccountNumberWithBankCode: zod.z.string(),
-  creditorIban: zod.z.string(),
-  debtorHolderName: zod.z.string(),
-  debtorAccountNumberWithBankCode: zod.z.string(),
-  debtorIban: zod.z.string()
+  vs: zod.z.string().optional(),
+  ss: zod.z.string().optional(),
+  ks: zod.z.string().optional(),
+  message: zod.z.string().optional(),
+  creditor: backendSdk.bankAccountMetadataSchema,
+  debtor: backendSdk.bankAccountMetadataSchema,
+  purpose: zod.z.string().optional()
 });
 
 const getAuthUriInputSchema = zod.z.object({
@@ -393,11 +394,6 @@ const setLastSyncAtInputSchema = zod.z.object({
   lastSyncedAt: zod.z.coerce.date()
 });
 
-const initiateConnectorInputSchema = zod.z.object({
-  connectorKey: zod.z.enum(database_schema.CONNECTOR_KEYS),
-  withAuth: zod.z.boolean().default(true).optional()
-});
-
 const ALLOWED_BATCH_FILTERS = {
   ACCOUNT_ID: "filterBatchAccountId",
   STATUS: "filterBatchStatus"
@@ -447,6 +443,10 @@ const syncAccountInputSchema = zod.z.object({
   accountId: zod.z.uuid()
 });
 
+const updateAccountInputSchema = zod.z.object({
+  account: database_schema.accountInsertSchema
+});
+
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __decorateClass = (decorators, target, key, kind) => {
@@ -464,22 +464,123 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
     this.allowedProviders = config.allowedProviders;
     this.db = d1.drizzle(this.env.BANK_D1, { schema: database_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 = database_schema.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: backendSdk.uuidv4(),
+          timestamp: (/* @__PURE__ */ new Date()).toDateString()
+        }
+      }))
+    );
+  }
+  async _initiateBankConnector({
+    connectorKey,
+    withAuth
+  }) {
+    if (!this.allowedProviders.includes(connectorKey)) {
+      throw backendSdk.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 backendSdk.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 database_schema.ErsteConnector.FETCH_INTERVAL;
@@ -491,10 +592,19 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
         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
@@ -505,38 +615,40 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
             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) {
@@ -551,7 +663,7 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
   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
@@ -592,53 +704,6 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
     ]);
     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 backendSdk.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 backendSdk.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
   }) {
@@ -648,9 +713,8 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
         (payment) => {
           return {
             id: backendSdk.uuidv4(),
-            accountId: "",
+            correlationId: payment.correlationId,
             refId: payment.refId,
-            connectorKey: "MOCK",
             amount: payment.amount,
             direction: "OUTGOING",
             paymentType: payment.paymentType,
@@ -662,16 +726,14 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
             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 });
@@ -682,23 +744,16 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
             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"
             },
             metadata: {
-              correlationId: backendSdk.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) => ({
@@ -716,7 +771,7 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
           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`
@@ -752,7 +807,7 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
             status: "PROCESSING"
           }
         }).command.execute();
-        await this.initiateBankConnector({ connectorKey });
+        await this._initiateBankConnector({ connectorKey });
         if (!this.bankConnector) {
           await upsertBatchCommand(this.db, {
             batch: {
@@ -881,7 +936,7 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
       { data: input, schema: getAuthUriInputSchema },
       { successMessage: "Auth URI obtained." },
       async ({ connectorKey }) => {
-        await this.initiateBankConnector({ connectorKey, withAuth: false });
+        await this._initiateBankConnector({ connectorKey, withAuth: false });
         const ott = backendSdk.uuidv4();
         const { command: createOneTimeToken } = createOneTimeTokenCommand(
           this.db,
@@ -919,14 +974,14 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
             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(
@@ -953,7 +1008,7 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
           ...deleteCredentials,
           ...createAccountCredentials
         ]);
-        const fetchedAccounts = await this.getAccounts();
+        const fetchedAccounts = await this._getAccounts();
         if (!fetchedAccounts)
           throw backendSdk.createInternalError(null, {
             message: "Account not found",
@@ -966,79 +1021,6 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
       }
     );
   }
-  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 = database_schema.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: backendSdk.uuidv4(),
-            timestamp: (/* @__PURE__ */ new Date()).toDateString()
-          }
-        }))
-      );
-    });
-  }
   async simulateDeposit(input) {
     return this.handleAction(
       { data: input, schema: simulateDepositInputSchema },
@@ -1119,7 +1101,6 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
           accountId: account.id,
           lastSyncedAt
         }).command.execute();
-        return {};
       }
     );
   }
@@ -1136,9 +1117,33 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
     );
   }
   async getBankAccounts() {
-    return backendSdk.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(backendSdk.first);
+        if (!updatedAccount) {
+          throw backendSdk.createInternalError(null, {
+            message: "Account not found",
+            code: "ACCOUNT_NOT_FOUND",
+            status: 404
+          });
+        }
+        return updatedAccount;
+      }
+    );
   }
   async getBatches(input) {
     return this.handleAction(
@@ -1180,9 +1185,6 @@ __decorateClass([
 __decorateClass([
   backendSdk.action("authorize-account")
 ], BankServiceBase.prototype, "authorizeAccount", 1);
-__decorateClass([
-  backendSdk.action("save-or-update-payments")
-], BankServiceBase.prototype, "saveOrUpdatePayments", 1);
 __decorateClass([
   backendSdk.action("simulate-deposit")
 ], BankServiceBase.prototype, "simulateDeposit", 1);
@@ -1195,6 +1197,9 @@ __decorateClass([
 __decorateClass([
   backendSdk.action("get-bank-accounts")
 ], BankServiceBase.prototype, "getBankAccounts", 1);
+__decorateClass([
+  backendSdk.action("update-account")
+], BankServiceBase.prototype, "updateAccount", 1);
 __decorateClass([
   backendSdk.action("getBatches")
 ], BankServiceBase.prototype, "getBatches", 1);