@develit-services/bank 0.8.5 → 0.8.7

package/dist/export/worker.cjs

@@ -1,29 +1,29 @@
 'use strict';
 
 const backendSdk = require('@develit-io/backend-sdk');
-const drizzle = require('../shared/bank.BOnP9p9Y.cjs');
+const drizzle = require('../shared/bank.Dm8GHThw.cjs');
 const cloudflare_workers = require('cloudflare:workers');
 const d1 = require('drizzle-orm/d1');
-const mock_connector = require('../shared/bank.CQURey1E.cjs');
+const mock_connector = require('../shared/bank.DwyCCyd0.cjs');
 require('jose');
 const zod = require('zod');
-const paymentRequest_schema = require('../shared/bank.SQ4Mmr8u.cjs');
+const paymentRequest_schema = require('../shared/bank.BS7fFjGA.cjs');
 const generalCodes = require('@develit-io/general-codes');
 require('date-fns');
 const drizzleOrm = require('drizzle-orm');
+const sqliteCore = require('drizzle-orm/sqlite-core');
 require('node:crypto');
-require('../shared/bank.C-T1FQxg.cjs');
+require('../shared/bank.62VzK9Aj.cjs');
 require('drizzle-orm/relations');
-require('drizzle-orm/sqlite-core');
 require('drizzle-zod');
 
 const upsertAccountCommand = (db, { account }) => {
   const id = account.id || backendSdk.uuidv4();
+  const { id: _id, ...accountWithoutId } = account;
   const command = db.insert(drizzle.tables.account).values({ ...account, id }).onConflictDoUpdate({
     target: drizzle.tables.account.iban,
-    set: {
-      ...account
-    }
+    set: accountWithoutId
+    // preserve existing id on re-auth
   }).returning();
   return {
     id,
@@ -141,16 +141,25 @@ const getAllAccountsQuery = async (db, filters) => {
       filters?.filterBankRefIds
     )
   );
-  const accountsWithExpiration = await db.select().from(drizzle.tables.account).leftJoin(
-    drizzle.tables.accountCredentials,
-    drizzleOrm.eq(drizzle.tables.accountCredentials.accountId, drizzle.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(drizzle.tables.account).leftJoin(
+      drizzle.tables.accountCredentials,
+      drizzleOrm.eq(drizzle.tables.accountCredentials.accountId, drizzle.tables.account.id)
+    ).where(whereConditions).limit(limit).offset(offset),
+    db.select({ count: drizzleOrm.sql`count(*)` }).from(drizzle.tables.account).where(whereConditions)
+  ]);
+  return {
+    accounts: accountsWithExpiration.map(
+      ({ account, account_credentials }) => ({
+        ...account,
+        expiresAt: account_credentials?.expiresAt
+      })
+    ),
+    totalCount: countResult[0]?.count ?? 0
+  };
 };
 
 const getAllPendingBatchesQuery = (db) => {
@@ -191,7 +200,17 @@ const getPaymentsWithPaginationQuery = async (db, {
   filterPaymentDateFrom,
   filterPaymentDateTo,
   filterPaymentStatus,
-  filterPaymentyDirection
+  filterPaymentDirection,
+  filterPaymentType,
+  filterPaymentMinAmount,
+  filterPaymentMaxAmount,
+  filterPaymentVariableSymbol,
+  filterPaymentSpecificSymbol,
+  filterPaymentConstantSymbol,
+  filterPaymentMessage,
+  filterPaymentCreditorIban,
+  filterPaymentDebtorIban,
+  filterPaymentBatchId
 }) => {
   const whereConditions = drizzleOrm.and(
     buildMultiFilterConditions(
@@ -208,9 +227,22 @@ const getPaymentsWithPaginationQuery = async (db, {
     buildMultiFilterConditions(drizzle.tables.payment.status, filterPaymentStatus),
     buildMultiFilterConditions(
       drizzle.tables.payment.direction,
-      filterPaymentyDirection
+      filterPaymentDirection
+    ),
+    buildMultiFilterConditions(drizzle.tables.payment.id, ids),
+    buildMultiFilterConditions(drizzle.tables.payment.paymentType, filterPaymentType),
+    buildRangeFilterConditions(
+      drizzle.tables.payment.amount,
+      filterPaymentMinAmount,
+      filterPaymentMaxAmount
     ),
-    buildMultiFilterConditions(drizzle.tables.payment.id, ids)
+    filterPaymentVariableSymbol !== void 0 ? drizzleOrm.eq(drizzle.tables.payment.vs, filterPaymentVariableSymbol) : void 0,
+    filterPaymentSpecificSymbol !== void 0 ? drizzleOrm.eq(drizzle.tables.payment.ss, filterPaymentSpecificSymbol) : void 0,
+    filterPaymentConstantSymbol !== void 0 ? drizzleOrm.eq(drizzle.tables.payment.ks, filterPaymentConstantSymbol) : void 0,
+    filterPaymentMessage !== void 0 ? drizzleOrm.like(drizzle.tables.payment.message, `%${filterPaymentMessage}%`) : void 0,
+    filterPaymentCreditorIban !== void 0 ? drizzleOrm.eq(drizzle.tables.payment.creditorIban, filterPaymentCreditorIban) : void 0,
+    filterPaymentDebtorIban !== void 0 ? drizzleOrm.eq(drizzle.tables.payment.debtorIban, filterPaymentDebtorIban) : void 0,
+    filterPaymentBatchId !== void 0 ? drizzleOrm.eq(drizzle.tables.payment.batchId, filterPaymentBatchId) : void 0
   );
   const sortColumn = resolveColumn(drizzle.tables.payment, sort.column);
   const [{ totalCount }] = await db.select({
@@ -270,28 +302,261 @@ const getOttQuery = async (db, { ott }) => {
 };
 
 const getPaymentRequestByIdQuery = async (db, { paymentId }) => {
-  const results = await db.select().from(drizzle.tables.paymentRequest).where(drizzleOrm.eq(drizzle.tables.paymentRequest.id, paymentId)).limit(1);
-  return results[0] ?? null;
+  const prResults = await db.select().from(drizzle.tables.paymentRequest).where(
+    drizzleOrm.and(
+      drizzleOrm.eq(drizzle.tables.paymentRequest.id, paymentId),
+      drizzleOrm.isNull(drizzle.tables.paymentRequest.deletedAt)
+    )
+  ).limit(1);
+  if (prResults[0]) return prResults[0];
+  const paymentResults = await db.select().from(drizzle.tables.payment).where(
+    drizzleOrm.or(
+      drizzleOrm.eq(drizzle.tables.payment.paymentRequestId, paymentId),
+      drizzleOrm.and(
+        drizzleOrm.isNull(drizzle.tables.payment.paymentRequestId),
+        drizzleOrm.eq(drizzle.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: drizzle.tables.paymentRequest.id,
+  createdAt: drizzle.tables.paymentRequest.createdAt,
+  createdBy: drizzle.tables.paymentRequest.createdBy,
+  updatedAt: drizzle.tables.paymentRequest.updatedAt,
+  updatedBy: drizzle.tables.paymentRequest.updatedBy,
+  deletedAt: drizzle.tables.paymentRequest.deletedAt,
+  deletedBy: drizzle.tables.paymentRequest.deletedBy,
+  batchId: drizzle.tables.paymentRequest.batchId,
+  accountId: drizzle.tables.paymentRequest.accountId,
+  correlationId: drizzle.tables.paymentRequest.correlationId,
+  refId: drizzle.tables.paymentRequest.refId,
+  bankRefId: drizzle.tables.paymentRequest.bankRefId,
+  connectorKey: drizzle.tables.paymentRequest.connectorKey,
+  amount: drizzle.tables.paymentRequest.amount,
+  paymentType: drizzle.tables.paymentRequest.paymentType,
+  currency: drizzle.tables.paymentRequest.currency,
+  status: drizzle.tables.paymentRequest.status,
+  statusReason: drizzle.tables.paymentRequest.statusReason,
+  authorizationUrl: drizzle.tables.paymentRequest.authorizationUrl,
+  initiatedAt: drizzle.tables.paymentRequest.initiatedAt,
+  processedAt: drizzle.tables.paymentRequest.processedAt,
+  vs: drizzle.tables.paymentRequest.vs,
+  ss: drizzle.tables.paymentRequest.ss,
+  ks: drizzle.tables.paymentRequest.ks,
+  message: drizzle.tables.paymentRequest.message,
+  chargeBearer: drizzle.tables.paymentRequest.chargeBearer,
+  instructionPriority: drizzle.tables.paymentRequest.instructionPriority,
+  creditor: drizzle.tables.paymentRequest.creditor,
+  creditorIban: drizzle.tables.paymentRequest.creditorIban,
+  debtor: drizzle.tables.paymentRequest.debtor,
+  debtorIban: drizzle.tables.paymentRequest.debtorIban,
+  sendAsSinglePayment: drizzle.tables.paymentRequest.sendAsSinglePayment,
+  // payment_request je vždy OUTGOING — typ musí být kompatibilní s payment.direction
+  direction: drizzleOrm.sql`'OUTGOING'`.as("direction")
+});
+const getPaymentUnionColumns = () => ({
+  id: drizzleOrm.sql`COALESCE(${drizzle.tables.payment.paymentRequestId}, ${drizzle.tables.payment.id})`.as(
+    "id"
+  ),
+  createdAt: drizzle.tables.payment.createdAt,
+  createdBy: drizzle.tables.payment.createdBy,
+  updatedAt: drizzle.tables.payment.updatedAt,
+  updatedBy: drizzle.tables.payment.updatedBy,
+  deletedAt: drizzle.tables.payment.deletedAt,
+  deletedBy: drizzle.tables.payment.deletedBy,
+  batchId: drizzle.tables.payment.batchId,
+  accountId: drizzle.tables.payment.accountId,
+  correlationId: drizzle.tables.payment.correlationId,
+  refId: drizzle.tables.payment.refId,
+  bankRefId: drizzle.tables.payment.bankRefId,
+  connectorKey: drizzle.tables.payment.connectorKey,
+  amount: drizzle.tables.payment.amount,
+  paymentType: drizzle.tables.payment.paymentType,
+  currency: drizzle.tables.payment.currency,
+  status: drizzle.tables.payment.status,
+  statusReason: drizzle.tables.payment.statusReason,
+  authorizationUrl: drizzleOrm.sql`NULL`.as("authorization_url"),
+  initiatedAt: drizzle.tables.payment.initiatedAt,
+  processedAt: drizzle.tables.payment.processedAt,
+  vs: drizzle.tables.payment.vs,
+  ss: drizzle.tables.payment.ss,
+  ks: drizzle.tables.payment.ks,
+  message: drizzle.tables.payment.message,
+  chargeBearer: drizzle.tables.payment.chargeBearer,
+  instructionPriority: drizzle.tables.payment.instructionPriority,
+  creditor: drizzle.tables.payment.creditor,
+  creditorIban: drizzle.tables.payment.creditorIban,
+  debtor: drizzle.tables.payment.debtor,
+  debtorIban: drizzle.tables.payment.debtorIban,
+  sendAsSinglePayment: drizzleOrm.sql`NULL`.as("send_as_single_payment"),
+  direction: drizzle.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 = () => drizzleOrm.and(
+    drizzleOrm.isNull(drizzle.tables.paymentRequest.deletedAt),
+    buildMultiFilterConditions(
+      drizzle.tables.paymentRequest.accountId,
+      filterAccountId
+    ),
+    buildMultiFilterConditions(drizzle.tables.paymentRequest.status, filterStatus),
+    buildMultiFilterConditions(
+      drizzle.tables.paymentRequest.paymentType,
+      filterPaymentType
+    ),
+    buildMultiFilterConditions(
+      drizzle.tables.paymentRequest.currency,
+      filterCurrency
+    ),
+    buildRangeFilterConditions(
+      drizzle.tables.paymentRequest.amount,
+      filterMinAmount,
+      filterMaxAmount
+    ),
+    filterBatchId !== void 0 ? drizzleOrm.eq(drizzle.tables.paymentRequest.batchId, filterBatchId) : void 0,
+    filterCreditorIban !== void 0 ? drizzleOrm.eq(drizzle.tables.paymentRequest.creditorIban, filterCreditorIban) : void 0,
+    filterDebtorIban !== void 0 ? drizzleOrm.eq(drizzle.tables.paymentRequest.debtorIban, filterDebtorIban) : void 0,
+    filterDateFrom !== void 0 ? drizzleOrm.gte(drizzle.tables.paymentRequest.createdAt, filterDateFrom) : void 0,
+    filterDateTo !== void 0 ? drizzleOrm.lte(drizzle.tables.paymentRequest.createdAt, filterDateTo) : void 0,
+    filterVariableSymbol !== void 0 ? drizzleOrm.eq(drizzle.tables.paymentRequest.vs, filterVariableSymbol) : void 0,
+    filterSpecificSymbol !== void 0 ? drizzleOrm.eq(drizzle.tables.paymentRequest.ss, filterSpecificSymbol) : void 0,
+    filterConstantSymbol !== void 0 ? drizzleOrm.eq(drizzle.tables.paymentRequest.ks, filterConstantSymbol) : void 0,
+    filterMessage !== void 0 ? drizzleOrm.like(drizzle.tables.paymentRequest.message, `%${filterMessage}%`) : void 0,
+    filterBankRefId !== void 0 ? drizzleOrm.eq(drizzle.tables.paymentRequest.bankRefId, filterBankRefId) : void 0,
+    filterPaymentId !== void 0 ? drizzleOrm.eq(drizzle.tables.paymentRequest.id, filterPaymentId) : void 0,
+    // payment_request is always OUTGOING — exclude branch entirely when filtering INCOMING
+    filterDirection === "INCOMING" ? drizzleOrm.sql`0` : void 0,
+    // payment_request is always API (has no bank-synced payments)
+    filterSource === "BANK" ? drizzleOrm.sql`0` : void 0
   );
+  const buildPaymentWhereConditions = () => drizzleOrm.and(
+    drizzleOrm.isNull(drizzle.tables.payment.deletedAt),
+    buildMultiFilterConditions(drizzle.tables.payment.accountId, filterAccountId),
+    buildMultiFilterConditions(drizzle.tables.payment.status, filterStatus),
+    buildMultiFilterConditions(drizzle.tables.payment.paymentType, filterPaymentType),
+    buildMultiFilterConditions(drizzle.tables.payment.currency, filterCurrency),
+    buildRangeFilterConditions(
+      drizzle.tables.payment.amount,
+      filterMinAmount,
+      filterMaxAmount
+    ),
+    filterBatchId !== void 0 ? drizzleOrm.eq(drizzle.tables.payment.batchId, filterBatchId) : void 0,
+    filterCreditorIban !== void 0 ? drizzleOrm.eq(drizzle.tables.payment.creditorIban, filterCreditorIban) : void 0,
+    filterDebtorIban !== void 0 ? drizzleOrm.eq(drizzle.tables.payment.debtorIban, filterDebtorIban) : void 0,
+    filterDateFrom !== void 0 ? drizzleOrm.gte(drizzle.tables.payment.createdAt, filterDateFrom) : void 0,
+    filterDateTo !== void 0 ? drizzleOrm.lte(drizzle.tables.payment.createdAt, filterDateTo) : void 0,
+    filterVariableSymbol !== void 0 ? drizzleOrm.eq(drizzle.tables.payment.vs, filterVariableSymbol) : void 0,
+    filterSpecificSymbol !== void 0 ? drizzleOrm.eq(drizzle.tables.payment.ss, filterSpecificSymbol) : void 0,
+    filterConstantSymbol !== void 0 ? drizzleOrm.eq(drizzle.tables.payment.ks, filterConstantSymbol) : void 0,
+    filterMessage !== void 0 ? drizzleOrm.like(drizzle.tables.payment.message, `%${filterMessage}%`) : void 0,
+    filterBankRefId !== void 0 ? drizzleOrm.eq(drizzle.tables.payment.bankRefId, filterBankRefId) : void 0,
+    filterPaymentId !== void 0 ? drizzleOrm.sql`COALESCE(${drizzle.tables.payment.paymentRequestId}, ${drizzle.tables.payment.id}) = ${filterPaymentId}` : void 0,
+    filterDirection !== void 0 ? drizzleOrm.eq(drizzle.tables.payment.direction, filterDirection) : void 0,
+    filterSource === "BANK" ? drizzleOrm.isNull(drizzle.tables.payment.paymentRequestId) : filterSource === "API" ? drizzleOrm.isNotNull(drizzle.tables.payment.paymentRequestId) : void 0
+  );
+  const queryInFlight = !isCompletedOnly(filterStatus);
+  const queryCompleted = true;
+  if (!queryInFlight && queryCompleted) {
+    const whereConditions = buildPaymentWhereConditions();
+    const sortColumn = resolveColumn(drizzle.tables.payment, sort.column);
+    const [{ totalCount }] = await db.select({ totalCount: drizzleOrm.sql`count(*)` }).from(drizzle.tables.payment).where(whereConditions);
+    const payments = await db.select().from(drizzle.tables.payment).where(whereConditions).limit(limit).offset(offset).orderBy(sort.direction === "asc" ? drizzleOrm.asc(sortColumn) : drizzleOrm.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: drizzleOrm.sql`count(*)` }).from(drizzle.tables.paymentRequest).where(prWhereConditions).then(([row]) => row),
+    db.select({ totalCount: drizzleOrm.sql`count(*)` }).from(drizzle.tables.payment).where(paymentWhereConditions).then(([row]) => row)
+  ]);
+  const paymentRequests = await sqliteCore.unionAll(
+    db.select(unionColumns).from(drizzle.tables.paymentRequest).where(prWhereConditions),
+    db.select(paymentUnionColumns).from(drizzle.tables.payment).where(paymentWhereConditions)
+  ).orderBy(sort.direction === "asc" ? drizzleOrm.asc(sortColObj) : drizzleOrm.desc(sortColObj)).limit(limit).offset(offset);
   return {
-    supportedPayments,
-    unsupportedPayments
+    paymentRequests,
+    totalCount: countPR + countP
   };
 };
 
@@ -301,7 +566,6 @@ const sendPaymentInputSchema = zod.z.object({
   amount: zod.z.number().positive(),
   paymentType: zod.z.enum(paymentRequest_schema.PAYMENT_TYPES),
   chargeBearer: zod.z.enum(paymentRequest_schema.CHARGE_BEARERS).optional(),
-  executionDate: zod.z.string().optional(),
   instructionPriority: zod.z.enum(paymentRequest_schema.INSTRUCTION_PRIORITIES).optional(),
   currency: zod.z.enum(generalCodes.CURRENCY_CODES),
   vs: zod.z.string().optional(),
@@ -310,7 +574,6 @@ const sendPaymentInputSchema = zod.z.object({
   message: zod.z.string().optional(),
   creditor: backendSdk.bankAccountMetadataSchema,
   debtor: backendSdk.bankAccountMetadataSchema,
-  purpose: zod.z.string().optional(),
   sendAsSinglePayment: zod.z.boolean().optional()
 });
 
@@ -390,10 +653,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 = zod.z.object({
   page: zod.z.number().positive(),
@@ -409,7 +682,17 @@ const getPaymentsInputSchema = zod.z.object({
   [ALLOWED_PAYMENT_FILTERS.DIRECTION]: zod.z.union([zod.z.enum(paymentRequest_schema.PAYMENT_DIRECTIONS), zod.z.enum(paymentRequest_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(paymentRequest_schema.PAYMENT_STATUSES), zod.z.enum(paymentRequest_schema.PAYMENT_STATUSES).array()]).optional()
+  [ALLOWED_PAYMENT_FILTERS.STATUS]: zod.z.union([zod.z.enum(paymentRequest_schema.PAYMENT_STATUSES), zod.z.enum(paymentRequest_schema.PAYMENT_STATUSES).array()]).optional(),
+  [ALLOWED_PAYMENT_FILTERS.PAYMENT_TYPE]: zod.z.enum(paymentRequest_schema.PAYMENT_TYPES).optional(),
+  [ALLOWED_PAYMENT_FILTERS.MIN_AMOUNT]: zod.z.number().positive().optional(),
+  [ALLOWED_PAYMENT_FILTERS.MAX_AMOUNT]: zod.z.number().positive().optional(),
+  [ALLOWED_PAYMENT_FILTERS.VARIABLE_SYMBOL]: zod.z.string().regex(/^\d{1,10}$/).optional(),
+  [ALLOWED_PAYMENT_FILTERS.SPECIFIC_SYMBOL]: zod.z.string().regex(/^\d{1,10}$/).optional(),
+  [ALLOWED_PAYMENT_FILTERS.CONSTANT_SYMBOL]: zod.z.string().regex(/^\d{4}$/).optional(),
+  [ALLOWED_PAYMENT_FILTERS.MESSAGE]: zod.z.string().optional(),
+  [ALLOWED_PAYMENT_FILTERS.CREDITOR_IBAN]: zod.z.string().optional(),
+  [ALLOWED_PAYMENT_FILTERS.DEBTOR_IBAN]: zod.z.string().optional(),
+  [ALLOWED_PAYMENT_FILTERS.BATCH_ID]: zod.z.uuid().optional()
 });
 
 const syncAccountInputSchema = zod.z.object({
@@ -448,6 +731,8 @@ const updateAccountInputSchema = zod.z.object({
 });
 
 const getBankAccountsInputSchema = zod.z.object({
+  page: zod.z.number().positive().optional(),
+  limit: zod.z.number().positive().optional(),
   includeWorkflow: zod.z.boolean().optional(),
   includeBatchCounts: zod.z.boolean().optional(),
   filterIbans: zod.z.array(zod.z.string()).optional(),
@@ -468,6 +753,34 @@ const handleAuthorizationCallbackInputSchema = zod.z.object({
 
 const sendPaymentSyncInputSchema = sendPaymentInputSchema;
 
+const getPaymentRequestsInputSchema = 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"])
+  }),
+  filterAccountId: zod.z.union([zod.z.uuid(), zod.z.uuid().array()]).optional(),
+  filterStatus: zod.z.union([zod.z.enum(paymentRequest_schema.PAYMENT_STATUSES), zod.z.enum(paymentRequest_schema.PAYMENT_STATUSES).array()]).optional(),
+  filterPaymentType: zod.z.union([zod.z.enum(paymentRequest_schema.PAYMENT_TYPES), zod.z.enum(paymentRequest_schema.PAYMENT_TYPES).array()]).optional(),
+  filterCurrency: zod.z.union([zod.z.enum(generalCodes.CURRENCY_CODES), zod.z.enum(generalCodes.CURRENCY_CODES).array()]).optional(),
+  filterMinAmount: zod.z.number().positive().optional(),
+  filterMaxAmount: zod.z.number().positive().optional(),
+  filterBatchId: zod.z.uuid().optional(),
+  filterCreditorIban: zod.z.string().optional(),
+  filterDebtorIban: zod.z.string().optional(),
+  filterDateFrom: zod.z.date().optional(),
+  filterDateTo: zod.z.date().optional(),
+  filterVariableSymbol: zod.z.string().optional(),
+  filterSpecificSymbol: zod.z.string().optional(),
+  filterConstantSymbol: zod.z.string().optional(),
+  filterMessage: zod.z.string().optional(),
+  filterBankRefId: zod.z.string().optional(),
+  filterPaymentId: zod.z.uuid().optional(),
+  filterDirection: zod.z.enum(["INCOMING", "OUTGOING"]).optional(),
+  filterSource: zod.z.enum(["API", "BANK"]).optional()
+});
+
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __decorateClass = (decorators, target, key, kind) => {
@@ -489,7 +802,9 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
     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({
@@ -523,6 +838,27 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
       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 backendSdk.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 backendSdk.createInternalError(null, {
+        message: "SEPA payments require creditor IBAN",
+        code: "VALID-B-009",
+        status: 422
+      });
+    }
+  }
   async getPayments(input) {
     return this.handleAction(
       { data: input, schema: getPaymentsInputSchema },
@@ -806,50 +1142,49 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
       }
     );
   }
-  async addPaymentsToBatch({
-    paymentsToBatch
-  }) {
+  async addPaymentsToBatch({ paymentIds }) {
     return this.handleAction(null, {}, async () => {
-      this.logInput({ paymentsToBatch });
-      const incomingPayments = paymentsToBatch.map(mock_connector.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) => mock_connector.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) => drizzle.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 = backendSdk.uuidv4();
           const { command: upsertBatch } = drizzle.upsertBatchCommand(this.db, {
@@ -862,73 +1197,67 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
               metadata: { sizeLimit: 1 }
             }
           });
-          const { command: insertPaymentRequest } = createPaymentRequestCommand(
+          const { command: updateRequest } = drizzle.updatePaymentRequestStatusCommand(
             this.db,
-            {
-              paymentRequest: mock_connector.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 drizzle.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 = backendSdk.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 drizzle.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 } = drizzle.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: mock_connector.toPaymentRequestInsert(p, batchId)
-              }).command
-            );
-            await this.db.batch([upsertBatch, ...paymentRequestCommands]);
+          } else {
+            batchId = backendSdk.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 } = drizzle.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) => drizzle.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}`
+          });
         }
       }
     });
@@ -985,7 +1314,7 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
       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);
       }
@@ -1051,7 +1380,7 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
         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) => {
@@ -1099,7 +1428,7 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
           ...upsertAccounts,
           ...createAccountCredentials
         ]);
-        const fetchedAccounts = await this._getAccounts();
+        const { accounts: fetchedAccounts } = await this._getAccounts();
         if (!fetchedAccounts)
           throw backendSdk.createInternalError(null, {
             message: "Account not found",
@@ -1107,7 +1436,11 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
             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
             });
@@ -1149,12 +1482,18 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
             code: "VALID-B-003",
             status: 422
           });
+        if (account.connectorKey !== connectorKey)
+          throw backendSdk.createInternalError(null, {
+            message: `Connector key mismatch: account uses ${account.connectorKey}, got ${connectorKey}`,
+            code: "VALID-B-010",
+            status: 422
+          });
         const payment = {
           id: backendSdk.uuidv4(),
           bankRefId: backendSdk.uuidv4(),
           correlationId: backendSdk.uuidv4(),
           amount,
-          connectorKey,
+          connectorKey: account.connectorKey,
           accountId: account.id,
           direction: "INCOMING",
           paymentType: "DOMESTIC",
@@ -1194,10 +1533,51 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
       { data: input, schema: sendPaymentInputSchema },
       { successMessage: "Payment queued successfully" },
       async (data) => {
+        const incomingPayment = mock_connector.toIncomingPayment(data);
+        const { accounts } = await this._getAccounts();
+        const account = accounts.find(
+          (acc) => acc.iban === incomingPayment.debtorIban && acc.currency === incomingPayment.currency
+        );
+        if (!account) {
+          throw backendSdk.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 backendSdk.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 backendSdk.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 = mock_connector.assignAccount(incomingPayment, account);
+        const { command: insertPaymentRequest } = createPaymentRequestCommand(
+          this.db,
+          { paymentRequest: mock_connector.toPaymentRequestInsert(accountAssigned, null) }
+        );
+        await insertPaymentRequest.execute();
         await this.pushToQueue(
           this.env.PAYMENTS_READY_TO_BATCH_QUEUE,
-          data
+          { paymentId: incomingPayment.id }
         );
+        return { paymentId: incomingPayment.id };
       }
     );
   }
@@ -1207,7 +1587,7 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
       { successMessage: "Payment initiated successfully" },
       async (data) => {
         const incomingPayment = mock_connector.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
         );
@@ -1218,12 +1598,31 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
             status: 422
           });
         }
+        if (account.status !== "AUTHORIZED") {
+          throw backendSdk.createInternalError(null, {
+            message: `Account ${account.iban} is not authorized (status: ${account.status})`,
+            code: "VALID-B-007",
+            status: 422
+          });
+        }
         const batchedPayment = mock_connector.toBatchedPayment(
           mock_connector.assignAccount(incomingPayment, account)
         );
         const connector = await this._initiateBankConnector({
           connectorKey: account.connectorKey
         });
+        if (!connector.supportsPaymentType(data.paymentType)) {
+          throw backendSdk.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":
@@ -1252,16 +1651,20 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
       { 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) => {
@@ -1295,7 +1698,7 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
         );
         return {
           accounts: accountsWithOptionalFields,
-          totalCount: accounts.length
+          totalCount
         };
       }
     );
@@ -1413,6 +1816,34 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
       }
     );
   }
+  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 backendSdk.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"
@@ -1486,6 +1917,12 @@ __decorateClass([
 __decorateClass([
   backendSdk.action("getBatches")
 ], BankServiceBase.prototype, "getBatches", 1);
+__decorateClass([
+  backendSdk.action("get-payment-requests")
+], BankServiceBase.prototype, "getPaymentRequests", 1);
+__decorateClass([
+  backendSdk.action("get-payment-request")
+], BankServiceBase.prototype, "getPaymentRequest", 1);
 BankServiceBase = __decorateClass([
   backendSdk.service("bank")
 ], BankServiceBase);