@develit-services/bank 0.8.6 → 0.8.7

package/dist/export/worker.mjs

@@ -1,27 +1,27 @@
 import { uuidv4, first, buildMultiFilterConditions as buildMultiFilterConditions$1, bankAccountMetadataSchema, workflowInstanceStatusSchema, develitWorker, createInternalError, action, service } from '@develit-io/backend-sdk';
-import { t as tables, h as encrypt, d as createCredentialsResolver, u as upsertBatchCommand, a as getPaymentRequestsByBatchIdQuery, e as updatePaymentRequestStatusCommand, g as getBatchByIdQuery, i as importAesKey, f as createPaymentCommand, b as getAccountByIdQuery } from '../shared/bank.Cpy9PULF.mjs';
+import { t as tables, h as encrypt, d as createCredentialsResolver, u as upsertBatchCommand, a as getPaymentRequestsByBatchIdQuery, e as updatePaymentRequestStatusCommand, g as getBatchByIdQuery, i as importAesKey, f as createPaymentCommand, b as getAccountByIdQuery } from '../shared/bank.DEmzZGZW.mjs';
 import { WorkerEntrypoint } from 'cloudflare:workers';
 import { drizzle } from 'drizzle-orm/d1';
-import { k as initiateConnector, m as mapFinbricksTransactionStatus, h as toIncomingPayment, d as assignAccount, i as toPaymentRequestInsert, t as toBatchedPayment, a as FinbricksClient, F as FINBRICKS_ENDPOINTS } from '../shared/bank.DRrBrAdI.mjs';
+import { j as initiateConnector, m as mapFinbricksTransactionStatus, g as toIncomingPayment, d as assignAccount, t as toBatchedPayment, a as FinbricksClient, F as FINBRICKS_ENDPOINTS, h as toPaymentRequestInsert } from '../shared/bank.D1jqaHaF.mjs';
 import 'jose';
 import { z } from 'zod';
-import { I as INSTRUCTION_PRIORITIES, C as CHARGE_BEARERS, e as PAYMENT_TYPES, a as CONNECTOR_KEYS, B as BATCH_STATUSES, d as PAYMENT_STATUSES, P as PAYMENT_DIRECTIONS, i as accountInsertSchema } from '../shared/bank.C4VOdIx1.mjs';
+import { I as INSTRUCTION_PRIORITIES, C as CHARGE_BEARERS, e as PAYMENT_TYPES, a as CONNECTOR_KEYS, B as BATCH_STATUSES, d as PAYMENT_STATUSES, P as PAYMENT_DIRECTIONS, i as accountInsertSchema } from '../shared/bank.C0UN6luZ.mjs';
 import { CURRENCY_CODES } from '@develit-io/general-codes';
 import 'date-fns';
-import { eq, sql, and, inArray, asc, desc, gte, lte } from 'drizzle-orm';
+import { eq, sql, and, inArray, like, asc, desc, gte, lte, isNull, or, isNotNull } from 'drizzle-orm';
+import { unionAll } from 'drizzle-orm/sqlite-core';
 import 'node:crypto';
-import '../shared/bank.DDHrdFgy.mjs';
+import '../shared/bank.CA5ytXxp.mjs';
 import 'drizzle-orm/relations';
-import 'drizzle-orm/sqlite-core';
 import 'drizzle-zod';
 
 const upsertAccountCommand = (db, { account }) => {
   const id = account.id || uuidv4();
+  const { id: _id, ...accountWithoutId } = account;
   const command = db.insert(tables.account).values({ ...account, id }).onConflictDoUpdate({
     target: tables.account.iban,
-    set: {
-      ...account
-    }
+    set: accountWithoutId
+    // preserve existing id on re-auth
   }).returning();
   return {
     id,
@@ -139,16 +139,25 @@ const getAllAccountsQuery = async (db, filters) => {
       filters?.filterBankRefIds
     )
   );
-  const accountsWithExpiration = await db.select().from(tables.account).leftJoin(
-    tables.accountCredentials,
-    eq(tables.accountCredentials.accountId, tables.account.id)
-  ).where(whereConditions);
-  return accountsWithExpiration.map(({ account, account_credentials }) => {
-    return {
-      ...account,
-      expiresAt: account_credentials?.expiresAt
-    };
-  });
+  const page = filters?.page ?? 1;
+  const limit = filters?.limit ?? 20;
+  const offset = (page - 1) * limit;
+  const [accountsWithExpiration, countResult] = await Promise.all([
+    db.select().from(tables.account).leftJoin(
+      tables.accountCredentials,
+      eq(tables.accountCredentials.accountId, tables.account.id)
+    ).where(whereConditions).limit(limit).offset(offset),
+    db.select({ count: sql`count(*)` }).from(tables.account).where(whereConditions)
+  ]);
+  return {
+    accounts: accountsWithExpiration.map(
+      ({ account, account_credentials }) => ({
+        ...account,
+        expiresAt: account_credentials?.expiresAt
+      })
+    ),
+    totalCount: countResult[0]?.count ?? 0
+  };
 };
 
 const getAllPendingBatchesQuery = (db) => {
@@ -189,7 +198,17 @@ const getPaymentsWithPaginationQuery = async (db, {
   filterPaymentDateFrom,
   filterPaymentDateTo,
   filterPaymentStatus,
-  filterPaymentyDirection
+  filterPaymentDirection,
+  filterPaymentType,
+  filterPaymentMinAmount,
+  filterPaymentMaxAmount,
+  filterPaymentVariableSymbol,
+  filterPaymentSpecificSymbol,
+  filterPaymentConstantSymbol,
+  filterPaymentMessage,
+  filterPaymentCreditorIban,
+  filterPaymentDebtorIban,
+  filterPaymentBatchId
 }) => {
   const whereConditions = and(
     buildMultiFilterConditions(
@@ -206,9 +225,22 @@ const getPaymentsWithPaginationQuery = async (db, {
     buildMultiFilterConditions(tables.payment.status, filterPaymentStatus),
     buildMultiFilterConditions(
       tables.payment.direction,
-      filterPaymentyDirection
+      filterPaymentDirection
+    ),
+    buildMultiFilterConditions(tables.payment.id, ids),
+    buildMultiFilterConditions(tables.payment.paymentType, filterPaymentType),
+    buildRangeFilterConditions(
+      tables.payment.amount,
+      filterPaymentMinAmount,
+      filterPaymentMaxAmount
     ),
-    buildMultiFilterConditions(tables.payment.id, ids)
+    filterPaymentVariableSymbol !== void 0 ? eq(tables.payment.vs, filterPaymentVariableSymbol) : void 0,
+    filterPaymentSpecificSymbol !== void 0 ? eq(tables.payment.ss, filterPaymentSpecificSymbol) : void 0,
+    filterPaymentConstantSymbol !== void 0 ? eq(tables.payment.ks, filterPaymentConstantSymbol) : void 0,
+    filterPaymentMessage !== void 0 ? like(tables.payment.message, `%${filterPaymentMessage}%`) : void 0,
+    filterPaymentCreditorIban !== void 0 ? eq(tables.payment.creditorIban, filterPaymentCreditorIban) : void 0,
+    filterPaymentDebtorIban !== void 0 ? eq(tables.payment.debtorIban, filterPaymentDebtorIban) : void 0,
+    filterPaymentBatchId !== void 0 ? eq(tables.payment.batchId, filterPaymentBatchId) : void 0
   );
   const sortColumn = resolveColumn(tables.payment, sort.column);
   const [{ totalCount }] = await db.select({
@@ -268,28 +300,261 @@ const getOttQuery = async (db, { ott }) => {
 };
 
 const getPaymentRequestByIdQuery = async (db, { paymentId }) => {
-  const results = await db.select().from(tables.paymentRequest).where(eq(tables.paymentRequest.id, paymentId)).limit(1);
-  return results[0] ?? null;
+  const prResults = await db.select().from(tables.paymentRequest).where(
+    and(
+      eq(tables.paymentRequest.id, paymentId),
+      isNull(tables.paymentRequest.deletedAt)
+    )
+  ).limit(1);
+  if (prResults[0]) return prResults[0];
+  const paymentResults = await db.select().from(tables.payment).where(
+    or(
+      eq(tables.payment.paymentRequestId, paymentId),
+      and(
+        isNull(tables.payment.paymentRequestId),
+        eq(tables.payment.id, paymentId)
+      )
+    )
+  ).limit(1);
+  if (!paymentResults[0]) return null;
+  const p = paymentResults[0];
+  return {
+    ...p,
+    id: p.paymentRequestId ?? p.id,
+    authorizationUrl: null,
+    sendAsSinglePayment: null,
+    direction: p.direction ?? "OUTGOING"
+  };
 };
 
-const seperateSupportedPayments = (incomingPayments, accounts) => {
-  const [supportedPayments, unsupportedPayments] = incomingPayments.reduce(
-    ([valid, invalid], payment) => {
-      const isValid = accounts.some(
-        (acc) => acc.iban === payment.debtorIban && acc.currency === payment.currency
-      );
-      if (isValid) {
-        valid.push(payment);
-      } else {
-        invalid.push(payment);
-      }
-      return [valid, invalid];
-    },
-    [[], []]
+function isCompletedOnly(filterStatus) {
+  if (!filterStatus) return false;
+  const statuses = Array.isArray(filterStatus) ? filterStatus : [filterStatus];
+  return statuses.length > 0 && statuses.every((s) => s === "COMPLETED");
+}
+function mapPaymentToPaymentRequest(p) {
+  return {
+    id: p.id,
+    createdAt: p.createdAt,
+    createdBy: p.createdBy,
+    updatedAt: p.updatedAt,
+    updatedBy: p.updatedBy,
+    deletedAt: p.deletedAt,
+    deletedBy: p.deletedBy,
+    batchId: p.batchId,
+    accountId: p.accountId,
+    correlationId: p.correlationId,
+    refId: p.refId,
+    bankRefId: p.bankRefId,
+    connectorKey: p.connectorKey,
+    amount: p.amount,
+    paymentType: p.paymentType,
+    currency: p.currency,
+    status: p.status,
+    statusReason: p.statusReason,
+    initiatedAt: p.initiatedAt,
+    processedAt: p.processedAt,
+    vs: p.vs,
+    ss: p.ss,
+    ks: p.ks,
+    message: p.message,
+    chargeBearer: p.chargeBearer,
+    instructionPriority: p.instructionPriority,
+    creditor: p.creditor,
+    creditorIban: p.creditorIban,
+    debtor: p.debtor,
+    debtorIban: p.debtorIban,
+    authorizationUrl: null,
+    sendAsSinglePayment: null
+  };
+}
+const getUnionColumns = () => ({
+  id: tables.paymentRequest.id,
+  createdAt: tables.paymentRequest.createdAt,
+  createdBy: tables.paymentRequest.createdBy,
+  updatedAt: tables.paymentRequest.updatedAt,
+  updatedBy: tables.paymentRequest.updatedBy,
+  deletedAt: tables.paymentRequest.deletedAt,
+  deletedBy: tables.paymentRequest.deletedBy,
+  batchId: tables.paymentRequest.batchId,
+  accountId: tables.paymentRequest.accountId,
+  correlationId: tables.paymentRequest.correlationId,
+  refId: tables.paymentRequest.refId,
+  bankRefId: tables.paymentRequest.bankRefId,
+  connectorKey: tables.paymentRequest.connectorKey,
+  amount: tables.paymentRequest.amount,
+  paymentType: tables.paymentRequest.paymentType,
+  currency: tables.paymentRequest.currency,
+  status: tables.paymentRequest.status,
+  statusReason: tables.paymentRequest.statusReason,
+  authorizationUrl: tables.paymentRequest.authorizationUrl,
+  initiatedAt: tables.paymentRequest.initiatedAt,
+  processedAt: tables.paymentRequest.processedAt,
+  vs: tables.paymentRequest.vs,
+  ss: tables.paymentRequest.ss,
+  ks: tables.paymentRequest.ks,
+  message: tables.paymentRequest.message,
+  chargeBearer: tables.paymentRequest.chargeBearer,
+  instructionPriority: tables.paymentRequest.instructionPriority,
+  creditor: tables.paymentRequest.creditor,
+  creditorIban: tables.paymentRequest.creditorIban,
+  debtor: tables.paymentRequest.debtor,
+  debtorIban: tables.paymentRequest.debtorIban,
+  sendAsSinglePayment: tables.paymentRequest.sendAsSinglePayment,
+  // payment_request je vždy OUTGOING — typ musí být kompatibilní s payment.direction
+  direction: sql`'OUTGOING'`.as("direction")
+});
+const getPaymentUnionColumns = () => ({
+  id: sql`COALESCE(${tables.payment.paymentRequestId}, ${tables.payment.id})`.as(
+    "id"
+  ),
+  createdAt: tables.payment.createdAt,
+  createdBy: tables.payment.createdBy,
+  updatedAt: tables.payment.updatedAt,
+  updatedBy: tables.payment.updatedBy,
+  deletedAt: tables.payment.deletedAt,
+  deletedBy: tables.payment.deletedBy,
+  batchId: tables.payment.batchId,
+  accountId: tables.payment.accountId,
+  correlationId: tables.payment.correlationId,
+  refId: tables.payment.refId,
+  bankRefId: tables.payment.bankRefId,
+  connectorKey: tables.payment.connectorKey,
+  amount: tables.payment.amount,
+  paymentType: tables.payment.paymentType,
+  currency: tables.payment.currency,
+  status: tables.payment.status,
+  statusReason: tables.payment.statusReason,
+  authorizationUrl: sql`NULL`.as("authorization_url"),
+  initiatedAt: tables.payment.initiatedAt,
+  processedAt: tables.payment.processedAt,
+  vs: tables.payment.vs,
+  ss: tables.payment.ss,
+  ks: tables.payment.ks,
+  message: tables.payment.message,
+  chargeBearer: tables.payment.chargeBearer,
+  instructionPriority: tables.payment.instructionPriority,
+  creditor: tables.payment.creditor,
+  creditorIban: tables.payment.creditorIban,
+  debtor: tables.payment.debtor,
+  debtorIban: tables.payment.debtorIban,
+  sendAsSinglePayment: sql`NULL`.as("send_as_single_payment"),
+  direction: tables.payment.direction
+});
+const getPaymentRequestsWithPaginationQuery = async (db, {
+  limit,
+  page,
+  sort,
+  filterAccountId,
+  filterStatus,
+  filterPaymentType,
+  filterCurrency,
+  filterMinAmount,
+  filterMaxAmount,
+  filterBatchId,
+  filterCreditorIban,
+  filterDebtorIban,
+  filterDateFrom,
+  filterDateTo,
+  filterVariableSymbol,
+  filterSpecificSymbol,
+  filterConstantSymbol,
+  filterMessage,
+  filterBankRefId,
+  filterPaymentId,
+  filterDirection,
+  filterSource
+}) => {
+  const offset = (page - 1) * limit;
+  const buildPrWhereConditions = () => and(
+    isNull(tables.paymentRequest.deletedAt),
+    buildMultiFilterConditions(
+      tables.paymentRequest.accountId,
+      filterAccountId
+    ),
+    buildMultiFilterConditions(tables.paymentRequest.status, filterStatus),
+    buildMultiFilterConditions(
+      tables.paymentRequest.paymentType,
+      filterPaymentType
+    ),
+    buildMultiFilterConditions(
+      tables.paymentRequest.currency,
+      filterCurrency
+    ),
+    buildRangeFilterConditions(
+      tables.paymentRequest.amount,
+      filterMinAmount,
+      filterMaxAmount
+    ),
+    filterBatchId !== void 0 ? eq(tables.paymentRequest.batchId, filterBatchId) : void 0,
+    filterCreditorIban !== void 0 ? eq(tables.paymentRequest.creditorIban, filterCreditorIban) : void 0,
+    filterDebtorIban !== void 0 ? eq(tables.paymentRequest.debtorIban, filterDebtorIban) : void 0,
+    filterDateFrom !== void 0 ? gte(tables.paymentRequest.createdAt, filterDateFrom) : void 0,
+    filterDateTo !== void 0 ? lte(tables.paymentRequest.createdAt, filterDateTo) : void 0,
+    filterVariableSymbol !== void 0 ? eq(tables.paymentRequest.vs, filterVariableSymbol) : void 0,
+    filterSpecificSymbol !== void 0 ? eq(tables.paymentRequest.ss, filterSpecificSymbol) : void 0,
+    filterConstantSymbol !== void 0 ? eq(tables.paymentRequest.ks, filterConstantSymbol) : void 0,
+    filterMessage !== void 0 ? like(tables.paymentRequest.message, `%${filterMessage}%`) : void 0,
+    filterBankRefId !== void 0 ? eq(tables.paymentRequest.bankRefId, filterBankRefId) : void 0,
+    filterPaymentId !== void 0 ? eq(tables.paymentRequest.id, filterPaymentId) : void 0,
+    // payment_request is always OUTGOING — exclude branch entirely when filtering INCOMING
+    filterDirection === "INCOMING" ? sql`0` : void 0,
+    // payment_request is always API (has no bank-synced payments)
+    filterSource === "BANK" ? sql`0` : void 0
   );
+  const buildPaymentWhereConditions = () => and(
+    isNull(tables.payment.deletedAt),
+    buildMultiFilterConditions(tables.payment.accountId, filterAccountId),
+    buildMultiFilterConditions(tables.payment.status, filterStatus),
+    buildMultiFilterConditions(tables.payment.paymentType, filterPaymentType),
+    buildMultiFilterConditions(tables.payment.currency, filterCurrency),
+    buildRangeFilterConditions(
+      tables.payment.amount,
+      filterMinAmount,
+      filterMaxAmount
+    ),
+    filterBatchId !== void 0 ? eq(tables.payment.batchId, filterBatchId) : void 0,
+    filterCreditorIban !== void 0 ? eq(tables.payment.creditorIban, filterCreditorIban) : void 0,
+    filterDebtorIban !== void 0 ? eq(tables.payment.debtorIban, filterDebtorIban) : void 0,
+    filterDateFrom !== void 0 ? gte(tables.payment.createdAt, filterDateFrom) : void 0,
+    filterDateTo !== void 0 ? lte(tables.payment.createdAt, filterDateTo) : void 0,
+    filterVariableSymbol !== void 0 ? eq(tables.payment.vs, filterVariableSymbol) : void 0,
+    filterSpecificSymbol !== void 0 ? eq(tables.payment.ss, filterSpecificSymbol) : void 0,
+    filterConstantSymbol !== void 0 ? eq(tables.payment.ks, filterConstantSymbol) : void 0,
+    filterMessage !== void 0 ? like(tables.payment.message, `%${filterMessage}%`) : void 0,
+    filterBankRefId !== void 0 ? eq(tables.payment.bankRefId, filterBankRefId) : void 0,
+    filterPaymentId !== void 0 ? sql`COALESCE(${tables.payment.paymentRequestId}, ${tables.payment.id}) = ${filterPaymentId}` : void 0,
+    filterDirection !== void 0 ? eq(tables.payment.direction, filterDirection) : void 0,
+    filterSource === "BANK" ? isNull(tables.payment.paymentRequestId) : filterSource === "API" ? isNotNull(tables.payment.paymentRequestId) : void 0
+  );
+  const queryInFlight = !isCompletedOnly(filterStatus);
+  const queryCompleted = true;
+  if (!queryInFlight && queryCompleted) {
+    const whereConditions = buildPaymentWhereConditions();
+    const sortColumn = resolveColumn(tables.payment, sort.column);
+    const [{ totalCount }] = await db.select({ totalCount: sql`count(*)` }).from(tables.payment).where(whereConditions);
+    const payments = await db.select().from(tables.payment).where(whereConditions).limit(limit).offset(offset).orderBy(sort.direction === "asc" ? asc(sortColumn) : desc(sortColumn));
+    return {
+      paymentRequests: payments.map(mapPaymentToPaymentRequest),
+      totalCount
+    };
+  }
+  const prWhereConditions = buildPrWhereConditions();
+  const paymentWhereConditions = buildPaymentWhereConditions();
+  const unionColumns = getUnionColumns();
+  const paymentUnionColumns = getPaymentUnionColumns();
+  const sortColObj = sort.column in unionColumns ? unionColumns[sort.column] : unionColumns.updatedAt;
+  const [{ totalCount: countPR }, { totalCount: countP }] = await Promise.all([
+    db.select({ totalCount: sql`count(*)` }).from(tables.paymentRequest).where(prWhereConditions).then(([row]) => row),
+    db.select({ totalCount: sql`count(*)` }).from(tables.payment).where(paymentWhereConditions).then(([row]) => row)
+  ]);
+  const paymentRequests = await unionAll(
+    db.select(unionColumns).from(tables.paymentRequest).where(prWhereConditions),
+    db.select(paymentUnionColumns).from(tables.payment).where(paymentWhereConditions)
+  ).orderBy(sort.direction === "asc" ? asc(sortColObj) : desc(sortColObj)).limit(limit).offset(offset);
   return {
-    supportedPayments,
-    unsupportedPayments
+    paymentRequests,
+    totalCount: countPR + countP
   };
 };
 
@@ -299,7 +564,6 @@ const sendPaymentInputSchema = z.object({
   amount: z.number().positive(),
   paymentType: z.enum(PAYMENT_TYPES),
   chargeBearer: z.enum(CHARGE_BEARERS).optional(),
-  executionDate: z.string().optional(),
   instructionPriority: z.enum(INSTRUCTION_PRIORITIES).optional(),
   currency: z.enum(CURRENCY_CODES),
   vs: z.string().optional(),
@@ -308,7 +572,6 @@ const sendPaymentInputSchema = z.object({
   message: z.string().optional(),
   creditor: bankAccountMetadataSchema,
   debtor: bankAccountMetadataSchema,
-  purpose: z.string().optional(),
   sendAsSinglePayment: z.boolean().optional()
 });
 
@@ -388,10 +651,20 @@ const ALLOWED_PAYMENT_FILTERS = {
   ACCOUNT_ID: "filterPaymentAccountId",
   AMOUNT: "filterPaymentAmount",
   CURRENCY: "filterPaymentCurrency",
-  DIRECTION: "filterPaymentyDirection",
+  DIRECTION: "filterPaymentDirection",
   FROM: "filterPaymentDateFrom",
   TO: "filterPaymentDateTo",
-  STATUS: "filterPaymentStatus"
+  STATUS: "filterPaymentStatus",
+  PAYMENT_TYPE: "filterPaymentType",
+  MIN_AMOUNT: "filterPaymentMinAmount",
+  MAX_AMOUNT: "filterPaymentMaxAmount",
+  VARIABLE_SYMBOL: "filterPaymentVariableSymbol",
+  SPECIFIC_SYMBOL: "filterPaymentSpecificSymbol",
+  CONSTANT_SYMBOL: "filterPaymentConstantSymbol",
+  MESSAGE: "filterPaymentMessage",
+  CREDITOR_IBAN: "filterPaymentCreditorIban",
+  DEBTOR_IBAN: "filterPaymentDebtorIban",
+  BATCH_ID: "filterPaymentBatchId"
 };
 const getPaymentsInputSchema = z.object({
   page: z.number().positive(),
@@ -407,7 +680,17 @@ const getPaymentsInputSchema = z.object({
   [ALLOWED_PAYMENT_FILTERS.DIRECTION]: z.union([z.enum(PAYMENT_DIRECTIONS), z.enum(PAYMENT_DIRECTIONS).array()]).optional(),
   [ALLOWED_PAYMENT_FILTERS.FROM]: z.date().optional(),
   [ALLOWED_PAYMENT_FILTERS.TO]: z.date().optional(),
-  [ALLOWED_PAYMENT_FILTERS.STATUS]: z.union([z.enum(PAYMENT_STATUSES), z.enum(PAYMENT_STATUSES).array()]).optional()
+  [ALLOWED_PAYMENT_FILTERS.STATUS]: z.union([z.enum(PAYMENT_STATUSES), z.enum(PAYMENT_STATUSES).array()]).optional(),
+  [ALLOWED_PAYMENT_FILTERS.PAYMENT_TYPE]: z.enum(PAYMENT_TYPES).optional(),
+  [ALLOWED_PAYMENT_FILTERS.MIN_AMOUNT]: z.number().positive().optional(),
+  [ALLOWED_PAYMENT_FILTERS.MAX_AMOUNT]: z.number().positive().optional(),
+  [ALLOWED_PAYMENT_FILTERS.VARIABLE_SYMBOL]: z.string().regex(/^\d{1,10}$/).optional(),
+  [ALLOWED_PAYMENT_FILTERS.SPECIFIC_SYMBOL]: z.string().regex(/^\d{1,10}$/).optional(),
+  [ALLOWED_PAYMENT_FILTERS.CONSTANT_SYMBOL]: z.string().regex(/^\d{4}$/).optional(),
+  [ALLOWED_PAYMENT_FILTERS.MESSAGE]: z.string().optional(),
+  [ALLOWED_PAYMENT_FILTERS.CREDITOR_IBAN]: z.string().optional(),
+  [ALLOWED_PAYMENT_FILTERS.DEBTOR_IBAN]: z.string().optional(),
+  [ALLOWED_PAYMENT_FILTERS.BATCH_ID]: z.uuid().optional()
 });
 
 const syncAccountInputSchema = z.object({
@@ -446,6 +729,8 @@ const updateAccountInputSchema = z.object({
 });
 
 const getBankAccountsInputSchema = z.object({
+  page: z.number().positive().optional(),
+  limit: z.number().positive().optional(),
   includeWorkflow: z.boolean().optional(),
   includeBatchCounts: z.boolean().optional(),
   filterIbans: z.array(z.string()).optional(),
@@ -466,6 +751,34 @@ const handleAuthorizationCallbackInputSchema = z.object({
 
 const sendPaymentSyncInputSchema = sendPaymentInputSchema;
 
+const getPaymentRequestsInputSchema = z.object({
+  page: z.number().positive(),
+  limit: z.number().positive(),
+  sort: z.object({
+    column: z.enum(["createdAt", "updatedAt", "amount"]),
+    direction: z.enum(["asc", "desc"])
+  }),
+  filterAccountId: z.union([z.uuid(), z.uuid().array()]).optional(),
+  filterStatus: z.union([z.enum(PAYMENT_STATUSES), z.enum(PAYMENT_STATUSES).array()]).optional(),
+  filterPaymentType: z.union([z.enum(PAYMENT_TYPES), z.enum(PAYMENT_TYPES).array()]).optional(),
+  filterCurrency: z.union([z.enum(CURRENCY_CODES), z.enum(CURRENCY_CODES).array()]).optional(),
+  filterMinAmount: z.number().positive().optional(),
+  filterMaxAmount: z.number().positive().optional(),
+  filterBatchId: z.uuid().optional(),
+  filterCreditorIban: z.string().optional(),
+  filterDebtorIban: z.string().optional(),
+  filterDateFrom: z.date().optional(),
+  filterDateTo: z.date().optional(),
+  filterVariableSymbol: z.string().optional(),
+  filterSpecificSymbol: z.string().optional(),
+  filterConstantSymbol: z.string().optional(),
+  filterMessage: z.string().optional(),
+  filterBankRefId: z.string().optional(),
+  filterPaymentId: z.uuid().optional(),
+  filterDirection: z.enum(["INCOMING", "OUTGOING"]).optional(),
+  filterSource: z.enum(["API", "BANK"]).optional()
+});
+
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __decorateClass = (decorators, target, key, kind) => {
@@ -487,7 +800,9 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
     return await getAllAccountsQuery(this.db, filters);
   }
   async _getConnectedAccounts() {
-    const accounts = await this._getAccounts();
+    const { accounts } = await this._getAccounts({
+      limit: Number.MAX_SAFE_INTEGER
+    });
     return accounts.filter((acc) => acc.status !== "DISABLED");
   }
   async _initiateBankConnector({
@@ -521,6 +836,27 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
       env: this.env
     });
   }
+  _validatePaymentTypeAndCurrency(paymentType, currency, creditor) {
+    const PAYMENT_TYPE_CURRENCY_MAP = {
+      DOMESTIC: ["CZK"],
+      SEPA: ["EUR"]
+    };
+    const allowedCurrencies = PAYMENT_TYPE_CURRENCY_MAP[paymentType];
+    if (allowedCurrencies && !allowedCurrencies.includes(currency)) {
+      throw createInternalError(null, {
+        message: `Payment type ${paymentType} requires currency ${allowedCurrencies.join(" or ")}, got ${currency}`,
+        code: "VALID-B-008",
+        status: 422
+      });
+    }
+    if (paymentType === "SEPA" && !creditor.iban) {
+      throw createInternalError(null, {
+        message: "SEPA payments require creditor IBAN",
+        code: "VALID-B-009",
+        status: 422
+      });
+    }
+  }
   async getPayments(input) {
     return this.handleAction(
       { data: input, schema: getPaymentsInputSchema },
@@ -804,50 +1140,49 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
       }
     );
   }
-  async addPaymentsToBatch({
-    paymentsToBatch
-  }) {
+  async addPaymentsToBatch({ paymentIds }) {
     return this.handleAction(null, {}, async () => {
-      this.logInput({ paymentsToBatch });
-      const incomingPayments = paymentsToBatch.map(toIncomingPayment);
-      const accounts = await this._getAccounts();
-      const { supportedPayments, unsupportedPayments } = seperateSupportedPayments(incomingPayments, accounts);
-      if (unsupportedPayments.length > 0) {
-        this.logError({ unsupportedPayments });
-        await this.pushToQueue(
-          this.env.QUEUE_BUS_QUEUE,
-          unsupportedPayments.map((unsupported) => ({
-            eventType: "BANK_PAYMENT",
-            eventSignal: "paymentFailed",
-            bankPayment: {
-              ...unsupported,
-              status: "FAILED",
-              statusReason: "UNSUPPORTED_ACCOUNT"
-            },
-            metadata: {
-              correlationId: unsupported.correlationId,
-              entityId: unsupported.id,
-              timestamp: (/* @__PURE__ */ new Date()).toDateString()
-            }
-          }))
-        );
+      this.logInput({ paymentIds });
+      const paymentRequests = (await Promise.all(
+        paymentIds.map(
+          (id) => getPaymentRequestByIdQuery(this.db, { paymentId: id })
+        )
+      )).filter((p) => p !== null);
+      const foundIds = new Set(paymentRequests.map((p) => p.id));
+      const missingIds = paymentIds.filter((id) => !foundIds.has(id));
+      if (missingIds.length > 0) {
+        this.logError({ missingIds });
       }
-      for (const acc of accounts) {
-        const accountAssignedPayments = supportedPayments.filter(
-          (payment) => payment.debtorIban === acc.iban && payment.currency === acc.currency
-        ).map((payment) => assignAccount(payment, acc));
-        if (accountAssignedPayments.length === 0) {
+      const byAccount = Map.groupBy(
+        paymentRequests,
+        (p) => `${p.accountId}:${p.paymentType}`
+      );
+      const { accounts } = await this._getAccounts();
+      for (const [, paymentsOfType] of byAccount) {
+        const first2 = paymentsOfType[0];
+        const acc = accounts.find((a) => a.id === first2.accountId);
+        if (!acc) {
+          this.logError({ message: `Account not found: ${first2.accountId}` });
+          await Promise.all(
+            paymentsOfType.map(
+              (p) => updatePaymentRequestStatusCommand(this.db, {
+                id: p.id,
+                status: "FAILED",
+                statusReason: "ACCOUNT_NOT_FOUND"
+              }).command.execute()
+            )
+          );
           continue;
         }
-        this.log({
-          message: `\u{1F4B0} Processing ${accountAssignedPayments.length} payments for account (${acc.iban}, ${acc.currency})`
-        });
-        const singlePayments = accountAssignedPayments.filter(
+        const singlePayments = paymentsOfType.filter(
           (p) => p.sendAsSinglePayment === true
         );
-        const regularPayments = accountAssignedPayments.filter(
+        const regularPayments = paymentsOfType.filter(
           (p) => p.sendAsSinglePayment !== true
         );
+        this.log({
+          message: `\u{1F4B0} Processing ${paymentsOfType.length} payments for account (${acc.iban}, ${acc.currency})`
+        });
         for (const singlePayment of singlePayments) {
           const batchId = uuidv4();
           const { command: upsertBatch } = upsertBatchCommand(this.db, {
@@ -860,73 +1195,67 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
               metadata: { sizeLimit: 1 }
             }
           });
-          const { command: insertPaymentRequest } = createPaymentRequestCommand(
+          const { command: updateRequest } = updatePaymentRequestStatusCommand(
             this.db,
-            {
-              paymentRequest: toPaymentRequestInsert(singlePayment, batchId)
-            }
+            { id: singlePayment.id, status: "CREATED", batchId }
           );
-          await this.db.batch([upsertBatch, insertPaymentRequest]);
+          await this.db.batch([upsertBatch, updateRequest]);
           this.log({
             message: `\u2728 Created single payment batch (${singlePayment.paymentType}) for account ${acc.id}`
           });
         }
         if (regularPayments.length > 0) {
-          const paymentsByType = Map.groupBy(
-            regularPayments,
-            (p) => p.paymentType
-          );
-          for (const [paymentType, paymentsOfType] of paymentsByType) {
-            const openBatches = await getAccountOpenBatchesQuery(this.db, {
-              accountId: acc.id,
-              paymentType
-            });
-            let batchId;
-            let availableCount = 0;
-            let availableBatch;
-            for (const ob of openBatches) {
-              const existingPayments = await getPaymentRequestsByBatchIdQuery(
-                this.db,
-                { batchId: ob.id }
-              );
-              const limit = ob.metadata?.sizeLimit ?? acc.batchSizeLimit;
-              if (existingPayments.length < limit) {
-                availableBatch = ob;
-                availableCount = existingPayments.length;
-                break;
-              }
-            }
-            if (availableBatch) {
-              batchId = availableBatch.id;
-              this.log({
-                message: `\u{1F504} Found existing OPEN batch (${paymentType}) for account ${acc.id}, merging ${availableCount} existing + ${paymentsOfType.length} new payments`
-              });
-            } else {
-              batchId = uuidv4();
-              this.log({
-                message: `\u2728 Creating new batch (${paymentType}) for account ${acc.id} with ${paymentsOfType.length} payments`
-              });
+          const openBatches = await getAccountOpenBatchesQuery(this.db, {
+            accountId: acc.id,
+            paymentType: first2.paymentType
+          });
+          let batchId;
+          let availableCount = 0;
+          let availableBatch;
+          for (const ob of openBatches) {
+            const existingPayments = await getPaymentRequestsByBatchIdQuery(
+              this.db,
+              { batchId: ob.id }
+            );
+            const limit = ob.metadata?.sizeLimit ?? acc.batchSizeLimit;
+            if (existingPayments.length < limit) {
+              availableBatch = ob;
+              availableCount = existingPayments.length;
+              break;
             }
-            const { command: upsertBatch } = upsertBatchCommand(this.db, {
-              batch: availableBatch ? { ...availableBatch } : {
-                id: batchId,
-                authorizationUrls: [],
-                accountId: acc.id,
-                paymentType,
-                status: "OPEN",
-                metadata: { sizeLimit: acc.batchSizeLimit }
-              }
+          }
+          if (availableBatch) {
+            batchId = availableBatch.id;
+            this.log({
+              message: `\u{1F504} Found existing OPEN batch (${first2.paymentType}) for account ${acc.id}, merging ${availableCount} existing + ${regularPayments.length} new payments`
             });
-            const paymentRequestCommands = paymentsOfType.map(
-              (p) => createPaymentRequestCommand(this.db, {
-                paymentRequest: toPaymentRequestInsert(p, batchId)
-              }).command
-            );
-            await this.db.batch([upsertBatch, ...paymentRequestCommands]);
+          } else {
+            batchId = uuidv4();
             this.log({
-              message: `\u2705 Batch (${paymentType}) upserted successfully for account ${acc.id}`
+              message: `\u2728 Creating new batch (${first2.paymentType}) for account ${acc.id} with ${regularPayments.length} payments`
             });
           }
+          const { command: upsertBatch } = upsertBatchCommand(this.db, {
+            batch: availableBatch ? { ...availableBatch } : {
+              id: batchId,
+              authorizationUrls: [],
+              accountId: acc.id,
+              paymentType: first2.paymentType,
+              status: "OPEN",
+              metadata: { sizeLimit: acc.batchSizeLimit }
+            }
+          });
+          const updateCommands = regularPayments.map(
+            (p) => updatePaymentRequestStatusCommand(this.db, {
+              id: p.id,
+              status: "CREATED",
+              batchId
+            }).command
+          );
+          await this.db.batch([upsertBatch, ...updateCommands]);
+          this.log({
+            message: `\u2705 Batch (${first2.paymentType}) upserted successfully for account ${acc.id}`
+          });
         }
       }
     });
@@ -983,7 +1312,7 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
       async () => {
         this.logQueuePull(b);
         const queueHandlerResponse = await this.addPaymentsToBatch({
-          paymentsToBatch: b.messages.map(({ body }) => body)
+          paymentIds: b.messages.map(({ body }) => body.paymentId)
         });
         this.logOutput(queueHandlerResponse);
       }
@@ -1049,7 +1378,7 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
         const { credentials, accounts } = await connector.authorizeAccount({
           urlParams
         });
-        const alreadyExistingAccounts = (await this._getAccounts()).filter(
+        const alreadyExistingAccounts = (await this._getAccounts()).accounts.filter(
           (acc) => acc.connectorKey === ottRow.refId && accounts.map((item) => item.iban).includes(acc.iban)
         );
         const upsertAccounts = accounts.map((acc) => {
@@ -1097,7 +1426,7 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
           ...upsertAccounts,
           ...createAccountCredentials
         ]);
-        const fetchedAccounts = await this._getAccounts();
+        const { accounts: fetchedAccounts } = await this._getAccounts();
         if (!fetchedAccounts)
           throw createInternalError(null, {
             message: "Account not found",
@@ -1105,7 +1434,11 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
             status: 404
           });
         if (startSync) {
-          for (const account of fetchedAccounts) {
+          const newAccountIbans = new Set(accounts.map((a) => a.iban));
+          const accountsToSync = fetchedAccounts.filter(
+            (a) => newAccountIbans.has(a.iban)
+          );
+          for (const account of accountsToSync) {
             const { error } = await this.syncAccount({
               accountId: account.id
             });
@@ -1147,12 +1480,18 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
             code: "VALID-B-003",
             status: 422
           });
+        if (account.connectorKey !== connectorKey)
+          throw createInternalError(null, {
+            message: `Connector key mismatch: account uses ${account.connectorKey}, got ${connectorKey}`,
+            code: "VALID-B-010",
+            status: 422
+          });
         const payment = {
           id: uuidv4(),
           bankRefId: uuidv4(),
           correlationId: uuidv4(),
           amount,
-          connectorKey,
+          connectorKey: account.connectorKey,
           accountId: account.id,
           direction: "INCOMING",
           paymentType: "DOMESTIC",
@@ -1192,10 +1531,51 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
       { data: input, schema: sendPaymentInputSchema },
       { successMessage: "Payment queued successfully" },
       async (data) => {
+        const incomingPayment = toIncomingPayment(data);
+        const { accounts } = await this._getAccounts();
+        const account = accounts.find(
+          (acc) => acc.iban === incomingPayment.debtorIban && acc.currency === incomingPayment.currency
+        );
+        if (!account) {
+          throw createInternalError(null, {
+            message: `No account found for IBAN ${incomingPayment.debtorIban} with currency ${incomingPayment.currency}`,
+            code: "VALID-B-004",
+            status: 422
+          });
+        }
+        if (account.status !== "AUTHORIZED") {
+          throw createInternalError(null, {
+            message: `Account ${account.iban} is not authorized (status: ${account.status})`,
+            code: "VALID-B-007",
+            status: 422
+          });
+        }
+        const connector = await this._initiateBankConnector({
+          connectorKey: account.connectorKey
+        });
+        if (!connector.supportsPaymentType(data.paymentType)) {
+          throw createInternalError(null, {
+            message: `Connector ${account.connectorKey} does not support ${data.paymentType} payments yet`,
+            code: "VALID-B-006",
+            status: 422
+          });
+        }
+        this._validatePaymentTypeAndCurrency(
+          data.paymentType,
+          data.currency,
+          data.creditor
+        );
+        const accountAssigned = assignAccount(incomingPayment, account);
+        const { command: insertPaymentRequest } = createPaymentRequestCommand(
+          this.db,
+          { paymentRequest: toPaymentRequestInsert(accountAssigned, null) }
+        );
+        await insertPaymentRequest.execute();
         await this.pushToQueue(
           this.env.PAYMENTS_READY_TO_BATCH_QUEUE,
-          data
+          { paymentId: incomingPayment.id }
         );
+        return { paymentId: incomingPayment.id };
       }
     );
   }
@@ -1205,7 +1585,7 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
       { successMessage: "Payment initiated successfully" },
       async (data) => {
         const incomingPayment = toIncomingPayment(data);
-        const accounts = await this._getAccounts();
+        const { accounts } = await this._getAccounts();
         const account = accounts.find(
           (acc) => acc.iban === incomingPayment.debtorIban && acc.currency === incomingPayment.currency
         );
@@ -1216,12 +1596,31 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
             status: 422
           });
         }
+        if (account.status !== "AUTHORIZED") {
+          throw createInternalError(null, {
+            message: `Account ${account.iban} is not authorized (status: ${account.status})`,
+            code: "VALID-B-007",
+            status: 422
+          });
+        }
         const batchedPayment = toBatchedPayment(
           assignAccount(incomingPayment, account)
         );
         const connector = await this._initiateBankConnector({
           connectorKey: account.connectorKey
         });
+        if (!connector.supportsPaymentType(data.paymentType)) {
+          throw createInternalError(null, {
+            message: `Connector ${account.connectorKey} does not support ${data.paymentType} payments yet`,
+            code: "VALID-B-006",
+            status: 422
+          });
+        }
+        this._validatePaymentTypeAndCurrency(
+          data.paymentType,
+          data.currency,
+          data.creditor
+        );
         const initiate = () => {
           switch (data.paymentType) {
             case "DOMESTIC":
@@ -1250,16 +1649,20 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
       { data: input, schema: getBankAccountsInputSchema },
       { successMessage: "Bank accounts retrieved successfully" },
       async ({
+        page,
+        limit,
         includeWorkflow,
         includeBatchCounts,
         filterIbans,
         filterCurrencies,
         filterBankRefIds
       }) => {
-        const accounts = await this._getAccounts({
+        const { accounts, totalCount } = await this._getAccounts({
           filterIbans,
           filterCurrencies,
-          filterBankRefIds
+          filterBankRefIds,
+          page,
+          limit
         });
         const accountsWithOptionalFields = await Promise.all(
           accounts.map(async (a) => {
@@ -1293,7 +1696,7 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
         );
         return {
           accounts: accountsWithOptionalFields,
-          totalCount: accounts.length
+          totalCount
         };
       }
     );
@@ -1411,6 +1814,34 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
       }
     );
   }
+  async getPaymentRequests(input) {
+    return this.handleAction(
+      { data: input, schema: getPaymentRequestsInputSchema },
+      { successMessage: "Payment requests fetched successfully" },
+      async (params) => {
+        return await getPaymentRequestsWithPaginationQuery(this.db, params);
+      }
+    );
+  }
+  async getPaymentRequest(input) {
+    return this.handleAction(
+      null,
+      { successMessage: "Payment request fetched successfully" },
+      async () => {
+        const paymentRequest = await getPaymentRequestByIdQuery(this.db, {
+          paymentId: input.paymentId
+        });
+        if (!paymentRequest) {
+          throw createInternalError(null, {
+            message: `Payment request not found: ${input.paymentId}`,
+            code: "NOT-FOUND-B-001",
+            status: 404
+          });
+        }
+        return { paymentRequest };
+      }
+    );
+  }
   async getFinbricksSupportedBanks() {
     const privateKeyPem = (await this.env.SECRETS_STORE.get({
       secretName: "BANK_SERVICE_FINBRICKS_PRIVATE_KEY_PEM"
@@ -1484,6 +1915,12 @@ __decorateClass([
 __decorateClass([
   action("getBatches")
 ], BankServiceBase.prototype, "getBatches", 1);
+__decorateClass([
+  action("get-payment-requests")
+], BankServiceBase.prototype, "getPaymentRequests", 1);
+__decorateClass([
+  action("get-payment-request")
+], BankServiceBase.prototype, "getPaymentRequest", 1);
 BankServiceBase = __decorateClass([
   service("bank")
 ], BankServiceBase);