@develit-services/bank 0.8.7 → 0.8.9

package/dist/export/worker.mjs

@@ -1,18 +1,18 @@
 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.DEmzZGZW.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.B5bZRvgq.mjs';
 import { WorkerEntrypoint } from 'cloudflare:workers';
 import { drizzle } from 'drizzle-orm/d1';
-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 { 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.BtszLapg.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.C0UN6luZ.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.C6jjS1Pl.mjs';
 import { CURRENCY_CODES } from '@develit-io/general-codes';
 import 'date-fns';
-import { eq, sql, and, inArray, like, asc, desc, gte, lte, isNull, or, isNotNull } from 'drizzle-orm';
-import { unionAll } from 'drizzle-orm/sqlite-core';
+import { eq, sql, and, inArray, like, asc, desc, gte, lte, isNull, count } from 'drizzle-orm';
 import 'node:crypto';
-import '../shared/bank.CA5ytXxp.mjs';
+import '../shared/bank.BoZtXQpG.mjs';
 import 'drizzle-orm/relations';
+import 'drizzle-orm/sqlite-core';
 import 'drizzle-zod';
 
 const upsertAccountCommand = (db, { account }) => {
@@ -208,7 +208,8 @@ const getPaymentsWithPaginationQuery = async (db, {
   filterPaymentMessage,
   filterPaymentCreditorIban,
   filterPaymentDebtorIban,
-  filterPaymentBatchId
+  filterPaymentBatchId,
+  filterPaymentBankRefId
 }) => {
   const whereConditions = and(
     buildMultiFilterConditions(
@@ -240,7 +241,8 @@ const getPaymentsWithPaginationQuery = async (db, {
     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
+    filterPaymentBatchId !== void 0 ? eq(tables.payment.batchId, filterPaymentBatchId) : void 0,
+    filterPaymentBankRefId !== void 0 ? eq(tables.payment.bankRefId, filterPaymentBankRefId) : void 0
   );
   const sortColumn = resolveColumn(tables.payment, sort.column);
   const [{ totalCount }] = await db.select({
@@ -285,11 +287,12 @@ const getBatchesQuery = async (db, {
   };
 };
 
-const getAccountOpenBatchesQuery = async (db, { accountId, paymentType }) => {
+const getAccountAccumulatingBatchesQuery = async (db, { accountId, paymentType }) => {
   return await db.select().from(tables.batch).where(
     and(
       eq(tables.batch.accountId, accountId),
       eq(tables.batch.status, "OPEN"),
+      isNull(tables.batch.batchPaymentInitiatedAt),
       paymentType ? eq(tables.batch.paymentType, paymentType) : void 0
     )
   );
@@ -299,265 +302,60 @@ const getOttQuery = async (db, { ott }) => {
   return await db.select().from(tables.ott).where(eq(tables.ott.oneTimeToken, ott)).get();
 };
 
-const getPaymentRequestByIdQuery = async (db, { paymentId }) => {
-  const prResults = await db.select().from(tables.paymentRequest).where(
+const getPaymentRequestByIdQuery = async (db, { paymentRequestId }) => {
+  const result = await db.select().from(tables.paymentRequest).where(
     and(
-      eq(tables.paymentRequest.id, paymentId),
+      eq(tables.paymentRequest.id, paymentRequestId),
       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"
-  };
+  return first(result);
 };
 
-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(
+const getPaymentRequestsQuery = async (db, params) => {
+  const limit = params.limit;
+  const offset = (params.page - 1) * params.limit;
+  const orderDir = params.sort.direction === "asc" ? asc : desc;
+  const orderCol = params.sort.column === "amount" ? tables.paymentRequest.amount : params.sort.column === "updatedAt" ? tables.paymentRequest.updatedAt : tables.paymentRequest.createdAt;
+  const where = 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
+    params.filterAccountId ? Array.isArray(params.filterAccountId) ? inArray(tables.paymentRequest.accountId, params.filterAccountId) : eq(tables.paymentRequest.accountId, params.filterAccountId) : void 0,
+    params.filterStatus ? Array.isArray(params.filterStatus) ? inArray(tables.paymentRequest.status, params.filterStatus) : eq(tables.paymentRequest.status, params.filterStatus) : void 0,
+    params.filterPaymentType ? Array.isArray(params.filterPaymentType) ? inArray(tables.paymentRequest.paymentType, params.filterPaymentType) : eq(tables.paymentRequest.paymentType, params.filterPaymentType) : void 0,
+    params.filterCurrency ? Array.isArray(params.filterCurrency) ? inArray(tables.paymentRequest.currency, params.filterCurrency) : eq(tables.paymentRequest.currency, params.filterCurrency) : void 0,
+    params.filterBatchId ? eq(tables.paymentRequest.batchId, params.filterBatchId) : void 0,
+    params.filterDateFrom ? gte(tables.paymentRequest.createdAt, params.filterDateFrom) : void 0,
+    params.filterDateTo ? lte(tables.paymentRequest.createdAt, params.filterDateTo) : void 0,
+    params.filterMinAmount !== void 0 ? gte(tables.paymentRequest.amount, params.filterMinAmount) : void 0,
+    params.filterMaxAmount !== void 0 ? lte(tables.paymentRequest.amount, params.filterMaxAmount) : void 0,
+    params.filterVariableSymbol ? eq(tables.paymentRequest.vs, params.filterVariableSymbol) : void 0,
+    params.filterSpecificSymbol ? eq(tables.paymentRequest.ss, params.filterSpecificSymbol) : void 0,
+    params.filterConstantSymbol ? eq(tables.paymentRequest.ks, params.filterConstantSymbol) : void 0,
+    params.filterMessage ? like(tables.paymentRequest.message, `%${params.filterMessage}%`) : void 0,
+    params.filterBankRefId ? eq(tables.paymentRequest.bankRefId, params.filterBankRefId) : void 0,
+    params.filterCreditorIban ? eq(tables.paymentRequest.creditorIban, params.filterCreditorIban) : void 0,
+    params.filterDebtorIban ? eq(tables.paymentRequest.debtorIban, params.filterDebtorIban) : void 0,
+    params.ids?.length ? inArray(tables.paymentRequest.id, params.ids) : 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, [{ value: totalCount }]] = await Promise.all([
+    db.select().from(tables.paymentRequest).where(where).orderBy(orderDir(orderCol)).limit(limit).offset(offset),
+    db.select({ value: count() }).from(tables.paymentRequest).where(where)
   ]);
-  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 {
-    paymentRequests,
-    totalCount: countPR + countP
-  };
+  return { paymentRequests, totalCount };
 };
 
+const NON_BATCH_CONNECTOR_KEYS = ["DBU", "CREDITAS"];
+const getPendingNonBatchPaymentRequestsQuery = (db) => db.select().from(tables.paymentRequest).where(
+  and(
+    inArray(tables.paymentRequest.status, [
+      "PREPARED",
+      "SIGNED",
+      "PENDING"
+    ]),
+    inArray(tables.paymentRequest.connectorKey, NON_BATCH_CONNECTOR_KEYS)
+  )
+);
+
 const sendPaymentInputSchema = z.object({
   correlationId: z.string().min(1),
   refId: z.string().optional(),
@@ -664,7 +462,8 @@ const ALLOWED_PAYMENT_FILTERS = {
   MESSAGE: "filterPaymentMessage",
   CREDITOR_IBAN: "filterPaymentCreditorIban",
   DEBTOR_IBAN: "filterPaymentDebtorIban",
-  BATCH_ID: "filterPaymentBatchId"
+  BATCH_ID: "filterPaymentBatchId",
+  BANK_REF_ID: "filterPaymentBankRefId"
 };
 const getPaymentsInputSchema = z.object({
   page: z.number().positive(),
@@ -681,7 +480,7 @@ const getPaymentsInputSchema = z.object({
   [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.PAYMENT_TYPE]: z.enum(PAYMENT_TYPES).optional(),
+  [ALLOWED_PAYMENT_FILTERS.PAYMENT_TYPE]: z.union([z.enum(PAYMENT_TYPES), z.enum(PAYMENT_TYPES).array()]).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(),
@@ -690,7 +489,8 @@ const getPaymentsInputSchema = z.object({
   [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()
+  [ALLOWED_PAYMENT_FILTERS.BATCH_ID]: z.uuid().optional(),
+  [ALLOWED_PAYMENT_FILTERS.BANK_REF_ID]: z.string().optional()
 });
 
 const syncAccountInputSchema = z.object({
@@ -774,9 +574,14 @@ const getPaymentRequestsInputSchema = z.object({
   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()
+  ids: z.array(z.string().uuid()).optional()
+  // filterSource: removed — payment_request is always API
+  // filterDirection: removed — payment_request is always OUTGOING
+});
+
+z.object({
+  processed: z.number(),
+  statusChanged: z.number()
 });
 
 var __defProp = Object.defineProperty;
@@ -789,6 +594,7 @@ var __decorateClass = (decorators, target, key, kind) => {
   if (kind && result) __defProp(target, key, result);
   return result;
 };
+const POLLING_TIMEOUT_MS = 14 * 24 * 60 * 60 * 1e3;
 let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
   constructor(ctx, env, config) {
     super(ctx, env);
@@ -942,6 +748,10 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
       console.log("Scheduled CRON batch statuses");
       await this.updateBatchStatuses();
     }
+    if (controller.cron === this.env.CRON_PAYMENT_STATUSES) {
+      console.log("Scheduled CRON payment statuses");
+      await this.updatePaymentStatuses();
+    }
   }
   async _resolveSingleBatch(batch, connector) {
     const previousStatus = batch.status;
@@ -971,14 +781,25 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
         SIGNATURE_FAILED: "FAILED"
       };
       for (const pr of paymentRequests) {
+        if (pr.status !== "COMPLETED" && pr.status !== "FAILED" && pr.createdAt != null && Date.now() - pr.createdAt.getTime() > POLLING_TIMEOUT_MS) {
+          await updatePaymentRequestStatusCommand(this.db, {
+            id: pr.id,
+            status: "FAILED",
+            statusReason: "Polling timeout: no final status received after 14 days",
+            processedAt: /* @__PURE__ */ new Date()
+          }).command.execute();
+          continue;
+        }
         let newStatus = pr.status;
+        let match;
         if (perPaymentStatuses) {
-          const match = perPaymentStatuses.find(
+          match = perPaymentStatuses.find(
             (p) => p.merchantTransactionId === pr.id
           );
           if (match) {
             newStatus = mapFinbricksTransactionStatus(
-              match.resultCode
+              match.resultCode,
+              match.finalBankStatus ?? false
             );
           }
         } else {
@@ -988,10 +809,30 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
           await updatePaymentRequestStatusCommand(this.db, {
             id: pr.id,
             status: newStatus,
+            ...newStatus === "FAILED" && {
+              statusReason: perPaymentStatuses ? match?.resultCode ?? currentStatus : currentStatus
+            },
             processedAt: newStatus === "COMPLETED" || newStatus === "FAILED" ? /* @__PURE__ */ new Date() : void 0
           }).command.execute();
         }
       }
+      if (paymentRequests.length > 0) {
+        const freshPRs = await getPaymentRequestsByBatchIdQuery(this.db, {
+          batchId: batch.id
+        });
+        const allTerminal = freshPRs.every(
+          (pr) => pr.status === "COMPLETED" || pr.status === "FAILED"
+        );
+        if (allTerminal && currentStatus !== "COMPLETED" && currentStatus !== "FAILED") {
+          const finalBatchStatus = freshPRs.some((pr) => pr.status === "FAILED") ? "FAILED" : "COMPLETED";
+          await upsertBatchCommand(this.db, {
+            batch: { ...batch, status: finalBatchStatus }
+          }).command.execute();
+          console.log(
+            `Batch ${batch.id} auto-closed with status ${finalBatchStatus}`
+          );
+        }
+      }
     }
     return {
       batchId: batch.id,
@@ -1030,13 +871,28 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
             this.logError({
               message: `Account not found for batch ${batch.id}, skipping`
             });
-            await upsertBatchCommand(this.db, {
+            const prs = await getPaymentRequestsByBatchIdQuery(this.db, {
+              batchId: batch.id
+            });
+            const prCmds = prs.filter((p) => p.status !== "FAILED").map(
+              (p) => updatePaymentRequestStatusCommand(this.db, {
+                id: p.id,
+                status: "FAILED",
+                statusReason: "ACCOUNT_NOT_FOUND",
+                processedAt: /* @__PURE__ */ new Date()
+              }).command
+            );
+            const batchCmd = upsertBatchCommand(this.db, {
               batch: {
                 ...batch,
                 status: "FAILED",
                 statusReason: "ACCOUNT_NOT_FOUND"
               }
-            }).command.execute();
+            }).command;
+            const allCmds = [batchCmd, ...prCmds];
+            if (allCmds.length > 0) {
+              await this.db.batch(allCmds);
+            }
             continue;
           }
           const batches = batchesByConnector.get(account.connectorKey) || [];
@@ -1051,6 +907,9 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
           const connector = await this._initiateBankConnector({
             connectorKey
           });
+          if (connector.lifecycleMode === "per-payment") {
+            continue;
+          }
           for (const batch of batches) {
             const result = await this._resolveSingleBatch(batch, connector);
             if (result) {
@@ -1069,6 +928,92 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
       }
     );
   }
+  async updatePaymentStatuses() {
+    return this.handleAction(
+      null,
+      { successMessage: "Payment statuses updated" },
+      async () => {
+        const pendingRequests = await getPendingNonBatchPaymentRequestsQuery(
+          this.db
+        );
+        if (pendingRequests.length === 0) {
+          return { processed: 0, statusChanged: 0 };
+        }
+        const requestsByConnector = /* @__PURE__ */ new Map();
+        for (const pr of pendingRequests) {
+          const list = requestsByConnector.get(pr.connectorKey) || [];
+          list.push(pr);
+          requestsByConnector.set(pr.connectorKey, list);
+        }
+        let processed = 0;
+        let statusChanged = 0;
+        for (const [connectorKey, requests] of requestsByConnector) {
+          let connector;
+          try {
+            connector = await this._initiateBankConnector({ connectorKey });
+          } catch (err) {
+            this.logError({
+              message: `[updatePaymentStatuses] Failed to init connector ${connectorKey}: ${err}`
+            });
+            continue;
+          }
+          for (const pr of requests) {
+            try {
+              if (pr.createdAt != null && Date.now() - pr.createdAt.getTime() > POLLING_TIMEOUT_MS) {
+                await updatePaymentRequestStatusCommand(this.db, {
+                  id: pr.id,
+                  status: "FAILED",
+                  statusReason: "Polling timeout: no final status received after 14 days",
+                  processedAt: /* @__PURE__ */ new Date()
+                }).command.execute();
+                statusChanged++;
+                processed++;
+                continue;
+              }
+              const paymentId = pr.bankRefId ?? pr.id;
+              const newStatus = await connector.getPaymentStatus({ paymentId });
+              if (newStatus !== pr.status) {
+                await updatePaymentRequestStatusCommand(this.db, {
+                  id: pr.id,
+                  status: newStatus,
+                  processedAt: newStatus === "COMPLETED" || newStatus === "FAILED" ? /* @__PURE__ */ new Date() : void 0
+                }).command.execute();
+                statusChanged++;
+              }
+              processed++;
+            } catch (err) {
+              this.logError({
+                message: `Failed to get status for payment ${pr.id}: ${err}`
+              });
+            }
+          }
+        }
+        const affectedBatchIds = [
+          ...new Set(
+            pendingRequests.map((pr) => pr.batchId).filter((id) => id != null)
+          )
+        ];
+        for (const batchId of affectedBatchIds) {
+          const [allPRs, batch] = await Promise.all([
+            getPaymentRequestsByBatchIdQuery(this.db, { batchId }),
+            getBatchByIdQuery(this.db, { batchId })
+          ]);
+          if (!batch || batch.status === "COMPLETED" || batch.status === "FAILED")
+            continue;
+          const allTerminal = allPRs.every(
+            (pr) => pr.status === "COMPLETED" || pr.status === "FAILED"
+          );
+          if (allTerminal && allPRs.length > 0) {
+            const finalStatus = allPRs.some((pr) => pr.status === "FAILED") ? "FAILED" : "COMPLETED";
+            await upsertBatchCommand(this.db, {
+              batch: { ...batch, status: finalStatus }
+            }).command.execute();
+          }
+        }
+        return { processed, statusChanged };
+      }
+    );
+  }
   async handleAuthorizationCallback(input) {
     return this.handleAction(
       { data: input, schema: handleAuthorizationCallbackInputSchema },
@@ -1077,7 +1022,9 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
         let targetBatchId = null;
         let paymentsUpdated = 0;
         if (paymentId) {
-          const pr = await getPaymentRequestByIdQuery(this.db, { paymentId });
+          const pr = await getPaymentRequestByIdQuery(this.db, {
+            paymentRequestId: paymentId
+          });
           if (!pr) {
             throw createInternalError(null, {
               message: `Payment request not found: ${paymentId}`,
@@ -1145,9 +1092,9 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
       this.logInput({ paymentIds });
       const paymentRequests = (await Promise.all(
         paymentIds.map(
-          (id) => getPaymentRequestByIdQuery(this.db, { paymentId: id })
+          (id) => getPaymentRequestByIdQuery(this.db, { paymentRequestId: id })
         )
-      )).filter((p) => p !== null);
+      )).filter((p) => p !== void 0);
       const foundIds = new Set(paymentRequests.map((p) => p.id));
       const missingIds = paymentIds.filter((id) => !foundIds.has(id));
       if (missingIds.length > 0) {
@@ -1205,10 +1152,13 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
           });
         }
         if (regularPayments.length > 0) {
-          const openBatches = await getAccountOpenBatchesQuery(this.db, {
-            accountId: acc.id,
-            paymentType: first2.paymentType
-          });
+          const openBatches = await getAccountAccumulatingBatchesQuery(
+            this.db,
+            {
+              accountId: acc.id,
+              paymentType: first2.paymentType
+            }
+          );
           let batchId;
           let availableCount = 0;
           let availableBatch;
@@ -1410,8 +1360,15 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
             secretName: "BANK_SERVICE_ENCRYPTION_KEY"
           })).data?.secretValue || ""
         );
+        const remappedCredentials = credentials.map((cr) => {
+          const matchingNewAccount = accounts.find((a) => a.id === cr.accountId);
+          const existingAccount = matchingNewAccount ? alreadyExistingAccounts.find(
+            (e) => e.iban === matchingNewAccount.iban
+          ) : void 0;
+          return existingAccount ? { ...cr, accountId: existingAccount.id } : cr;
+        });
         const createAccountCredentials = (await Promise.all(
-          credentials.map(
+          remappedCredentials.map(
             async (cr) => createAccountCredentialsCommand(this.db, encryptionKey, {
               credentials: cr
             })
@@ -1819,7 +1776,7 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
       { data: input, schema: getPaymentRequestsInputSchema },
       { successMessage: "Payment requests fetched successfully" },
       async (params) => {
-        return await getPaymentRequestsWithPaginationQuery(this.db, params);
+        return await getPaymentRequestsQuery(this.db, params);
       }
     );
   }
@@ -1829,11 +1786,11 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
       { successMessage: "Payment request fetched successfully" },
       async () => {
         const paymentRequest = await getPaymentRequestByIdQuery(this.db, {
-          paymentId: input.paymentId
+          paymentRequestId: input.paymentRequestId
         });
         if (!paymentRequest) {
           throw createInternalError(null, {
-            message: `Payment request not found: ${input.paymentId}`,
+            message: `Payment request not found: ${input.paymentRequestId}`,
             code: "NOT-FOUND-B-001",
             status: 404
           });
@@ -1876,6 +1833,9 @@ __decorateClass([
 __decorateClass([
   action("update-batch-statuses")
 ], BankServiceBase.prototype, "updateBatchStatuses", 1);
+__decorateClass([
+  action("update-payment-statuses")
+], BankServiceBase.prototype, "updatePaymentStatuses", 1);
 __decorateClass([
   action("handle-authorization-callback")
 ], BankServiceBase.prototype, "handleAuthorizationCallback", 1);