@develit-services/bank 0.0.28 → 0.0.30

package/dist/export/worker.cjs

@@ -3,100 +3,57 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 const backendSdk = require('@develit-io/backend-sdk');
-const db = require('../shared/bank.Cy_TcyKb.cjs');
+const database_schema = require('../shared/bank.BMRBXGF1.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 database_schema = require('../shared/bank.P9gDUycr.cjs');
 require('jose');
 const drizzleOrm = require('drizzle-orm');
+const mockCobs_connector = require('../shared/bank.DuY4d2y_.cjs');
 const superjson = require('superjson');
-require('date-fns');
+require('drizzle-zod');
 require('drizzle-orm/sqlite-core');
+require('date-fns');
 require('drizzle-orm/relations');
 
 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 getAuthUriInputSchema = zod.z.object({
-  accountId: zod.z.string()
-});
-
-const authorizeAccountInputSchema = zod.z.object({
-  ott: zod.z.string(),
-  urlParams: 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),
-  bankingSs: zod.z.string().max(10).optional(),
-  bankingKs: zod.z.string().max(10).optional(),
-  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.enum(database_schema.CONNECTOR_KEYS)
-});
-
-const getBatchesInputSchema = zod.z.object({
-  limit: zod.z.number().positive().optional().default(100),
-  offset: zod.z.number().min(0).optional().default(0)
-});
-
-const processBatchInputSchema = zod.z.object({
-  connectorKey: zod.z.enum(database_schema.CONNECTOR_KEYS),
-  batch: zod.z.custom()
-});
+const upsertAccountCommand = (db, { account }) => {
+  const id = account.id || backendSdk.uuidv4();
+  const command = db.insert(database_schema.tables.account).values({ ...account, id }).onConflictDoUpdate({
+    target: database_schema.tables.account.iban,
+    set: {
+      ...account
+    }
+  }).returning();
+  return {
+    id,
+    command
+  };
+};
 
-const createPaymentCommand = (db$1, { payment }) => {
+const createPaymentCommand = (db, { payment }) => {
   return {
-    command: db$1.insert(db.tables.payment).values(payment).returning()
+    command: db.insert(database_schema.tables.payment).values(payment).returning()
   };
 };
 
-const updatePaymentCommand = (db$1, { payment }) => {
+const updatePaymentCommand = (db, { payment }) => {
   return {
-    command: db$1.update(db.tables.payment).set(payment).where(drizzleOrm.eq(db.tables.payment.id, payment.id)).returning()
+    command: db.update(database_schema.tables.payment).set(payment).where(drizzleOrm.eq(database_schema.tables.payment.id, payment.id)).returning()
   };
 };
 
-const upsertBatchCommand = (db$1, { batch }) => {
+const upsertBatchCommand = (db, { batch }) => {
   const id = batch.id || backendSdk.uuidv4();
-  const command = db$1.insert(db.tables.batch).values({
+  const command = db.insert(database_schema.tables.batch).values({
     ...batch,
     id
   }).onConflictDoUpdate({
-    target: db.tables.batch.id,
+    target: database_schema.tables.batch.id,
     set: {
       ...batch
     }
@@ -107,112 +64,237 @@ const upsertBatchCommand = (db$1, { batch }) => {
   };
 };
 
-const createOneTimeTokenCommand = (db$1, {
+const createOneTimeTokenCommand = (db, {
   ott,
-  account,
+  refId,
   tokenType
 }) => {
   const id = backendSdk.uuidv4();
   const expiresAt = new Date(Date.now() + 1e3 * 60 * 60) ;
-  const command = db$1.insert(db.tables.ott).values({
+  const command = db.insert(database_schema.tables.ott).values({
     id,
     oneTimeToken: ott,
     tokenType,
-    accountId: account.id,
-    connectorKey: account.connectorKey,
-    expiresAt
+    expiresAt,
+    refId
   }).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();
+const expireOneTimeTokenCommand = (db, {
+  ott
+}) => {
+  return {
+    command: db.update(database_schema.tables.ott).set({
+      expiresAt: /* @__PURE__ */ new Date()
+    }).where(drizzleOrm.eq(database_schema.tables.ott.oneTimeToken, ott))
+  };
+};
+
+const createAccountCredentialsCommand = (db, { credentials }) => {
+  const id = credentials.id || backendSdk.uuidv4();
+  const command = db.insert(database_schema.tables.accountCredentials).values({ ...credentials, id }).returning();
+  return {
+    id,
+    command
+  };
+};
+
+const deleteAccountCredentialsCommand = (db, { accountId }) => {
+  const command = db.delete(database_schema.tables.accountCredentials).where(drizzleOrm.eq(database_schema.tables.accountCredentials.accountId, accountId));
+  return {
+    command
+  };
+};
+
+const getPaymentByRefIdQuery = async (db, { refId }) => {
+  const payment = await db.select().from(database_schema.tables.payment).where(drizzleOrm.eq(database_schema.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(
+const getOpenBatchByAccountIdQuery = async (db, { accountId }) => {
+  const batch = await db.select().from(database_schema.tables.batch).where(
     drizzleOrm.and(
-      drizzleOrm.eq(db.tables.batch.accountId, accountId),
-      drizzleOrm.eq(db.tables.batch.status, "OPEN")
+      drizzleOrm.eq(database_schema.tables.batch.accountId, accountId),
+      drizzleOrm.eq(database_schema.tables.batch.status, "OPEN")
     )
   ).limit(1).get();
   return batch;
 };
 
-const getPaymentsByBankRefIdsQuery = async (db$1, { ids }) => {
-  return await db$1.select().from(db.tables.payment).where(drizzleOrm.inArray(db.tables.payment.bankRefId, ids));
+const getPaymentsByBankRefIdsQuery = async (db, { ids }) => {
+  return await db.select().from(database_schema.tables.payment).where(drizzleOrm.inArray(database_schema.tables.payment.bankRefId, ids));
+};
+
+const getOttQuery = async (db, { ott }) => {
+  return await db.select().from(database_schema.tables.ott).where(drizzleOrm.eq(database_schema.tables.ott.oneTimeToken, ott)).get();
+};
+
+const getAllPendingBatchesQuery = (db) => {
+  return db.select().from(database_schema.tables.batch).where(
+    drizzleOrm.inArray(database_schema.tables.batch.status, [
+      "PROCESSING",
+      "READY_TO_SIGN",
+      "WAITING_FOR_PROCESSING"
+    ])
+  );
+};
+
+const getCredentialsByAccountId = async (db, { accountId }) => {
+  const cred = await db.select().from(database_schema.tables.accountCredentials).where(drizzleOrm.eq(database_schema.tables.accountCredentials.accountId, accountId)).get();
+  return cred;
 };
 
-const getOttQuery = async (db$1, { ott }) => {
-  return await db$1.select().from(db.tables.ott).where(drizzleOrm.eq(db.tables.ott.oneTimeToken, ott)).get();
+const getAccountByIbanQuery = async (db, { iban }) => {
+  return await db.select().from(database_schema.tables.account).where(drizzleOrm.eq(database_schema.tables.account.iban, iban)).get();
 };
 
-class CreditasConnector extends db.FinbricksConnector {
+const getAllAccountsQuery = async (db) => {
+  const accountsWithExpiration = await db.select().from(database_schema.tables.account).leftJoin(
+    database_schema.tables.accountCredentials,
+    drizzleOrm.eq(database_schema.tables.accountCredentials.accountId, database_schema.tables.account.id)
+  );
+  return accountsWithExpiration.map(({ account, account_credentials }) => {
+    return {
+      ...account,
+      expiresAt: account_credentials?.expiresAt
+    };
+  });
+};
+
+const buildMultiFilterConditions = (column, value) => {
+  if (value === void 0) return void 0;
+  if (Array.isArray(value)) {
+    return value.length > 0 ? drizzleOrm.inArray(column, value) : void 0;
+  }
+  return drizzleOrm.eq(column, value);
+};
+const buildRangeFilterConditions = (column, minValue, maxValue) => {
+  const conditions = [];
+  if (minValue !== void 0) {
+    conditions.push(drizzleOrm.gte(column, minValue));
+  }
+  if (maxValue !== void 0) {
+    conditions.push(drizzleOrm.lte(column, maxValue));
+  }
+  if (conditions.length === 0) return void 0;
+  if (conditions.length === 1) return conditions[0];
+  return drizzleOrm.and(...conditions);
+};
+const resolveColumn = (table, column, fallback = "updatedAt") => {
+  const key = column && column in table ? column : fallback;
+  return table[key];
+};
+const getPaymentsWithPaginationQuery = async (db, {
+  limit,
+  page,
+  sort,
+  filterPaymentAccountId,
+  filterPaymentAmount,
+  filterPaymentCurrency,
+  filterPaymentDateFrom,
+  filterPaymentDateTo,
+  filterPaymentStatus,
+  filterPaymentyDirection
+}) => {
+  const whereConditions = drizzleOrm.and(
+    buildMultiFilterConditions(
+      database_schema.tables.payment.accountId,
+      filterPaymentAccountId
+    ),
+    buildMultiFilterConditions(database_schema.tables.payment.amount, filterPaymentAmount),
+    buildMultiFilterConditions(database_schema.tables.payment.currency, filterPaymentCurrency),
+    buildRangeFilterConditions(
+      database_schema.tables.payment.createdAt,
+      filterPaymentDateFrom,
+      filterPaymentDateTo
+    ),
+    buildMultiFilterConditions(database_schema.tables.payment.status, filterPaymentStatus),
+    buildMultiFilterConditions(
+      database_schema.tables.payment.direction,
+      filterPaymentyDirection
+    )
+  );
+  const sortColumn = resolveColumn(database_schema.tables.payment, sort.column);
+  const [{ totalCount }] = await db.select({
+    totalCount: drizzleOrm.sql`count(*)`
+  }).from(database_schema.tables.payment).where(whereConditions);
+  const payments = await db.select().from(database_schema.tables.payment).where(whereConditions).limit(limit).offset((page - 1) * limit).orderBy(sort.direction === "asc" ? drizzleOrm.asc(sortColumn) : drizzleOrm.desc(sortColumn));
+  return {
+    payments,
+    totalCount
+  };
+};
+
+class CreditasConnector extends database_schema.FinbricksConnector {
   constructor(config) {
     super("CREDITAS", config);
   }
 }
 
-class FioConnector extends db.FinbricksConnector {
+class FioConnector extends database_schema.FinbricksConnector {
   constructor(config) {
     super("FIO", config);
   }
 }
 
-class MonetaConnector extends db.FinbricksConnector {
+class MonetaConnector extends database_schema.FinbricksConnector {
   constructor(config) {
     super("MONETA", config);
   }
 }
 
-const initiateConnector = (bank, env) => {
+const initiateConnector = ({
+  bank,
+  env,
+  connectedAccounts
+}) => {
   switch (bank) {
     case "ERSTE":
-      return new db.ErsteConnector({
+      return new database_schema.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,
+        REDIRECT_URI: env.REDIRECT_URI,
         AUTH_URI: env.ERSTE_AUTH_URI,
         PAYMENTS_URI: env.ERSTE_PAYMENTS_URI,
         ACCOUNTS_URI: env.ERSTE_ACCOUNTS_URI,
-        KV: env.BANK_KV
+        connectedAccounts
       });
     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,
-        REDIRECT_URI: env.ERSTE_REDIRECT_URI,
-        KV: env.BANK_KV
+        REDIRECT_URI: env.REDIRECT_URI,
+        connectedAccounts
       });
     case "MOCK_COBS":
-      return new db.MockCobsConnector({
+      return new mockCobs_connector.MockCobsConnector({
         BASE_URI: env.FINBRICKS_BASE_URI,
         MERCHANT_ID: env.FINBRICKS_MERCHANT_ID,
         PRIVATE_KEY_PEM: env.FINBRICKS_PRIVATE_KEY_PEM,
-        REDIRECT_URI: env.ERSTE_REDIRECT_URI,
-        KV: env.BANK_KV
+        REDIRECT_URI: env.REDIRECT_URI,
+        connectedAccounts
       });
     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,
-        REDIRECT_URI: env.ERSTE_REDIRECT_URI,
-        KV: env.BANK_KV
+        REDIRECT_URI: env.REDIRECT_URI,
+        connectedAccounts
       });
     case "MONETA":
       return new MonetaConnector({
         BASE_URI: env.FINBRICKS_BASE_URI,
         MERCHANT_ID: env.FINBRICKS_MERCHANT_ID,
         PRIVATE_KEY_PEM: env.FINBRICKS_PRIVATE_KEY_PEM,
-        REDIRECT_URI: env.ERSTE_REDIRECT_URI,
-        KV: env.BANK_KV
+        REDIRECT_URI: env.REDIRECT_URI,
+        connectedAccounts
       });
     default:
-      return new db.MockConnector(env.BANK_KV);
+      return new database_schema.MockConnector();
   }
 };
 
@@ -221,7 +303,7 @@ const useSync = (kv) => {
     account
   }) => {
     const [rawSync, rawSyncError] = await backendSdk.useResult(
-      kv.get(`sync-log:${account.identification.iban}:${account.currency}`)
+      kv.get(`sync-log:${account.iban}:${account.currency}`)
     );
     if (rawSyncError) throw backendSdk.createInternalError(rawSyncError);
     if (!rawSync) return null;
@@ -233,7 +315,7 @@ const useSync = (kv) => {
   }) => {
     const [_, error] = await backendSdk.useResult(
       kv.put(
-        `sync-log:${account.identification.iban}:${account.currency}`,
+        `sync-log:${account.iban}:${account.currency}`,
         superjson__default.stringify(log)
       )
     );
@@ -249,7 +331,7 @@ 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
+        (acc) => acc.iban === payment.debtorIban && acc.currency === payment.currency
       );
       if (isValid) {
         valid.push(payment);
@@ -266,6 +348,91 @@ const seperateSupportedPayments = (mappedPayments, accounts) => {
   };
 };
 
+const sendPaymentInputSchema = zod.z.object({
+  refId: zod.z.string(),
+  amount: zod.z.number().positive(),
+  paymentType: zod.z.enum(database_schema.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 getAuthUriInputSchema = zod.z.object({
+  connectorKey: zod.z.enum(database_schema.CONNECTOR_KEYS)
+});
+
+const authorizeAccountInputSchema = zod.z.object({
+  ott: zod.z.string(),
+  urlParams: 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),
+  bankingSs: zod.z.string().max(10).optional(),
+  bankingKs: zod.z.string().max(10).optional(),
+  message: zod.z.string(),
+  creditorIban: zod.z.string().max(34),
+  creditorHolderName: zod.z.string(),
+  debtorIban: zod.z.string().max(34),
+  debtorHolderName: zod.z.string(),
+  connectorKey: zod.z.enum(database_schema.CONNECTOR_KEYS)
+});
+
+const setLastSyncAtInputSchema = zod.z.object({
+  iban: zod.z.string(),
+  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 getBatchesInputSchema = zod.z.object({
+  limit: zod.z.number().positive().optional().default(100),
+  offset: zod.z.number().min(0).optional().default(0)
+});
+
+const processBatchInputSchema = zod.z.object({
+  connectorKey: zod.z.enum(database_schema.CONNECTOR_KEYS),
+  batch: zod.z.custom()
+});
+
+const ALLOWED_PAYMENT_FILTERS = {
+  ACCOUNT_ID: "filterPaymentAccountId",
+  AMOUNT: "filterPaymentAmount",
+  CURRENCY: "filterPaymentCurrency",
+  DIRECTION: "filterPaymentyDirection",
+  FROM: "filterPaymentDateFrom",
+  TO: "filterPaymentDateTo",
+  STATUS: "filterPaymentStatus"
+};
+const getPaymentsInputSchema = zod.z.object({
+  page: zod.z.number().positive(),
+  limit: zod.z.number().positive(),
+  sort: zod.z.object({
+    column: zod.z.enum(["createdAt", "updatedAt", "amount"]),
+    direction: zod.z.enum(["asc", "desc"])
+  }),
+  [ALLOWED_PAYMENT_FILTERS.ACCOUNT_ID]: zod.z.union([zod.z.uuid(), zod.z.uuid().array()]).optional(),
+  [ALLOWED_PAYMENT_FILTERS.AMOUNT]: zod.z.union([zod.z.number(), zod.z.number().array()]).optional(),
+  [ALLOWED_PAYMENT_FILTERS.CURRENCY]: zod.z.union([zod.z.enum(generalCodes.CURRENCY_CODES), zod.z.enum(generalCodes.CURRENCY_CODES).array()]).optional(),
+  [ALLOWED_PAYMENT_FILTERS.DIRECTION]: zod.z.union([zod.z.enum(database_schema.PAYMENT_DIRECTIONS), zod.z.enum(database_schema.PAYMENT_DIRECTIONS).array()]).optional(),
+  [ALLOWED_PAYMENT_FILTERS.FROM]: zod.z.date().optional(),
+  [ALLOWED_PAYMENT_FILTERS.TO]: zod.z.date().optional(),
+  [ALLOWED_PAYMENT_FILTERS.STATUS]: zod.z.union([zod.z.enum(database_schema.PAYMENT_STATUSES), zod.z.enum(database_schema.PAYMENT_STATUSES).array()]).optional()
+});
+
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __decorateClass = (decorators, target, key, kind) => {
@@ -277,22 +444,35 @@ var __decorateClass = (decorators, target, key, kind) => {
   return result;
 };
 let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.WorkerEntrypoint) {
-  constructor(ctx, env, configAccounts) {
+  constructor(ctx, env, config) {
     super(ctx, env);
-    this.configAccounts = configAccounts;
-    this.db = d1.drizzle(this.env.BANK_D1, { schema: db.tables });
+    this.allowedProviders = [];
+    this.allowedProviders = config.allowedProviders;
+    this.db = d1.drizzle(this.env.BANK_D1, { schema: database_schema.tables });
+  }
+  getAllowedProviders() {
+    return this.allowedProviders;
   }
-  get accounts() {
-    return this.env.ENVIRONMENT === "production" ? this.configAccounts.productionAccounts : this.configAccounts.stagingAccounts;
+  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);
+      }
+    );
   }
   accountFetchInterval(connectorKey) {
     switch (connectorKey) {
       case "ERSTE":
-        return db.ErsteConnector.FETCH_INTERVAL;
+        return database_schema.ErsteConnector.FETCH_INTERVAL;
       case "FINBRICKS":
-        return db.FinbricksConnector.FETCH_INTERVAL;
+        return database_schema.FinbricksConnector.FETCH_INTERVAL;
       case "MOCK":
-        return db.MockConnector.FETCH_INTERVAL;
+        return database_schema.MockConnector.FETCH_INTERVAL;
       default:
         return 0;
     }
@@ -301,16 +481,17 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
     return this.handleAction(null, {}, async () => {
       const accountsToSync = [];
       const { getLastSync } = useSync(this.env.BANK_KV);
-      for (const account of this.accounts.filter(
+      const accounts = await this.getAccounts();
+      for (const account of accounts.filter(
         (acc) => !!!acc.connectorKey.includes("MOCK")
       )) {
-        let lastSync = await getLastSync({ account });
+        let lastSync = await getLastSync({ account: { ...account, token: "" } });
         if (!lastSync) {
           await this.setLastSyncAt({
-            iban: account.identification.iban,
-            lastSyncedAt: account.fallbackLastSync
+            iban: account.iban,
+            lastSyncedAt: account.lastSyncedAt || /* @__PURE__ */ new Date()
           });
-          lastSync = await getLastSync({ account });
+          lastSync = await getLastSync({ account: { ...account, token: "" } });
           if (!lastSync) continue;
         }
         const accountFetchInterval = this.accountFetchInterval(
@@ -323,7 +504,8 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
         if (!shouldFetch) continue;
         accountsToSync.push({
           ...account,
-          lastSyncAt: lastSync
+          lastSyncAt: lastSync,
+          token: ""
         });
       }
       console.log("ACCS TO SYNC", accountsToSync.length);
@@ -336,16 +518,95 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
       console.log("Scheduled CRON payments processing");
       await this.syncAccounts();
     }
+    if (controller.cron === this.env.CRON_BATCH_STATUSES) {
+      console.log("Scheduled CRON batch statuses");
+      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);
+      }
+    }
+    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 {
+            ...batch,
+            status: newStatus
+          };
+        })
+      );
+      finalBatches.push(...updatedBatches);
+    }
+    const updateBatchesCommands = finalBatches.map((batch) => {
+      const { command } = upsertBatchCommand(this.db, {
+        batch: {
+          ...batch
+        }
+      });
+      return command;
+    });
+    console.log("Updated batches", finalBatches);
+    await this.db.batch([
+      updateBatchesCommands[0],
+      ...updateBatchesCommands.slice(1)
+    ]);
+    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 }) => {
-        this.bankConnector = initiateConnector(connectorKey, this.env);
-        const token = await this.env.BANK_KV.get(`${connectorKey}:auth`);
-        if (!token) throw backendSdk.createInternalError("Provider not authorized");
+      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();
       }
     );
@@ -358,7 +619,9 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
       const mappedPayments = paymentsToBatch.map(
         (payment) => ({
           id: backendSdk.uuidv4(),
+          accountId: "",
           refId: payment.refId,
+          connectorKey: "MOCK",
           amount: payment.amount,
           direction: "OUTGOING",
           paymentType: payment.paymentType,
@@ -378,7 +641,10 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
           debtorIban: payment.debtorIban
         })
       );
-      const { supportedPayments, unsupportedPayments } = seperateSupportedPayments(mappedPayments, this.accounts);
+      const { supportedPayments, unsupportedPayments } = seperateSupportedPayments(
+        mappedPayments,
+        this.bankConnector.connectedAccounts
+      );
       if (unsupportedPayments.length > 0) {
         this.logError({ unsupportedPayments });
         await this.pushToQueue(
@@ -404,15 +670,19 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
           }))
         );
       }
-      for (const acc of this.accounts) {
+      for (const acc of this.bankConnector.connectedAccounts) {
         const newPayments = supportedPayments.filter(
-          (payment) => payment.debtorIban === acc.identification.iban && payment.currency === acc.currency
-        );
+          (payment) => payment.debtorIban === acc.iban && payment.currency === acc.currency
+        ).map((payment) => ({
+          ...payment,
+          connectorKey: acc.connectorKey,
+          accountId: acc.id
+        }));
         if (newPayments.length === 0) {
           continue;
         }
         this.log({
-          message: `\u{1F4B0} Processing ${newPayments.length} payments for account ${acc.id} (${acc.identification.iban}, ${acc.currency})`
+          message: `\u{1F4B0} Processing ${newPayments.length} payments for account (${acc.iban}, ${acc.currency})`
         });
         const existingBatch = await getOpenBatchByAccountIdQuery(this.db, {
           accountId: acc.id
@@ -584,26 +854,19 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
     return this.handleAction(
       { data: input, schema: getAuthUriInputSchema },
       { successMessage: "Auth URI obtained." },
-      async ({ accountId }) => {
-        const account = this.accounts.find((acc) => acc.id === accountId);
-        if (!account)
-          throw backendSdk.createInternalError(null, {
-            message: "Account not found",
-            code: "ACCOUNT_NOT_FOUND",
-            status: 404
-          });
-        this.bankConnector = initiateConnector(account.connectorKey, this.env);
+      async ({ connectorKey }) => {
+        await this.initiateBankConnector({ connectorKey, withAuth: false });
         const ott = backendSdk.uuidv4();
-        const { command: oneTimeTokenCommand } = createOneTimeTokenCommand(
+        const { command: createOneTimeToken } = createOneTimeTokenCommand(
           this.db,
           {
             ott,
-            account,
+            refId: connectorKey,
             tokenType: "ACCOUNT_AUTHORIZATION"
           }
         );
-        await oneTimeTokenCommand.execute();
-        const uri = await this.bankConnector.getAuthUri({ accountId, ott });
+        await createOneTimeToken.execute();
+        const uri = await this.bankConnector.getAuthUri({ ott });
         return { uri };
       }
     );
@@ -630,11 +893,50 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
             status: 400
           });
         }
-        this.bankConnector = initiateConnector(ottRow.connectorKey, this.env);
-        const authorized = await this.bankConnector.authorizeAccount({
+        await this.initiateBankConnector({
+          connectorKey: ottRow.refId
+        });
+        const { credentials, accounts } = await this.bankConnector.authorizeAccount({
           urlParams
         });
-        return { authorized };
+        console.log("Bank connector initiated");
+        const alreadyExistingAccounts = (await this.getAccounts()).filter(
+          (acc) => acc.connectorKey === ottRow.refId && accounts.map((item) => item.iban).includes(acc.iban)
+        );
+        const upsertAccounts = accounts.map(
+          (acc) => upsertAccountCommand(this.db, {
+            account: acc
+          }).command
+        );
+        const deleteCredentials = alreadyExistingAccounts.map(
+          (acc) => deleteAccountCredentialsCommand(this.db, {
+            accountId: acc.id
+          }).command
+        );
+        const createAccountCredentials = credentials.map(
+          (cr) => createAccountCredentialsCommand(this.db, {
+            credentials: cr
+          }).command
+        );
+        const { command: updateOtt } = expireOneTimeTokenCommand(this.db, {
+          ott
+        });
+        await this.db.batch([
+          updateOtt,
+          ...upsertAccounts,
+          ...deleteCredentials,
+          ...createAccountCredentials
+        ]);
+        const fetchedAccounts = await this.getAccounts();
+        if (!fetchedAccounts)
+          throw backendSdk.createInternalError(null, {
+            message: "Account not found",
+            code: "NOT_FOUND",
+            status: 404
+          });
+        return {
+          accounts: fetchedAccounts
+        };
       }
     );
   }
@@ -660,10 +962,7 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
           if (!payments || payments.length === 0) continue;
           this.log(payments);
           payments.forEach((payment) => {
-            payment.direction = db.getPaymentDirection(
-              payment,
-              account.identification.iban
-            );
+            payment.direction = database_schema.getPaymentDirection(payment, account.iban);
           });
           allFetchedPayments.push(...payments);
         }
@@ -686,7 +985,7 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
       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
+          (payment) => (payment.direction === "OUTGOING" ? payment.debtorIban : payment.creditorIban) === account.iban
         );
         let lastSyncPayment;
         lastSyncPayment = paymentsForAccount.filter(({ status }) => status !== "COMPLETED").sort(
@@ -733,11 +1032,23 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
         creditorIban,
         creditorHolderName,
         debtorIban,
-        debtorHolderName
+        debtorHolderName,
+        connectorKey
       }) => {
+        const account = await getAccountByIbanQuery(this.db, {
+          iban: creditorIban
+        });
+        if (!account)
+          throw backendSdk.createInternalError(null, {
+            message: "Unsupported account",
+            code: "UNSUPPORTED_ACCOUNT",
+            status: 422
+          });
         const payment = {
           id: backendSdk.uuidv4(),
           amount,
+          connectorKey,
+          accountId: account.id,
           direction: "INCOMING",
           paymentType: "DOMESTIC",
           currency,
@@ -775,10 +1086,10 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
       { 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) {
+        const account = await getAccountByIbanQuery(this.db, {
+          iban
+        });
+        if (!account) {
           throw backendSdk.createInternalError(null, {
             status: 404,
             message: "Account for this organization does not exist."
@@ -788,7 +1099,7 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
           log: {
             lastSyncedAt
           },
-          account: configAccount
+          account: { ...account, token: "" }
         });
         return {};
       }
@@ -808,7 +1119,7 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
   }
   async getBankAccounts() {
     return backendSdk.RPCResponse.ok("Bank accounts retrieved successfully", {
-      data: this.accounts
+      data: await this.getAccounts()
     });
   }
   async getBatches(input) {
@@ -817,8 +1128,8 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
       { 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)
+          this.db.select().from(database_schema.tables.batch).limit(limit).offset(offset).orderBy(drizzleOrm.desc(database_schema.tables.batch.createdAt)),
+          this.db.select({ count: drizzleOrm.sql`count(*)`.as("count") }).from(database_schema.tables.batch)
         ]);
         const totalCount = Number(countResult[0]?.count) || 0;
         return {
@@ -829,12 +1140,18 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
     );
   }
 };
+__decorateClass([
+  backendSdk.action("get-payments")
+], BankServiceBase.prototype, "getPayments", 1);
 __decorateClass([
   backendSdk.action("synchronize-accounts")
 ], BankServiceBase.prototype, "syncAccounts", 1);
 __decorateClass([
   backendSdk.action("scheduled")
 ], BankServiceBase.prototype, "scheduled", 1);
+__decorateClass([
+  backendSdk.action("update-batch-statuses")
+], BankServiceBase.prototype, "updateBatchStatuses", 1);
 __decorateClass([
   backendSdk.action("add-payments-to-batch")
 ], BankServiceBase.prototype, "addPaymentsToBatch", 1);
@@ -872,433 +1189,429 @@ BankServiceBase = __decorateClass([
   backendSdk.service("bank")
 ], BankServiceBase);
 function defineBankService({
-  configAccounts
+  config
 }) {
   return class BankService extends BankServiceBase {
     constructor(ctx, env) {
-      super(ctx, env, configAccounts);
+      super(ctx, env, config);
     }
   };
 }
 
-const monthAgo = new Date(
-  Date.now() - 30 * 24 * 60 * 60 * 1e3
-  // 30 days ago
-);
 const BankService = defineBankService({
-  configAccounts: {
-    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,
-      // },
-    ],
-    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
-      }
-    ]
+  config: {
+    allowedProviders: []
+    // {
+    //   connectorKey: 'MOCK_COBS',
+    //   id: 'staging-czk',
+    //   identification: {
+    //     number: '1234567890',
+    //     bankCode: '5051',
+    //     iban: 'CZ0350510000000000000449',
+    //     holderName: 'Devizová Burza a.s.',
+    //   },
+    //   fallbackLastSync: monthAgo,
+    //   currency: 'CZK',
+    //   production: false,
+    // },
+    // {
+    //   connectorKey: 'MOCK_COBS',
+    //   id: 'staging-eur',
+    //   identification: {
+    //     number: '2345678901',
+    //     bankCode: '5051',
+    //     iban: 'CZ0750510000000000000668',
+    //     holderName: 'Devizová 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,
+    // },
+    // ],
+    // productionAccounts: [
+    //   // Banka CREDITAS (2250)
+    //   {
+    //     connectorKey: 'CREDITAS',
+    //     id: '2250-CZK',
+    //     identification: {
+    //       number: '100602391',
+    //       bankCode: '2250',
+    //       iban: 'CZ5122500000000100602391',
+    //       holderName: 'Devizová Burza a.s.',
+    //     },
+    //     fallbackLastSync: monthAgo,
+    //     currency: 'CZK',
+    //     production: true,
+    //   },
+    //   {
+    //     connectorKey: 'CREDITAS',
+    //     id: '2250-EUR',
+    //     identification: {
+    //       number: '100602404',
+    //       bankCode: '2250',
+    //       iban: 'CZ8822500000000100602404',
+    //       holderName: 'Devizová Burza a.s.',
+    //     },
+    //     fallbackLastSync: monthAgo,
+    //     currency: 'EUR',
+    //     production: true,
+    //   },
+    //   {
+    //     connectorKey: 'CREDITAS',
+    //     id: '2250-USD',
+    //     identification: {
+    //       number: '100602412',
+    //       bankCode: '2250',
+    //       iban: 'CZ6622500000000100602412',
+    //       holderName: 'Devizová Burza a.s.',
+    //     },
+    //     fallbackLastSync: monthAgo,
+    //     currency: 'USD',
+    //     production: true,
+    //   },
+    //   {
+    //     connectorKey: 'CREDITAS',
+    //     id: '2250-GBP',
+    //     identification: {
+    //       number: '100602420',
+    //       bankCode: '2250',
+    //       iban: 'CZ4422500000000100602420',
+    //       holderName: 'Devizová Burza a.s.',
+    //     },
+    //     fallbackLastSync: monthAgo,
+    //     currency: 'GBP',
+    //     production: true,
+    //   },
+    //   {
+    //     connectorKey: 'CREDITAS',
+    //     id: '2250-CHF',
+    //     identification: {
+    //       number: '100602439',
+    //       bankCode: '2250',
+    //       iban: 'CZ1622500000000100602439',
+    //       holderName: 'Devizová Burza a.s.',
+    //     },
+    //     fallbackLastSync: monthAgo,
+    //     currency: 'CHF',
+    //     production: true,
+    //   },
+    //   {
+    //     connectorKey: 'CREDITAS',
+    //     id: '2250-PLN',
+    //     identification: {
+    //       number: '100602447',
+    //       bankCode: '2250',
+    //       iban: 'CZ9122500000000100602447',
+    //       holderName: 'Devizová 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á Burza a.s.',
+    //     },
+    //     fallbackLastSync: monthAgo,
+    //     currency: 'CZK',
+    //     production: true,
+    //   },
+    //   {
+    //     connectorKey: 'FINBRICKS',
+    //     id: '2010-EUR',
+    //     identification: {
+    //       number: '2600884128',
+    //       bankCode: '2010',
+    //       iban: 'CZ0820100000002600884128',
+    //       holderName: 'Devizová Burza a.s.',
+    //     },
+    //     fallbackLastSync: monthAgo,
+    //     currency: 'EUR',
+    //     production: true,
+    //   },
+    //   {
+    //     connectorKey: 'FINBRICKS',
+    //     id: '2010-USD',
+    //     identification: {
+    //       number: '2700884133',
+    //       bankCode: '2010',
+    //       iban: 'CZ1420100000002700884133',
+    //       holderName: 'Devizová Burza a.s.',
+    //     },
+    //     fallbackLastSync: monthAgo,
+    //     currency: 'USD',
+    //     production: true,
+    //   },
+    //   {
+    //     connectorKey: 'FINBRICKS',
+    //     id: '2010-CHF',
+    //     identification: {
+    //       number: '2401098351',
+    //       bankCode: '2010',
+    //       iban: 'CZ0920100000002401098351',
+    //       holderName: 'Devizová Burza a.s.',
+    //     },
+    //     fallbackLastSync: monthAgo,
+    //     currency: 'CHF',
+    //     production: true,
+    //   },
+    //   {
+    //     connectorKey: 'FINBRICKS',
+    //     id: '2010-GBP',
+    //     identification: {
+    //       number: '2400884131',
+    //       bankCode: '2010',
+    //       iban: 'CZ3320100000002400884131',
+    //       holderName: 'Devizová Burza a.s.',
+    //     },
+    //     fallbackLastSync: monthAgo,
+    //     currency: 'GBP',
+    //     production: true,
+    //   },
+    //   {
+    //     connectorKey: 'FINBRICKS',
+    //     id: '2010-PLN',
+    //     identification: {
+    //       number: '2701098353',
+    //       bankCode: '2010',
+    //       iban: 'CZ8720100000002701098353',
+    //       holderName: 'Devizová Burza a.s.',
+    //     },
+    //     fallbackLastSync: monthAgo,
+    //     currency: 'PLN',
+    //     production: true,
+    //   },
+    //   {
+    //     connectorKey: 'FINBRICKS',
+    //     id: '2010-CAD',
+    //     identification: {
+    //       number: '2701478102',
+    //       bankCode: '2010',
+    //       iban: 'CZ5520100000002701478102',
+    //       holderName: 'Devizová 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á Burza a.s.',
+    //     },
+    //     fallbackLastSync: monthAgo,
+    //     currency: 'CZK',
+    //     production: true,
+    //   },
+    //   {
+    //     connectorKey: 'FINBRICKS',
+    //     id: '0100-EUR',
+    //     identification: {
+    //       number: '115-1484940297',
+    //       bankCode: '0100',
+    //       iban: 'CZ4201000001151484940297',
+    //       holderName: 'Devizová Burza a.s.',
+    //     },
+    //     fallbackLastSync: monthAgo,
+    //     currency: 'EUR',
+    //     production: true,
+    //   },
+    //   {
+    //     connectorKey: 'FINBRICKS',
+    //     id: '0100-USD',
+    //     identification: {
+    //       number: '115-1483960237',
+    //       bankCode: '0100',
+    //       iban: 'CZ6201000001151483960237',
+    //       holderName: 'Devizová Burza a.s.',
+    //     },
+    //     fallbackLastSync: monthAgo,
+    //     currency: 'USD',
+    //     production: true,
+    //   },
+    //   {
+    //     connectorKey: 'FINBRICKS',
+    //     id: '0100-PLN',
+    //     identification: {
+    //       number: '115-6674290267',
+    //       bankCode: '0100',
+    //       iban: 'CZ3501000001156674290267',
+    //       holderName: 'Devizová Burza a.s.',
+    //     },
+    //     fallbackLastSync: monthAgo,
+    //     currency: 'PLN',
+    //     production: true,
+    //   },
+    //   {
+    //     connectorKey: 'FINBRICKS',
+    //     id: '0100-SEK',
+    //     identification: {
+    //       number: '115-9578110207',
+    //       bankCode: '0100',
+    //       iban: 'CZ2401000001159578110207',
+    //       holderName: 'Devizová 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á Burza a.s.',
+    //     },
+    //     fallbackLastSync: monthAgo,
+    //     currency: 'CZK',
+    //     production: true,
+    //   },
+    //   {
+    //     connectorKey: 'ERSTE',
+    //     id: '0800-EUR',
+    //     identification: {
+    //       number: '1966646293',
+    //       bankCode: '0800',
+    //       iban: 'CZ2308000000001966646293',
+    //       holderName: 'Devizová Burza a.s.',
+    //     },
+    //     fallbackLastSync: monthAgo,
+    //     currency: 'EUR',
+    //     production: true,
+    //   },
+    //   {
+    //     connectorKey: 'ERSTE',
+    //     id: '0800-USD',
+    //     identification: {
+    //       number: '1978982243',
+    //       bankCode: '0800',
+    //       iban: 'CZ1908000000001978982243',
+    //       holderName: 'Devizová Burza a.s.',
+    //     },
+    //     fallbackLastSync: monthAgo,
+    //     currency: 'USD',
+    //     production: true,
+    //   },
+    //   {
+    //     connectorKey: 'ERSTE',
+    //     id: '0800-HUF',
+    //     identification: {
+    //       number: '13461252',
+    //       bankCode: '0800',
+    //       iban: 'CZ1908000000000013461252',
+    //       holderName: 'Devizová 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á Burza a.s.',
+    //     },
+    //     fallbackLastSync: monthAgo,
+    //     currency: 'CZK',
+    //     production: true,
+    //   },
+    //   {
+    //     connectorKey: 'FINBRICKS',
+    //     id: '0600-EUR',
+    //     identification: {
+    //       number: '224252231',
+    //       bankCode: '0600',
+    //       iban: 'CZ0806000000000224252231',
+    //       holderName: 'Devizová Burza a.s.',
+    //     },
+    //     fallbackLastSync: monthAgo,
+    //     currency: 'EUR',
+    //     production: true,
+    //   },
+    //   {
+    //     connectorKey: 'FINBRICKS',
+    //     id: '0600-USD',
+    //     identification: {
+    //       number: '224252290',
+    //       bankCode: '0600',
+    //       iban: 'CZ6406000000000224252290',
+    //       holderName: 'Devizová 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á Burza a.s.',
+    //     },
+    //     fallbackLastSync: monthAgo,
+    //     currency: 'CZK',
+    //     production: true,
+    //   },
+    // ],
   }
 });