@develit-services/bank 0.8.19 → 0.8.20

package/dist/export/worker.cjs

@@ -1,27 +1,26 @@
 'use strict';
 
 const backendSdk = require('@develit-io/backend-sdk');
-const drizzle = require('../shared/bank.Cev1E9sk.cjs');
+const database_schema = require('../shared/bank.o95cOH_P.cjs');
 const drizzleOrm = require('drizzle-orm');
 const cloudflare_workers = require('cloudflare:workers');
 const d1 = require('drizzle-orm/d1');
-const mock_connector = require('../shared/bank.C75Z9vML.cjs');
+const mock_connector = require('../shared/bank.DWsHTK_n.cjs');
 require('jose');
 const zod = require('zod');
-const paymentRequest_schema = require('../shared/bank.BBXoZ5QU.cjs');
 const generalCodes = require('@develit-io/general-codes');
 require('date-fns');
 require('node:crypto');
-require('../shared/bank.CVi6R7fr.cjs');
-require('drizzle-orm/relations');
+const credentialsResolver = require('../shared/bank.vGCuP898.cjs');
 require('drizzle-orm/sqlite-core');
+require('drizzle-orm/relations');
 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,
+  const command = db.insert(database_schema.tables.account).values({ ...account, id }).onConflictDoUpdate({
+    target: database_schema.tables.account.iban,
     set: accountWithoutId
     // preserve existing id on re-auth
   }).returning();
@@ -38,7 +37,7 @@ const createOneTimeTokenCommand = (db, {
 }) => {
   const id = backendSdk.uuidv4();
   const expiresAt = new Date(Date.now() + 1e3 * 60 * 60) ;
-  const command = db.insert(drizzle.tables.ott).values({
+  const command = db.insert(database_schema.tables.ott).values({
     id,
     oneTimeToken: ott,
     tokenType,
@@ -50,7 +49,7 @@ const createOneTimeTokenCommand = (db, {
 
 const updateAccountCommand = (db, { account }) => {
   return {
-    command: db.update(drizzle.tables.account).set({ ...account }).where(drizzleOrm.eq(drizzle.tables.account.id, account.id)).returning()
+    command: db.update(database_schema.tables.account).set({ ...account }).where(drizzleOrm.eq(database_schema.tables.account.id, account.id)).returning()
   };
 };
 
@@ -58,16 +57,16 @@ const expireOneTimeTokenCommand = (db, {
   ott
 }) => {
   return {
-    command: db.update(drizzle.tables.ott).set({
+    command: db.update(database_schema.tables.ott).set({
       expiresAt: /* @__PURE__ */ new Date()
-    }).where(drizzleOrm.eq(drizzle.tables.ott.oneTimeToken, ott))
+    }).where(drizzleOrm.eq(database_schema.tables.ott.oneTimeToken, ott))
   };
 };
 
 const createAccountCredentialsCommand = async (db, encryptionKey, { credentials }) => {
   const id = credentials.id || backendSdk.uuidv4();
-  const encryptedValue = await drizzle.encrypt(credentials.value, encryptionKey);
-  const command = db.insert(drizzle.tables.accountCredentials).values({
+  const encryptedValue = await credentialsResolver.encrypt(credentials.value, encryptionKey);
+  const command = db.insert(database_schema.tables.accountCredentials).values({
     ...credentials,
     id,
     value: encryptedValue
@@ -79,16 +78,16 @@ const createAccountCredentialsCommand = async (db, encryptionKey, { credentials
 };
 
 const deleteAccountCredentialsCommand = (db, { accountId }) => {
-  const command = db.delete(drizzle.tables.accountCredentials).where(drizzleOrm.eq(drizzle.tables.accountCredentials.accountId, accountId));
+  const command = db.delete(database_schema.tables.accountCredentials).where(drizzleOrm.eq(database_schema.tables.accountCredentials.accountId, accountId));
   return {
     command
   };
 };
 
 const deletePaymentsByAccountCommand = (db, { accountId }) => {
-  const command = db.update(drizzle.tables.payment).set({
+  const command = db.update(database_schema.tables.payment).set({
     deletedAt: /* @__PURE__ */ new Date()
-  }).where(drizzleOrm.eq(drizzle.tables.payment.accountId, accountId));
+  }).where(drizzleOrm.eq(database_schema.tables.payment.accountId, accountId));
   return {
     command
   };
@@ -96,7 +95,7 @@ const deletePaymentsByAccountCommand = (db, { accountId }) => {
 
 const createPaymentRequestCommand = (db, { paymentRequest }) => {
   return {
-    command: db.insert(drizzle.tables.paymentRequest).values({
+    command: db.insert(database_schema.tables.paymentRequest).values({
       ...paymentRequest,
       creditorIban: paymentRequest.creditor.iban,
       debtorIban: paymentRequest.debtor.iban
@@ -107,16 +106,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 ${drizzle.tables.batch.status} = 'PROCESSING' THEN 1 ELSE 0 END)`.as(
+    processingCount: drizzleOrm.sql`SUM(CASE WHEN ${database_schema.tables.batch.status} = 'PROCESSING' THEN 1 ELSE 0 END)`.as(
       "processingCount"
     ),
-    readyToSignCount: drizzleOrm.sql`SUM(CASE WHEN ${drizzle.tables.batch.status} = 'READY_TO_SIGN' THEN 1 ELSE 0 END)`.as(
+    readyToSignCount: drizzleOrm.sql`SUM(CASE WHEN ${database_schema.tables.batch.status} = 'READY_TO_SIGN' THEN 1 ELSE 0 END)`.as(
       "readyToSignCount"
     ),
-    failedCount: drizzleOrm.sql`SUM(CASE WHEN ${drizzle.tables.batch.status} = 'FAILED' THEN 1 ELSE 0 END)`.as(
+    failedCount: drizzleOrm.sql`SUM(CASE WHEN ${database_schema.tables.batch.status} = 'FAILED' THEN 1 ELSE 0 END)`.as(
       "failedCount"
     )
-  }).from(drizzle.tables.batch).where(drizzleOrm.eq(drizzle.tables.batch.accountId, accountId)).then(backendSdk.first);
+  }).from(database_schema.tables.batch).where(drizzleOrm.eq(database_schema.tables.batch.accountId, accountId)).then(backendSdk.first);
   return result || {
     totalCount: 0,
     processingCount: 0,
@@ -126,18 +125,18 @@ const getAccountBatchCountsQuery = async (db, { accountId }) => {
 };
 
 const getAccountByIbanQuery = async (db, { iban }) => {
-  return await db.select().from(drizzle.tables.account).where(drizzleOrm.eq(drizzle.tables.account.iban, iban)).get();
+  return await db.select().from(database_schema.tables.account).where(drizzleOrm.eq(database_schema.tables.account.iban, iban)).get();
 };
 
 const getAllAccountsQuery = async (db, filters) => {
   const whereConditions = drizzleOrm.and(
-    backendSdk.buildMultiFilterConditions(drizzle.tables.account.iban, filters?.filterIbans),
+    backendSdk.buildMultiFilterConditions(database_schema.tables.account.iban, filters?.filterIbans),
     backendSdk.buildMultiFilterConditions(
-      drizzle.tables.account.currency,
+      database_schema.tables.account.currency,
       filters?.filterCurrencies
     ),
     backendSdk.buildMultiFilterConditions(
-      drizzle.tables.account.bankRefId,
+      database_schema.tables.account.bankRefId,
       filters?.filterBankRefIds
     )
   );
@@ -145,11 +144,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(drizzle.tables.account).leftJoin(
-      drizzle.tables.accountCredentials,
-      drizzleOrm.eq(drizzle.tables.accountCredentials.accountId, drizzle.tables.account.id)
+    db.select().from(database_schema.tables.account).leftJoin(
+      database_schema.tables.accountCredentials,
+      drizzleOrm.eq(database_schema.tables.accountCredentials.accountId, database_schema.tables.account.id)
     ).where(whereConditions).limit(limit).offset(offset),
-    db.select({ count: drizzleOrm.sql`count(*)` }).from(drizzle.tables.account).where(whereConditions)
+    db.select({ count: drizzleOrm.sql`count(*)` }).from(database_schema.tables.account).where(whereConditions)
   ]);
   return {
     accounts: accountsWithExpiration.map(
@@ -211,42 +210,42 @@ const getPaymentsWithPaginationQuery = async (db, {
 }) => {
   const whereConditions = drizzleOrm.and(
     buildMultiFilterConditions(
-      drizzle.tables.payment.accountId,
+      database_schema.tables.payment.accountId,
       filterPaymentAccountId
     ),
-    buildMultiFilterConditions(drizzle.tables.payment.amount, filterPaymentAmount),
-    buildMultiFilterConditions(drizzle.tables.payment.currency, filterPaymentCurrency),
+    buildMultiFilterConditions(database_schema.tables.payment.amount, filterPaymentAmount),
+    buildMultiFilterConditions(database_schema.tables.payment.currency, filterPaymentCurrency),
     buildRangeFilterConditions(
-      drizzle.tables.payment.createdAt,
+      database_schema.tables.payment.createdAt,
       filterPaymentDateFrom,
       filterPaymentDateTo
     ),
-    buildMultiFilterConditions(drizzle.tables.payment.status, filterPaymentStatus),
+    buildMultiFilterConditions(database_schema.tables.payment.status, filterPaymentStatus),
     buildMultiFilterConditions(
-      drizzle.tables.payment.direction,
+      database_schema.tables.payment.direction,
       filterPaymentDirection
     ),
-    buildMultiFilterConditions(drizzle.tables.payment.id, ids),
-    buildMultiFilterConditions(drizzle.tables.payment.paymentType, filterPaymentType),
+    buildMultiFilterConditions(database_schema.tables.payment.id, ids),
+    buildMultiFilterConditions(database_schema.tables.payment.paymentType, filterPaymentType),
     buildRangeFilterConditions(
-      drizzle.tables.payment.amount,
+      database_schema.tables.payment.amount,
       filterPaymentMinAmount,
       filterPaymentMaxAmount
     ),
-    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,
-    filterPaymentBankRefId !== void 0 ? drizzleOrm.eq(drizzle.tables.payment.bankRefId, filterPaymentBankRefId) : void 0
+    filterPaymentVariableSymbol !== void 0 ? drizzleOrm.eq(database_schema.tables.payment.vs, filterPaymentVariableSymbol) : void 0,
+    filterPaymentSpecificSymbol !== void 0 ? drizzleOrm.eq(database_schema.tables.payment.ss, filterPaymentSpecificSymbol) : void 0,
+    filterPaymentConstantSymbol !== void 0 ? drizzleOrm.eq(database_schema.tables.payment.ks, filterPaymentConstantSymbol) : void 0,
+    filterPaymentMessage !== void 0 ? drizzleOrm.like(database_schema.tables.payment.message, `%${filterPaymentMessage}%`) : void 0,
+    filterPaymentCreditorIban !== void 0 ? drizzleOrm.eq(database_schema.tables.payment.creditorIban, filterPaymentCreditorIban) : void 0,
+    filterPaymentDebtorIban !== void 0 ? drizzleOrm.eq(database_schema.tables.payment.debtorIban, filterPaymentDebtorIban) : void 0,
+    filterPaymentBatchId !== void 0 ? drizzleOrm.eq(database_schema.tables.payment.batchId, filterPaymentBatchId) : void 0,
+    filterPaymentBankRefId !== void 0 ? drizzleOrm.eq(database_schema.tables.payment.bankRefId, filterPaymentBankRefId) : void 0
   );
-  const sortColumn = resolveColumn(drizzle.tables.payment, sort.column);
+  const sortColumn = resolveColumn(database_schema.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((page - 1) * limit).orderBy(sort.direction === "asc" ? drizzleOrm.asc(sortColumn) : drizzleOrm.desc(sortColumn));
+  }).from(database_schema.tables.payment).where(whereConditions);
+  const payments = await db.select().from(database_schema.tables.payment).where(whereConditions).limit(limit).offset((page - 1) * limit).orderBy(sort.direction === "asc" ? drizzleOrm.asc(sortColumn) : drizzleOrm.desc(sortColumn));
   return {
     payments,
     totalCount
@@ -261,20 +260,20 @@ const getBatchesQuery = async (db, {
   filterBatchStatus
 }) => {
   const whereConditions = drizzleOrm.and(
-    drizzleOrm.isNull(drizzle.tables.batch.deletedAt),
-    buildMultiFilterConditions(drizzle.tables.batch.accountId, filterBatchAccountId),
-    buildMultiFilterConditions(drizzle.tables.batch.status, filterBatchStatus)
+    drizzleOrm.isNull(database_schema.tables.batch.deletedAt),
+    buildMultiFilterConditions(database_schema.tables.batch.accountId, filterBatchAccountId),
+    buildMultiFilterConditions(database_schema.tables.batch.status, filterBatchStatus)
   );
-  const sortColumn = resolveColumn(drizzle.tables.batch, sort.column);
+  const sortColumn = resolveColumn(database_schema.tables.batch, sort.column);
   const [{ totalCount }] = await db.select({
     totalCount: drizzleOrm.sql`count(*)`
-  }).from(drizzle.tables.batch).where(whereConditions);
-  const batches = await db.select().from(drizzle.tables.batch).where(whereConditions).limit(limit).offset((page - 1) * limit).orderBy(sort.direction === "asc" ? drizzleOrm.asc(sortColumn) : drizzleOrm.desc(sortColumn));
+  }).from(database_schema.tables.batch).where(whereConditions);
+  const batches = await db.select().from(database_schema.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(drizzle.tables.paymentRequest).where(
+  const paymentRequests = batchIds.length > 0 ? await db.select().from(database_schema.tables.paymentRequest).where(
     drizzleOrm.and(
-      drizzleOrm.inArray(drizzle.tables.paymentRequest.batchId, batchIds),
-      drizzleOrm.isNull(drizzle.tables.paymentRequest.deletedAt)
+      drizzleOrm.inArray(database_schema.tables.paymentRequest.batchId, batchIds),
+      drizzleOrm.isNull(database_schema.tables.paymentRequest.deletedAt)
     )
   ) : [];
   const paymentRequestsByBatchId = Map.groupBy(
@@ -292,14 +291,14 @@ const getBatchesQuery = async (db, {
 };
 
 const getOttQuery = async (db, { ott }) => {
-  return await db.select().from(drizzle.tables.ott).where(drizzleOrm.eq(drizzle.tables.ott.oneTimeToken, ott)).get();
+  return await db.select().from(database_schema.tables.ott).where(drizzleOrm.eq(database_schema.tables.ott.oneTimeToken, ott)).get();
 };
 
 const getPaymentRequestByIdQuery = async (db, { paymentRequestId }) => {
-  const result = await db.select().from(drizzle.tables.paymentRequest).where(
+  const result = await db.select().from(database_schema.tables.paymentRequest).where(
     drizzleOrm.and(
-      drizzleOrm.eq(drizzle.tables.paymentRequest.id, paymentRequestId),
-      drizzleOrm.isNull(drizzle.tables.paymentRequest.deletedAt)
+      drizzleOrm.eq(database_schema.tables.paymentRequest.id, paymentRequestId),
+      drizzleOrm.isNull(database_schema.tables.paymentRequest.deletedAt)
     )
   ).limit(1);
   return backendSdk.first(result);
@@ -309,53 +308,63 @@ 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" ? drizzle.tables.paymentRequest.amount : params.sort.column === "updatedAt" ? drizzle.tables.paymentRequest.updatedAt : drizzle.tables.paymentRequest.createdAt;
+  const orderCol = params.sort.column === "amount" ? database_schema.tables.paymentRequest.amount : params.sort.column === "updatedAt" ? database_schema.tables.paymentRequest.updatedAt : database_schema.tables.paymentRequest.createdAt;
   const where = drizzleOrm.and(
-    drizzleOrm.isNull(drizzle.tables.paymentRequest.deletedAt),
-    params.filterAccountId ? Array.isArray(params.filterAccountId) ? drizzleOrm.inArray(drizzle.tables.paymentRequest.accountId, params.filterAccountId) : drizzleOrm.eq(drizzle.tables.paymentRequest.accountId, params.filterAccountId) : void 0,
-    params.filterStatus ? Array.isArray(params.filterStatus) ? drizzleOrm.inArray(drizzle.tables.paymentRequest.status, params.filterStatus) : drizzleOrm.eq(drizzle.tables.paymentRequest.status, params.filterStatus) : void 0,
-    params.filterPaymentType ? Array.isArray(params.filterPaymentType) ? drizzleOrm.inArray(drizzle.tables.paymentRequest.paymentType, params.filterPaymentType) : drizzleOrm.eq(drizzle.tables.paymentRequest.paymentType, params.filterPaymentType) : void 0,
-    params.filterCurrency ? Array.isArray(params.filterCurrency) ? drizzleOrm.inArray(drizzle.tables.paymentRequest.currency, params.filterCurrency) : drizzleOrm.eq(drizzle.tables.paymentRequest.currency, params.filterCurrency) : void 0,
-    params.filterBatchId ? drizzleOrm.eq(drizzle.tables.paymentRequest.batchId, params.filterBatchId) : void 0,
-    params.filterDateFrom ? drizzleOrm.gte(drizzle.tables.paymentRequest.createdAt, params.filterDateFrom) : void 0,
-    params.filterDateTo ? drizzleOrm.lte(drizzle.tables.paymentRequest.createdAt, params.filterDateTo) : void 0,
-    params.filterMinAmount !== void 0 ? drizzleOrm.gte(drizzle.tables.paymentRequest.amount, params.filterMinAmount) : void 0,
-    params.filterMaxAmount !== void 0 ? drizzleOrm.lte(drizzle.tables.paymentRequest.amount, params.filterMaxAmount) : void 0,
-    params.filterVariableSymbol ? drizzleOrm.eq(drizzle.tables.paymentRequest.vs, params.filterVariableSymbol) : void 0,
-    params.filterSpecificSymbol ? drizzleOrm.eq(drizzle.tables.paymentRequest.ss, params.filterSpecificSymbol) : void 0,
-    params.filterConstantSymbol ? drizzleOrm.eq(drizzle.tables.paymentRequest.ks, params.filterConstantSymbol) : void 0,
-    params.filterMessage ? drizzleOrm.like(drizzle.tables.paymentRequest.message, `%${params.filterMessage}%`) : void 0,
-    params.filterBankRefId ? drizzleOrm.eq(drizzle.tables.paymentRequest.bankRefId, params.filterBankRefId) : void 0,
-    params.filterCreditorIban ? drizzleOrm.eq(drizzle.tables.paymentRequest.creditorIban, params.filterCreditorIban) : void 0,
-    params.filterDebtorIban ? drizzleOrm.eq(drizzle.tables.paymentRequest.debtorIban, params.filterDebtorIban) : void 0,
-    params.ids?.length ? drizzleOrm.inArray(drizzle.tables.paymentRequest.id, params.ids) : void 0
+    drizzleOrm.isNull(database_schema.tables.paymentRequest.deletedAt),
+    params.filterAccountId ? Array.isArray(params.filterAccountId) ? drizzleOrm.inArray(database_schema.tables.paymentRequest.accountId, params.filterAccountId) : drizzleOrm.eq(database_schema.tables.paymentRequest.accountId, params.filterAccountId) : void 0,
+    params.filterStatus ? Array.isArray(params.filterStatus) ? drizzleOrm.inArray(database_schema.tables.paymentRequest.status, params.filterStatus) : drizzleOrm.eq(database_schema.tables.paymentRequest.status, params.filterStatus) : void 0,
+    params.filterPaymentType ? Array.isArray(params.filterPaymentType) ? drizzleOrm.inArray(database_schema.tables.paymentRequest.paymentType, params.filterPaymentType) : drizzleOrm.eq(database_schema.tables.paymentRequest.paymentType, params.filterPaymentType) : void 0,
+    params.filterCurrency ? Array.isArray(params.filterCurrency) ? drizzleOrm.inArray(database_schema.tables.paymentRequest.currency, params.filterCurrency) : drizzleOrm.eq(database_schema.tables.paymentRequest.currency, params.filterCurrency) : void 0,
+    params.filterBatchId ? drizzleOrm.eq(database_schema.tables.paymentRequest.batchId, params.filterBatchId) : void 0,
+    params.filterDateFrom ? drizzleOrm.gte(database_schema.tables.paymentRequest.createdAt, params.filterDateFrom) : void 0,
+    params.filterDateTo ? drizzleOrm.lte(database_schema.tables.paymentRequest.createdAt, params.filterDateTo) : void 0,
+    params.filterMinAmount !== void 0 ? drizzleOrm.gte(database_schema.tables.paymentRequest.amount, params.filterMinAmount) : void 0,
+    params.filterMaxAmount !== void 0 ? drizzleOrm.lte(database_schema.tables.paymentRequest.amount, params.filterMaxAmount) : void 0,
+    params.filterVariableSymbol ? drizzleOrm.eq(database_schema.tables.paymentRequest.vs, params.filterVariableSymbol) : void 0,
+    params.filterSpecificSymbol ? drizzleOrm.eq(database_schema.tables.paymentRequest.ss, params.filterSpecificSymbol) : void 0,
+    params.filterConstantSymbol ? drizzleOrm.eq(database_schema.tables.paymentRequest.ks, params.filterConstantSymbol) : void 0,
+    params.filterMessage ? drizzleOrm.like(database_schema.tables.paymentRequest.message, `%${params.filterMessage}%`) : void 0,
+    params.filterBankRefId ? drizzleOrm.eq(database_schema.tables.paymentRequest.bankRefId, params.filterBankRefId) : void 0,
+    params.filterCreditorIban ? drizzleOrm.eq(database_schema.tables.paymentRequest.creditorIban, params.filterCreditorIban) : void 0,
+    params.filterDebtorIban ? drizzleOrm.eq(database_schema.tables.paymentRequest.debtorIban, params.filterDebtorIban) : void 0,
+    params.ids?.length ? drizzleOrm.inArray(database_schema.tables.paymentRequest.id, params.ids) : void 0
   );
   const [paymentRequests, [{ value: totalCount }]] = await Promise.all([
-    db.select().from(drizzle.tables.paymentRequest).where(where).orderBy(orderDir(orderCol)).limit(limit).offset(offset),
-    db.select({ value: drizzleOrm.count() }).from(drizzle.tables.paymentRequest).where(where)
+    db.select().from(database_schema.tables.paymentRequest).where(where).orderBy(orderDir(orderCol)).limit(limit).offset(offset),
+    db.select({ value: drizzleOrm.count() }).from(database_schema.tables.paymentRequest).where(where)
   ]);
   return { paymentRequests, totalCount };
 };
 
-const TERMINAL_STATUSES = [
-  "SETTLED",
-  "REJECTED",
-  "CLOSED"
-];
-const getNonTerminalPaymentRequestsQuery = (db) => db.select().from(drizzle.tables.paymentRequest).where(
-  drizzleOrm.and(
-    drizzleOrm.not(drizzleOrm.inArray(drizzle.tables.paymentRequest.status, TERMINAL_STATUSES)),
-    drizzleOrm.isNull(drizzle.tables.paymentRequest.deletedAt)
-  )
-);
+const SIGNAL_MAP = {
+  OPENED: "paymentRequestOpened",
+  AUTHORIZED: "paymentRequestAuthorized",
+  COMPLETED: "paymentRequestCompleted",
+  BOOKED: "paymentRequestBooked",
+  SETTLED: "paymentRequestSettled",
+  REJECTED: "paymentRequestRejected",
+  CLOSED: "paymentRequestClosed"
+};
+function buildPaymentRequestEvent(pr) {
+  return {
+    eventType: "BANK_PAYMENT_REQUEST",
+    eventSignal: SIGNAL_MAP[pr.status],
+    paymentRequest: pr,
+    metadata: {
+      correlationId: pr.correlationId,
+      entityId: pr.id,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
 
 const sendPaymentInputSchema = zod.z.object({
   correlationId: zod.z.string().min(1),
   refId: zod.z.string().optional(),
   amount: zod.z.number().positive(),
-  paymentType: zod.z.enum(paymentRequest_schema.PAYMENT_TYPES),
-  chargeBearer: zod.z.enum(paymentRequest_schema.CHARGE_BEARERS).optional(),
-  instructionPriority: zod.z.enum(paymentRequest_schema.INSTRUCTION_PRIORITIES).optional(),
+  paymentType: zod.z.enum(database_schema.PAYMENT_TYPES),
+  chargeBearer: zod.z.enum(database_schema.CHARGE_BEARERS).optional(),
+  instructionPriority: zod.z.enum(database_schema.INSTRUCTION_PRIORITIES).optional(),
   currency: zod.z.enum(generalCodes.CURRENCY_CODES),
   vs: zod.z.string().optional(),
   ss: zod.z.string().optional(),
@@ -371,7 +380,7 @@ const sendBatchInputSchema = zod.z.object({
 });
 
 const getAuthUriInputSchema = zod.z.object({
-  connectorKey: zod.z.enum(paymentRequest_schema.CONNECTOR_KEYS)
+  connectorKey: zod.z.enum(database_schema.CONNECTOR_KEYS)
 });
 
 const authorizeAccountInputSchema = zod.z.object({
@@ -392,7 +401,7 @@ const simulateDepositInputSchema = zod.z.object({
   message: zod.z.string(),
   creditor: backendSdk.bankAccountMetadataSchema,
   debtor: backendSdk.bankAccountMetadataSchema,
-  connectorKey: zod.z.enum(paymentRequest_schema.CONNECTOR_KEYS)
+  connectorKey: zod.z.enum(database_schema.CONNECTOR_KEYS)
 });
 
 const ALLOWED_BATCH_FILTERS = {
@@ -407,7 +416,7 @@ const getBatchesInputSchema = zod.z.object({
     direction: zod.z.enum(["asc", "desc"])
   }),
   [ALLOWED_BATCH_FILTERS.ACCOUNT_ID]: zod.z.union([zod.z.uuid(), zod.z.uuid().array()]).optional(),
-  [ALLOWED_BATCH_FILTERS.STATUS]: zod.z.union([zod.z.enum(paymentRequest_schema.BATCH_STATUSES), zod.z.enum(paymentRequest_schema.BATCH_STATUSES).array()]).optional()
+  [ALLOWED_BATCH_FILTERS.STATUS]: zod.z.union([zod.z.enum(database_schema.BATCH_STATUSES), zod.z.enum(database_schema.BATCH_STATUSES).array()]).optional()
 });
 
 const processBatchInputSchema = zod.z.object({
@@ -465,11 +474,11 @@ const getPaymentsInputSchema = zod.z.object({
   [ALLOWED_PAYMENT_FILTERS.ACCOUNT_ID]: zod.z.union([zod.z.uuid(), zod.z.uuid().array()]).optional(),
   [ALLOWED_PAYMENT_FILTERS.AMOUNT]: zod.z.union([zod.z.number(), zod.z.number().array()]).optional(),
   [ALLOWED_PAYMENT_FILTERS.CURRENCY]: zod.z.union([zod.z.enum(generalCodes.CURRENCY_CODES), zod.z.enum(generalCodes.CURRENCY_CODES).array()]).optional(),
-  [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.DIRECTION]: zod.z.union([zod.z.enum(database_schema.PAYMENT_DIRECTIONS), zod.z.enum(database_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.PAYMENT_TYPE]: zod.z.union([zod.z.enum(paymentRequest_schema.PAYMENT_TYPES), zod.z.enum(paymentRequest_schema.PAYMENT_TYPES).array()]).optional(),
+  [ALLOWED_PAYMENT_FILTERS.STATUS]: zod.z.union([zod.z.enum(database_schema.PAYMENT_STATUSES), zod.z.enum(database_schema.PAYMENT_STATUSES).array()]).optional(),
+  [ALLOWED_PAYMENT_FILTERS.PAYMENT_TYPE]: zod.z.union([zod.z.enum(database_schema.PAYMENT_TYPES), zod.z.enum(database_schema.PAYMENT_TYPES).array()]).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(),
@@ -514,7 +523,7 @@ zod.z.object({
 });
 
 const updateAccountInputSchema = zod.z.object({
-  account: paymentRequest_schema.accountInsertSchema
+  account: database_schema.accountInsertSchema
 });
 
 const getBankAccountsInputSchema = zod.z.object({
@@ -545,10 +554,10 @@ const getPaymentRequestsInputSchema = zod.z.object({
   }),
   filterAccountId: zod.z.union([zod.z.uuid(), zod.z.uuid().array()]).optional(),
   filterStatus: zod.z.union([
-    zod.z.enum(paymentRequest_schema.PAYMENT_REQUEST_STATUSES),
-    zod.z.enum(paymentRequest_schema.PAYMENT_REQUEST_STATUSES).array()
+    zod.z.enum(database_schema.PAYMENT_REQUEST_STATUSES),
+    zod.z.enum(database_schema.PAYMENT_REQUEST_STATUSES).array()
   ]).optional(),
-  filterPaymentType: zod.z.union([zod.z.enum(paymentRequest_schema.PAYMENT_TYPES), zod.z.enum(paymentRequest_schema.PAYMENT_TYPES).array()]).optional(),
+  filterPaymentType: zod.z.union([zod.z.enum(database_schema.PAYMENT_TYPES), zod.z.enum(database_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(),
@@ -586,7 +595,7 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
     // 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: drizzle.tables });
+    this.db = d1.drizzle(this.env.BANK_D1, { schema: database_schema.tables });
   }
   async _getAccounts(filters) {
     return await getAllAccountsQuery(this.db, filters);
@@ -619,7 +628,7 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
         connectorKey: acc.connectorKey,
         bankRefId: acc.bankRefId
       }));
-      resolveCredentials = await drizzle.createCredentialsResolver(this.db, this.env);
+      resolveCredentials = await credentialsResolver.createCredentialsResolver(this.db, this.env);
     }
     return mock_connector.initiateConnector({
       bank: connectorKey,
@@ -760,31 +769,15 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
           const paymentId = pr.bankRefId ?? pr.id;
           const newStatus = await connector.getPaymentStatus({ paymentId });
           if (newStatus !== pr.status) {
-            await drizzle.updatePaymentRequestStatusCommand(this.db, {
+            await credentialsResolver.updatePaymentRequestStatusCommand(this.db, {
               id: pr.id,
               status: newStatus,
-              processedAt: newStatus === "COMPLETED" ? /* @__PURE__ */ new Date() : void 0
+              processedAt: database_schema.isProcessedStatus(newStatus) ? /* @__PURE__ */ new Date() : void 0
             }).command.execute();
             statusChanged++;
-            const signalMap = {
-              OPENED: "paymentRequestOpened",
-              AUTHORIZED: "paymentRequestAuthorized",
-              COMPLETED: "paymentRequestCompleted",
-              BOOKED: "paymentRequestBooked",
-              SETTLED: "paymentRequestSettled",
-              REJECTED: "paymentRequestRejected",
-              CLOSED: "paymentRequestClosed"
-            };
-            eventsToEmit.push({
-              eventType: "BANK_PAYMENT_REQUEST",
-              eventSignal: signalMap[newStatus],
-              paymentRequest: { ...pr, status: newStatus },
-              metadata: {
-                correlationId: pr.correlationId,
-                entityId: pr.id,
-                timestamp: (/* @__PURE__ */ new Date()).toISOString()
-              }
-            });
+            eventsToEmit.push(
+              buildPaymentRequestEvent({ ...pr, status: newStatus })
+            );
           }
           processed++;
         } catch (err) {
@@ -815,40 +808,25 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
    */
   async _deriveBatchStatus(batchId) {
     const [allPRs, batch] = await Promise.all([
-      drizzle.getPaymentRequestsByBatchIdQuery(this.db, { batchId }),
-      drizzle.getBatchByIdQuery(this.db, { batchId })
+      credentialsResolver.getPaymentRequestsByBatchIdQuery(this.db, { batchId }),
+      credentialsResolver.getBatchByIdQuery(this.db, { batchId })
     ]);
     if (!batch || batch.status === "COMPLETED" || batch.status === "FAILED")
       return;
     if (allPRs.length === 0) return;
-    const terminalStatuses = [
-      "SETTLED",
-      "REJECTED",
-      "CLOSED"
-    ];
-    const authorizedOrHigher = [
-      "AUTHORIZED",
-      "COMPLETED",
-      "BOOKED",
-      "SETTLED"
-    ];
     const allTerminal = allPRs.every(
-      (pr) => terminalStatuses.includes(pr.status)
-    );
-    const allAuthorizedOrHigher = allPRs.every(
-      (pr) => [...authorizedOrHigher, ...terminalStatuses].includes(
-        pr.status
-      )
+      (pr) => database_schema.isTerminalStatus(pr.status)
     );
+    const allAuthorizedOrHigher = allPRs.every((pr) => pr.status !== "OPENED");
     if (allTerminal) {
       const hasFailed = allPRs.some(
         (pr) => pr.status === "REJECTED" || pr.status === "CLOSED"
       );
-      await drizzle.upsertBatchCommand(this.db, {
+      await credentialsResolver.upsertBatchCommand(this.db, {
         batch: { ...batch, status: hasFailed ? "FAILED" : "COMPLETED" }
       }).command.execute();
     } else if (allAuthorizedOrHigher && batch.status !== "AUTHORIZED") {
-      await drizzle.upsertBatchCommand(this.db, {
+      await credentialsResolver.upsertBatchCommand(this.db, {
         batch: { ...batch, status: "AUTHORIZED" }
       }).command.execute();
     }
@@ -858,7 +836,7 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
       null,
       { successMessage: "Payment request statuses updated" },
       async () => {
-        const nonTerminalPRs = await getNonTerminalPaymentRequestsQuery(this.db);
+        const nonTerminalPRs = await database_schema.getNonTerminalPaymentRequestsQuery(this.db);
         if (nonTerminalPRs.length === 0) {
           return { processed: 0, statusChanged: 0 };
         }
@@ -868,7 +846,7 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
           const status = pr.status;
           if (status === "OPENED" || status === "AUTHORIZED") {
             if (pr.createdAt != null && now - pr.createdAt.getTime() > this.POLLING_TIMEOUT_MS) {
-              await drizzle.updatePaymentRequestStatusCommand(this.db, {
+              await credentialsResolver.updatePaymentRequestStatusCommand(this.db, {
                 id: pr.id,
                 status: "CLOSED",
                 statusReason: "Polling timeout: no final status received after 14 days",
@@ -910,7 +888,7 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
           });
           if (pr) connectorKey = pr.connectorKey;
         } else if (batchId) {
-          const batchPrs = await drizzle.getPaymentRequestsByBatchIdQuery(this.db, {
+          const batchPrs = await credentialsResolver.getPaymentRequestsByBatchIdQuery(this.db, {
             batchId
           });
           if (batchPrs.length > 0) connectorKey = batchPrs[0].connectorKey;
@@ -939,7 +917,7 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
           prIds.push(result.paymentRequestId);
         }
         if (result.type === "batch") {
-          const batchPayments = await drizzle.getPaymentRequestsByBatchIdQuery(
+          const batchPayments = await credentialsResolver.getPaymentRequestsByBatchIdQuery(
             this.db,
             { batchId: result.batchId }
           );
@@ -1090,7 +1068,7 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
             accountId: acc.id
           }).command
         );
-        const encryptionKey = await drizzle.importAesKey(
+        const encryptionKey = await credentialsResolver.importAesKey(
           (await this.env.SECRETS_STORE.get({
             secretName: "BANK_SERVICE_ENCRYPTION_KEY"
           })).data?.secretValue || ""
@@ -1201,7 +1179,7 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
           debtor,
           debtorIban: debtor.iban
         };
-        const { command } = drizzle.createPaymentCommand(this.db, { payment });
+        const { command } = credentialsResolver.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, {
@@ -1291,17 +1269,19 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
         try {
           initiated = await initiate();
         } catch (err) {
-          await drizzle.updatePaymentRequestStatusCommand(this.db, {
+          await credentialsResolver.updatePaymentRequestStatusCommand(this.db, {
             id: incomingPayment.id,
             deletedAt: /* @__PURE__ */ new Date()
           }).command.execute();
           throw err;
         }
-        await drizzle.updatePaymentRequestStatusCommand(this.db, {
+        await credentialsResolver.updatePaymentRequestStatusCommand(this.db, {
           id: incomingPayment.id,
+          status: initiated.payment.status,
           bankRefId: initiated.payment.bankRefId,
           initiatedAt: initiated.payment.initiatedAt,
-          authorizationUrl: initiated.authorizationUrl
+          authorizationUrl: initiated.authorizationUrl,
+          processedAt: database_schema.isProcessedStatus(initiated.payment.status) ? /* @__PURE__ */ new Date() : void 0
         }).command.execute();
         const paymentRequest = await getPaymentRequestByIdQuery(this.db, {
           paymentRequestId: incomingPayment.id
@@ -1313,6 +1293,12 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
             status: 500
           });
         }
+        if (initiated.payment.status !== "OPENED") {
+          await this.pushToQueue(
+            this.env.QUEUE_BUS_QUEUE,
+            buildPaymentRequestEvent(paymentRequest)
+          );
+        }
         return {
           paymentRequest,
           authorizationUrl: initiated.authorizationUrl
@@ -1405,7 +1391,7 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
         );
         const batchId = backendSdk.uuidv4();
         const batchMode = connector.supportsBatch(paymentType) ? "NATIVE" : "SINGLE";
-        const batchCmd = drizzle.upsertBatchCommand(this.db, {
+        const batchCmd = credentialsResolver.upsertBatchCommand(this.db, {
           batch: {
             id: batchId,
             authorizationUrls: [],
@@ -1442,12 +1428,12 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
           result = await initiateBatch();
         } catch (err) {
           const deletePrCmds = incomingPayments.map(
-            (p) => drizzle.updatePaymentRequestStatusCommand(this.db, {
+            (p) => credentialsResolver.updatePaymentRequestStatusCommand(this.db, {
               id: p.id,
               deletedAt: /* @__PURE__ */ new Date()
             }).command
           );
-          const deleteBatchCmd = drizzle.upsertBatchCommand(this.db, {
+          const deleteBatchCmd = credentialsResolver.upsertBatchCommand(this.db, {
             batch: {
               id: batchId,
               accountId: account.id,
@@ -1462,14 +1448,16 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
         const { authorizationUrls, payments: preparedPayments } = result;
         const isPerPaymentFallback = authorizationUrls.length === preparedPayments.length;
         const updatePrCmds = preparedPayments.map(
-          (pp, i) => drizzle.updatePaymentRequestStatusCommand(this.db, {
+          (pp, i) => credentialsResolver.updatePaymentRequestStatusCommand(this.db, {
             id: pp.id,
+            status: pp.status,
             bankRefId: pp.bankRefId,
             initiatedAt: pp.initiatedAt,
-            authorizationUrl: isPerPaymentFallback ? authorizationUrls[i] : authorizationUrls[0]
+            authorizationUrl: isPerPaymentFallback ? authorizationUrls[i] : authorizationUrls[0],
+            processedAt: database_schema.isProcessedStatus(pp.status) ? /* @__PURE__ */ new Date() : void 0
           }).command
         );
-        const updateBatchCmd = drizzle.upsertBatchCommand(this.db, {
+        const updateBatchCmd = credentialsResolver.upsertBatchCommand(this.db, {
           batch: {
             id: batchId,
             accountId: account.id,
@@ -1482,8 +1470,8 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
         }).command;
         await this.db.batch([updateBatchCmd, ...updatePrCmds]);
         const [updatedBatch, paymentRequests] = await Promise.all([
-          drizzle.getBatchByIdQuery(this.db, { batchId }),
-          drizzle.getPaymentRequestsByBatchIdQuery(this.db, { batchId })
+          credentialsResolver.getBatchByIdQuery(this.db, { batchId }),
+          credentialsResolver.getPaymentRequestsByBatchIdQuery(this.db, { batchId })
         ]);
         if (!updatedBatch) {
           throw backendSdk.createInternalError(null, {
@@ -1492,6 +1480,13 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
             status: 500
           });
         }
+        const prEvents = paymentRequests.filter((pr) => pr.status !== "OPENED").map((pr) => buildPaymentRequestEvent(pr));
+        if (prEvents.length > 0) {
+          await this.pushToQueue(
+            this.env.QUEUE_BUS_QUEUE,
+            prEvents
+          );
+        }
         return { ...updatedBatch, paymentRequests };
       }
     );
@@ -1548,11 +1543,11 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
             if (includePendingPaymentRequestCount) {
               const [row] = await this.db.select({
                 count: drizzleOrm.sql`count(*)`
-              }).from(drizzle.tables.paymentRequest).where(
+              }).from(database_schema.tables.paymentRequest).where(
                 drizzleOrm.and(
-                  drizzleOrm.eq(drizzle.tables.paymentRequest.accountId, a.id),
-                  drizzleOrm.eq(drizzle.tables.paymentRequest.status, "OPENED"),
-                  drizzleOrm.isNull(drizzle.tables.paymentRequest.deletedAt)
+                  drizzleOrm.eq(database_schema.tables.paymentRequest.accountId, a.id),
+                  drizzleOrm.eq(database_schema.tables.paymentRequest.status, "OPENED"),
+                  drizzleOrm.isNull(database_schema.tables.paymentRequest.deletedAt)
                 )
               );
               result.pendingPaymentRequestCount = row?.count ?? 0;
@@ -1594,7 +1589,7 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
       { data: input, schema: disconnectAccountInputSchema },
       { successMessage: "Account disconnected successfully" },
       async ({ accountId }) => {
-        const account = await drizzle.getAccountByIdQuery(this.db, { accountId });
+        const account = await credentialsResolver.getAccountByIdQuery(this.db, { accountId });
         if (!account) {
           throw backendSdk.createInternalError(null, {
             message: "Account not found",