@develit-services/bank 5.4.2 → 5.5.1

package/dist/base.cjs

@@ -1,17 +1,17 @@
 'use strict';
 
 const backendSdk = require('@develit-io/backend-sdk');
-const bank = require('./shared/bank.3A2oRRgQ.cjs');
+const paymentDirection = require('./shared/bank.DMrkshJa.cjs');
 const drizzleOrm = require('drizzle-orm');
 const cloudflare_workers = require('cloudflare:workers');
 const d1 = require('drizzle-orm/d1');
 require('jose');
+const bank = require('./shared/bank.B04qoHtD.cjs');
 const zod = require('zod');
 const database_schema = require('./shared/bank.9Yw4KHyl.cjs');
 const generalCodes = require('@develit-io/general-codes');
 require('date-fns');
 require('node:crypto');
-const credentialsResolver = require('./shared/bank.C_IudwLH.cjs');
 require('drizzle-orm/zod');
 require('drizzle-orm/sqlite-core');
 
@@ -73,11 +73,30 @@ async function heartbeatSyncWorkflows({
   );
 }
 
+const FINITE_STATUSES = /* @__PURE__ */ new Set([
+  "complete",
+  "errored",
+  "terminated"
+]);
+async function terminateSyncWorkflow(instance) {
+  const { status } = await instance.status();
+  if (FINITE_STATUSES.has(status)) return;
+  try {
+    await instance.terminate();
+  } catch (err) {
+    if (!isAlreadyFiniteError(err)) throw err;
+  }
+}
+function isAlreadyFiniteError(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  return /cannot_terminate|finite state/i.test(message);
+}
+
 const upsertAccountCommand = (db, { account }) => {
   const id = account.id || backendSdk.uuidv4();
   const { id: _id, ...accountWithoutId } = account;
-  const command = db.insert(bank.tables.account).values({ ...account, id }).onConflictDoUpdate({
-    target: bank.tables.account.iban,
+  const command = db.insert(paymentDirection.tables.account).values({ ...account, id }).onConflictDoUpdate({
+    target: paymentDirection.tables.account.iban,
     set: accountWithoutId
     // preserve existing id on re-auth
   }).returning();
@@ -94,7 +113,7 @@ const createOneTimeTokenCommand = (db, {
 }) => {
   const id = backendSdk.uuidv4();
   const expiresAt = new Date(Date.now() + 1e3 * 60 * 60) ;
-  const command = db.insert(bank.tables.ott).values({
+  const command = db.insert(paymentDirection.tables.ott).values({
     id,
     oneTimeToken: ott,
     tokenType,
@@ -106,7 +125,7 @@ const createOneTimeTokenCommand = (db, {
 
 const updateAccountCommand = (db, { account }) => {
   return {
-    command: db.update(bank.tables.account).set({ ...account }).where(drizzleOrm.eq(bank.tables.account.id, account.id)).returning()
+    command: db.update(paymentDirection.tables.account).set({ ...account }).where(drizzleOrm.eq(paymentDirection.tables.account.id, account.id)).returning()
   };
 };
 
@@ -114,16 +133,16 @@ const expireOneTimeTokenCommand = (db, {
   ott
 }) => {
   return {
-    command: db.update(bank.tables.ott).set({
+    command: db.update(paymentDirection.tables.ott).set({
       expiresAt: /* @__PURE__ */ new Date()
-    }).where(drizzleOrm.eq(bank.tables.ott.oneTimeToken, ott))
+    }).where(drizzleOrm.eq(paymentDirection.tables.ott.oneTimeToken, ott))
   };
 };
 
 const createAccountCredentialsCommand = async (db, encryptionKey, { credentials }) => {
   const id = credentials.id || backendSdk.uuidv4();
-  const encryptedValue = await credentialsResolver.encrypt(credentials.value, encryptionKey);
-  const command = db.insert(bank.tables.accountCredentials).values({
+  const encryptedValue = await bank.encrypt(credentials.value, encryptionKey);
+  const command = db.insert(paymentDirection.tables.accountCredentials).values({
     ...credentials,
     id,
     value: encryptedValue
@@ -135,16 +154,16 @@ const createAccountCredentialsCommand = async (db, encryptionKey, { credentials
 };
 
 const deleteAccountCredentialsCommand = (db, { accountId }) => {
-  const command = db.delete(bank.tables.accountCredentials).where(drizzleOrm.eq(bank.tables.accountCredentials.accountId, accountId));
+  const command = db.delete(paymentDirection.tables.accountCredentials).where(drizzleOrm.eq(paymentDirection.tables.accountCredentials.accountId, accountId));
   return {
     command
   };
 };
 
 const deletePaymentsByAccountCommand = (db, { accountId }) => {
-  const command = db.update(bank.tables.payment).set({
+  const command = db.update(paymentDirection.tables.payment).set({
     deletedAt: /* @__PURE__ */ new Date()
-  }).where(drizzleOrm.eq(bank.tables.payment.accountId, accountId));
+  }).where(drizzleOrm.eq(paymentDirection.tables.payment.accountId, accountId));
   return {
     command
   };
@@ -152,7 +171,7 @@ const deletePaymentsByAccountCommand = (db, { accountId }) => {
 
 const createPaymentRequestCommand = (db, { paymentRequest }) => {
   return {
-    command: db.insert(bank.tables.paymentRequest).values({
+    command: db.insert(paymentDirection.tables.paymentRequest).values({
       ...paymentRequest,
       creditorIban: paymentRequest.creditor.iban,
       debtorIban: paymentRequest.debtor.iban
@@ -163,16 +182,16 @@ const createPaymentRequestCommand = (db, { paymentRequest }) => {
 const getAccountBatchCountsQuery = async (db, { accountId }) => {
   const result = await db.select({
     totalCount: drizzleOrm.sql`COUNT(*)`.as("totalCount"),
-    processingCount: drizzleOrm.sql`SUM(CASE WHEN ${bank.tables.batch.status} = 'PROCESSING' THEN 1 ELSE 0 END)`.as(
+    processingCount: drizzleOrm.sql`SUM(CASE WHEN ${paymentDirection.tables.batch.status} = 'PROCESSING' THEN 1 ELSE 0 END)`.as(
       "processingCount"
     ),
-    readyToSignCount: drizzleOrm.sql`SUM(CASE WHEN ${bank.tables.batch.status} = 'READY_TO_SIGN' THEN 1 ELSE 0 END)`.as(
+    readyToSignCount: drizzleOrm.sql`SUM(CASE WHEN ${paymentDirection.tables.batch.status} = 'READY_TO_SIGN' THEN 1 ELSE 0 END)`.as(
       "readyToSignCount"
     ),
-    failedCount: drizzleOrm.sql`SUM(CASE WHEN ${bank.tables.batch.status} = 'FAILED' THEN 1 ELSE 0 END)`.as(
+    failedCount: drizzleOrm.sql`SUM(CASE WHEN ${paymentDirection.tables.batch.status} = 'FAILED' THEN 1 ELSE 0 END)`.as(
       "failedCount"
     )
-  }).from(bank.tables.batch).where(drizzleOrm.eq(bank.tables.batch.accountId, accountId)).then(backendSdk.first);
+  }).from(paymentDirection.tables.batch).where(drizzleOrm.eq(paymentDirection.tables.batch.accountId, accountId)).then(backendSdk.first);
   return result || {
     totalCount: 0,
     processingCount: 0,
@@ -182,18 +201,18 @@ const getAccountBatchCountsQuery = async (db, { accountId }) => {
 };
 
 const getAccountByIbanQuery = async (db, { iban }) => {
-  return await db.select().from(bank.tables.account).where(drizzleOrm.eq(bank.tables.account.iban, iban)).get();
+  return await db.select().from(paymentDirection.tables.account).where(drizzleOrm.eq(paymentDirection.tables.account.iban, iban)).get();
 };
 
 const getAllAccountsQuery = async (db, filters) => {
   const whereConditions = drizzleOrm.and(
-    backendSdk.buildMultiFilterConditions(bank.tables.account.iban, filters?.filterIbans),
+    backendSdk.buildMultiFilterConditions(paymentDirection.tables.account.iban, filters?.filterIbans),
     backendSdk.buildMultiFilterConditions(
-      bank.tables.account.currency,
+      paymentDirection.tables.account.currency,
       filters?.filterCurrencies
     ),
     backendSdk.buildMultiFilterConditions(
-      bank.tables.account.bankRefId,
+      paymentDirection.tables.account.bankRefId,
       filters?.filterBankRefIds
     )
   );
@@ -201,11 +220,11 @@ const getAllAccountsQuery = async (db, filters) => {
   const limit = filters?.limit ?? 20;
   const offset = (page - 1) * limit;
   const [accountsWithExpiration, countResult] = await Promise.all([
-    db.select().from(bank.tables.account).leftJoin(
-      bank.tables.accountCredentials,
-      drizzleOrm.eq(bank.tables.accountCredentials.accountId, bank.tables.account.id)
+    db.select().from(paymentDirection.tables.account).leftJoin(
+      paymentDirection.tables.accountCredentials,
+      drizzleOrm.eq(paymentDirection.tables.accountCredentials.accountId, paymentDirection.tables.account.id)
     ).where(whereConditions).limit(limit).offset(offset),
-    db.select({ count: drizzleOrm.sql`count(*)` }).from(bank.tables.account).where(whereConditions)
+    db.select({ count: drizzleOrm.sql`count(*)` }).from(paymentDirection.tables.account).where(whereConditions)
   ]);
   return {
     accounts: accountsWithExpiration.map(
@@ -267,42 +286,42 @@ const getPaymentsWithPaginationQuery = async (db, {
 }) => {
   const whereConditions = drizzleOrm.and(
     buildMultiFilterConditions(
-      bank.tables.payment.accountId,
+      paymentDirection.tables.payment.accountId,
       filterPaymentAccountId
     ),
-    buildMultiFilterConditions(bank.tables.payment.amount, filterPaymentAmount),
-    buildMultiFilterConditions(bank.tables.payment.currency, filterPaymentCurrency),
+    buildMultiFilterConditions(paymentDirection.tables.payment.amount, filterPaymentAmount),
+    buildMultiFilterConditions(paymentDirection.tables.payment.currency, filterPaymentCurrency),
     buildRangeFilterConditions(
-      bank.tables.payment.createdAt,
+      paymentDirection.tables.payment.createdAt,
       filterPaymentDateFrom,
       filterPaymentDateTo
     ),
-    buildMultiFilterConditions(bank.tables.payment.status, filterPaymentStatus),
+    buildMultiFilterConditions(paymentDirection.tables.payment.status, filterPaymentStatus),
     buildMultiFilterConditions(
-      bank.tables.payment.direction,
+      paymentDirection.tables.payment.direction,
       filterPaymentDirection
     ),
-    buildMultiFilterConditions(bank.tables.payment.id, ids),
-    buildMultiFilterConditions(bank.tables.payment.paymentType, filterPaymentType),
+    buildMultiFilterConditions(paymentDirection.tables.payment.id, ids),
+    buildMultiFilterConditions(paymentDirection.tables.payment.paymentType, filterPaymentType),
     buildRangeFilterConditions(
-      bank.tables.payment.amount,
+      paymentDirection.tables.payment.amount,
       filterPaymentMinAmount,
       filterPaymentMaxAmount
     ),
-    filterPaymentVariableSymbol !== void 0 ? drizzleOrm.eq(bank.tables.payment.vs, filterPaymentVariableSymbol) : void 0,
-    filterPaymentSpecificSymbol !== void 0 ? drizzleOrm.eq(bank.tables.payment.ss, filterPaymentSpecificSymbol) : void 0,
-    filterPaymentConstantSymbol !== void 0 ? drizzleOrm.eq(bank.tables.payment.ks, filterPaymentConstantSymbol) : void 0,
-    filterPaymentMessage !== void 0 ? drizzleOrm.like(bank.tables.payment.message, `%${filterPaymentMessage}%`) : void 0,
-    filterPaymentCreditorIban !== void 0 ? drizzleOrm.eq(bank.tables.payment.creditorIban, filterPaymentCreditorIban) : void 0,
-    filterPaymentDebtorIban !== void 0 ? drizzleOrm.eq(bank.tables.payment.debtorIban, filterPaymentDebtorIban) : void 0,
-    filterPaymentBatchId !== void 0 ? drizzleOrm.eq(bank.tables.payment.batchId, filterPaymentBatchId) : void 0,
-    filterPaymentBankRefId !== void 0 ? drizzleOrm.eq(bank.tables.payment.bankRefId, filterPaymentBankRefId) : void 0
+    filterPaymentVariableSymbol !== void 0 ? drizzleOrm.eq(paymentDirection.tables.payment.vs, filterPaymentVariableSymbol) : void 0,
+    filterPaymentSpecificSymbol !== void 0 ? drizzleOrm.eq(paymentDirection.tables.payment.ss, filterPaymentSpecificSymbol) : void 0,
+    filterPaymentConstantSymbol !== void 0 ? drizzleOrm.eq(paymentDirection.tables.payment.ks, filterPaymentConstantSymbol) : void 0,
+    filterPaymentMessage !== void 0 ? drizzleOrm.like(paymentDirection.tables.payment.message, `%${filterPaymentMessage}%`) : void 0,
+    filterPaymentCreditorIban !== void 0 ? drizzleOrm.eq(paymentDirection.tables.payment.creditorIban, filterPaymentCreditorIban) : void 0,
+    filterPaymentDebtorIban !== void 0 ? drizzleOrm.eq(paymentDirection.tables.payment.debtorIban, filterPaymentDebtorIban) : void 0,
+    filterPaymentBatchId !== void 0 ? drizzleOrm.eq(paymentDirection.tables.payment.batchId, filterPaymentBatchId) : void 0,
+    filterPaymentBankRefId !== void 0 ? drizzleOrm.eq(paymentDirection.tables.payment.bankRefId, filterPaymentBankRefId) : void 0
   );
-  const sortColumn = resolveColumn(bank.tables.payment, sort.column);
+  const sortColumn = resolveColumn(paymentDirection.tables.payment, sort.column);
   const [{ totalCount }] = await db.select({
     totalCount: drizzleOrm.sql`count(*)`
-  }).from(bank.tables.payment).where(whereConditions);
-  const payments = await db.select().from(bank.tables.payment).where(whereConditions).limit(limit).offset((page - 1) * limit).orderBy(sort.direction === "asc" ? drizzleOrm.asc(sortColumn) : drizzleOrm.desc(sortColumn));
+  }).from(paymentDirection.tables.payment).where(whereConditions);
+  const payments = await db.select().from(paymentDirection.tables.payment).where(whereConditions).limit(limit).offset((page - 1) * limit).orderBy(sort.direction === "asc" ? drizzleOrm.asc(sortColumn) : drizzleOrm.desc(sortColumn));
   return {
     payments,
     totalCount
@@ -317,20 +336,20 @@ const getBatchesQuery = async (db, {
   filterBatchStatus
 }) => {
   const whereConditions = drizzleOrm.and(
-    drizzleOrm.isNull(bank.tables.batch.deletedAt),
-    buildMultiFilterConditions(bank.tables.batch.accountId, filterBatchAccountId),
-    buildMultiFilterConditions(bank.tables.batch.status, filterBatchStatus)
+    drizzleOrm.isNull(paymentDirection.tables.batch.deletedAt),
+    buildMultiFilterConditions(paymentDirection.tables.batch.accountId, filterBatchAccountId),
+    buildMultiFilterConditions(paymentDirection.tables.batch.status, filterBatchStatus)
   );
-  const sortColumn = resolveColumn(bank.tables.batch, sort.column);
+  const sortColumn = resolveColumn(paymentDirection.tables.batch, sort.column);
   const [{ totalCount }] = await db.select({
     totalCount: drizzleOrm.sql`count(*)`
-  }).from(bank.tables.batch).where(whereConditions);
-  const batches = await db.select().from(bank.tables.batch).where(whereConditions).limit(limit).offset((page - 1) * limit).orderBy(sort.direction === "asc" ? drizzleOrm.asc(sortColumn) : drizzleOrm.desc(sortColumn));
+  }).from(paymentDirection.tables.batch).where(whereConditions);
+  const batches = await db.select().from(paymentDirection.tables.batch).where(whereConditions).limit(limit).offset((page - 1) * limit).orderBy(sort.direction === "asc" ? drizzleOrm.asc(sortColumn) : drizzleOrm.desc(sortColumn));
   const batchIds = batches.map((b) => b.id);
-  const paymentRequests = batchIds.length > 0 ? await db.select().from(bank.tables.paymentRequest).where(
+  const paymentRequests = batchIds.length > 0 ? await db.select().from(paymentDirection.tables.paymentRequest).where(
     drizzleOrm.and(
-      drizzleOrm.inArray(bank.tables.paymentRequest.batchId, batchIds),
-      drizzleOrm.isNull(bank.tables.paymentRequest.deletedAt)
+      drizzleOrm.inArray(paymentDirection.tables.paymentRequest.batchId, batchIds),
+      drizzleOrm.isNull(paymentDirection.tables.paymentRequest.deletedAt)
     )
   ) : [];
   const paymentRequestsByBatchId = Map.groupBy(
@@ -348,7 +367,7 @@ const getBatchesQuery = async (db, {
 };
 
 const getOttQuery = async (db, { ott }) => {
-  return await db.select().from(bank.tables.ott).where(drizzleOrm.eq(bank.tables.ott.oneTimeToken, ott)).get();
+  return await db.select().from(paymentDirection.tables.ott).where(drizzleOrm.eq(paymentDirection.tables.ott.oneTimeToken, ott)).get();
 };
 
 const CHUNK_SIZE = 90;
@@ -358,15 +377,15 @@ const getPaymentsByPaymentRequestIdsQuery = async (db, { paymentRequestIds }) =>
   for (let i = 0; i < paymentRequestIds.length; i += CHUNK_SIZE) {
     const chunkIds = paymentRequestIds.slice(i, i + CHUNK_SIZE);
     const rows = await db.select({
-      id: bank.tables.paymentRequest.id,
-      correlationId: bank.tables.paymentRequest.correlationId,
-      status: bank.tables.paymentRequest.status,
-      amount: bank.tables.paymentRequest.amount,
-      currency: bank.tables.paymentRequest.currency,
-      creditor: bank.tables.paymentRequest.creditor,
-      createdAt: bank.tables.paymentRequest.createdAt,
-      updatedAt: bank.tables.paymentRequest.updatedAt
-    }).from(bank.tables.paymentRequest).where(drizzleOrm.inArray(bank.tables.paymentRequest.id, chunkIds));
+      id: paymentDirection.tables.paymentRequest.id,
+      correlationId: paymentDirection.tables.paymentRequest.correlationId,
+      status: paymentDirection.tables.paymentRequest.status,
+      amount: paymentDirection.tables.paymentRequest.amount,
+      currency: paymentDirection.tables.paymentRequest.currency,
+      creditor: paymentDirection.tables.paymentRequest.creditor,
+      createdAt: paymentDirection.tables.paymentRequest.createdAt,
+      updatedAt: paymentDirection.tables.paymentRequest.updatedAt
+    }).from(paymentDirection.tables.paymentRequest).where(drizzleOrm.inArray(paymentDirection.tables.paymentRequest.id, chunkIds));
     paymentRequests.push(...rows);
   }
   return paymentRequests.map((pr) => {
@@ -388,10 +407,10 @@ const getPaymentsByPaymentRequestIdsQuery = async (db, { paymentRequestIds }) =>
 };
 
 const getPaymentRequestByIdQuery = async (db, { paymentRequestId }) => {
-  const result = await db.select().from(bank.tables.paymentRequest).where(
+  const result = await db.select().from(paymentDirection.tables.paymentRequest).where(
     drizzleOrm.and(
-      drizzleOrm.eq(bank.tables.paymentRequest.id, paymentRequestId),
-      drizzleOrm.isNull(bank.tables.paymentRequest.deletedAt)
+      drizzleOrm.eq(paymentDirection.tables.paymentRequest.id, paymentRequestId),
+      drizzleOrm.isNull(paymentDirection.tables.paymentRequest.deletedAt)
     )
   ).limit(1);
   return backendSdk.first(result);
@@ -401,30 +420,30 @@ const getPaymentRequestsQuery = async (db, params) => {
   const limit = params.limit;
   const offset = (params.page - 1) * params.limit;
   const orderDir = params.sort.direction === "asc" ? drizzleOrm.asc : drizzleOrm.desc;
-  const orderCol = params.sort.column === "amount" ? bank.tables.paymentRequest.amount : params.sort.column === "updatedAt" ? bank.tables.paymentRequest.updatedAt : bank.tables.paymentRequest.createdAt;
+  const orderCol = params.sort.column === "amount" ? paymentDirection.tables.paymentRequest.amount : params.sort.column === "updatedAt" ? paymentDirection.tables.paymentRequest.updatedAt : paymentDirection.tables.paymentRequest.createdAt;
   const where = drizzleOrm.and(
-    drizzleOrm.isNull(bank.tables.paymentRequest.deletedAt),
-    params.filterAccountId ? Array.isArray(params.filterAccountId) ? drizzleOrm.inArray(bank.tables.paymentRequest.accountId, params.filterAccountId) : drizzleOrm.eq(bank.tables.paymentRequest.accountId, params.filterAccountId) : void 0,
-    params.filterStatus ? Array.isArray(params.filterStatus) ? drizzleOrm.inArray(bank.tables.paymentRequest.status, params.filterStatus) : drizzleOrm.eq(bank.tables.paymentRequest.status, params.filterStatus) : void 0,
-    params.filterPaymentType ? Array.isArray(params.filterPaymentType) ? drizzleOrm.inArray(bank.tables.paymentRequest.paymentType, params.filterPaymentType) : drizzleOrm.eq(bank.tables.paymentRequest.paymentType, params.filterPaymentType) : void 0,
-    params.filterCurrency ? Array.isArray(params.filterCurrency) ? drizzleOrm.inArray(bank.tables.paymentRequest.currency, params.filterCurrency) : drizzleOrm.eq(bank.tables.paymentRequest.currency, params.filterCurrency) : void 0,
-    params.filterBatchId ? drizzleOrm.eq(bank.tables.paymentRequest.batchId, params.filterBatchId) : void 0,
-    params.filterDateFrom ? drizzleOrm.gte(bank.tables.paymentRequest.createdAt, params.filterDateFrom) : void 0,
-    params.filterDateTo ? drizzleOrm.lte(bank.tables.paymentRequest.createdAt, params.filterDateTo) : void 0,
-    params.filterMinAmount !== void 0 ? drizzleOrm.gte(bank.tables.paymentRequest.amount, params.filterMinAmount) : void 0,
-    params.filterMaxAmount !== void 0 ? drizzleOrm.lte(bank.tables.paymentRequest.amount, params.filterMaxAmount) : void 0,
-    params.filterVariableSymbol ? drizzleOrm.eq(bank.tables.paymentRequest.vs, params.filterVariableSymbol) : void 0,
-    params.filterSpecificSymbol ? drizzleOrm.eq(bank.tables.paymentRequest.ss, params.filterSpecificSymbol) : void 0,
-    params.filterConstantSymbol ? drizzleOrm.eq(bank.tables.paymentRequest.ks, params.filterConstantSymbol) : void 0,
-    params.filterMessage ? drizzleOrm.like(bank.tables.paymentRequest.message, `%${params.filterMessage}%`) : void 0,
-    params.filterBankRefId ? drizzleOrm.eq(bank.tables.paymentRequest.bankRefId, params.filterBankRefId) : void 0,
-    params.filterCreditorIban ? drizzleOrm.eq(bank.tables.paymentRequest.creditorIban, params.filterCreditorIban) : void 0,
-    params.filterDebtorIban ? drizzleOrm.eq(bank.tables.paymentRequest.debtorIban, params.filterDebtorIban) : void 0,
-    params.ids?.length ? drizzleOrm.inArray(bank.tables.paymentRequest.id, params.ids) : void 0
+    drizzleOrm.isNull(paymentDirection.tables.paymentRequest.deletedAt),
+    params.filterAccountId ? Array.isArray(params.filterAccountId) ? drizzleOrm.inArray(paymentDirection.tables.paymentRequest.accountId, params.filterAccountId) : drizzleOrm.eq(paymentDirection.tables.paymentRequest.accountId, params.filterAccountId) : void 0,
+    params.filterStatus ? Array.isArray(params.filterStatus) ? drizzleOrm.inArray(paymentDirection.tables.paymentRequest.status, params.filterStatus) : drizzleOrm.eq(paymentDirection.tables.paymentRequest.status, params.filterStatus) : void 0,
+    params.filterPaymentType ? Array.isArray(params.filterPaymentType) ? drizzleOrm.inArray(paymentDirection.tables.paymentRequest.paymentType, params.filterPaymentType) : drizzleOrm.eq(paymentDirection.tables.paymentRequest.paymentType, params.filterPaymentType) : void 0,
+    params.filterCurrency ? Array.isArray(params.filterCurrency) ? drizzleOrm.inArray(paymentDirection.tables.paymentRequest.currency, params.filterCurrency) : drizzleOrm.eq(paymentDirection.tables.paymentRequest.currency, params.filterCurrency) : void 0,
+    params.filterBatchId ? drizzleOrm.eq(paymentDirection.tables.paymentRequest.batchId, params.filterBatchId) : void 0,
+    params.filterDateFrom ? drizzleOrm.gte(paymentDirection.tables.paymentRequest.createdAt, params.filterDateFrom) : void 0,
+    params.filterDateTo ? drizzleOrm.lte(paymentDirection.tables.paymentRequest.createdAt, params.filterDateTo) : void 0,
+    params.filterMinAmount !== void 0 ? drizzleOrm.gte(paymentDirection.tables.paymentRequest.amount, params.filterMinAmount) : void 0,
+    params.filterMaxAmount !== void 0 ? drizzleOrm.lte(paymentDirection.tables.paymentRequest.amount, params.filterMaxAmount) : void 0,
+    params.filterVariableSymbol ? drizzleOrm.eq(paymentDirection.tables.paymentRequest.vs, params.filterVariableSymbol) : void 0,
+    params.filterSpecificSymbol ? drizzleOrm.eq(paymentDirection.tables.paymentRequest.ss, params.filterSpecificSymbol) : void 0,
+    params.filterConstantSymbol ? drizzleOrm.eq(paymentDirection.tables.paymentRequest.ks, params.filterConstantSymbol) : void 0,
+    params.filterMessage ? drizzleOrm.like(paymentDirection.tables.paymentRequest.message, `%${params.filterMessage}%`) : void 0,
+    params.filterBankRefId ? drizzleOrm.eq(paymentDirection.tables.paymentRequest.bankRefId, params.filterBankRefId) : void 0,
+    params.filterCreditorIban ? drizzleOrm.eq(paymentDirection.tables.paymentRequest.creditorIban, params.filterCreditorIban) : void 0,
+    params.filterDebtorIban ? drizzleOrm.eq(paymentDirection.tables.paymentRequest.debtorIban, params.filterDebtorIban) : void 0,
+    params.ids?.length ? drizzleOrm.inArray(paymentDirection.tables.paymentRequest.id, params.ids) : void 0
   );
   const [paymentRequests, [{ value: totalCount }]] = await Promise.all([
-    db.select().from(bank.tables.paymentRequest).where(where).orderBy(orderDir(orderCol)).limit(limit).offset(offset),
-    db.select({ value: drizzleOrm.count() }).from(bank.tables.paymentRequest).where(where)
+    db.select().from(paymentDirection.tables.paymentRequest).where(where).orderBy(orderDir(orderCol)).limit(limit).offset(offset),
+    db.select({ value: drizzleOrm.count() }).from(paymentDirection.tables.paymentRequest).where(where)
   ]);
   return { paymentRequests, totalCount };
 };
@@ -659,7 +678,7 @@ zod.z.object({
 });
 
 const updateAccountInputSchema = zod.z.object({
-  account: bank.accountInsertSchema
+  account: paymentDirection.accountInsertSchema
 });
 
 const getBankAccountsInputSchema = zod.z.object({
@@ -735,7 +754,7 @@ exports.BankServiceBase = class BankServiceBase extends backendSdk.develitWorker
     // 14 days
     this.COMPLETED_POLLING_WINDOW_MS = 7 * 24 * 60 * 60 * 1e3;
     this.allowedProviders = config.allowedProviders;
-    this.db = d1.drizzle(this.env.BANK_D1, { schema: bank.tables, relations: bank.relations });
+    this.db = d1.drizzle(this.env.BANK_D1, { schema: paymentDirection.tables, relations: paymentDirection.relations });
   }
   async _getAccounts(filters) {
     return await getAllAccountsQuery(this.db, filters);
@@ -769,7 +788,7 @@ exports.BankServiceBase = class BankServiceBase extends backendSdk.develitWorker
         bankRefId: acc.bankRefId,
         config: acc.connectorConfig
       }));
-      resolveCredentials = await credentialsResolver.createCredentialsResolver(this.db, this.env);
+      resolveCredentials = await bank.createCredentialsResolver(this.db, this.env);
     }
     return bank.initiateConnector({
       bank: connectorKey,
@@ -871,7 +890,7 @@ exports.BankServiceBase = class BankServiceBase extends backendSdk.develitWorker
       { successMessage: "Account sync workflow terminated" },
       async ({ accountId }) => {
         const instance = await this.env.SYNC_ACCOUNT_PAYMENTS_WORKFLOW.get(accountId);
-        await instance.terminate();
+        await terminateSyncWorkflow(instance);
         return {
           instanceId: instance.id
         };
@@ -943,10 +962,10 @@ exports.BankServiceBase = class BankServiceBase extends backendSdk.develitWorker
               oldStatus: pr.status,
               newStatus
             });
-            await credentialsResolver.updatePaymentRequestStatusCommand(this.db, {
+            await bank.updatePaymentRequestStatusCommand(this.db, {
               id: pr.id,
               status: newStatus,
-              processedAt: bank.isProcessedStatus(newStatus) ? /* @__PURE__ */ new Date() : void 0
+              processedAt: paymentDirection.isProcessedStatus(newStatus) ? /* @__PURE__ */ new Date() : void 0
             }).command.execute();
             statusChanged++;
             eventsToEmit.push(
@@ -1024,26 +1043,26 @@ exports.BankServiceBase = class BankServiceBase extends backendSdk.develitWorker
    */
   async _deriveBatchStatus(batchId) {
     const [allPRs, batch] = await Promise.all([
-      credentialsResolver.getPaymentRequestsByBatchIdQuery(this.db, { batchId }),
-      credentialsResolver.getBatchByIdQuery(this.db, { batchId })
+      bank.getPaymentRequestsByBatchIdQuery(this.db, { batchId }),
+      bank.getBatchByIdQuery(this.db, { batchId })
     ]);
     if (!batch || batch.status === "COMPLETED" || batch.status === "FAILED")
       return;
     if (allPRs.length === 0) return;
     const connectorKey = allPRs[0]?.connectorKey;
     const allTerminal = allPRs.every(
-      (pr) => bank.isTerminalStatus(pr.status, connectorKey)
+      (pr) => paymentDirection.isTerminalStatus(pr.status, connectorKey)
     );
     const allAuthorizedOrHigher = allPRs.every((pr) => pr.status !== "OPENED");
     if (allTerminal) {
       const hasFailed = allPRs.some(
         (pr) => pr.status === "REJECTED" || pr.status === "CLOSED"
       );
-      await credentialsResolver.upsertBatchCommand(this.db, {
+      await bank.upsertBatchCommand(this.db, {
         batch: { ...batch, status: hasFailed ? "FAILED" : "COMPLETED" }
       }).command.execute();
     } else if (allAuthorizedOrHigher && batch.status !== "AUTHORIZED") {
-      await credentialsResolver.upsertBatchCommand(this.db, {
+      await bank.upsertBatchCommand(this.db, {
         batch: { ...batch, status: "AUTHORIZED" }
       }).command.execute();
     }
@@ -1057,7 +1076,7 @@ exports.BankServiceBase = class BankServiceBase extends backendSdk.develitWorker
         console.log("[updatePaymentRequestStatuses] Starting", {
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         });
-        const nonTerminalPRs = await bank.getNonTerminalPaymentRequestsQuery(this.db);
+        const nonTerminalPRs = await paymentDirection.getNonTerminalPaymentRequestsQuery(this.db);
         if (nonTerminalPRs.length === 0) {
           console.log(
             "[updatePaymentRequestStatuses] No non-terminal PRs found",
@@ -1080,7 +1099,7 @@ exports.BankServiceBase = class BankServiceBase extends backendSdk.develitWorker
         const pollableIds = [];
         for (const pr of nonTerminalPRs) {
           const status = pr.status;
-          if (bank.isTerminalStatus(status, pr.connectorKey)) {
+          if (paymentDirection.isTerminalStatus(status, pr.connectorKey)) {
             continue;
           }
           if (status === "OPENED" || status === "AUTHORIZED") {
@@ -1096,7 +1115,7 @@ exports.BankServiceBase = class BankServiceBase extends backendSdk.develitWorker
                   age: `${Math.floor((now - pr.createdAt.getTime()) / (24 * 60 * 60 * 1e3))} days`
                 }
               );
-              await credentialsResolver.updatePaymentRequestStatusCommand(this.db, {
+              await bank.updatePaymentRequestStatusCommand(this.db, {
                 id: pr.id,
                 status: "CLOSED",
                 statusReason: "Polling timeout: no final status received after 14 days",
@@ -1135,9 +1154,9 @@ exports.BankServiceBase = class BankServiceBase extends backendSdk.develitWorker
   }
   async heartbeatSyncWorkflows() {
     const accounts = await this.db.select({
-      id: bank.tables.account.id,
-      lastSyncMetadata: bank.tables.account.lastSyncMetadata
-    }).from(bank.tables.account).where(drizzleOrm.eq(bank.tables.account.status, "AUTHORIZED")).all();
+      id: paymentDirection.tables.account.id,
+      lastSyncMetadata: paymentDirection.tables.account.lastSyncMetadata
+    }).from(paymentDirection.tables.account).where(drizzleOrm.eq(paymentDirection.tables.account.status, "AUTHORIZED")).all();
     const resetAfterIterations = Number(
       this.env.SYNC_WORKFLOW_RESET_AFTER_ITERATIONS
     );
@@ -1182,7 +1201,7 @@ exports.BankServiceBase = class BankServiceBase extends backendSdk.develitWorker
           });
           if (pr) connectorKey = pr.connectorKey;
         } else if (batchId) {
-          const batchPrs = await credentialsResolver.getPaymentRequestsByBatchIdQuery(this.db, {
+          const batchPrs = await bank.getPaymentRequestsByBatchIdQuery(this.db, {
             batchId
           });
           if (batchPrs.length > 0) connectorKey = batchPrs[0].connectorKey;
@@ -1211,7 +1230,7 @@ exports.BankServiceBase = class BankServiceBase extends backendSdk.develitWorker
           prIds.push(result.paymentRequestId);
         }
         if (result.type === "batch") {
-          const batchPayments = await credentialsResolver.getPaymentRequestsByBatchIdQuery(
+          const batchPayments = await bank.getPaymentRequestsByBatchIdQuery(
             this.db,
             { batchId: result.batchId }
           );
@@ -1362,7 +1381,7 @@ exports.BankServiceBase = class BankServiceBase extends backendSdk.develitWorker
             accountId: acc.id
           }).command
         );
-        const encryptionKey = await credentialsResolver.importAesKey(
+        const encryptionKey = await bank.importAesKey(
           (await this.env.SECRETS_STORE.get({
             secretName: "BANK_SERVICE_ENCRYPTION_KEY"
           })).data?.secretValue || ""
@@ -1473,7 +1492,7 @@ exports.BankServiceBase = class BankServiceBase extends backendSdk.develitWorker
           debtor,
           debtorIban: debtor.iban
         };
-        const { command } = credentialsResolver.createPaymentCommand(this.db, { payment });
+        const { command } = bank.createPaymentCommand(this.db, { payment });
         const createdPayment = await command.execute().then(backendSdk.first);
         this.logQueuePush({ payment, isPaymentExecuted: true });
         await this.pushToQueue(this.env.QUEUE_BUS_QUEUE, {
@@ -1495,7 +1514,7 @@ exports.BankServiceBase = class BankServiceBase extends backendSdk.develitWorker
       { data: input, schema: sendPaymentInputSchema },
       { successMessage: "Payment initiated successfully" },
       async (data) => {
-        const incomingPayment = bank.toIncomingPayment(data);
+        const incomingPayment = paymentDirection.toIncomingPayment(data);
         this._validatePaymentTypeAndCurrency(
           data.paymentType,
           data.currency,
@@ -1503,7 +1522,7 @@ exports.BankServiceBase = class BankServiceBase extends backendSdk.develitWorker
         );
         if (data.creditor.bankCode?.length === 4 && !data.creditor.iban && data.creditor.number) {
           try {
-            data.creditor.iban = bank.calculateCzechIban(
+            data.creditor.iban = paymentDirection.calculateCzechIban(
               data.creditor.number,
               data.creditor.bankCode
             );
@@ -1545,11 +1564,11 @@ exports.BankServiceBase = class BankServiceBase extends backendSdk.develitWorker
             status: 422
           });
         }
-        const accountAssigned = bank.assignAccount(incomingPayment, account);
-        const batchedPayment = bank.toBatchedPayment(accountAssigned);
+        const accountAssigned = paymentDirection.assignAccount(incomingPayment, account);
+        const batchedPayment = paymentDirection.toBatchedPayment(accountAssigned);
         const { command: insertPaymentRequest } = createPaymentRequestCommand(
           this.db,
-          { paymentRequest: bank.toPaymentRequestInsert(accountAssigned, null) }
+          { paymentRequest: paymentDirection.toPaymentRequestInsert(accountAssigned, null) }
         );
         await insertPaymentRequest.execute();
         const initiate = () => {
@@ -1572,19 +1591,19 @@ exports.BankServiceBase = class BankServiceBase extends backendSdk.develitWorker
         try {
           initiated = await initiate();
         } catch (err) {
-          await credentialsResolver.updatePaymentRequestStatusCommand(this.db, {
+          await bank.updatePaymentRequestStatusCommand(this.db, {
             id: incomingPayment.id,
             deletedAt: /* @__PURE__ */ new Date()
           }).command.execute();
           throw err;
         }
-        await credentialsResolver.updatePaymentRequestStatusCommand(this.db, {
+        await bank.updatePaymentRequestStatusCommand(this.db, {
           id: incomingPayment.id,
           status: initiated.payment.status,
           bankRefId: initiated.payment.bankRefId,
           initiatedAt: initiated.payment.initiatedAt,
           authorizationUrl: initiated.authorizationUrl,
-          processedAt: bank.isProcessedStatus(initiated.payment.status) ? /* @__PURE__ */ new Date() : void 0
+          processedAt: paymentDirection.isProcessedStatus(initiated.payment.status) ? /* @__PURE__ */ new Date() : void 0
         }).command.execute();
         const paymentRequest = await getPaymentRequestByIdQuery(this.db, {
           paymentRequestId: incomingPayment.id
@@ -1690,13 +1709,13 @@ exports.BankServiceBase = class BankServiceBase extends backendSdk.develitWorker
             status: 422
           });
         }
-        const incomingPayments = paymentInputs.map(bank.toIncomingPayment);
+        const incomingPayments = paymentInputs.map(paymentDirection.toIncomingPayment);
         const batchedPayments = incomingPayments.map(
-          (p) => bank.toBatchedPayment(bank.assignAccount(p, account))
+          (p) => paymentDirection.toBatchedPayment(paymentDirection.assignAccount(p, account))
         );
         const batchId = backendSdk.uuidv4();
         const batchMode = connector.supportsBatch(paymentType) ? "NATIVE" : "SINGLE";
-        const batchCmd = credentialsResolver.upsertBatchCommand(this.db, {
+        const batchCmd = bank.upsertBatchCommand(this.db, {
           batch: {
             id: batchId,
             authorizationUrls: [],
@@ -1709,8 +1728,8 @@ exports.BankServiceBase = class BankServiceBase extends backendSdk.develitWorker
         }).command;
         const prCmds = incomingPayments.map(
           (p) => createPaymentRequestCommand(this.db, {
-            paymentRequest: bank.toPaymentRequestInsert(
-              bank.assignAccount(p, account),
+            paymentRequest: paymentDirection.toPaymentRequestInsert(
+              paymentDirection.assignAccount(p, account),
               batchId
             )
           }).command
@@ -1733,12 +1752,12 @@ exports.BankServiceBase = class BankServiceBase extends backendSdk.develitWorker
           result = await initiateBatch();
         } catch (err) {
           const deletePrCmds = incomingPayments.map(
-            (p) => credentialsResolver.updatePaymentRequestStatusCommand(this.db, {
+            (p) => bank.updatePaymentRequestStatusCommand(this.db, {
               id: p.id,
               deletedAt: /* @__PURE__ */ new Date()
             }).command
           );
-          const deleteBatchCmd = credentialsResolver.upsertBatchCommand(this.db, {
+          const deleteBatchCmd = bank.upsertBatchCommand(this.db, {
             batch: {
               id: batchId,
               accountId: account.id,
@@ -1753,16 +1772,16 @@ exports.BankServiceBase = class BankServiceBase extends backendSdk.develitWorker
         const { authorizationUrls, payments: preparedPayments } = result;
         const isPerPaymentFallback = authorizationUrls.length === preparedPayments.length;
         const updatePrCmds = preparedPayments.map(
-          (pp, i) => credentialsResolver.updatePaymentRequestStatusCommand(this.db, {
+          (pp, i) => bank.updatePaymentRequestStatusCommand(this.db, {
             id: pp.id,
             status: pp.status,
             bankRefId: pp.bankRefId,
             initiatedAt: pp.initiatedAt,
             authorizationUrl: isPerPaymentFallback ? authorizationUrls[i] : authorizationUrls[0],
-            processedAt: bank.isProcessedStatus(pp.status) ? /* @__PURE__ */ new Date() : void 0
+            processedAt: paymentDirection.isProcessedStatus(pp.status) ? /* @__PURE__ */ new Date() : void 0
           }).command
         );
-        const updateBatchCmd = credentialsResolver.upsertBatchCommand(this.db, {
+        const updateBatchCmd = bank.upsertBatchCommand(this.db, {
           batch: {
             id: batchId,
             accountId: account.id,
@@ -1775,8 +1794,8 @@ exports.BankServiceBase = class BankServiceBase extends backendSdk.develitWorker
         }).command;
         await this.db.batch([updateBatchCmd, ...updatePrCmds]);
         const [updatedBatch, paymentRequests] = await Promise.all([
-          credentialsResolver.getBatchByIdQuery(this.db, { batchId }),
-          credentialsResolver.getPaymentRequestsByBatchIdQuery(this.db, { batchId })
+          bank.getBatchByIdQuery(this.db, { batchId }),
+          bank.getPaymentRequestsByBatchIdQuery(this.db, { batchId })
         ]);
         if (!updatedBatch) {
           throw backendSdk.createInternalError(null, {
@@ -1848,11 +1867,11 @@ exports.BankServiceBase = class BankServiceBase extends backendSdk.develitWorker
             if (includePendingPaymentRequestCount) {
               const [row] = await this.db.select({
                 count: drizzleOrm.sql`count(*)`
-              }).from(bank.tables.paymentRequest).where(
+              }).from(paymentDirection.tables.paymentRequest).where(
                 drizzleOrm.and(
-                  drizzleOrm.eq(bank.tables.paymentRequest.accountId, a.id),
-                  drizzleOrm.eq(bank.tables.paymentRequest.status, "OPENED"),
-                  drizzleOrm.isNull(bank.tables.paymentRequest.deletedAt)
+                  drizzleOrm.eq(paymentDirection.tables.paymentRequest.accountId, a.id),
+                  drizzleOrm.eq(paymentDirection.tables.paymentRequest.status, "OPENED"),
+                  drizzleOrm.isNull(paymentDirection.tables.paymentRequest.deletedAt)
                 )
               );
               result.pendingPaymentRequestCount = row?.count ?? 0;
@@ -1872,7 +1891,7 @@ exports.BankServiceBase = class BankServiceBase extends backendSdk.develitWorker
       { data: input, schema: getAccountBalanceInputSchema },
       { successMessage: "Account balance retrieved successfully" },
       async (data) => {
-        const account = await credentialsResolver.getAccountByIdQuery(this.db, {
+        const account = await bank.getAccountByIdQuery(this.db, {
           accountId: data.accountId
         });
         if (!account) {
@@ -1924,7 +1943,7 @@ exports.BankServiceBase = class BankServiceBase extends backendSdk.develitWorker
       { data: input, schema: disconnectAccountInputSchema },
       { successMessage: "Account disconnected successfully" },
       async ({ accountId }) => {
-        const account = await credentialsResolver.getAccountByIdQuery(this.db, { accountId });
+        const account = await bank.getAccountByIdQuery(this.db, { accountId });
         if (!account) {
           throw backendSdk.createInternalError(null, {
             message: "Account not found",
@@ -1934,7 +1953,7 @@ exports.BankServiceBase = class BankServiceBase extends backendSdk.develitWorker
         }
         try {
           const instance = await this.env.SYNC_ACCOUNT_PAYMENTS_WORKFLOW.get(accountId);
-          await instance.terminate();
+          await terminateSyncWorkflow(instance);
         } catch (error) {
           this.log({
             message: "No workflow instance found for account, skipping termination.",
@@ -2043,14 +2062,14 @@ exports.BankServiceBase = class BankServiceBase extends backendSdk.develitWorker
     const privateKeyPem = (await this.env.SECRETS_STORE.get({
       secretName: "BANK_SERVICE_FINBRICKS_PRIVATE_KEY_PEM"
     })).data?.secretValue || "";
-    const client = new bank.FinbricksClient(
+    const client = new paymentDirection.FinbricksClient(
       this.env.FINBRICKS_BASE_URI,
       this.env.FINBRICKS_MERCHANT_ID,
       privateKeyPem,
       this.env.REDIRECT_URI
     );
     return client.request({
-      endpoint: bank.FINBRICKS_ENDPOINTS.BANK_INFO,
+      endpoint: paymentDirection.FINBRICKS_ENDPOINTS.BANK_INFO,
       method: "GET",
       query: {
         merchantId: this.env.FINBRICKS_MERCHANT_ID