@develit-services/bank 2.2.3 → 2.3.0

package/dist/shared/{bank.CmgGdN-q.mjs → bank.gVOunsjq.mjs}

@@ -1,10 +1,13 @@
-import { uuidv4, createInternalError, useResult } from '@develit-io/backend-sdk';
+import { uuidv4, createInternalError, useResult, bankAccount, base, structuredAddressSchema } from '@develit-io/backend-sdk';
+import { sqliteTable, text, integer, unique, real, index } from 'drizzle-orm/sqlite-core';
 import { format, parseISO } from 'date-fns';
-import { CURRENCY_CODES } from '@develit-io/general-codes';
-import './bank.C7MA33AX.mjs';
-import 'drizzle-orm';
 import { importPKCS8, SignJWT } from 'jose';
+import { z } from 'zod';
+import { COUNTRY_CODES_2, CURRENCY_CODES, BANK_CODES } from '@develit-io/general-codes';
+import { relations } from 'drizzle-orm/relations';
+import { and, not, inArray, isNull } from 'drizzle-orm';
 import 'node:crypto';
+import { createInsertSchema, createUpdateSchema, createSelectSchema } from 'drizzle-zod';
 
 function toIncomingPayment(input) {
   return {
@@ -667,7 +670,8 @@ class FinbricksConnector extends IBankConnector {
         connectorKey: this.PROVIDER,
         currency: acc.currency,
         iban: acc.identification.iban,
-        id: acc.id
+        id: acc.id,
+        config: null
       }))
     );
     return {
@@ -1074,6 +1078,40 @@ class CsobConnector extends FinbricksConnector {
   }
 }
 
+const PAYMENT_TYPES = ["SEPA", "SWIFT", "DOMESTIC", "UNKNOWN"];
+const CHARGE_BEARERS = ["SHA", "OUR", "BEN"];
+const INSTRUCTION_PRIORITIES = ["NORM", "HIGH", "INST"];
+const PAYMENT_REQUEST_STATUSES = [
+  "OPENED",
+  "AUTHORIZED",
+  "COMPLETED",
+  "BOOKED",
+  "SETTLED",
+  "REJECTED",
+  "CLOSED"
+];
+const PAYMENT_STATUSES = [
+  "PENDING",
+  "PROCESSING",
+  "BOOKED",
+  "CANCELLED",
+  "REJECTED",
+  "SCHEDULED",
+  "HOLD",
+  "INFO"
+];
+const PAYMENT_DIRECTIONS = ["INCOMING", "OUTGOING"];
+const BATCH_STATUSES = [
+  "PROCESSING",
+  "READY_TO_SIGN",
+  "AUTHORIZED",
+  "COMPLETED",
+  "FAILED"
+];
+const BATCH_MODES = ["NATIVE", "SINGLE"];
+const ACCOUNT_STATUSES = ["AUTHORIZED", "DISABLED", "EXPIRED"];
+const COUNTRY_CODES = COUNTRY_CODES_2;
+
 class AirBankConnector extends FinbricksConnector {
   constructor(config) {
     super("AIRBANK", config);
@@ -1332,6 +1370,14 @@ const calculateCzechIban = (accountNumber, bankCode) => {
   return `CZ${checkDigits}${basicIban}`;
 };
 
+const dbuAccountConfigSchema = z.object({
+  with4EyeApproval: z.enum(["Y", "N"]).default("Y"),
+  channelCode: z.string().default("WWW"),
+  actionTypeCode: z.string().default("TRANSFER"),
+  transactionTypeCode: z.string().default("TRANSFER"),
+  partialRealization: z.enum(["Y", "N"]).default("N"),
+  forceRealization: z.enum(["Y", "N"]).default("N")
+});
 class DbuConnector extends IBankConnector {
   constructor({
     BASE_URL,
@@ -1353,7 +1399,10 @@ class DbuConnector extends IBankConnector {
     this.api = API;
     this.redirectUri = REDIRECT_URI;
     this.txAuthUri = TX_AUTH_URI;
-    this.connectedAccounts = connectedAccounts;
+    this.connectedAccounts = connectedAccounts.map((acc) => ({
+      ...acc,
+      config: dbuAccountConfigSchema.parse(acc.config ?? {})
+    }));
     this.sessionId = uuidv4();
     this.allowedPostEndpoints = [
       "/required-transactions",
@@ -1608,7 +1657,7 @@ class DbuConnector extends IBankConnector {
     return [];
   }
   // ── Single payment methods ──────────────────────────────────────────
-  resolveIdAccountDebit(payment) {
+  resolveAccount(payment) {
     const account = this.connectedAccounts.find(
       (acc) => acc.id === payment.accountId
     );
@@ -1618,7 +1667,10 @@ class DbuConnector extends IBankConnector {
         code: "DBU_ACCOUNT_NOT_FOUND"
       });
     }
-    return Number(account.bankRefId);
+    return account;
+  }
+  resolveIdAccountDebit(payment) {
+    return Number(this.resolveAccount(payment).bankRefId);
   }
   resolveAccountDetails(account) {
     if (account.number && account.bankCode) {
@@ -1635,13 +1687,15 @@ class DbuConnector extends IBankConnector {
   }
   async initiateInstantPayment(payment) {
     const creditor = this.resolveAccountDetails(payment.creditor);
+    const debtorAccount = this.resolveAccount(payment);
+    const cfg = debtorAccount.config;
     const body = {
       accountNumberCredit: creditor.number,
-      idAccountDebit: this.resolveIdAccountDebit(payment),
+      idAccountDebit: Number(debtorAccount.bankRefId),
       bankCodeCredit: creditor.bankCode,
       amount: payment.amount,
       currencyCode: "CZK",
-      channelCode: "WWW",
+      channelCode: cfg.channelCode,
       textMessage: payment.message,
       varSymbol: payment.vs,
       specSymbol: payment.ss,
@@ -1675,6 +1729,7 @@ class DbuConnector extends IBankConnector {
     }
     const debtor = this.resolveAccountDetails(payment.debtor);
     const creditor = this.resolveAccountDetails(payment.creditor);
+    const cfg = this.resolveAccount(payment).config;
     const body = {
       accountNumberDebit: debtor.number,
       accountNumberCredit: creditor.number,
@@ -1682,20 +1737,20 @@ class DbuConnector extends IBankConnector {
       bankCodeCredit: creditor.bankCode,
       amount: payment.amount,
       currencyCode: "CZK",
-      actionTypeCode: "TRANSFER",
-      channelCode: "WWW",
+      actionTypeCode: cfg.actionTypeCode,
+      channelCode: cfg.channelCode,
       textMessage: payment.message,
-      transactionTypeCode: "TRANSFER",
+      transactionTypeCode: cfg.transactionTypeCode,
       validFrom: format(/* @__PURE__ */ new Date(), "yyyy-MM-dd"),
       validTo: null,
       subEntity: "DOMESTIC",
-      partialRealization: "N",
-      forceRealization: "N",
+      partialRealization: cfg.partialRealization,
+      forceRealization: cfg.forceRealization,
       varSymbol: payment.vs,
       specSymbol: payment.ss,
       constSymbol: payment.ks,
       uniqueExternalId: payment.id,
-      with4EyeApproval: "Y",
+      with4EyeApproval: cfg.with4EyeApproval,
       applicationCode: this.applicationCode
     };
     const response = await this.makeRequest(
@@ -1891,6 +1946,39 @@ class DbuConnector extends IBankConnector {
   }
 }
 
+const TERMINAL_STATUSES$1 = /* @__PURE__ */ new Set([
+  "SETTLED",
+  "REJECTED",
+  "CLOSED"
+]);
+const PENDING_STATUSES = /* @__PURE__ */ new Set([
+  "OPENED",
+  "AUTHORIZED"
+]);
+function isTerminalStatus(status) {
+  return TERMINAL_STATUSES$1.has(status);
+}
+function isPendingStatus(status) {
+  return PENDING_STATUSES.has(status);
+}
+function isProcessedStatus(status) {
+  return !isPendingStatus(status);
+}
+function hasPaymentAccountAssigned(payment) {
+  return "accountId" in payment && "connectorKey" in payment && payment.accountId !== void 0 && payment.connectorKey !== void 0;
+}
+function isPaymentCompleted(payment) {
+  return (payment.status === "COMPLETED" || payment.status === "BOOKED" || payment.status === "SETTLED" || payment.status === "REJECTED" || payment.status === "CLOSED") && "bankRefId" in payment && typeof payment.bankRefId === "string";
+}
+
+const TERMINAL_STATUSES = PAYMENT_REQUEST_STATUSES.filter(isTerminalStatus);
+const getNonTerminalPaymentRequestsQuery = (db) => db.select().from(tables.paymentRequest).where(
+  and(
+    not(inArray(tables.paymentRequest.status, TERMINAL_STATUSES)),
+    isNull(tables.paymentRequest.deletedAt)
+  )
+);
+
 class ErsteConnector extends IBankConnector {
   constructor(config) {
     super();
@@ -2305,4 +2393,254 @@ class MockConnector extends IBankConnector {
   }
 }
 
-export { CsobConnector as C, DbuConnector as D, ErsteConnector as E, FINBRICKS_ENDPOINTS as F, IBankConnector as I, KBConnector as K, MockCobsConnector as M, FinbricksClient as a, FinbricksConnector as b, MockConnector as c, assignAccount as d, toBatchedPaymentFromPaymentRequest as e, toCompletedPayment as f, toIncomingPayment as g, toPaymentRequestInsert as h, toPreparedPayment as i, initiateConnector as j, signFinbricksJws as s, toBatchedPayment as t, useFinbricksFetch as u };
+const CONNECTOR_KEYS = [
+  "ERSTE",
+  "FINBRICKS",
+  "MOCK",
+  "CREDITAS",
+  "MOCK_COBS",
+  "FIO",
+  "MONETA",
+  "DBU",
+  "CSAS",
+  "AIRBANK",
+  "KB",
+  "CSOB"
+];
+const CREDENTIALS_TYPES = [
+  "AUTH_TOKEN",
+  "REFRESH_TOKEN",
+  "CLIENT_ID",
+  "API_KEY"
+];
+const TOKEN_TYPES = ["ACCOUNT_AUTHORIZATION"];
+
+const account = sqliteTable(
+  "account",
+  {
+    ...base,
+    ...bankAccount,
+    // countryCode is temporary until bankAccount is update to include US country code
+    countryCode: text("country_code", { enum: COUNTRY_CODES }).$type().notNull(),
+    number: text("number").notNull(),
+    name: text("name"),
+    iban: text("iban").notNull(),
+    bankCode: text("bank_code", { enum: BANK_CODES }).notNull(),
+    connectorKey: text("connector_key", {
+      enum: CONNECTOR_KEYS
+    }).$type().notNull(),
+    status: text("status", { enum: ACCOUNT_STATUSES }).$type().notNull(),
+    bankRefId: text("bank_ref_id").notNull(),
+    batchSizeLimit: integer("batch_size_limit").notNull().default(50),
+    syncIntervalS: integer("sync_interval_s").notNull().default(600),
+    lastSyncAt: integer("last_sync_at", { mode: "timestamp_ms" }),
+    lastSyncMetadata: text("last_sync_metadata", {
+      mode: "json"
+    }).$type(),
+    connectorConfig: text("connector_config", {
+      mode: "json"
+    }).$type()
+  },
+  (t) => [unique().on(t.iban)]
+);
+
+const accountInsertSchema = createInsertSchema(account, {
+  address: () => structuredAddressSchema.optional()
+});
+const accountUpdateSchema = createUpdateSchema(account, {
+  address: () => structuredAddressSchema.optional()
+});
+const accountSelectSchema = createSelectSchema(account, {
+  address: () => structuredAddressSchema.nullable()
+});
+
+const accountCredentials = sqliteTable("account_credentials", {
+  ...base,
+  accountId: text("account_id").references(() => account.id, { onDelete: "restrict", onUpdate: "cascade" }).notNull(),
+  connectorKey: text("connector_key", {
+    enum: CONNECTOR_KEYS
+  }).$type().notNull(),
+  type: text("type", {
+    enum: CREDENTIALS_TYPES
+  }).$type().notNull(),
+  value: text("value").notNull(),
+  expiresAt: integer("expires_at", { mode: "timestamp_ms" }).notNull()
+});
+
+const accountCredentialsInsertSchema = createInsertSchema(accountCredentials);
+const accountCredentialsUpdateSchema = createUpdateSchema(accountCredentials);
+const accountCredentialsSelectSchema = createSelectSchema(accountCredentials);
+
+const ott = sqliteTable("ott", {
+  ...base,
+  oneTimeToken: text("one_time_token").notNull(),
+  refId: text("ref_id").notNull(),
+  tokenType: text("token_type", { enum: TOKEN_TYPES }).$type().notNull(),
+  expiresAt: integer("expires_at", { mode: "timestamp_ms" }).notNull()
+});
+
+const ottInsertSchema = createInsertSchema(ott);
+const ottUpdateSchema = createUpdateSchema(ott);
+const ottSelectSchema = createSelectSchema(ott);
+
+const batch = sqliteTable("batch", {
+  ...base,
+  batchPaymentInitiatedAt: integer("batch_payment_initiated_at", {
+    mode: "timestamp_ms"
+  }),
+  authorizationUrls: text("authorization_urls", { mode: "json" }).$type(),
+  accountId: text("account_id").references(() => account.id, {
+    onDelete: "restrict",
+    onUpdate: "cascade"
+  }),
+  status: text("status", { enum: BATCH_STATUSES }).$type(),
+  statusReason: text("status_reason"),
+  statusResponse: text("status_response", { mode: "json" }).$type(),
+  metadata: text("metadata", { mode: "json" }).$type(),
+  paymentType: text("payment_type", {
+    enum: PAYMENT_TYPES
+  }).$type(),
+  paymentsChecksum: text("payments_checksum"),
+  batchMode: text("batch_mode", { enum: BATCH_MODES }).$type()
+});
+
+const payment = sqliteTable(
+  "payment",
+  {
+    ...base,
+    correlationId: text("correlation_id").notNull(),
+    refId: text("ref_id"),
+    bankRefId: text("bank_ref_id").notNull(),
+    accountId: text("account_id").references(() => account.id, {
+      onDelete: "restrict",
+      onUpdate: "cascade"
+    }).notNull(),
+    connectorKey: text("connector_key", { enum: CONNECTOR_KEYS }).$type().notNull(),
+    amount: real("amount").notNull(),
+    direction: text("direction").$type().notNull(),
+    paymentType: text("payment_type").$type().notNull(),
+    currency: text("currency").$type().notNull(),
+    status: text("status", { enum: PAYMENT_STATUSES }).$type().notNull(),
+    statusReason: text("status_reason"),
+    batchId: text("bank_execution_batch_id"),
+    initiatedAt: integer("initiated_at", {
+      mode: "timestamp_ms"
+    }),
+    vs: text("vs"),
+    ss: text("ss"),
+    ks: text("ks"),
+    message: text("message"),
+    chargeBearer: text("charge_bearer", {
+      enum: CHARGE_BEARERS
+    }).$type(),
+    instructionPriority: text("instruction_priority", {
+      enum: INSTRUCTION_PRIORITIES
+    }).$type(),
+    processedAt: integer("processed_at", {
+      mode: "timestamp_ms"
+    }),
+    creditor: text("creditor", { mode: "json" }).$type().notNull(),
+    creditorIban: text("creditor_iban"),
+    debtor: text("debtor", { mode: "json" }).$type().notNull(),
+    debtorIban: text("debtor_iban")
+  },
+  (t) => [
+    unique().on(t.connectorKey, t.accountId, t.bankRefId),
+    index("payment_account_id_idx").on(t.accountId),
+    index("payment_account_id_status_idx").on(t.accountId, t.status),
+    index("payment_account_id_created_at_idx").on(t.accountId, t.createdAt),
+    index("payment_created_at_idx").on(t.createdAt),
+    index("payment_direction_idx").on(t.direction),
+    index("payment_batch_id_idx").on(t.batchId),
+    index("payment_creditor_iban_idx").on(t.creditorIban),
+    index("payment_debtor_iban_idx").on(t.debtorIban)
+  ]
+);
+const paymentRelations = relations(payment, ({ one }) => ({
+  batch: one(batch, { fields: [payment.batchId], references: [batch.id] })
+}));
+
+const paymentRequest = sqliteTable(
+  "payment_request",
+  {
+    ...base,
+    batchId: text("batch_id").references(() => batch.id, {
+      onDelete: "restrict",
+      onUpdate: "cascade"
+    }),
+    accountId: text("account_id").references(() => account.id, {
+      onDelete: "restrict",
+      onUpdate: "cascade"
+    }).notNull(),
+    correlationId: text("correlation_id").notNull(),
+    refId: text("ref_id"),
+    bankRefId: text("bank_ref_id"),
+    connectorKey: text("connector_key", { enum: CONNECTOR_KEYS }).$type().notNull(),
+    amount: real("amount").notNull(),
+    paymentType: text("payment_type", { enum: PAYMENT_TYPES }).$type().notNull(),
+    currency: text("currency").$type().notNull(),
+    status: text("status", { enum: PAYMENT_REQUEST_STATUSES }).$type().notNull(),
+    statusReason: text("status_reason"),
+    authorizationUrl: text("authorization_url"),
+    initiatedAt: integer("initiated_at", { mode: "timestamp_ms" }),
+    processedAt: integer("processed_at", { mode: "timestamp_ms" }),
+    vs: text("vs"),
+    ss: text("ss"),
+    ks: text("ks"),
+    message: text("message"),
+    chargeBearer: text("charge_bearer", {
+      enum: CHARGE_BEARERS
+    }).$type(),
+    instructionPriority: text("instruction_priority", {
+      enum: INSTRUCTION_PRIORITIES
+    }).$type(),
+    creditor: text("creditor", { mode: "json" }).$type().notNull(),
+    creditorIban: text("creditor_iban"),
+    debtor: text("debtor", { mode: "json" }).$type().notNull(),
+    debtorIban: text("debtor_iban"),
+    sendAsSinglePayment: integer("send_as_single_payment", {
+      mode: "boolean"
+    })
+  },
+  (t) => [
+    index("payment_request_batch_id_idx").on(t.batchId),
+    index("payment_request_account_id_idx").on(t.accountId),
+    index("payment_request_creditor_iban_idx").on(t.creditorIban),
+    index("payment_request_debtor_iban_idx").on(t.debtorIban),
+    index("payment_request_status_idx").on(t.status),
+    index("payment_request_created_at_idx").on(t.createdAt),
+    index("payment_request_account_status_idx").on(t.accountId, t.status),
+    index("payment_request_status_created_at_idx").on(t.status, t.createdAt),
+    index("payment_request_account_status_created_at_idx").on(
+      t.accountId,
+      t.status,
+      t.createdAt
+    )
+  ]
+);
+const paymentRequestRelations = relations(paymentRequest, ({ one }) => ({
+  batch: one(batch, {
+    fields: [paymentRequest.batchId],
+    references: [batch.id]
+  }),
+  account: one(account, {
+    fields: [paymentRequest.accountId],
+    references: [account.id]
+  })
+}));
+
+const schema = {
+  __proto__: null,
+  account: account,
+  accountCredentials: accountCredentials,
+  batch: batch,
+  ott: ott,
+  payment: payment,
+  paymentRelations: paymentRelations,
+  paymentRequest: paymentRequest,
+  paymentRequestRelations: paymentRequestRelations
+};
+
+const tables = schema;
+
+export { ott as $, ACCOUNT_STATUSES as A, BATCH_MODES as B, CHARGE_BEARERS as C, DbuConnector as D, ErsteConnector as E, FINBRICKS_ENDPOINTS as F, ottSelectSchema as G, ottUpdateSchema as H, IBankConnector as I, signFinbricksJws as J, KBConnector as K, toBatchedPayment as L, MockCobsConnector as M, toBatchedPaymentFromPaymentRequest as N, toCompletedPayment as O, PAYMENT_DIRECTIONS as P, toIncomingPayment as Q, toPaymentRequestInsert as R, toPreparedPayment as S, TOKEN_TYPES as T, useFinbricksFetch as U, tables as V, initiateConnector as W, getNonTerminalPaymentRequestsQuery as X, account as Y, accountCredentials as Z, batch as _, BATCH_STATUSES as a, payment as a0, paymentRelations as a1, paymentRequest as a2, paymentRequestRelations as a3, CONNECTOR_KEYS as b, COUNTRY_CODES as c, CREDENTIALS_TYPES as d, CsobConnector as e, FinbricksClient as f, FinbricksConnector as g, INSTRUCTION_PRIORITIES as h, MockConnector as i, PAYMENT_REQUEST_STATUSES as j, PAYMENT_STATUSES as k, PAYMENT_TYPES as l, accountCredentialsInsertSchema as m, accountCredentialsSelectSchema as n, accountCredentialsUpdateSchema as o, accountInsertSchema as p, accountSelectSchema as q, accountUpdateSchema as r, assignAccount as s, dbuAccountConfigSchema as t, hasPaymentAccountAssigned as u, isPaymentCompleted as v, isPendingStatus as w, isProcessedStatus as x, isTerminalStatus as y, ottInsertSchema as z };

package/dist/types.cjs

@@ -1,39 +1,20 @@
 'use strict';
 
-const mock_connector = require('./shared/bank.CQfKMyzc.cjs');
-const database_schema = require('./shared/bank.CIWYI18z.cjs');
+const database_schema = require('./shared/bank.avgw-IRO.cjs');
 const batchLifecycle = require('./shared/bank.NF8bZBy0.cjs');
 const generalCodes = require('@develit-io/general-codes');
 require('@develit-io/backend-sdk');
+require('drizzle-orm/sqlite-core');
 require('date-fns');
-require('drizzle-orm');
 require('jose');
-require('node:crypto');
-require('drizzle-orm/sqlite-core');
+require('zod');
 require('drizzle-orm/relations');
+require('drizzle-orm');
+require('node:crypto');
 require('drizzle-zod');
 
 
 
-exports.CsobConnector = mock_connector.CsobConnector;
-exports.DbuConnector = mock_connector.DbuConnector;
-exports.ErsteConnector = mock_connector.ErsteConnector;
-exports.FINBRICKS_ENDPOINTS = mock_connector.FINBRICKS_ENDPOINTS;
-exports.FinbricksClient = mock_connector.FinbricksClient;
-exports.FinbricksConnector = mock_connector.FinbricksConnector;
-exports.IBankConnector = mock_connector.IBankConnector;
-exports.KBConnector = mock_connector.KBConnector;
-exports.MockCobsConnector = mock_connector.MockCobsConnector;
-exports.MockConnector = mock_connector.MockConnector;
-exports.assignAccount = mock_connector.assignAccount;
-exports.signFinbricksJws = mock_connector.signFinbricksJws;
-exports.toBatchedPayment = mock_connector.toBatchedPayment;
-exports.toBatchedPaymentFromPaymentRequest = mock_connector.toBatchedPaymentFromPaymentRequest;
-exports.toCompletedPayment = mock_connector.toCompletedPayment;
-exports.toIncomingPayment = mock_connector.toIncomingPayment;
-exports.toPaymentRequestInsert = mock_connector.toPaymentRequestInsert;
-exports.toPreparedPayment = mock_connector.toPreparedPayment;
-exports.useFinbricksFetch = mock_connector.useFinbricksFetch;
 exports.ACCOUNT_STATUSES = database_schema.ACCOUNT_STATUSES;
 exports.BATCH_MODES = database_schema.BATCH_MODES;
 exports.BATCH_STATUES = database_schema.BATCH_STATUSES;
@@ -42,7 +23,17 @@ exports.CHARGE_BEARERS = database_schema.CHARGE_BEARERS;
 exports.CONNECTOR_KEYS = database_schema.CONNECTOR_KEYS;
 exports.COUNTRY_CODES = database_schema.COUNTRY_CODES;
 exports.CREDENTIALS_TYPES = database_schema.CREDENTIALS_TYPES;
+exports.CsobConnector = database_schema.CsobConnector;
+exports.DbuConnector = database_schema.DbuConnector;
+exports.ErsteConnector = database_schema.ErsteConnector;
+exports.FINBRICKS_ENDPOINTS = database_schema.FINBRICKS_ENDPOINTS;
+exports.FinbricksClient = database_schema.FinbricksClient;
+exports.FinbricksConnector = database_schema.FinbricksConnector;
+exports.IBankConnector = database_schema.IBankConnector;
 exports.INSTRUCTION_PRIORITIES = database_schema.INSTRUCTION_PRIORITIES;
+exports.KBConnector = database_schema.KBConnector;
+exports.MockCobsConnector = database_schema.MockCobsConnector;
+exports.MockConnector = database_schema.MockConnector;
 exports.PAYMENT_DIRECTIONS = database_schema.PAYMENT_DIRECTIONS;
 exports.PAYMENT_REQUEST_STATUSES = database_schema.PAYMENT_REQUEST_STATUSES;
 exports.PAYMENT_STATUSES = database_schema.PAYMENT_STATUSES;
@@ -54,6 +45,8 @@ exports.accountCredentialsUpdateSchema = database_schema.accountCredentialsUpdat
 exports.accountInsertSchema = database_schema.accountInsertSchema;
 exports.accountSelectSchema = database_schema.accountSelectSchema;
 exports.accountUpdateSchema = database_schema.accountUpdateSchema;
+exports.assignAccount = database_schema.assignAccount;
+exports.dbuAccountConfigSchema = database_schema.dbuAccountConfigSchema;
 exports.hasPaymentAccountAssigned = database_schema.hasPaymentAccountAssigned;
 exports.isPaymentCompleted = database_schema.isPaymentCompleted;
 exports.isPendingStatus = database_schema.isPendingStatus;
@@ -62,6 +55,14 @@ exports.isTerminalStatus = database_schema.isTerminalStatus;
 exports.ottInsertSchema = database_schema.ottInsertSchema;
 exports.ottSelectSchema = database_schema.ottSelectSchema;
 exports.ottUpdateSchema = database_schema.ottUpdateSchema;
+exports.signFinbricksJws = database_schema.signFinbricksJws;
+exports.toBatchedPayment = database_schema.toBatchedPayment;
+exports.toBatchedPaymentFromPaymentRequest = database_schema.toBatchedPaymentFromPaymentRequest;
+exports.toCompletedPayment = database_schema.toCompletedPayment;
+exports.toIncomingPayment = database_schema.toIncomingPayment;
+exports.toPaymentRequestInsert = database_schema.toPaymentRequestInsert;
+exports.toPreparedPayment = database_schema.toPreparedPayment;
+exports.useFinbricksFetch = database_schema.useFinbricksFetch;
 exports.isBatchAuthorized = batchLifecycle.isBatchAuthorized;
 exports.isBatchCompleted = batchLifecycle.isBatchCompleted;
 exports.isBatchFailed = batchLifecycle.isBatchFailed;

package/dist/types.d.cts

@@ -1,12 +1,12 @@
-import { I as IBankConnector, b as ConnectorKey, f as ConnectedAccount, c as PaymentType, g as CredentialsResolver, h as AccountCredentialsInsertType, i as AccountInsertType, j as BatchedPayment, k as InitiatedBatch, l as IncomingPayment, m as InitiatedPayment, A as AccountSelectType, n as ParsedBankPayment, o as PaymentRequestStatus, p as AuthorizationCallbackResult, q as BatchMetadata, r as Currency, a as PaymentSelectType, P as PaymentRequestSelectType, s as AccountAssignedPayment, u as PreparedPayment, v as CompletedPayment, w as PaymentRequestInsertType } from './shared/bank.COez_hEH.cjs';
-export { x as ACCOUNT_STATUSES, y as AccountCredentialsPatchType, z as AccountCredentialsSelectType, D as AccountCredentialsUpdateType, E as AccountPatchType, F as AccountStatus, G as AccountUpdateType, J as AuthorizedBatch, K as BATCH_MODES, M as BATCH_STATUES, M as BATCH_STATUSES, N as BankAccountWithLastSync, O as BankCode, Q as BatchInsertType, R as BatchLifecycle, S as BatchMode, T as BatchPayment, B as BatchSelectType, U as BatchStatus, V as CHARGE_BEARERS, W as CONNECTOR_KEYS, X as COUNTRY_CODES, Y as CREDENTIALS_TYPES, Z as ChargeBearer, _ as CompletedBatch, C as ConfigEnvironmentBank, $ as CountryCode, a0 as CredentialsType, d as CurrencyCode, a1 as INSTRUCTION_PRIORITIES, a2 as InstructionPriority, L as LastSyncMetadata, a3 as PAYMENT_DIRECTIONS, a4 as PAYMENT_REQUEST_STATUSES, a5 as PAYMENT_STATUSES, a6 as PAYMENT_TYPES, a7 as PaymentDirection, a8 as PaymentFailedInsertType, a9 as PaymentInsertType, aa as PaymentLifecycle, ab as PaymentPreparedInsertType, ac as PaymentStatus, ad as ProcessingBatch, ae as ReadyToSignBatch, af as ResolvedCredentials, ag as TOKEN_TYPES, ah as TokenType, ai as accountCredentialsInsertSchema, aj as accountCredentialsSelectSchema, ak as accountCredentialsUpdateSchema, al as accountInsertSchema, am as accountSelectSchema, an as accountUpdateSchema, ao as hasPaymentAccountAssigned, ap as isBatchAuthorized, aq as isBatchCompleted, ar as isBatchFailed, as as isBatchInitiated, at as isBatchProcessing, au as isBatchReadyToSign, av as isPaymentCompleted, aw as isPendingStatus, ax as isProcessedStatus, ay as isTerminalStatus } from './shared/bank.COez_hEH.cjs';
-import { d as FinbricksAccount, R as ReferenceType, S as SendPaymentInput } from './shared/bank.Cw3K7nIh.cjs';
-export { e as FinbricksAccountTransactionsResponse, f as FinbricksAccountsListResponse, g as FinbricksAuthTokenResponse, h as FinbricksBatchResponse, i as FinbricksConnectAccountResponse, j as FinbricksPaymentResponse, k as FinbricksSupportedBank, F as FinbricksSupportedBanksResponse, b as SendPaymentSyncInput } from './shared/bank.Cw3K7nIh.cjs';
+import { I as IBankConnector, c as ConnectorKey, g as ConnectedAccount, d as PaymentType, h as CredentialsResolver, i as AccountCredentialsInsertType, j as AccountInsertType, k as BatchedPayment, l as InitiatedBatch, m as IncomingPayment, n as InitiatedPayment, A as AccountSelectType, o as ParsedBankPayment, p as PaymentRequestStatus, q as AuthorizationCallbackResult, r as BatchMetadata, s as Currency, a as PaymentSelectType, P as PaymentRequestSelectType, u as AccountAssignedPayment, v as PreparedPayment, w as CompletedPayment, x as PaymentRequestInsertType } from './shared/bank.CC4p6Jf-.cjs';
+export { y as ACCOUNT_STATUSES, z as AccountCredentialsPatchType, D as AccountCredentialsSelectType, E as AccountCredentialsUpdateType, F as AccountPatchType, G as AccountStatus, J as AccountUpdateType, K as AuthorizedBatch, M as BATCH_MODES, N as BATCH_STATUES, N as BATCH_STATUSES, O as BankAccountWithLastSync, Q as BankCode, R as BatchInsertType, S as BatchLifecycle, T as BatchMode, U as BatchPayment, B as BatchSelectType, V as BatchStatus, W as CHARGE_BEARERS, X as CONNECTOR_KEYS, Y as COUNTRY_CODES, Z as CREDENTIALS_TYPES, _ as ChargeBearer, $ as CompletedBatch, b as ConfigEnvironmentBank, C as ConnectorConfig, a0 as CountryCode, a1 as CredentialsType, e as CurrencyCode, a2 as INSTRUCTION_PRIORITIES, a3 as InstructionPriority, L as LastSyncMetadata, a4 as PAYMENT_DIRECTIONS, a5 as PAYMENT_REQUEST_STATUSES, a6 as PAYMENT_STATUSES, a7 as PAYMENT_TYPES, a8 as PaymentDirection, a9 as PaymentFailedInsertType, aa as PaymentInsertType, ab as PaymentLifecycle, ac as PaymentPreparedInsertType, ad as PaymentStatus, ae as ProcessingBatch, af as ReadyToSignBatch, ag as ResolvedCredentials, ah as TOKEN_TYPES, ai as TokenType, aj as accountCredentialsInsertSchema, ak as accountCredentialsSelectSchema, al as accountCredentialsUpdateSchema, am as accountInsertSchema, an as accountSelectSchema, ao as accountUpdateSchema, ap as hasPaymentAccountAssigned, aq as isBatchAuthorized, ar as isBatchCompleted, as as isBatchFailed, at as isBatchInitiated, au as isBatchProcessing, av as isBatchReadyToSign, aw as isPaymentCompleted, ax as isPendingStatus, ay as isProcessedStatus, az as isTerminalStatus } from './shared/bank.CC4p6Jf-.cjs';
+import { d as FinbricksAccount, R as ReferenceType, S as SendPaymentInput } from './shared/bank.CxAHQOwW.cjs';
+export { e as FinbricksAccountTransactionsResponse, f as FinbricksAccountsListResponse, g as FinbricksAuthTokenResponse, h as FinbricksBatchResponse, i as FinbricksConnectAccountResponse, j as FinbricksPaymentResponse, k as FinbricksSupportedBank, F as FinbricksSupportedBanksResponse, b as SendPaymentSyncInput } from './shared/bank.CxAHQOwW.cjs';
+import { z } from 'zod';
 export { a as BankServiceEnv, b as BankServiceEnvironmentConfig, B as BankServiceWranglerConfig } from './shared/bank.Bz4DIxJL.cjs';
 import { BaseEvent } from '@develit-io/backend-sdk';
 import * as drizzle_zod from 'drizzle-zod';
 import * as drizzle_orm_sqlite_core from 'drizzle-orm/sqlite-core';
-import { z } from 'zod';
 export { BANK_CODES, CURRENCY_CODES } from '@develit-io/general-codes';
 import 'drizzle-orm';
 import 'zod/v4/core';
@@ -301,6 +301,27 @@ declare class CsobConnector extends FinbricksConnector {
     supportsBatch(paymentType: PaymentType): boolean;
 }
 
+declare const dbuAccountConfigSchema: z.ZodObject<{
+    with4EyeApproval: z.ZodDefault<z.ZodEnum<{
+        Y: "Y";
+        N: "N";
+    }>>;
+    channelCode: z.ZodDefault<z.ZodString>;
+    actionTypeCode: z.ZodDefault<z.ZodString>;
+    transactionTypeCode: z.ZodDefault<z.ZodString>;
+    partialRealization: z.ZodDefault<z.ZodEnum<{
+        Y: "Y";
+        N: "N";
+    }>>;
+    forceRealization: z.ZodDefault<z.ZodEnum<{
+        Y: "Y";
+        N: "N";
+    }>>;
+}, z.core.$strip>;
+type DbuAccountConfig = z.infer<typeof dbuAccountConfigSchema>;
+type DbuConnectedAccount = Omit<ConnectedAccount, 'config'> & {
+    config: DbuAccountConfig;
+};
 interface DbuConnectorConfig {
     BASE_URL: string;
     USERNAME: string;
@@ -313,7 +334,7 @@ interface DbuConnectorConfig {
 }
 declare class DbuConnector extends IBankConnector {
     connectorKey: ConnectorKey;
-    connectedAccounts: ConnectedAccount[];
+    connectedAccounts: DbuConnectedAccount[];
     readonly kv: KVNamespace;
     readonly api: Fetcher;
     private readonly baseUrl;
@@ -340,6 +361,7 @@ declare class DbuConnector extends IBankConnector {
         accounts: AccountInsertType[];
     }>;
     listAccounts(): Promise<AccountInsertType[]>;
+    private resolveAccount;
     private resolveIdAccountDebit;
     private resolveAccountDetails;
     private initiateInstantPayment;
@@ -1340,5 +1362,5 @@ declare function toCompletedPayment(payment: PreparedPayment, status: 'SETTLED'
 declare function toPaymentRequestInsert(payment: AccountAssignedPayment, batchId: string | null): PaymentRequestInsertType;
 declare function toBatchedPaymentFromPaymentRequest(sp: PaymentRequestSelectType): BatchedPayment;
 
-export { AccountAssignedPayment, AccountCredentialsInsertType, AccountInsertType, AccountSelectType, BatchMetadata, BatchedPayment, CompletedPayment, ConnectedAccount, ConnectorKey, CredentialsResolver, CsobConnector, Currency, DbuConnector, ErsteConnector, FINBRICKS_ENDPOINTS, FinbricksAccount, FinbricksClient, FinbricksConnector, IBankConnector, IncomingPayment, IncomingPayment as IncomingPaymentMessage, InitiatedBatch, InitiatedPayment, KBConnector, MockCobsConnector, MockConnector, ParsedBankPayment, PaymentRequestInsertType, PaymentRequestSelectType, PaymentRequestStatus, PaymentSelectType, PaymentType, PreparedPayment, SendPaymentInput, assignAccount, ottInsertSchema, ottSelectSchema, ottUpdateSchema, signFinbricksJws, toBatchedPayment, toBatchedPaymentFromPaymentRequest, toCompletedPayment, toIncomingPayment, toPaymentRequestInsert, toPreparedPayment, useFinbricksFetch };
-export type { BankPaymentEvent, BankPaymentRequestEvent, DbuConnectorConfig, ErsteAuthenticationResponse, ErsteBatchPaymentInitiationResponse, ErsteIncomingPaymentResponse, ErsteObtainAuthorizationURLResponse, ErstePaymentInitiationResponse, FinbricksBatchBody, FinbricksBatchStatus, FinbricksConnectAccountBody, FinbricksConnectorConfig, FinbricksEndpoint, FinbricksEndpointPath, FinbricksFetchConfig, FinbricksForeignPaymentBody, FinbricksGetBatchStatusBody, FinbricksGetBatchStatusResponse, FinbricksGetTransactionStatusResponse, FinbricksJWSData, FinbricksPaymentBody, FinbricksProvider, FinbricksRequestInit, FinbricksSupportedBanksQuery, FinbricksTransactionStatus, OneTimeTokenInsertType, OneTimeTokenPatchType, OneTimeTokenSelectType, OneTimeTokenUpdateType };
+export { AccountAssignedPayment, AccountCredentialsInsertType, AccountInsertType, AccountSelectType, BatchMetadata, BatchedPayment, CompletedPayment, ConnectedAccount, ConnectorKey, CredentialsResolver, CsobConnector, Currency, DbuConnector, ErsteConnector, FINBRICKS_ENDPOINTS, FinbricksAccount, FinbricksClient, FinbricksConnector, IBankConnector, IncomingPayment, IncomingPayment as IncomingPaymentMessage, InitiatedBatch, InitiatedPayment, KBConnector, MockCobsConnector, MockConnector, ParsedBankPayment, PaymentRequestInsertType, PaymentRequestSelectType, PaymentRequestStatus, PaymentSelectType, PaymentType, PreparedPayment, SendPaymentInput, assignAccount, dbuAccountConfigSchema, ottInsertSchema, ottSelectSchema, ottUpdateSchema, signFinbricksJws, toBatchedPayment, toBatchedPaymentFromPaymentRequest, toCompletedPayment, toIncomingPayment, toPaymentRequestInsert, toPreparedPayment, useFinbricksFetch };
+export type { BankPaymentEvent, BankPaymentRequestEvent, DbuAccountConfig, DbuConnectorConfig, ErsteAuthenticationResponse, ErsteBatchPaymentInitiationResponse, ErsteIncomingPaymentResponse, ErsteObtainAuthorizationURLResponse, ErstePaymentInitiationResponse, FinbricksBatchBody, FinbricksBatchStatus, FinbricksConnectAccountBody, FinbricksConnectorConfig, FinbricksEndpoint, FinbricksEndpointPath, FinbricksFetchConfig, FinbricksForeignPaymentBody, FinbricksGetBatchStatusBody, FinbricksGetBatchStatusResponse, FinbricksGetTransactionStatusResponse, FinbricksJWSData, FinbricksPaymentBody, FinbricksProvider, FinbricksRequestInit, FinbricksSupportedBanksQuery, FinbricksTransactionStatus, OneTimeTokenInsertType, OneTimeTokenPatchType, OneTimeTokenSelectType, OneTimeTokenUpdateType };