@develit-services/bank 5.0.1 → 5.2.0

package/dist/base.cjs

@@ -1,7 +1,7 @@
 'use strict';
 
 const backendSdk = require('@develit-io/backend-sdk');
-const ott_zod = require('./shared/bank.BSX82jhx.cjs');
+const bank = require('./shared/bank.BkctD4hR.cjs');
 const drizzleOrm = require('drizzle-orm');
 const cloudflare_workers = require('cloudflare:workers');
 const d1 = require('drizzle-orm/d1');
@@ -11,7 +11,7 @@ const database_schema = require('./shared/bank.9Yw4KHyl.cjs');
 const generalCodes = require('@develit-io/general-codes');
 require('date-fns');
 require('node:crypto');
-const credentialsResolver = require('./shared/bank.CibQRM2D.cjs');
+const credentialsResolver = require('./shared/bank.Bgz1SSIP.cjs');
 require('drizzle-orm/zod');
 require('drizzle-orm/sqlite-core');
 
@@ -73,82 +73,11 @@ async function heartbeatSyncWorkflows({
   );
 }
 
-const sendPaymentInputSchema = zod.z.object({
-  correlationId: zod.z.string().min(1),
-  refId: zod.z.string().optional(),
-  amount: zod.z.number().positive(),
-  paymentType: zod.z.enum(database_schema.PAYMENT_TYPES),
-  chargeBearer: zod.z.enum(database_schema.CHARGE_BEARERS).optional(),
-  instructionPriority: zod.z.enum(database_schema.INSTRUCTION_PRIORITIES).optional(),
-  currency: zod.z.enum(generalCodes.CURRENCY_CODES),
-  vs: zod.z.string().optional(),
-  ss: zod.z.string().optional(),
-  ks: zod.z.string().optional(),
-  message: zod.z.string().optional(),
-  creditor: backendSdk.bankAccountMetadataSchema,
-  debtor: backendSdk.bankAccountMetadataSchema,
-  sendAsSinglePayment: zod.z.boolean().optional()
-}).superRefine((data, ctx) => {
-  if (data.paymentType === "UNKNOWN") {
-    ctx.addIssue({
-      code: "custom",
-      message: "paymentType=UNKNOWN is not supported. Use DOMESTIC, SEPA, or SWIFT.",
-      path: ["paymentType"]
-    });
-    return;
-  }
-  if (!data.debtor.iban) {
-    ctx.addIssue({
-      code: "custom",
-      message: "debtor.iban is required",
-      path: ["debtor", "iban"]
-    });
-  }
-  if (data.paymentType === "DOMESTIC" || data.paymentType === "SEPA") {
-    if (!data.creditor.iban) {
-      ctx.addIssue({
-        code: "custom",
-        message: `creditor.iban is required for ${data.paymentType} payments`,
-        path: ["creditor", "iban"]
-      });
-    }
-    return;
-  }
-  if (data.paymentType === "SWIFT") {
-    const hasIban = !!data.creditor.iban;
-    const hasBban = !!data.creditor.number && !!(data.creditor.swiftBic ?? data.creditor.bicCor);
-    if (!hasIban && !hasBban) {
-      ctx.addIssue({
-        code: "custom",
-        message: "SWIFT creditor requires either iban OR (number + swiftBic/bicCor)",
-        path: ["creditor"]
-      });
-    }
-  }
-});
-
-const sendBatchInputSchema = zod.z.object({
-  payments: zod.z.array(sendPaymentInputSchema).min(1)
-});
-
-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(),
-  syncIntervalS: zod.z.number().int().positive().optional(),
-  startSync: zod.z.boolean().optional(),
-  lastSyncAt: zod.z.date().optional(),
-  address: backendSdk.structuredAddressSchema.optional()
-});
-
 const upsertAccountCommand = (db, { account }) => {
   const id = account.id || backendSdk.uuidv4();
   const { id: _id, ...accountWithoutId } = account;
-  const command = db.insert(ott_zod.tables.account).values({ ...account, id }).onConflictDoUpdate({
-    target: ott_zod.tables.account.iban,
+  const command = db.insert(bank.tables.account).values({ ...account, id }).onConflictDoUpdate({
+    target: bank.tables.account.iban,
     set: accountWithoutId
     // preserve existing id on re-auth
   }).returning();
@@ -165,7 +94,7 @@ const createOneTimeTokenCommand = (db, {
 }) => {
   const id = backendSdk.uuidv4();
   const expiresAt = new Date(Date.now() + 1e3 * 60 * 60) ;
-  const command = db.insert(ott_zod.tables.ott).values({
+  const command = db.insert(bank.tables.ott).values({
     id,
     oneTimeToken: ott,
     tokenType,
@@ -177,7 +106,7 @@ const createOneTimeTokenCommand = (db, {
 
 const updateAccountCommand = (db, { account }) => {
   return {
-    command: db.update(ott_zod.tables.account).set({ ...account }).where(drizzleOrm.eq(ott_zod.tables.account.id, account.id)).returning()
+    command: db.update(bank.tables.account).set({ ...account }).where(drizzleOrm.eq(bank.tables.account.id, account.id)).returning()
   };
 };
 
@@ -185,16 +114,16 @@ const expireOneTimeTokenCommand = (db, {
   ott
 }) => {
   return {
-    command: db.update(ott_zod.tables.ott).set({
+    command: db.update(bank.tables.ott).set({
       expiresAt: /* @__PURE__ */ new Date()
-    }).where(drizzleOrm.eq(ott_zod.tables.ott.oneTimeToken, ott))
+    }).where(drizzleOrm.eq(bank.tables.ott.oneTimeToken, ott))
   };
 };
 
 const createAccountCredentialsCommand = async (db, encryptionKey, { credentials }) => {
   const id = credentials.id || backendSdk.uuidv4();
   const encryptedValue = await credentialsResolver.encrypt(credentials.value, encryptionKey);
-  const command = db.insert(ott_zod.tables.accountCredentials).values({
+  const command = db.insert(bank.tables.accountCredentials).values({
     ...credentials,
     id,
     value: encryptedValue
@@ -206,16 +135,16 @@ const createAccountCredentialsCommand = async (db, encryptionKey, { credentials
 };
 
 const deleteAccountCredentialsCommand = (db, { accountId }) => {
-  const command = db.delete(ott_zod.tables.accountCredentials).where(drizzleOrm.eq(ott_zod.tables.accountCredentials.accountId, accountId));
+  const command = db.delete(bank.tables.accountCredentials).where(drizzleOrm.eq(bank.tables.accountCredentials.accountId, accountId));
   return {
     command
   };
 };
 
 const deletePaymentsByAccountCommand = (db, { accountId }) => {
-  const command = db.update(ott_zod.tables.payment).set({
+  const command = db.update(bank.tables.payment).set({
     deletedAt: /* @__PURE__ */ new Date()
-  }).where(drizzleOrm.eq(ott_zod.tables.payment.accountId, accountId));
+  }).where(drizzleOrm.eq(bank.tables.payment.accountId, accountId));
   return {
     command
   };
@@ -223,7 +152,7 @@ const deletePaymentsByAccountCommand = (db, { accountId }) => {
 
 const createPaymentRequestCommand = (db, { paymentRequest }) => {
   return {
-    command: db.insert(ott_zod.tables.paymentRequest).values({
+    command: db.insert(bank.tables.paymentRequest).values({
       ...paymentRequest,
       creditorIban: paymentRequest.creditor.iban,
       debtorIban: paymentRequest.debtor.iban
@@ -234,16 +163,16 @@ const createPaymentRequestCommand = (db, { paymentRequest }) => {
 const getAccountBatchCountsQuery = async (db, { accountId }) => {
   const result = await db.select({
     totalCount: drizzleOrm.sql`COUNT(*)`.as("totalCount"),
-    processingCount: drizzleOrm.sql`SUM(CASE WHEN ${ott_zod.tables.batch.status} = 'PROCESSING' THEN 1 ELSE 0 END)`.as(
+    processingCount: drizzleOrm.sql`SUM(CASE WHEN ${bank.tables.batch.status} = 'PROCESSING' THEN 1 ELSE 0 END)`.as(
       "processingCount"
     ),
-    readyToSignCount: drizzleOrm.sql`SUM(CASE WHEN ${ott_zod.tables.batch.status} = 'READY_TO_SIGN' THEN 1 ELSE 0 END)`.as(
+    readyToSignCount: drizzleOrm.sql`SUM(CASE WHEN ${bank.tables.batch.status} = 'READY_TO_SIGN' THEN 1 ELSE 0 END)`.as(
       "readyToSignCount"
     ),
-    failedCount: drizzleOrm.sql`SUM(CASE WHEN ${ott_zod.tables.batch.status} = 'FAILED' THEN 1 ELSE 0 END)`.as(
+    failedCount: drizzleOrm.sql`SUM(CASE WHEN ${bank.tables.batch.status} = 'FAILED' THEN 1 ELSE 0 END)`.as(
       "failedCount"
     )
-  }).from(ott_zod.tables.batch).where(drizzleOrm.eq(ott_zod.tables.batch.accountId, accountId)).then(backendSdk.first);
+  }).from(bank.tables.batch).where(drizzleOrm.eq(bank.tables.batch.accountId, accountId)).then(backendSdk.first);
   return result || {
     totalCount: 0,
     processingCount: 0,
@@ -253,18 +182,18 @@ const getAccountBatchCountsQuery = async (db, { accountId }) => {
 };
 
 const getAccountByIbanQuery = async (db, { iban }) => {
-  return await db.select().from(ott_zod.tables.account).where(drizzleOrm.eq(ott_zod.tables.account.iban, iban)).get();
+  return await db.select().from(bank.tables.account).where(drizzleOrm.eq(bank.tables.account.iban, iban)).get();
 };
 
 const getAllAccountsQuery = async (db, filters) => {
   const whereConditions = drizzleOrm.and(
-    backendSdk.buildMultiFilterConditions(ott_zod.tables.account.iban, filters?.filterIbans),
+    backendSdk.buildMultiFilterConditions(bank.tables.account.iban, filters?.filterIbans),
     backendSdk.buildMultiFilterConditions(
-      ott_zod.tables.account.currency,
+      bank.tables.account.currency,
       filters?.filterCurrencies
     ),
     backendSdk.buildMultiFilterConditions(
-      ott_zod.tables.account.bankRefId,
+      bank.tables.account.bankRefId,
       filters?.filterBankRefIds
     )
   );
@@ -272,11 +201,11 @@ const getAllAccountsQuery = async (db, filters) => {
   const limit = filters?.limit ?? 20;
   const offset = (page - 1) * limit;
   const [accountsWithExpiration, countResult] = await Promise.all([
-    db.select().from(ott_zod.tables.account).leftJoin(
-      ott_zod.tables.accountCredentials,
-      drizzleOrm.eq(ott_zod.tables.accountCredentials.accountId, ott_zod.tables.account.id)
+    db.select().from(bank.tables.account).leftJoin(
+      bank.tables.accountCredentials,
+      drizzleOrm.eq(bank.tables.accountCredentials.accountId, bank.tables.account.id)
     ).where(whereConditions).limit(limit).offset(offset),
-    db.select({ count: drizzleOrm.sql`count(*)` }).from(ott_zod.tables.account).where(whereConditions)
+    db.select({ count: drizzleOrm.sql`count(*)` }).from(bank.tables.account).where(whereConditions)
   ]);
   return {
     accounts: accountsWithExpiration.map(
@@ -338,42 +267,42 @@ const getPaymentsWithPaginationQuery = async (db, {
 }) => {
   const whereConditions = drizzleOrm.and(
     buildMultiFilterConditions(
-      ott_zod.tables.payment.accountId,
+      bank.tables.payment.accountId,
       filterPaymentAccountId
     ),
-    buildMultiFilterConditions(ott_zod.tables.payment.amount, filterPaymentAmount),
-    buildMultiFilterConditions(ott_zod.tables.payment.currency, filterPaymentCurrency),
+    buildMultiFilterConditions(bank.tables.payment.amount, filterPaymentAmount),
+    buildMultiFilterConditions(bank.tables.payment.currency, filterPaymentCurrency),
     buildRangeFilterConditions(
-      ott_zod.tables.payment.createdAt,
+      bank.tables.payment.createdAt,
       filterPaymentDateFrom,
       filterPaymentDateTo
     ),
-    buildMultiFilterConditions(ott_zod.tables.payment.status, filterPaymentStatus),
+    buildMultiFilterConditions(bank.tables.payment.status, filterPaymentStatus),
     buildMultiFilterConditions(
-      ott_zod.tables.payment.direction,
+      bank.tables.payment.direction,
       filterPaymentDirection
     ),
-    buildMultiFilterConditions(ott_zod.tables.payment.id, ids),
-    buildMultiFilterConditions(ott_zod.tables.payment.paymentType, filterPaymentType),
+    buildMultiFilterConditions(bank.tables.payment.id, ids),
+    buildMultiFilterConditions(bank.tables.payment.paymentType, filterPaymentType),
     buildRangeFilterConditions(
-      ott_zod.tables.payment.amount,
+      bank.tables.payment.amount,
       filterPaymentMinAmount,
       filterPaymentMaxAmount
     ),
-    filterPaymentVariableSymbol !== void 0 ? drizzleOrm.eq(ott_zod.tables.payment.vs, filterPaymentVariableSymbol) : void 0,
-    filterPaymentSpecificSymbol !== void 0 ? drizzleOrm.eq(ott_zod.tables.payment.ss, filterPaymentSpecificSymbol) : void 0,
-    filterPaymentConstantSymbol !== void 0 ? drizzleOrm.eq(ott_zod.tables.payment.ks, filterPaymentConstantSymbol) : void 0,
-    filterPaymentMessage !== void 0 ? drizzleOrm.like(ott_zod.tables.payment.message, `%${filterPaymentMessage}%`) : void 0,
-    filterPaymentCreditorIban !== void 0 ? drizzleOrm.eq(ott_zod.tables.payment.creditorIban, filterPaymentCreditorIban) : void 0,
-    filterPaymentDebtorIban !== void 0 ? drizzleOrm.eq(ott_zod.tables.payment.debtorIban, filterPaymentDebtorIban) : void 0,
-    filterPaymentBatchId !== void 0 ? drizzleOrm.eq(ott_zod.tables.payment.batchId, filterPaymentBatchId) : void 0,
-    filterPaymentBankRefId !== void 0 ? drizzleOrm.eq(ott_zod.tables.payment.bankRefId, filterPaymentBankRefId) : void 0
+    filterPaymentVariableSymbol !== void 0 ? drizzleOrm.eq(bank.tables.payment.vs, filterPaymentVariableSymbol) : void 0,
+    filterPaymentSpecificSymbol !== void 0 ? drizzleOrm.eq(bank.tables.payment.ss, filterPaymentSpecificSymbol) : void 0,
+    filterPaymentConstantSymbol !== void 0 ? drizzleOrm.eq(bank.tables.payment.ks, filterPaymentConstantSymbol) : void 0,
+    filterPaymentMessage !== void 0 ? drizzleOrm.like(bank.tables.payment.message, `%${filterPaymentMessage}%`) : void 0,
+    filterPaymentCreditorIban !== void 0 ? drizzleOrm.eq(bank.tables.payment.creditorIban, filterPaymentCreditorIban) : void 0,
+    filterPaymentDebtorIban !== void 0 ? drizzleOrm.eq(bank.tables.payment.debtorIban, filterPaymentDebtorIban) : void 0,
+    filterPaymentBatchId !== void 0 ? drizzleOrm.eq(bank.tables.payment.batchId, filterPaymentBatchId) : void 0,
+    filterPaymentBankRefId !== void 0 ? drizzleOrm.eq(bank.tables.payment.bankRefId, filterPaymentBankRefId) : void 0
   );
-  const sortColumn = resolveColumn(ott_zod.tables.payment, sort.column);
+  const sortColumn = resolveColumn(bank.tables.payment, sort.column);
   const [{ totalCount }] = await db.select({
     totalCount: drizzleOrm.sql`count(*)`
-  }).from(ott_zod.tables.payment).where(whereConditions);
-  const payments = await db.select().from(ott_zod.tables.payment).where(whereConditions).limit(limit).offset((page - 1) * limit).orderBy(sort.direction === "asc" ? drizzleOrm.asc(sortColumn) : drizzleOrm.desc(sortColumn));
+  }).from(bank.tables.payment).where(whereConditions);
+  const payments = await db.select().from(bank.tables.payment).where(whereConditions).limit(limit).offset((page - 1) * limit).orderBy(sort.direction === "asc" ? drizzleOrm.asc(sortColumn) : drizzleOrm.desc(sortColumn));
   return {
     payments,
     totalCount
@@ -388,20 +317,20 @@ const getBatchesQuery = async (db, {
   filterBatchStatus
 }) => {
   const whereConditions = drizzleOrm.and(
-    drizzleOrm.isNull(ott_zod.tables.batch.deletedAt),
-    buildMultiFilterConditions(ott_zod.tables.batch.accountId, filterBatchAccountId),
-    buildMultiFilterConditions(ott_zod.tables.batch.status, filterBatchStatus)
+    drizzleOrm.isNull(bank.tables.batch.deletedAt),
+    buildMultiFilterConditions(bank.tables.batch.accountId, filterBatchAccountId),
+    buildMultiFilterConditions(bank.tables.batch.status, filterBatchStatus)
   );
-  const sortColumn = resolveColumn(ott_zod.tables.batch, sort.column);
+  const sortColumn = resolveColumn(bank.tables.batch, sort.column);
   const [{ totalCount }] = await db.select({
     totalCount: drizzleOrm.sql`count(*)`
-  }).from(ott_zod.tables.batch).where(whereConditions);
-  const batches = await db.select().from(ott_zod.tables.batch).where(whereConditions).limit(limit).offset((page - 1) * limit).orderBy(sort.direction === "asc" ? drizzleOrm.asc(sortColumn) : drizzleOrm.desc(sortColumn));
+  }).from(bank.tables.batch).where(whereConditions);
+  const batches = await db.select().from(bank.tables.batch).where(whereConditions).limit(limit).offset((page - 1) * limit).orderBy(sort.direction === "asc" ? drizzleOrm.asc(sortColumn) : drizzleOrm.desc(sortColumn));
   const batchIds = batches.map((b) => b.id);
-  const paymentRequests = batchIds.length > 0 ? await db.select().from(ott_zod.tables.paymentRequest).where(
+  const paymentRequests = batchIds.length > 0 ? await db.select().from(bank.tables.paymentRequest).where(
     drizzleOrm.and(
-      drizzleOrm.inArray(ott_zod.tables.paymentRequest.batchId, batchIds),
-      drizzleOrm.isNull(ott_zod.tables.paymentRequest.deletedAt)
+      drizzleOrm.inArray(bank.tables.paymentRequest.batchId, batchIds),
+      drizzleOrm.isNull(bank.tables.paymentRequest.deletedAt)
     )
   ) : [];
   const paymentRequestsByBatchId = Map.groupBy(
@@ -419,14 +348,50 @@ const getBatchesQuery = async (db, {
 };
 
 const getOttQuery = async (db, { ott }) => {
-  return await db.select().from(ott_zod.tables.ott).where(drizzleOrm.eq(ott_zod.tables.ott.oneTimeToken, ott)).get();
+  return await db.select().from(bank.tables.ott).where(drizzleOrm.eq(bank.tables.ott.oneTimeToken, ott)).get();
+};
+
+const CHUNK_SIZE = 90;
+const getPaymentsByPaymentRequestIdsQuery = async (db, { paymentRequestIds }) => {
+  if (paymentRequestIds.length === 0) return [];
+  const paymentRequests = [];
+  for (let i = 0; i < paymentRequestIds.length; i += CHUNK_SIZE) {
+    const chunkIds = paymentRequestIds.slice(i, i + CHUNK_SIZE);
+    const rows = await db.select({
+      id: bank.tables.paymentRequest.id,
+      correlationId: bank.tables.paymentRequest.correlationId,
+      status: bank.tables.paymentRequest.status,
+      amount: bank.tables.paymentRequest.amount,
+      currency: bank.tables.paymentRequest.currency,
+      creditor: bank.tables.paymentRequest.creditor,
+      createdAt: bank.tables.paymentRequest.createdAt,
+      updatedAt: bank.tables.paymentRequest.updatedAt
+    }).from(bank.tables.paymentRequest).where(drizzleOrm.inArray(bank.tables.paymentRequest.id, chunkIds));
+    paymentRequests.push(...rows);
+  }
+  return paymentRequests.map((pr) => {
+    const creditor = typeof pr.creditor === "string" ? JSON.parse(pr.creditor) : pr.creditor || {};
+    return {
+      paymentRequestId: pr.id,
+      payment: {
+        id: pr.id,
+        correlationId: pr.correlationId,
+        status: pr.status,
+        amount: pr.amount,
+        currency: pr.currency,
+        creditor,
+        createdAt: pr.createdAt,
+        updatedAt: pr.updatedAt
+      }
+    };
+  });
 };
 
 const getPaymentRequestByIdQuery = async (db, { paymentRequestId }) => {
-  const result = await db.select().from(ott_zod.tables.paymentRequest).where(
+  const result = await db.select().from(bank.tables.paymentRequest).where(
     drizzleOrm.and(
-      drizzleOrm.eq(ott_zod.tables.paymentRequest.id, paymentRequestId),
-      drizzleOrm.isNull(ott_zod.tables.paymentRequest.deletedAt)
+      drizzleOrm.eq(bank.tables.paymentRequest.id, paymentRequestId),
+      drizzleOrm.isNull(bank.tables.paymentRequest.deletedAt)
     )
   ).limit(1);
   return backendSdk.first(result);
@@ -436,30 +401,30 @@ const getPaymentRequestsQuery = async (db, params) => {
   const limit = params.limit;
   const offset = (params.page - 1) * params.limit;
   const orderDir = params.sort.direction === "asc" ? drizzleOrm.asc : drizzleOrm.desc;
-  const orderCol = params.sort.column === "amount" ? ott_zod.tables.paymentRequest.amount : params.sort.column === "updatedAt" ? ott_zod.tables.paymentRequest.updatedAt : ott_zod.tables.paymentRequest.createdAt;
+  const orderCol = params.sort.column === "amount" ? bank.tables.paymentRequest.amount : params.sort.column === "updatedAt" ? bank.tables.paymentRequest.updatedAt : bank.tables.paymentRequest.createdAt;
   const where = drizzleOrm.and(
-    drizzleOrm.isNull(ott_zod.tables.paymentRequest.deletedAt),
-    params.filterAccountId ? Array.isArray(params.filterAccountId) ? drizzleOrm.inArray(ott_zod.tables.paymentRequest.accountId, params.filterAccountId) : drizzleOrm.eq(ott_zod.tables.paymentRequest.accountId, params.filterAccountId) : void 0,
-    params.filterStatus ? Array.isArray(params.filterStatus) ? drizzleOrm.inArray(ott_zod.tables.paymentRequest.status, params.filterStatus) : drizzleOrm.eq(ott_zod.tables.paymentRequest.status, params.filterStatus) : void 0,
-    params.filterPaymentType ? Array.isArray(params.filterPaymentType) ? drizzleOrm.inArray(ott_zod.tables.paymentRequest.paymentType, params.filterPaymentType) : drizzleOrm.eq(ott_zod.tables.paymentRequest.paymentType, params.filterPaymentType) : void 0,
-    params.filterCurrency ? Array.isArray(params.filterCurrency) ? drizzleOrm.inArray(ott_zod.tables.paymentRequest.currency, params.filterCurrency) : drizzleOrm.eq(ott_zod.tables.paymentRequest.currency, params.filterCurrency) : void 0,
-    params.filterBatchId ? drizzleOrm.eq(ott_zod.tables.paymentRequest.batchId, params.filterBatchId) : void 0,
-    params.filterDateFrom ? drizzleOrm.gte(ott_zod.tables.paymentRequest.createdAt, params.filterDateFrom) : void 0,
-    params.filterDateTo ? drizzleOrm.lte(ott_zod.tables.paymentRequest.createdAt, params.filterDateTo) : void 0,
-    params.filterMinAmount !== void 0 ? drizzleOrm.gte(ott_zod.tables.paymentRequest.amount, params.filterMinAmount) : void 0,
-    params.filterMaxAmount !== void 0 ? drizzleOrm.lte(ott_zod.tables.paymentRequest.amount, params.filterMaxAmount) : void 0,
-    params.filterVariableSymbol ? drizzleOrm.eq(ott_zod.tables.paymentRequest.vs, params.filterVariableSymbol) : void 0,
-    params.filterSpecificSymbol ? drizzleOrm.eq(ott_zod.tables.paymentRequest.ss, params.filterSpecificSymbol) : void 0,
-    params.filterConstantSymbol ? drizzleOrm.eq(ott_zod.tables.paymentRequest.ks, params.filterConstantSymbol) : void 0,
-    params.filterMessage ? drizzleOrm.like(ott_zod.tables.paymentRequest.message, `%${params.filterMessage}%`) : void 0,
-    params.filterBankRefId ? drizzleOrm.eq(ott_zod.tables.paymentRequest.bankRefId, params.filterBankRefId) : void 0,
-    params.filterCreditorIban ? drizzleOrm.eq(ott_zod.tables.paymentRequest.creditorIban, params.filterCreditorIban) : void 0,
-    params.filterDebtorIban ? drizzleOrm.eq(ott_zod.tables.paymentRequest.debtorIban, params.filterDebtorIban) : void 0,
-    params.ids?.length ? drizzleOrm.inArray(ott_zod.tables.paymentRequest.id, params.ids) : void 0
+    drizzleOrm.isNull(bank.tables.paymentRequest.deletedAt),
+    params.filterAccountId ? Array.isArray(params.filterAccountId) ? drizzleOrm.inArray(bank.tables.paymentRequest.accountId, params.filterAccountId) : drizzleOrm.eq(bank.tables.paymentRequest.accountId, params.filterAccountId) : void 0,
+    params.filterStatus ? Array.isArray(params.filterStatus) ? drizzleOrm.inArray(bank.tables.paymentRequest.status, params.filterStatus) : drizzleOrm.eq(bank.tables.paymentRequest.status, params.filterStatus) : void 0,
+    params.filterPaymentType ? Array.isArray(params.filterPaymentType) ? drizzleOrm.inArray(bank.tables.paymentRequest.paymentType, params.filterPaymentType) : drizzleOrm.eq(bank.tables.paymentRequest.paymentType, params.filterPaymentType) : void 0,
+    params.filterCurrency ? Array.isArray(params.filterCurrency) ? drizzleOrm.inArray(bank.tables.paymentRequest.currency, params.filterCurrency) : drizzleOrm.eq(bank.tables.paymentRequest.currency, params.filterCurrency) : void 0,
+    params.filterBatchId ? drizzleOrm.eq(bank.tables.paymentRequest.batchId, params.filterBatchId) : void 0,
+    params.filterDateFrom ? drizzleOrm.gte(bank.tables.paymentRequest.createdAt, params.filterDateFrom) : void 0,
+    params.filterDateTo ? drizzleOrm.lte(bank.tables.paymentRequest.createdAt, params.filterDateTo) : void 0,
+    params.filterMinAmount !== void 0 ? drizzleOrm.gte(bank.tables.paymentRequest.amount, params.filterMinAmount) : void 0,
+    params.filterMaxAmount !== void 0 ? drizzleOrm.lte(bank.tables.paymentRequest.amount, params.filterMaxAmount) : void 0,
+    params.filterVariableSymbol ? drizzleOrm.eq(bank.tables.paymentRequest.vs, params.filterVariableSymbol) : void 0,
+    params.filterSpecificSymbol ? drizzleOrm.eq(bank.tables.paymentRequest.ss, params.filterSpecificSymbol) : void 0,
+    params.filterConstantSymbol ? drizzleOrm.eq(bank.tables.paymentRequest.ks, params.filterConstantSymbol) : void 0,
+    params.filterMessage ? drizzleOrm.like(bank.tables.paymentRequest.message, `%${params.filterMessage}%`) : void 0,
+    params.filterBankRefId ? drizzleOrm.eq(bank.tables.paymentRequest.bankRefId, params.filterBankRefId) : void 0,
+    params.filterCreditorIban ? drizzleOrm.eq(bank.tables.paymentRequest.creditorIban, params.filterCreditorIban) : void 0,
+    params.filterDebtorIban ? drizzleOrm.eq(bank.tables.paymentRequest.debtorIban, params.filterDebtorIban) : void 0,
+    params.ids?.length ? drizzleOrm.inArray(bank.tables.paymentRequest.id, params.ids) : void 0
   );
   const [paymentRequests, [{ value: totalCount }]] = await Promise.all([
-    db.select().from(ott_zod.tables.paymentRequest).where(where).orderBy(orderDir(orderCol)).limit(limit).offset(offset),
-    db.select({ value: drizzleOrm.count() }).from(ott_zod.tables.paymentRequest).where(where)
+    db.select().from(bank.tables.paymentRequest).where(where).orderBy(orderDir(orderCol)).limit(limit).offset(offset),
+    db.select({ value: drizzleOrm.count() }).from(bank.tables.paymentRequest).where(where)
   ]);
   return { paymentRequests, totalCount };
 };
@@ -486,6 +451,79 @@ function buildPaymentRequestEvent(pr) {
   };
 }
 
+const sendPaymentInputSchema = zod.z.object({
+  correlationId: zod.z.string().min(1),
+  refId: zod.z.string().optional(),
+  amount: zod.z.number().positive(),
+  paymentType: zod.z.enum(database_schema.PAYMENT_TYPES),
+  chargeBearer: zod.z.enum(database_schema.CHARGE_BEARERS).optional(),
+  instructionPriority: zod.z.enum(database_schema.INSTRUCTION_PRIORITIES).optional(),
+  currency: zod.z.enum(generalCodes.CURRENCY_CODES),
+  vs: zod.z.string().optional(),
+  ss: zod.z.string().optional(),
+  ks: zod.z.string().optional(),
+  message: zod.z.string().optional(),
+  creditor: backendSdk.bankAccountMetadataSchema,
+  debtor: backendSdk.bankAccountMetadataSchema,
+  sendAsSinglePayment: zod.z.boolean().optional()
+}).superRefine((data, ctx) => {
+  if (data.paymentType === "UNKNOWN") {
+    ctx.addIssue({
+      code: "custom",
+      message: "paymentType=UNKNOWN is not supported. Use DOMESTIC, SEPA, or SWIFT.",
+      path: ["paymentType"]
+    });
+    return;
+  }
+  if (!data.debtor.iban) {
+    ctx.addIssue({
+      code: "custom",
+      message: "debtor.iban is required",
+      path: ["debtor", "iban"]
+    });
+  }
+  if (data.paymentType === "DOMESTIC" || data.paymentType === "SEPA") {
+    const hasIban = !!data.creditor.iban;
+    const hasAccountNumber = !!data.creditor.number && !!data.creditor.bankCode;
+    if (!hasIban && !hasAccountNumber) {
+      ctx.addIssue({
+        code: "custom",
+        message: `creditor must have either iban OR (number + bankCode) for ${data.paymentType} payments`,
+        path: ["creditor"]
+      });
+    }
+    return;
+  }
+  if (data.paymentType === "SWIFT") {
+    const hasIban = !!data.creditor.iban;
+    const hasBban = !!data.creditor.number && !!(data.creditor.swiftBic ?? data.creditor.bicCor);
+    if (!hasIban && !hasBban) {
+      ctx.addIssue({
+        code: "custom",
+        message: "SWIFT creditor requires either iban OR (number + swiftBic/bicCor)",
+        path: ["creditor"]
+      });
+    }
+  }
+});
+
+const sendBatchInputSchema = zod.z.object({
+  payments: zod.z.array(sendPaymentInputSchema).min(1)
+});
+
+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(),
+  syncIntervalS: zod.z.number().int().positive().optional(),
+  startSync: zod.z.boolean().optional(),
+  lastSyncAt: zod.z.date().optional(),
+  address: backendSdk.structuredAddressSchema.optional()
+});
+
 const simulateDepositInputSchema = zod.z.object({
   amount: zod.z.number(),
   currency: zod.z.enum(generalCodes.CURRENCY_CODES),
@@ -585,6 +623,10 @@ const getPaymentsInputSchema = zod.z.object({
   [ALLOWED_PAYMENT_FILTERS.BANK_REF_ID]: zod.z.string().optional()
 });
 
+const getPaymentsByRequestIdsInputSchema = zod.z.object({
+  paymentRequestIds: zod.z.array(zod.z.string().uuid()).min(1, "At least one payment request ID is required").max(100, "Maximum 100 payment request IDs per request")
+});
+
 const syncAccountInputSchema = zod.z.object({
   accountId: zod.z.uuid()
 });
@@ -617,7 +659,7 @@ zod.z.object({
 });
 
 const updateAccountInputSchema = zod.z.object({
-  account: ott_zod.accountInsertSchema
+  account: bank.accountInsertSchema
 });
 
 const getBankAccountsInputSchema = zod.z.object({
@@ -693,7 +735,7 @@ exports.BankServiceBase = class BankServiceBase extends backendSdk.develitWorker
     // 14 days
     this.COMPLETED_POLLING_WINDOW_MS = 7 * 24 * 60 * 60 * 1e3;
     this.allowedProviders = config.allowedProviders;
-    this.db = d1.drizzle(this.env.BANK_D1, { schema: ott_zod.tables, relations: ott_zod.relations });
+    this.db = d1.drizzle(this.env.BANK_D1, { schema: bank.tables, relations: bank.relations });
   }
   async _getAccounts(filters) {
     return await getAllAccountsQuery(this.db, filters);
@@ -729,7 +771,7 @@ exports.BankServiceBase = class BankServiceBase extends backendSdk.develitWorker
       }));
       resolveCredentials = await credentialsResolver.createCredentialsResolver(this.db, this.env);
     }
-    return ott_zod.initiateConnector({
+    return bank.initiateConnector({
       bank: connectorKey,
       connectedAccounts,
       resolveCredentials,
@@ -766,6 +808,18 @@ exports.BankServiceBase = class BankServiceBase extends backendSdk.develitWorker
       }
     );
   }
+  async getPaymentsByRequestIds(input) {
+    return this.handleAction(
+      { data: input, schema: getPaymentsByRequestIdsInputSchema },
+      { successMessage: "Payments retrieved successfully" },
+      async (validated) => {
+        const payments = await getPaymentsByPaymentRequestIdsQuery(this.db, {
+          paymentRequestIds: validated.paymentRequestIds
+        });
+        return { payments };
+      }
+    );
+  }
   async syncAccount(input) {
     return this.handleAction(
       { data: input, schema: syncAccountInputSchema },
@@ -892,7 +946,7 @@ exports.BankServiceBase = class BankServiceBase extends backendSdk.develitWorker
             await credentialsResolver.updatePaymentRequestStatusCommand(this.db, {
               id: pr.id,
               status: newStatus,
-              processedAt: ott_zod.isProcessedStatus(newStatus) ? /* @__PURE__ */ new Date() : void 0
+              processedAt: bank.isProcessedStatus(newStatus) ? /* @__PURE__ */ new Date() : void 0
             }).command.execute();
             statusChanged++;
             eventsToEmit.push(
@@ -978,7 +1032,7 @@ exports.BankServiceBase = class BankServiceBase extends backendSdk.develitWorker
     if (allPRs.length === 0) return;
     const connectorKey = allPRs[0]?.connectorKey;
     const allTerminal = allPRs.every(
-      (pr) => ott_zod.isTerminalStatus(pr.status, connectorKey)
+      (pr) => bank.isTerminalStatus(pr.status, connectorKey)
     );
     const allAuthorizedOrHigher = allPRs.every((pr) => pr.status !== "OPENED");
     if (allTerminal) {
@@ -1003,7 +1057,7 @@ exports.BankServiceBase = class BankServiceBase extends backendSdk.develitWorker
         console.log("[updatePaymentRequestStatuses] Starting", {
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         });
-        const nonTerminalPRs = await ott_zod.getNonTerminalPaymentRequestsQuery(this.db);
+        const nonTerminalPRs = await bank.getNonTerminalPaymentRequestsQuery(this.db);
         if (nonTerminalPRs.length === 0) {
           console.log(
             "[updatePaymentRequestStatuses] No non-terminal PRs found",
@@ -1026,7 +1080,7 @@ exports.BankServiceBase = class BankServiceBase extends backendSdk.develitWorker
         const pollableIds = [];
         for (const pr of nonTerminalPRs) {
           const status = pr.status;
-          if (ott_zod.isTerminalStatus(status, pr.connectorKey)) {
+          if (bank.isTerminalStatus(status, pr.connectorKey)) {
             continue;
           }
           if (status === "OPENED" || status === "AUTHORIZED") {
@@ -1081,9 +1135,9 @@ exports.BankServiceBase = class BankServiceBase extends backendSdk.develitWorker
   }
   async heartbeatSyncWorkflows() {
     const accounts = await this.db.select({
-      id: ott_zod.tables.account.id,
-      lastSyncMetadata: ott_zod.tables.account.lastSyncMetadata
-    }).from(ott_zod.tables.account).where(drizzleOrm.eq(ott_zod.tables.account.status, "AUTHORIZED")).all();
+      id: bank.tables.account.id,
+      lastSyncMetadata: bank.tables.account.lastSyncMetadata
+    }).from(bank.tables.account).where(drizzleOrm.eq(bank.tables.account.status, "AUTHORIZED")).all();
     const resetAfterIterations = Number(
       this.env.SYNC_WORKFLOW_RESET_AFTER_ITERATIONS
     );
@@ -1441,12 +1495,21 @@ exports.BankServiceBase = class BankServiceBase extends backendSdk.develitWorker
       { data: input, schema: sendPaymentInputSchema },
       { successMessage: "Payment initiated successfully" },
       async (data) => {
-        const incomingPayment = ott_zod.toIncomingPayment(data);
+        const incomingPayment = bank.toIncomingPayment(data);
         this._validatePaymentTypeAndCurrency(
           data.paymentType,
           data.currency,
           data.creditor
         );
+        if (data.creditor.bankCode?.length === 4 && !data.creditor.iban && data.creditor.number) {
+          try {
+            data.creditor.iban = bank.calculateCzechIban(
+              data.creditor.number,
+              data.creditor.bankCode
+            );
+          } catch (_error) {
+          }
+        }
         const { accounts } = await this._getAccounts({
           filterIbans: [incomingPayment.debtorIban]
         });
@@ -1482,11 +1545,11 @@ exports.BankServiceBase = class BankServiceBase extends backendSdk.develitWorker
             status: 422
           });
         }
-        const accountAssigned = ott_zod.assignAccount(incomingPayment, account);
-        const batchedPayment = ott_zod.toBatchedPayment(accountAssigned);
+        const accountAssigned = bank.assignAccount(incomingPayment, account);
+        const batchedPayment = bank.toBatchedPayment(accountAssigned);
         const { command: insertPaymentRequest } = createPaymentRequestCommand(
           this.db,
-          { paymentRequest: ott_zod.toPaymentRequestInsert(accountAssigned, null) }
+          { paymentRequest: bank.toPaymentRequestInsert(accountAssigned, null) }
         );
         await insertPaymentRequest.execute();
         const initiate = () => {
@@ -1521,7 +1584,7 @@ exports.BankServiceBase = class BankServiceBase extends backendSdk.develitWorker
           bankRefId: initiated.payment.bankRefId,
           initiatedAt: initiated.payment.initiatedAt,
           authorizationUrl: initiated.authorizationUrl,
-          processedAt: ott_zod.isProcessedStatus(initiated.payment.status) ? /* @__PURE__ */ new Date() : void 0
+          processedAt: bank.isProcessedStatus(initiated.payment.status) ? /* @__PURE__ */ new Date() : void 0
         }).command.execute();
         const paymentRequest = await getPaymentRequestByIdQuery(this.db, {
           paymentRequestId: incomingPayment.id
@@ -1627,9 +1690,9 @@ exports.BankServiceBase = class BankServiceBase extends backendSdk.develitWorker
             status: 422
           });
         }
-        const incomingPayments = paymentInputs.map(ott_zod.toIncomingPayment);
+        const incomingPayments = paymentInputs.map(bank.toIncomingPayment);
         const batchedPayments = incomingPayments.map(
-          (p) => ott_zod.toBatchedPayment(ott_zod.assignAccount(p, account))
+          (p) => bank.toBatchedPayment(bank.assignAccount(p, account))
         );
         const batchId = backendSdk.uuidv4();
         const batchMode = connector.supportsBatch(paymentType) ? "NATIVE" : "SINGLE";
@@ -1646,8 +1709,8 @@ exports.BankServiceBase = class BankServiceBase extends backendSdk.develitWorker
         }).command;
         const prCmds = incomingPayments.map(
           (p) => createPaymentRequestCommand(this.db, {
-            paymentRequest: ott_zod.toPaymentRequestInsert(
-              ott_zod.assignAccount(p, account),
+            paymentRequest: bank.toPaymentRequestInsert(
+              bank.assignAccount(p, account),
               batchId
             )
           }).command
@@ -1696,7 +1759,7 @@ exports.BankServiceBase = class BankServiceBase extends backendSdk.develitWorker
             bankRefId: pp.bankRefId,
             initiatedAt: pp.initiatedAt,
             authorizationUrl: isPerPaymentFallback ? authorizationUrls[i] : authorizationUrls[0],
-            processedAt: ott_zod.isProcessedStatus(pp.status) ? /* @__PURE__ */ new Date() : void 0
+            processedAt: bank.isProcessedStatus(pp.status) ? /* @__PURE__ */ new Date() : void 0
           }).command
         );
         const updateBatchCmd = credentialsResolver.upsertBatchCommand(this.db, {
@@ -1785,11 +1848,11 @@ exports.BankServiceBase = class BankServiceBase extends backendSdk.develitWorker
             if (includePendingPaymentRequestCount) {
               const [row] = await this.db.select({
                 count: drizzleOrm.sql`count(*)`
-              }).from(ott_zod.tables.paymentRequest).where(
+              }).from(bank.tables.paymentRequest).where(
                 drizzleOrm.and(
-                  drizzleOrm.eq(ott_zod.tables.paymentRequest.accountId, a.id),
-                  drizzleOrm.eq(ott_zod.tables.paymentRequest.status, "OPENED"),
-                  drizzleOrm.isNull(ott_zod.tables.paymentRequest.deletedAt)
+                  drizzleOrm.eq(bank.tables.paymentRequest.accountId, a.id),
+                  drizzleOrm.eq(bank.tables.paymentRequest.status, "OPENED"),
+                  drizzleOrm.isNull(bank.tables.paymentRequest.deletedAt)
                 )
               );
               result.pendingPaymentRequestCount = row?.count ?? 0;
@@ -1980,14 +2043,14 @@ exports.BankServiceBase = class BankServiceBase extends backendSdk.develitWorker
     const privateKeyPem = (await this.env.SECRETS_STORE.get({
       secretName: "BANK_SERVICE_FINBRICKS_PRIVATE_KEY_PEM"
     })).data?.secretValue || "";
-    const client = new ott_zod.FinbricksClient(
+    const client = new bank.FinbricksClient(
       this.env.FINBRICKS_BASE_URI,
       this.env.FINBRICKS_MERCHANT_ID,
       privateKeyPem,
       this.env.REDIRECT_URI
     );
     return client.request({
-      endpoint: ott_zod.FINBRICKS_ENDPOINTS.BANK_INFO,
+      endpoint: bank.FINBRICKS_ENDPOINTS.BANK_INFO,
       method: "GET",
       query: {
         merchantId: this.env.FINBRICKS_MERCHANT_ID
@@ -1998,6 +2061,9 @@ exports.BankServiceBase = class BankServiceBase extends backendSdk.develitWorker
 __decorateClass([
   backendSdk.action("get-payments")
 ], exports.BankServiceBase.prototype, "getPayments", 1);
+__decorateClass([
+  backendSdk.action("get-payments-by-request-ids")
+], exports.BankServiceBase.prototype, "getPaymentsByRequestIds", 1);
 __decorateClass([
   backendSdk.action("sync-account")
 ], exports.BankServiceBase.prototype, "syncAccount", 1);