@develit-services/bank 0.0.3 → 0.0.5

package/dist/export/worker.cjs

@@ -0,0 +1,1224 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const backendSdk = require('@develit-io/backend-sdk');
+const db = require('../shared/bank.BU2_AKRG.cjs');
+const cloudflare_workers = require('cloudflare:workers');
+const d1 = require('drizzle-orm/d1');
+const zod = require('zod');
+const generalCodes = require('@develit-io/general-codes');
+const drizzleOrm = require('drizzle-orm');
+const superjson = require('superjson');
+require('../shared/bank.CrAQe4PH.cjs');
+require('drizzle-orm/sqlite-core');
+require('drizzle-orm/relations');
+require('date-fns');
+require('jose');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const superjson__default = /*#__PURE__*/_interopDefaultCompat(superjson);
+
+const sendPaymentInputSchema = zod.z.object({
+  refId: zod.z.string(),
+  amount: zod.z.number().positive(),
+  paymentType: zod.z.enum(db.PAYMENT_TYPES),
+  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()
+});
+
+const saveErsteCodeInputSchema = zod.z.object({
+  code: zod.z.string()
+});
+
+const simulateDepositInputSchema = zod.z.object({
+  amount: zod.z.number(),
+  currency: zod.z.enum(generalCodes.CURRENCY_CODES),
+  bankingVs: zod.z.string().max(10),
+  message: zod.z.string(),
+  creditorIban: zod.z.string().max(34),
+  creditorHolderName: zod.z.string(),
+  debtorIban: zod.z.string().max(34),
+  debtorHolderName: zod.z.string()
+});
+
+const setLastSyncAtInputSchema = zod.z.object({
+  iban: zod.z.string(),
+  lastSyncedAt: zod.z.coerce.date()
+});
+
+const initiateConnectorInputSchema = zod.z.object({
+  connectorKey: zod.z.string()
+});
+
+const getBatchesInputSchema = zod.z.object({
+  limit: zod.z.number().positive().optional().default(100),
+  offset: zod.z.number().min(0).optional().default(0)
+});
+
+const monthAgo = new Date(
+  Date.now() - 30 * 24 * 60 * 60 * 1e3
+  // 30 days ago
+);
+const stagingAccounts = [
+  {
+    connectorKey: "MOCK_COBS",
+    id: "staging-czk",
+    identification: {
+      number: "1234567890",
+      bankCode: "5051",
+      iban: "CZ0350510000000000000449",
+      holderName: "Devizov\xE1 Burza a.s."
+    },
+    fallbackLastSync: monthAgo,
+    currency: "CZK",
+    production: false
+  },
+  {
+    connectorKey: "MOCK_COBS",
+    id: "staging-eur",
+    identification: {
+      number: "2345678901",
+      bankCode: "5051",
+      iban: "CZ0750510000000000000668",
+      holderName: "Devizov\xE1 Burza a.s."
+    },
+    fallbackLastSync: monthAgo,
+    currency: "EUR",
+    production: false
+  },
+  {
+    connectorKey: "FIO",
+    id: "kleinpetr-test",
+    identification: {
+      number: "2502130437",
+      bankCode: "2010",
+      iban: "CZ8520100000002502130437",
+      holderName: "Petr Klein"
+    },
+    fallbackLastSync: monthAgo,
+    currency: "CZK",
+    production: true
+  },
+  {
+    connectorKey: "MOCK",
+    id: "id-test",
+    identification: {
+      number: "777777777",
+      bankCode: "0800",
+      iban: "PL0000000000002444430437",
+      holderName: "Test Test"
+    },
+    fallbackLastSync: monthAgo,
+    currency: "PLN",
+    production: false
+  }
+  // {
+  //   connectorKey: 'MOCK_COBS',
+  //   id: 'staging-usd',
+  //   identification: {
+  //     iban: 'CZ3456789012345678901234',
+  //     accountNumberWithBankCode: '3456789012/3456',
+  //   },
+  //   currency: 'USD',
+  //   bankCode: '0800',
+  //   accountNumber: '3456789012',
+  //   production: false,
+  // },
+];
+const productionAccounts = [
+  // Banka CREDITAS (2250)
+  {
+    connectorKey: "CREDITAS",
+    id: "2250-CZK",
+    identification: {
+      number: "100602391",
+      bankCode: "2250",
+      iban: "CZ5122500000000100602391",
+      holderName: "Devizov\xE1 Burza a.s."
+    },
+    fallbackLastSync: monthAgo,
+    currency: "CZK",
+    production: true
+  },
+  {
+    connectorKey: "CREDITAS",
+    id: "2250-EUR",
+    identification: {
+      number: "100602404",
+      bankCode: "2250",
+      iban: "CZ8822500000000100602404",
+      holderName: "Devizov\xE1 Burza a.s."
+    },
+    fallbackLastSync: monthAgo,
+    currency: "EUR",
+    production: true
+  },
+  {
+    connectorKey: "CREDITAS",
+    id: "2250-USD",
+    identification: {
+      number: "100602412",
+      bankCode: "2250",
+      iban: "CZ6622500000000100602412",
+      holderName: "Devizov\xE1 Burza a.s."
+    },
+    fallbackLastSync: monthAgo,
+    currency: "USD",
+    production: true
+  },
+  {
+    connectorKey: "CREDITAS",
+    id: "2250-GBP",
+    identification: {
+      number: "100602420",
+      bankCode: "2250",
+      iban: "CZ4422500000000100602420",
+      holderName: "Devizov\xE1 Burza a.s."
+    },
+    fallbackLastSync: monthAgo,
+    currency: "GBP",
+    production: true
+  },
+  {
+    connectorKey: "CREDITAS",
+    id: "2250-CHF",
+    identification: {
+      number: "100602439",
+      bankCode: "2250",
+      iban: "CZ1622500000000100602439",
+      holderName: "Devizov\xE1 Burza a.s."
+    },
+    fallbackLastSync: monthAgo,
+    currency: "CHF",
+    production: true
+  },
+  {
+    connectorKey: "CREDITAS",
+    id: "2250-PLN",
+    identification: {
+      number: "100602447",
+      bankCode: "2250",
+      iban: "CZ9122500000000100602447",
+      holderName: "Devizov\xE1 Burza a.s."
+    },
+    fallbackLastSync: monthAgo,
+    currency: "PLN",
+    production: true
+  },
+  // Fio banka (2010)
+  {
+    connectorKey: "FINBRICKS",
+    id: "2010-CZK",
+    identification: {
+      number: "2500845869",
+      bankCode: "2010",
+      iban: "CZ0420100000002500845869",
+      holderName: "Devizov\xE1 Burza a.s."
+    },
+    fallbackLastSync: monthAgo,
+    currency: "CZK",
+    production: true
+  },
+  {
+    connectorKey: "FINBRICKS",
+    id: "2010-EUR",
+    identification: {
+      number: "2600884128",
+      bankCode: "2010",
+      iban: "CZ0820100000002600884128",
+      holderName: "Devizov\xE1 Burza a.s."
+    },
+    fallbackLastSync: monthAgo,
+    currency: "EUR",
+    production: true
+  },
+  {
+    connectorKey: "FINBRICKS",
+    id: "2010-USD",
+    identification: {
+      number: "2700884133",
+      bankCode: "2010",
+      iban: "CZ1420100000002700884133",
+      holderName: "Devizov\xE1 Burza a.s."
+    },
+    fallbackLastSync: monthAgo,
+    currency: "USD",
+    production: true
+  },
+  {
+    connectorKey: "FINBRICKS",
+    id: "2010-CHF",
+    identification: {
+      number: "2401098351",
+      bankCode: "2010",
+      iban: "CZ0920100000002401098351",
+      holderName: "Devizov\xE1 Burza a.s."
+    },
+    fallbackLastSync: monthAgo,
+    currency: "CHF",
+    production: true
+  },
+  {
+    connectorKey: "FINBRICKS",
+    id: "2010-GBP",
+    identification: {
+      number: "2400884131",
+      bankCode: "2010",
+      iban: "CZ3320100000002400884131",
+      holderName: "Devizov\xE1 Burza a.s."
+    },
+    fallbackLastSync: monthAgo,
+    currency: "GBP",
+    production: true
+  },
+  {
+    connectorKey: "FINBRICKS",
+    id: "2010-PLN",
+    identification: {
+      number: "2701098353",
+      bankCode: "2010",
+      iban: "CZ8720100000002701098353",
+      holderName: "Devizov\xE1 Burza a.s."
+    },
+    fallbackLastSync: monthAgo,
+    currency: "PLN",
+    production: true
+  },
+  {
+    connectorKey: "FINBRICKS",
+    id: "2010-CAD",
+    identification: {
+      number: "2701478102",
+      bankCode: "2010",
+      iban: "CZ5520100000002701478102",
+      holderName: "Devizov\xE1 Burza a.s."
+    },
+    fallbackLastSync: monthAgo,
+    currency: "CAD",
+    production: true
+  },
+  // Komerční banka (0100)
+  {
+    connectorKey: "FINBRICKS",
+    id: "0100-CZK",
+    identification: {
+      number: "115-1483630297",
+      bankCode: "0100",
+      iban: "CZ5901000001151483630297",
+      holderName: "Devizov\xE1 Burza a.s."
+    },
+    fallbackLastSync: monthAgo,
+    currency: "CZK",
+    production: true
+  },
+  {
+    connectorKey: "FINBRICKS",
+    id: "0100-EUR",
+    identification: {
+      number: "115-1484940297",
+      bankCode: "0100",
+      iban: "CZ4201000001151484940297",
+      holderName: "Devizov\xE1 Burza a.s."
+    },
+    fallbackLastSync: monthAgo,
+    currency: "EUR",
+    production: true
+  },
+  {
+    connectorKey: "FINBRICKS",
+    id: "0100-USD",
+    identification: {
+      number: "115-1483960237",
+      bankCode: "0100",
+      iban: "CZ6201000001151483960237",
+      holderName: "Devizov\xE1 Burza a.s."
+    },
+    fallbackLastSync: monthAgo,
+    currency: "USD",
+    production: true
+  },
+  {
+    connectorKey: "FINBRICKS",
+    id: "0100-PLN",
+    identification: {
+      number: "115-6674290267",
+      bankCode: "0100",
+      iban: "CZ3501000001156674290267",
+      holderName: "Devizov\xE1 Burza a.s."
+    },
+    fallbackLastSync: monthAgo,
+    currency: "PLN",
+    production: true
+  },
+  {
+    connectorKey: "FINBRICKS",
+    id: "0100-SEK",
+    identification: {
+      number: "115-9578110207",
+      bankCode: "0100",
+      iban: "CZ2401000001159578110207",
+      holderName: "Devizov\xE1 Burza a.s."
+    },
+    fallbackLastSync: monthAgo,
+    currency: "SEK",
+    production: true
+  },
+  // Česká spořitelna (0800)
+  {
+    connectorKey: "ERSTE",
+    id: "0800-CZK",
+    identification: {
+      number: "4413926379",
+      bankCode: "0800",
+      iban: "CZ7908000000004413926379",
+      holderName: "Devizov\xE1 Burza a.s."
+    },
+    fallbackLastSync: monthAgo,
+    currency: "CZK",
+    production: true
+  },
+  {
+    connectorKey: "ERSTE",
+    id: "0800-EUR",
+    identification: {
+      number: "1966646293",
+      bankCode: "0800",
+      iban: "CZ2308000000001966646293",
+      holderName: "Devizov\xE1 Burza a.s."
+    },
+    fallbackLastSync: monthAgo,
+    currency: "EUR",
+    production: true
+  },
+  {
+    connectorKey: "ERSTE",
+    id: "0800-USD",
+    identification: {
+      number: "1978982243",
+      bankCode: "0800",
+      iban: "CZ1908000000001978982243",
+      holderName: "Devizov\xE1 Burza a.s."
+    },
+    fallbackLastSync: monthAgo,
+    currency: "USD",
+    production: true
+  },
+  {
+    connectorKey: "ERSTE",
+    id: "0800-HUF",
+    identification: {
+      number: "13461252",
+      bankCode: "0800",
+      iban: "CZ1908000000000013461252",
+      holderName: "Devizov\xE1 Burza a.s."
+    },
+    fallbackLastSync: monthAgo,
+    currency: "HUF",
+    production: true
+  },
+  // MONETA Money Bank (0600)
+  {
+    connectorKey: "FINBRICKS",
+    id: "0600-CZK",
+    identification: {
+      number: "224252186",
+      bankCode: "0600",
+      iban: "CZ5906000000000224252186",
+      holderName: "Devizov\xE1 Burza a.s."
+    },
+    fallbackLastSync: monthAgo,
+    currency: "CZK",
+    production: true
+  },
+  {
+    connectorKey: "FINBRICKS",
+    id: "0600-EUR",
+    identification: {
+      number: "224252231",
+      bankCode: "0600",
+      iban: "CZ0806000000000224252231",
+      holderName: "Devizov\xE1 Burza a.s."
+    },
+    fallbackLastSync: monthAgo,
+    currency: "EUR",
+    production: true
+  },
+  {
+    connectorKey: "FINBRICKS",
+    id: "0600-USD",
+    identification: {
+      number: "224252290",
+      bankCode: "0600",
+      iban: "CZ6406000000000224252290",
+      holderName: "Devizov\xE1 Burza a.s."
+    },
+    fallbackLastSync: monthAgo,
+    currency: "USD",
+    production: true
+  },
+  // NEY spořitelní družstvo (2260)
+  {
+    connectorKey: "FINBRICKS",
+    id: "2260-CZK",
+    identification: {
+      number: "1702700014",
+      bankCode: "2260",
+      iban: "CZ7422600000001702700014",
+      holderName: "Devizov\xE1 Burza a.s."
+    },
+    fallbackLastSync: monthAgo,
+    currency: "CZK",
+    production: true
+  }
+];
+
+const createPaymentCommand = (db$1, { payment }) => {
+  return {
+    command: db$1.insert(db.tables.payment).values(payment).returning()
+  };
+};
+
+const updatePaymentCommand = (db$1, { payment }) => {
+  return {
+    command: db$1.update(db.tables.payment).set(payment).where(drizzleOrm.eq(db.tables.payment.id, payment.id)).returning()
+  };
+};
+
+const upsertBatchCommand = (db$1, { batch }) => {
+  const id = batch.id || backendSdk.uuidv4();
+  const command = db$1.insert(db.tables.batch).values({
+    ...batch,
+    id
+  }).onConflictDoUpdate({
+    target: db.tables.batch.id,
+    set: {
+      ...batch
+    }
+  }).returning();
+  return {
+    id,
+    command
+  };
+};
+
+const getPaymentByRefIdQuery = async (db$1, { refId }) => {
+  const payment = await db$1.select().from(db.tables.payment).where(drizzleOrm.eq(db.tables.payment.refId, refId)).limit(1).get();
+  return payment;
+};
+
+const getOpenBatchByAccountIdQuery = async (db$1, { accountId }) => {
+  const batch = await db$1.select().from(db.tables.batch).where(
+    drizzleOrm.and(
+      drizzleOrm.eq(db.tables.batch.accountId, accountId),
+      drizzleOrm.eq(db.tables.batch.status, "OPEN")
+    )
+  ).limit(1).get();
+  return batch;
+};
+
+const getAllOpenBatchesQuery = async (db$1) => {
+  return await db$1.select().from(db.tables.batch).where(drizzleOrm.eq(db.tables.batch.status, "OPEN"));
+};
+
+const getPaymentsByBankRefIdsQuery = async (db$1, { ids }) => {
+  return await db$1.select().from(db.tables.payment).where(drizzleOrm.inArray(db.tables.payment.bankRefId, ids));
+};
+
+class CreditasConnector extends db.FinbricksConnector {
+  constructor(config) {
+    super("CREDITAS", config);
+  }
+}
+
+class FioConnector extends db.FinbricksConnector {
+  constructor(config) {
+    super("FIO", config);
+  }
+}
+
+const initiateConnector = (bank, env) => {
+  switch (bank) {
+    case "ERSTE":
+      return new db.ErsteConnector({
+        API_KEY: env.ERSTE_API_KEY,
+        CLIENT_ID: env.ERSTE_CLIENT_ID,
+        CLIENT_SECRET: env.ERSTE_CLIENT_SECRET,
+        REDIRECT_URI: env.ERSTE_REDIRECT_URI,
+        AUTH_URI: env.ERSTE_AUTH_URI,
+        PAYMENTS_URI: env.ERSTE_PAYMENTS_URI,
+        ACCOUNTS_URI: env.ERSTE_ACCOUNTS_URI
+      });
+    case "CREDITAS":
+      return new CreditasConnector({
+        BASE_URI: env.FINBRICKS_BASE_URI,
+        MERCHANT_ID: env.FINBRICKS_MERCHANT_ID,
+        PRIVATE_KEY_PEM: env.FINBRICKS_PRIVATE_KEY_PEM
+      });
+    case "MOCK_COBS":
+      return new db.MockCobsConnector({
+        BASE_URI: env.FINBRICKS_BASE_URI,
+        MERCHANT_ID: env.FINBRICKS_MERCHANT_ID,
+        PRIVATE_KEY_PEM: env.FINBRICKS_PRIVATE_KEY_PEM
+      });
+    case "FIO":
+      return new FioConnector({
+        BASE_URI: env.FINBRICKS_BASE_URI,
+        MERCHANT_ID: env.FINBRICKS_MERCHANT_ID,
+        PRIVATE_KEY_PEM: env.FINBRICKS_PRIVATE_KEY_PEM
+      });
+    default:
+      return new db.MockConnector();
+  }
+};
+
+const useSync = (kv) => {
+  const getLastSync = async ({
+    account
+  }) => {
+    const [rawSync, rawSyncError] = await backendSdk.useResult(
+      kv.get(`sync-log:${account.identification.iban}:${account.currency}`)
+    );
+    if (rawSyncError) throw backendSdk.createInternalError(rawSyncError);
+    if (!rawSync) return null;
+    return superjson__default.parse(rawSync);
+  };
+  const setLastSync = async ({
+    account,
+    log
+  }) => {
+    const [_, error] = await backendSdk.useResult(
+      kv.put(
+        `sync-log:${account.identification.iban}:${account.currency}`,
+        superjson__default.stringify(log)
+      )
+    );
+    if (error) throw error;
+  };
+  return {
+    getLastSync,
+    setLastSync
+  };
+};
+
+const seperateSupportedPayments = (mappedPayments, accounts) => {
+  const [supportedPayments, unsupportedPayments] = mappedPayments.reduce(
+    ([valid, invalid], payment) => {
+      const isValid = accounts.some(
+        (acc) => acc.identification.iban === payment.debtorIban && acc.currency === payment.currency
+      );
+      if (isValid) {
+        valid.push(payment);
+      } else {
+        invalid.push(payment);
+      }
+      return [valid, invalid];
+    },
+    [[], []]
+  );
+  return {
+    supportedPayments,
+    unsupportedPayments
+  };
+};
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = __getOwnPropDesc(target, key) ;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (decorator(target, key, result) ) || result;
+  if (result) __defProp(target, key, result);
+  return result;
+};
+class BankServiceBase extends backendSdk.develitWorker(cloudflare_workers.WorkerEntrypoint) {
+  constructor(ctx, env) {
+    super(ctx, env);
+    this.name = "bank-service";
+    this.db = d1.drizzle(this.env.BANK_D1, { schema: db.tables });
+  }
+  get accounts() {
+    return this.env.ENVIRONMENT === "production" ? productionAccounts : stagingAccounts;
+  }
+  accountFetchInterval(connectorKey) {
+    switch (connectorKey) {
+      case "ERSTE":
+        return db.ErsteConnector.FETCH_INTERVAL;
+      case "FINBRICKS":
+        return db.FinbricksConnector.FETCH_INTERVAL;
+      case "MOCK":
+        return db.MockConnector.FETCH_INTERVAL;
+      default:
+        return 0;
+    }
+  }
+  async syncAccounts() {
+    return this.handleAction(null, {}, async () => {
+      const accountsToSync = [];
+      const { getLastSync } = useSync(this.env.BANK_KV);
+      for (const account of this.accounts.filter(
+        (acc) => !!!acc.connectorKey.includes("MOCK")
+      )) {
+        let lastSync = await getLastSync({ account });
+        if (!lastSync) {
+          await this.setLastSyncAt({
+            iban: account.identification.iban,
+            lastSyncedAt: account.fallbackLastSync
+          });
+          lastSync = await getLastSync({ account });
+          if (!lastSync) continue;
+        }
+        const accountFetchInterval = this.accountFetchInterval(
+          account.connectorKey
+        );
+        const now = Date.now();
+        const lastSyncTime = lastSync.lastSyncedAt.getTime();
+        const intervalMs = accountFetchInterval * 1e3;
+        const shouldFetch = now - lastSyncTime >= intervalMs;
+        if (!shouldFetch) continue;
+        accountsToSync.push({
+          ...account,
+          lastSyncAt: lastSync
+        });
+      }
+      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_BATCHES_PROCESSING) {
+      console.log("Scheduled CRON batches processing");
+      const openBatches = await getAllOpenBatchesQuery(this.db);
+      if (!openBatches.length) return;
+      for (const batch of openBatches) {
+        const connectorKey = this.accounts.find(
+          (acc) => acc.id === batch.accountId
+        )?.connectorKey;
+        if (!connectorKey) {
+          this.logError({
+            message: "Failed to find connector key",
+            batch,
+            connectorKey
+          });
+          continue;
+        }
+        await this.processBatch({
+          batch,
+          connectorKey
+        });
+      }
+    }
+    if (controller.cron === this.env.CRON_PAYMENTS_PROCESSING) {
+      console.log("Scheduled CRON payments processing");
+      await this.syncAccounts();
+    }
+  }
+  // @action('initiate-bank-connector')
+  async initiateBankConnector(input) {
+    return this.handleAction(
+      { data: input, schema: initiateConnectorInputSchema },
+      { successMessage: "Bank connector initiated successfully" },
+      async ({ connectorKey }) => {
+        this.bankConnector = initiateConnector(
+          connectorKey,
+          this.env
+        );
+        await this.env.BANK_KV.put(
+          `${connectorKey}:token`,
+          "d32a83cf-d352-41f3-96d7-4d2961336ddc"
+          //hard-coded finbricks clientId (valid til 03/26)
+        );
+        const token = await this.env.BANK_KV.get(`${connectorKey}:token`);
+        if (!token) throw backendSdk.createInternalError("Provider not authorized");
+        await this.bankConnector.authenticate({
+          token
+        });
+      }
+    );
+  }
+  async addPaymentsToBatch({
+    paymentsToBatch
+  }) {
+    return this.handleAction(null, {}, async () => {
+      this.logInput({ paymentsToBatch });
+      const mappedPayments = paymentsToBatch.map(
+        (payment) => ({
+          id: backendSdk.uuidv4(),
+          refId: payment.refId,
+          amount: payment.amount,
+          direction: "OUTGOING",
+          paymentType: payment.paymentType,
+          currency: payment.currency,
+          status: "CREATED",
+          initiatedAt: /* @__PURE__ */ new Date(),
+          processedAt: null,
+          vs: payment.vs || null,
+          ss: payment.ss || null,
+          ks: payment.ks || null,
+          message: payment.message || null,
+          creditorHolderName: payment.creditorHolderName,
+          creditorAccountNumberWithBankCode: payment.creditorAccountNumberWithBankCode,
+          creditorIban: payment.creditorIban,
+          debtorHolderName: payment.debtorHolderName,
+          debtorAccountNumberWithBankCode: payment.debtorAccountNumberWithBankCode,
+          debtorIban: payment.debtorIban
+        })
+      );
+      const { supportedPayments, unsupportedPayments } = seperateSupportedPayments(mappedPayments, this.accounts);
+      if (unsupportedPayments.length > 0) {
+        this.logError({ unsupportedPayments });
+        await this.pushToQueue(
+          this.env.QUEUE_BUS_QUEUE,
+          unsupportedPayments.map((unsupported) => ({
+            eventType: "BANK_PAYMENT",
+            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
+            },
+            metadata: {
+              correlationId: backendSdk.uuidv4(),
+              timestamp: (/* @__PURE__ */ new Date()).toDateString()
+            }
+          }))
+        );
+      }
+      for (const acc of this.accounts) {
+        const newPayments = supportedPayments.filter(
+          (payment) => payment.debtorIban === acc.identification.iban && payment.currency === acc.currency
+        );
+        if (newPayments.length === 0) {
+          continue;
+        }
+        this.log({
+          message: `\u{1F4B0} Processing ${newPayments.length} payments for account ${acc.id} (${acc.identification.iban}, ${acc.currency})`
+        });
+        const existingBatch = await getOpenBatchByAccountIdQuery(this.db, {
+          accountId: acc.id
+        });
+        if (existingBatch) {
+          this.log({
+            message: `\u{1F504} Found existing OPEN batch for account ${acc.id}, merging ${existingBatch.payments.length} existing + ${newPayments.length} new payments`
+          });
+        } else {
+          this.log({
+            message: `\u2728 Creating new batch for account ${acc.id} with ${newPayments.length} payments`
+          });
+        }
+        const { command } = upsertBatchCommand(this.db, {
+          batch: existingBatch ? {
+            ...existingBatch,
+            payments: [...existingBatch.payments, ...newPayments]
+          } : {
+            id: backendSdk.uuidv4(),
+            authorizationUrls: [],
+            accountId: acc.id,
+            payments: newPayments,
+            status: "OPEN"
+          }
+        });
+        const upsertedBatch = await command.execute();
+        this.log({
+          message: `\u2705 Batch upserted successfully for account ${acc.id}`
+        });
+        return upsertedBatch;
+      }
+    });
+  }
+  async processBatch({
+    batch,
+    connectorKey
+  }) {
+    return this.handleAction(null, {}, async () => {
+      this.logInput({ batch, connectorKey });
+      await upsertBatchCommand(this.db, {
+        batch: {
+          ...batch,
+          status: "PROCESSING"
+        }
+      }).command.execute();
+      await this.initiateBankConnector({ connectorKey });
+      if (!this.bankConnector) {
+        throw backendSdk.createInternalError(null, {
+          message: `\u274C Failed to initialize ${connectorKey} bank connector`
+        });
+      }
+      this.log({
+        message: `\u2705 Bank connector initialized successfully for account ${connectorKey}`
+      });
+      const preparedBatch = {
+        retriedPayments: [],
+        newlyPreparedPayments: [],
+        failedPayments: []
+      };
+      for (const payment of batch.payments) {
+        const existingPayment = await getPaymentByRefIdQuery(this.db, {
+          refId: payment.refId
+        });
+        if (existingPayment) {
+          preparedBatch.retriedPayments.push({
+            ...existingPayment,
+            status: "PREPARED"
+          });
+          this.log({
+            message: `\u2705 Payment ${existingPayment.id} already exists`
+          });
+          continue;
+        }
+        const newlyPreparedPayment = await this.bankConnector.preparePayment(payment);
+        if (!newlyPreparedPayment) {
+          preparedBatch.failedPayments.push({ ...payment, status: "FAILED" });
+          continue;
+        }
+        preparedBatch.newlyPreparedPayments.push(newlyPreparedPayment);
+      }
+      await Promise.all([
+        [
+          ...preparedBatch.failedPayments,
+          ...preparedBatch.newlyPreparedPayments
+        ].map(
+          (p) => createPaymentCommand(this.db, { payment: p }).command.execute()
+        )
+      ]);
+      const { authorizationUrls, payments, metadata } = await this.bankConnector.initiateBatchFromPayments({
+        payments: [
+          ...preparedBatch.newlyPreparedPayments,
+          ...preparedBatch.retriedPayments
+        ]
+      });
+      if (!authorizationUrls) {
+        this.logError({ message: "Failed to retrieve signing URI" });
+        return;
+      }
+      const { command: upsertBatch } = upsertBatchCommand(this.db, {
+        batch: {
+          ...batch,
+          payments,
+          metadata,
+          status: "READY_TO_SIGN",
+          authorizationUrls,
+          batchPaymentInitiatedAt: /* @__PURE__ */ new Date()
+        }
+      });
+      const updatePayments = payments.map(
+        (payment) => updatePaymentCommand(this.db, {
+          payment: { ...payment, status: "INITIALIZED" }
+        }).command
+      );
+      await this.db.batch([upsertBatch, ...updatePayments]);
+      this.log({
+        message: "Authorization Urls for batch to create",
+        authorizationUrl: authorizationUrls[0]
+      });
+      await this.pushToQueue(this.env.NOTIFICATIONS_QUEUE, {
+        type: "email",
+        payload: {
+          email: {
+            to: ["petr@develit.io"],
+            subject: "Payment Authorization",
+            text: authorizationUrls[0] || "No Authorization Url"
+          }
+        },
+        metadata: {
+          initiator: {
+            service: this.name
+          }
+        }
+      });
+      this.logOutput({ message: "Batch successfully processed" });
+    });
+  }
+  async queue(b) {
+    await this.handleAction(
+      null,
+      { successMessage: "Queue handler executed successfully" },
+      async () => {
+        this.logQueuePull(b);
+        const queueHandlerResponse = await this.addPaymentsToBatch({
+          paymentsToBatch: b.messages.map(({ body }) => body)
+        });
+        this.logOutput(queueHandlerResponse);
+      }
+    );
+  }
+  async getErsteCodeURI() {
+    return this.handleAction(
+      null,
+      { successMessage: "Erste URI code obtained." },
+      async () => {
+        this.bankConnector = initiateConnector("ERSTE", this.env);
+        const uri = this.bankConnector instanceof db.ErsteConnector ? this.bankConnector.adminCodeCreationURI : "nothing";
+        return { uri };
+      }
+    );
+  }
+  async saveErsteCode(input) {
+    return this.handleAction(
+      { data: input, schema: saveErsteCodeInputSchema },
+      { successMessage: "Erste code saved." },
+      async ({ code }) => {
+        this.bankConnector = initiateConnector("ERSTE", this.env);
+        const token = await this.bankConnector.authenticate({
+          token: code
+        });
+        await this.env.BANK_KV.put("ERSTE:refreshToken", token);
+      }
+    );
+  }
+  async saveOrUpdatePayments(accounts) {
+    const { setLastSync } = useSync(this.env.BANK_KV);
+    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 { lastSyncAt } = account;
+          const payments = await this.bankConnector.getAllAccountPayments({
+            db: this.db,
+            env: this.env.ENVIRONMENT,
+            account,
+            lastSync: lastSyncAt
+          });
+          if (!payments || payments.length === 0) continue;
+          this.log(payments);
+          payments.forEach((payment) => {
+            payment.direction = db.getPaymentDirection(
+              payment,
+              account.identification.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.identification.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 setLastSync({
+            account,
+            log: {
+              lastSyncedAt: lastSyncPayment.createdAt
+            }
+          });
+        }
+      }
+      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 },
+      { successMessage: "Deposit saved." },
+      async ({
+        amount,
+        currency,
+        bankingVs,
+        message,
+        creditorIban,
+        creditorHolderName,
+        debtorIban,
+        debtorHolderName
+      }) => {
+        const payment = {
+          id: backendSdk.uuidv4(),
+          amount,
+          direction: "INCOMING",
+          paymentType: "DOMESTIC",
+          currency,
+          status: "COMPLETED",
+          batchId: backendSdk.uuidv4(),
+          initiatedAt: /* @__PURE__ */ new Date(),
+          processedAt: /* @__PURE__ */ new Date(),
+          vs: bankingVs,
+          message,
+          creditorIban,
+          creditorHolderName,
+          debtorIban,
+          debtorHolderName
+        };
+        const { command } = createPaymentCommand(this.db, { payment });
+        const createdPayment = await command.execute().then(backendSdk.first);
+        this.logQueuePush({ payment, isPaymentExecuted: true });
+        await this.pushToQueue(this.env.QUEUE_BUS_QUEUE, {
+          eventType: "BANK_PAYMENT",
+          bankPayment: createdPayment,
+          metadata: {
+            correlationId: createdPayment.id,
+            timestamp: (/* @__PURE__ */ new Date()).toDateString()
+          }
+        });
+        return createdPayment;
+      }
+    );
+  }
+  async setLastSyncAt(input) {
+    return this.handleAction(
+      { data: input, schema: setLastSyncAtInputSchema },
+      { successMessage: "Last sync set." },
+      async ({ iban, lastSyncedAt }) => {
+        const { setLastSync } = useSync(this.env.BANK_KV);
+        const configAccount = this.accounts.find(
+          (acc) => acc.identification.iban === iban
+        );
+        if (!configAccount) {
+          throw backendSdk.createInternalError(null, {
+            status: 404,
+            message: "Account for this organization does not exist."
+          });
+        }
+        await setLastSync({
+          log: {
+            lastSyncedAt
+          },
+          account: configAccount
+        });
+        return {};
+      }
+    );
+  }
+  async sendPayment(input) {
+    return this.handleAction(
+      { data: input, schema: sendPaymentInputSchema },
+      { successMessage: "Payment queued successfully" },
+      async (data) => {
+        await this.pushToQueue(
+          this.env.PAYMENTS_READY_TO_BATCH_QUEUE,
+          data
+        );
+      }
+    );
+  }
+  async getBankAccounts() {
+    return backendSdk.RPCResponse.ok("Bank accounts retrieved successfully", {
+      data: this.accounts
+    });
+  }
+  async getBatches(input) {
+    return this.handleAction(
+      { data: input, schema: getBatchesInputSchema },
+      { successMessage: "Batches retrieved successfully" },
+      async ({ limit = 100, offset = 0 }) => {
+        const [batchesResult, countResult] = await Promise.all([
+          this.db.select().from(db.tables.batch).limit(limit).offset(offset).orderBy(drizzleOrm.desc(db.tables.batch.createdAt)),
+          this.db.select({ count: drizzleOrm.sql`count(*)`.as("count") }).from(db.tables.batch)
+        ]);
+        const totalCount = Number(countResult[0]?.count) || 0;
+        return {
+          batches: batchesResult,
+          totalCount
+        };
+      }
+    );
+  }
+}
+__decorateClass([
+  backendSdk.action("synchronize-accounts")
+], BankServiceBase.prototype, "syncAccounts");
+__decorateClass([
+  backendSdk.action("scheduled")
+], BankServiceBase.prototype, "scheduled");
+__decorateClass([
+  backendSdk.action("add-payments-to-batch")
+], BankServiceBase.prototype, "addPaymentsToBatch");
+__decorateClass([
+  backendSdk.action("process-batch")
+], BankServiceBase.prototype, "processBatch");
+__decorateClass([
+  backendSdk.action("queue-handler")
+], BankServiceBase.prototype, "queue");
+__decorateClass([
+  backendSdk.action("get-erste-code-uri")
+], BankServiceBase.prototype, "getErsteCodeURI");
+__decorateClass([
+  backendSdk.action("save-erste-code")
+], BankServiceBase.prototype, "saveErsteCode");
+__decorateClass([
+  backendSdk.action("save-or-update-payments")
+], BankServiceBase.prototype, "saveOrUpdatePayments");
+__decorateClass([
+  backendSdk.action("simulate-deposit")
+], BankServiceBase.prototype, "simulateDeposit");
+__decorateClass([
+  backendSdk.action("set-last-sync-at")
+], BankServiceBase.prototype, "setLastSyncAt");
+__decorateClass([
+  backendSdk.action("send-payment")
+], BankServiceBase.prototype, "sendPayment");
+__decorateClass([
+  backendSdk.action("get-bank-accounts")
+], BankServiceBase.prototype, "getBankAccounts");
+__decorateClass([
+  backendSdk.action("getBatches")
+], BankServiceBase.prototype, "getBatches");
+function defineBankService() {
+  return class BankService extends BankServiceBase {
+    constructor(ctx, env) {
+      super(ctx, env);
+    }
+  };
+}
+
+const BankService = defineBankService();
+
+exports.default = BankService;
+exports.defineBankService = defineBankService;