@develit-services/bank 0.3.60 → 0.4.0

package/dist/export/workflows.d.cts

@@ -1,16 +1,16 @@
 import { WorkflowEntrypoint, WorkflowEvent, WorkflowStep } from 'cloudflare:workers';
 
 type Params$1 = {
-    accountId: string;
+    batchId: string;
 };
-declare class BankSyncAccountPayments extends WorkflowEntrypoint<BankEnv, Params$1> {
+declare class BankProcessBatch extends WorkflowEntrypoint<BankEnv, Params$1> {
     run(event: WorkflowEvent<Params$1>, step: WorkflowStep): Promise<void>;
 }
 
 type Params = {
-    batchId: string;
+    accountId: string;
 };
-declare class BankProcessBatch extends WorkflowEntrypoint<BankEnv, Params> {
+declare class BankSyncAccountPayments extends WorkflowEntrypoint<BankEnv, Params> {
     run(event: WorkflowEvent<Params>, step: WorkflowStep): Promise<void>;
 }
 

package/dist/export/workflows.d.mts

@@ -1,16 +1,16 @@
 import { WorkflowEntrypoint, WorkflowEvent, WorkflowStep } from 'cloudflare:workers';
 
 type Params$1 = {
-    accountId: string;
+    batchId: string;
 };
-declare class BankSyncAccountPayments extends WorkflowEntrypoint<BankEnv, Params$1> {
+declare class BankProcessBatch extends WorkflowEntrypoint<BankEnv, Params$1> {
     run(event: WorkflowEvent<Params$1>, step: WorkflowStep): Promise<void>;
 }
 
 type Params = {
-    batchId: string;
+    accountId: string;
 };
-declare class BankProcessBatch extends WorkflowEntrypoint<BankEnv, Params> {
+declare class BankSyncAccountPayments extends WorkflowEntrypoint<BankEnv, Params> {
     run(event: WorkflowEvent<Params>, step: WorkflowStep): Promise<void>;
 }
 

package/dist/export/workflows.d.ts

@@ -1,16 +1,16 @@
 import { WorkflowEntrypoint, WorkflowEvent, WorkflowStep } from 'cloudflare:workers';
 
 type Params$1 = {
-    accountId: string;
+    batchId: string;
 };
-declare class BankSyncAccountPayments extends WorkflowEntrypoint<BankEnv, Params$1> {
+declare class BankProcessBatch extends WorkflowEntrypoint<BankEnv, Params$1> {
     run(event: WorkflowEvent<Params$1>, step: WorkflowStep): Promise<void>;
 }
 
 type Params = {
-    batchId: string;
+    accountId: string;
 };
-declare class BankProcessBatch extends WorkflowEntrypoint<BankEnv, Params> {
+declare class BankSyncAccountPayments extends WorkflowEntrypoint<BankEnv, Params> {
     run(event: WorkflowEvent<Params>, step: WorkflowStep): Promise<void>;
 }
 

package/dist/export/workflows.mjs

@@ -1,14 +1,16 @@
+import { first, uuidv4, asNonEmpty } from '@develit-io/backend-sdk';
 import { WorkflowEntrypoint } from 'cloudflare:workers';
 import { NonRetryableError } from 'cloudflare:workflows';
 import { drizzle } from 'drizzle-orm/d1';
-import { t as tables } from '../shared/bank.DgGcjhmM.mjs';
-import { asNonEmpty, first } from '@develit-io/backend-sdk';
-import { g as getAccountByIdQuery, i as importAesKey, a as getCredentialsByAccountId, b as initiateConnector, c as createPaymentCommand, d as getBatchByIdQuery, e as checksum, u as upsertBatchCommand } from '../shared/bank.DSsVeR3F.mjs';
+import { t as tables, g as getBatchByIdQuery, c as checksum, u as upsertBatchCommand, a as getAccountByIdQuery, i as importAesKey, b as getCredentialsByAccountId, d as createPaymentCommand } from '../shared/bank.B51e8oDT.mjs';
+import { d as isBatchSigned, j as isBatchFailed, g as isBatchOpen, a as isPaymentCompleted } from '../shared/bank.Dpx6PvkA.mjs';
+import { f as toPreparedPayment, i as initiateConnector, g as toCompletedPayment } from '../shared/bank.DinCwx0P.mjs';
 import { eq } from 'drizzle-orm';
-import 'date-fns';
-import '../shared/bank.BqGzJNC6.mjs';
-import 'drizzle-orm/sqlite-core';
+import '../shared/bank.BUSlmr6r.mjs';
+import '../shared/bank.qc8ALZwm.mjs';
 import 'drizzle-orm/relations';
+import 'drizzle-orm/sqlite-core';
+import 'date-fns';
 import '@develit-io/general-codes';
 import 'jose';
 import 'node:crypto';
@@ -37,6 +39,206 @@ function pushToQueue$1(queue, message) {
     }))
   );
 }
+class BankProcessBatch extends WorkflowEntrypoint {
+  async run(event, step) {
+    const { batchId } = event.payload;
+    const db = drizzle(this.env.BANK_D1, { schema: tables });
+    const batch = await step.do("load batch", async () => {
+      const batch2 = await getBatchByIdQuery(db, { batchId });
+      if (!batch2) {
+        throw new NonRetryableError(`Batch not found`);
+      }
+      if (isBatchSigned(batch2))
+        throw new NonRetryableError(`Batch already signed`);
+      return batch2;
+    });
+    await step.do("lock batch", async () => {
+      const paymentsChecksum = checksum(batch.payments);
+      if (batch.paymentsChecksum && batch.paymentsChecksum !== paymentsChecksum)
+        throw new NonRetryableError(
+          `Batch payments have been modified externally, manual review needed`
+        );
+      if (isBatchFailed(batch))
+        throw new NonRetryableError(
+          `Batch is in FAILED status and cannot be processed, manual review needed`
+        );
+      if (isBatchOpen(batch)) {
+        const updatedBatch = await upsertBatchCommand(db, {
+          batch: {
+            ...batch,
+            status: "PROCESSING",
+            paymentsChecksum
+          }
+        }).command.execute().then(first);
+        return { status: updatedBatch.status };
+      }
+      return { status: batch.status };
+    });
+    const batchResult = await step.do(
+      "initiate batch with payments",
+      {
+        retries: { limit: 5, delay: 2e3, backoff: "constant" },
+        timeout: "30 seconds"
+      },
+      async () => {
+        if (batch.batchPaymentInitiatedAt) {
+          return {
+            authorizationUrls: batch.authorizationUrls,
+            preparedPayments: batch.payments.map(
+              (p) => toPreparedPayment(p, void 0, batch.batchPaymentInitiatedAt)
+            ),
+            metadata: batch.metadata
+          };
+        }
+        const account = await getAccountByIdQuery(db, {
+          accountId: batch.accountId
+        });
+        if (!account) {
+          throw new NonRetryableError(`Account not found: ${batch.accountId}`);
+        }
+        const encryptionKey = await importAesKey(this.env.ENCRYPTION_KEY);
+        const credentials = await getCredentialsByAccountId(db, encryptionKey, {
+          accountId: account.id
+        });
+        if (!credentials) {
+          throw new NonRetryableError(
+            `No credentials found for account: ${account.id}`
+          );
+        }
+        if (credentials.expiresAt < /* @__PURE__ */ new Date()) {
+          throw new NonRetryableError(
+            `Credentials have expired for account: ${account.id}`
+          );
+        }
+        const connector = initiateConnector({
+          env: this.env,
+          bank: account.connectorKey,
+          connectedAccounts: [
+            {
+              ...account,
+              iban: account.iban,
+              token: credentials.value
+            }
+          ]
+        });
+        const result = await connector.initiateBatch({
+          batchId: batch.id,
+          payments: batch.payments
+        });
+        const {
+          authorizationUrls,
+          payments: preparedPayments,
+          metadata
+        } = result;
+        if (!authorizationUrls || authorizationUrls.length === 0) {
+          throw new Error("Failed to retrieve authorization URLs");
+        }
+        return {
+          authorizationUrls,
+          preparedPayments,
+          metadata
+        };
+      }
+    );
+    await step.do("update batch to ready to sign", async () => {
+      const upsertBatch = upsertBatchCommand(db, {
+        batch: {
+          ...batch,
+          authorizationUrls: batchResult.authorizationUrls,
+          metadata: batchResult.metadata,
+          status: "READY_TO_SIGN",
+          batchPaymentInitiatedAt: /* @__PURE__ */ new Date()
+        }
+      }).command;
+      await upsertBatch.execute();
+      return {
+        status: "READY_TO_SIGN",
+        paymentsPrepared: batchResult.preparedPayments.length
+      };
+    });
+    const isMockConnector = batchResult.preparedPayments.some(
+      (p) => p.connectorKey === "MOCK"
+    );
+    if (isMockConnector) {
+      await step.do(
+        "mock: create completed payments and update batch",
+        async () => {
+          const processedAt = /* @__PURE__ */ new Date();
+          const completedPayments = batchResult.preparedPayments.map(
+            (p) => toCompletedPayment(p, "COMPLETED", `MOCK-${uuidv4()}`, processedAt)
+          );
+          const createCommands = completedPayments.map(
+            (payment) => createPaymentCommand(db, { payment }).command
+          );
+          const updateBatchCommand = upsertBatchCommand(db, {
+            batch: {
+              ...batch,
+              status: "SIGNED",
+              authorizationUrls: batchResult.authorizationUrls,
+              metadata: batchResult.metadata,
+              batchPaymentInitiatedAt: /* @__PURE__ */ new Date()
+            }
+          }).command;
+          if (createCommands.length > 0) {
+            await db.batch([updateBatchCommand, ...createCommands]);
+          } else {
+            await updateBatchCommand.execute();
+          }
+          const eventsToEmit = completedPayments.map(
+            (payment) => ({
+              eventType: "BANK_PAYMENT",
+              eventSignal: "paymentCompleted",
+              bankPayment: payment,
+              metadata: {
+                correlationId: uuidv4(),
+                entityId: payment.id,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              }
+            })
+          );
+          await pushToQueue$1(
+            this.env.QUEUE_BUS_QUEUE,
+            eventsToEmit
+          );
+          return {
+            paymentsCreated: completedPayments.length,
+            eventsEmitted: completedPayments.length
+          };
+        }
+      );
+    }
+    if (!isMockConnector) {
+      await step.do("enqueue authorization email", async () => {
+        await pushToQueue$1(this.env.NOTIFICATIONS_QUEUE, {
+          type: "email",
+          payload: {
+            email: {
+              to: [this.env.BANK_AUTH_RECIPIENT],
+              subject: "Payment Authorization",
+              text: Array.isArray(batchResult.authorizationUrls) ? batchResult.authorizationUrls[0] || "No Authorization URL" : batchResult.authorizationUrls || "No Authorization URL"
+            }
+          },
+          metadata: {
+            initiator: {
+              service: "bank"
+            }
+          }
+        });
+        return { emailSent: true };
+      });
+    }
+  }
+}
+
+function pushToQueue(queue, message) {
+  if (!Array.isArray(message)) return queue.send(message, { contentType: "v8" });
+  return queue.sendBatch(
+    message.map((m) => ({
+      body: m,
+      contentType: "v8"
+    }))
+  );
+}
 class BankSyncAccountPayments extends WorkflowEntrypoint {
   async run(event, step) {
     const { accountId } = event.payload;
@@ -89,15 +291,13 @@ class BankSyncAccountPayments extends WorkflowEntrypoint {
             ]
           });
           return await connector.getAllAccountPayments({
-            environment: this.env.ENVIRONMENT,
-            db,
             account,
             filter: { dateFrom: account.lastSyncAt }
           });
         }
       );
       const paymentsToProcess = payments.filter(
-        (p) => p.parsed.status === "COMPLETED" || p.parsed.status === "FAILED"
+        (p) => isPaymentCompleted(p.parsed)
       );
       if (paymentsToProcess.length) {
         const lastSyncBankRefIds = account.lastSyncMetadata?.lastSyncBankRefIds || [];
@@ -142,7 +342,7 @@ class BankSyncAccountPayments extends WorkflowEntrypoint {
               await db.batch(
                 asNonEmpty([updateLastSyncCommand, ...createCommands])
               );
-              await pushToQueue$1(
+              await pushToQueue(
                 this.env.QUEUE_BUS_QUEUE,
                 eventsToEmit
               );
@@ -162,200 +362,4 @@ class BankSyncAccountPayments extends WorkflowEntrypoint {
   }
 }
 
-function pushToQueue(queue, message) {
-  if (!Array.isArray(message)) return queue.send(message, { contentType: "v8" });
-  return queue.sendBatch(
-    message.map((m) => ({
-      body: m,
-      contentType: "v8"
-    }))
-  );
-}
-class BankProcessBatch extends WorkflowEntrypoint {
-  async run(event, step) {
-    const { batchId } = event.payload;
-    const db = drizzle(this.env.BANK_D1, { schema: tables });
-    const batch = await step.do("load batch", async () => {
-      const batch2 = await getBatchByIdQuery(db, { batchId });
-      if (!batch2) {
-        throw new NonRetryableError(`Batch not found`);
-      }
-      if (batch2.status === "SIGNED")
-        throw new NonRetryableError(`Batch already signed`);
-      return batch2;
-    });
-    await step.do("lock batch", async () => {
-      const paymentsChecksum = checksum(batch.payments);
-      if (batch.paymentsChecksum && batch.paymentsChecksum !== paymentsChecksum)
-        throw new NonRetryableError(
-          `Batch payments have been modified externally, manual review needed`
-        );
-      if (batch.status === "FAILED")
-        throw new NonRetryableError(
-          `Batch is in FAILED status and cannot be processed, manual review needed`
-        );
-      if (batch.status === "OPEN") {
-        const updatedBatch = await upsertBatchCommand(db, {
-          batch: {
-            ...batch,
-            status: "PROCESSING",
-            paymentsChecksum
-          }
-        }).command.execute().then(first);
-        return { status: updatedBatch.status };
-      }
-      return { status: batch.status };
-    });
-    const preparedPayments = await step.do(
-      "prepare payments",
-      {
-        retries: { limit: 5, delay: 2e3, backoff: "constant" },
-        timeout: "30 seconds"
-      },
-      async () => {
-        const account = await getAccountByIdQuery(db, {
-          accountId: batch.accountId
-        });
-        if (!account) {
-          throw new NonRetryableError(`Account not found: ${batch.accountId}`);
-        }
-        const encryptionKey = await importAesKey(this.env.ENCRYPTION_KEY);
-        const credentials = await getCredentialsByAccountId(db, encryptionKey, {
-          accountId: account.id
-        });
-        if (!credentials) {
-          throw new NonRetryableError(
-            `No credentials found for account: ${account.id}`
-          );
-        }
-        if (credentials.expiresAt < /* @__PURE__ */ new Date()) {
-          throw new NonRetryableError(
-            `Credentials have expired for account: ${account.id}`
-          );
-        }
-        const connector = initiateConnector({
-          env: this.env,
-          bank: account.connectorKey,
-          connectedAccounts: [
-            {
-              ...account,
-              iban: account.iban,
-              token: credentials.value
-            }
-          ]
-        });
-        const preparedPayments2 = [];
-        for (const payment of batch.payments) {
-          const prepared = await connector.preparePayment(payment);
-          if (prepared) {
-            preparedPayments2.push(prepared);
-          }
-        }
-        return preparedPayments2;
-      }
-    );
-    const batchResult = await step.do(
-      "initiate batch from payments",
-      {
-        retries: { limit: 5, delay: 2e3, backoff: "constant" },
-        timeout: "30 seconds"
-      },
-      async () => {
-        if (batch.batchPaymentInitiatedAt) {
-          return {
-            authorizationUrls: batch.authorizationUrls,
-            initializedPayments: preparedPayments.map((p) => ({
-              ...p,
-              status: "INITIALIZED"
-            })),
-            metadata: batch.metadata
-          };
-        }
-        const account = await getAccountByIdQuery(db, {
-          accountId: batch.accountId
-        });
-        if (!account) {
-          throw new NonRetryableError(`Account not found: ${batch.accountId}`);
-        }
-        const encryptionKey = await importAesKey(this.env.ENCRYPTION_KEY);
-        const credentials = await getCredentialsByAccountId(db, encryptionKey, {
-          accountId: account.id
-        });
-        if (!credentials) {
-          throw new NonRetryableError(
-            `No credentials found for account: ${account.id}`
-          );
-        }
-        if (credentials.expiresAt < /* @__PURE__ */ new Date()) {
-          throw new NonRetryableError(
-            `Credentials have expired for account: ${account.id}`
-          );
-        }
-        const connector = initiateConnector({
-          env: this.env,
-          bank: account.connectorKey,
-          connectedAccounts: [
-            {
-              ...account,
-              iban: account.iban,
-              token: credentials.value
-            }
-          ]
-        });
-        const result = await connector.initiateBatchFromPayments({
-          batchId: batch.id,
-          payments: preparedPayments
-        });
-        const {
-          authorizationUrls,
-          payments: initializedPayments,
-          metadata
-        } = result;
-        if (!authorizationUrls || authorizationUrls.length === 0) {
-          throw new Error("Failed to retrieve authorization URLs");
-        }
-        return {
-          authorizationUrls,
-          initializedPayments,
-          metadata
-        };
-      }
-    );
-    await step.do("update batch and payments to initialized", async () => {
-      const upsertBatch = upsertBatchCommand(db, {
-        batch: {
-          ...batch,
-          authorizationUrls: batchResult.authorizationUrls,
-          metadata: batchResult.metadata,
-          status: "READY_TO_SIGN",
-          batchPaymentInitiatedAt: /* @__PURE__ */ new Date()
-        }
-      }).command;
-      await upsertBatch.execute();
-      return {
-        status: "READY_TO_SIGN",
-        paymentsInitialized: batchResult.initializedPayments.length
-      };
-    });
-    await step.do("enqueue authorization email", async () => {
-      await pushToQueue(this.env.NOTIFICATIONS_QUEUE, {
-        type: "email",
-        payload: {
-          email: {
-            to: [this.env.BANK_AUTH_RECIPIENT],
-            subject: "Payment Authorization",
-            text: Array.isArray(batchResult.authorizationUrls) ? batchResult.authorizationUrls[0] || "No Authorization URL" : batchResult.authorizationUrls || "No Authorization URL"
-          }
-        },
-        metadata: {
-          initiator: {
-            service: "bank"
-          }
-        }
-      });
-      return { emailSent: true };
-    });
-  }
-}
-
 export { BankProcessBatch, BankSyncAccountPayments };

package/dist/export/wrangler.d.cts

@@ -1,4 +1,4 @@
-import { B as BankServiceWranglerConfig } from '../shared/bank.Dh_H_5rC.cjs';
+import { B as BankServiceWranglerConfig } from '../shared/bank.BJvgLwyZ.cjs';
 
 declare function defineBankServiceWrangler(config: BankServiceWranglerConfig): {
     vars: {
@@ -11,6 +11,8 @@ declare function defineBankServiceWrangler(config: BankServiceWranglerConfig): {
         CRON_BATCH_STATUSES: string;
         CRON_PAYMENTS_PROCESSING: string;
         BANK_AUTH_RECIPIENT: string;
+        DBUCS_BASE_URI: string;
+        DBUCS_USERNAME: string;
         REDIRECT_URI: string;
         ENCRYPTION_KEY: string;
         FINBRICKS_PRIVATE_KEY_PEM: string;

package/dist/export/wrangler.d.mts

@@ -1,4 +1,4 @@
-import { B as BankServiceWranglerConfig } from '../shared/bank.Dh_H_5rC.mjs';
+import { B as BankServiceWranglerConfig } from '../shared/bank.BJvgLwyZ.mjs';
 
 declare function defineBankServiceWrangler(config: BankServiceWranglerConfig): {
     vars: {
@@ -11,6 +11,8 @@ declare function defineBankServiceWrangler(config: BankServiceWranglerConfig): {
         CRON_BATCH_STATUSES: string;
         CRON_PAYMENTS_PROCESSING: string;
         BANK_AUTH_RECIPIENT: string;
+        DBUCS_BASE_URI: string;
+        DBUCS_USERNAME: string;
         REDIRECT_URI: string;
         ENCRYPTION_KEY: string;
         FINBRICKS_PRIVATE_KEY_PEM: string;

package/dist/export/wrangler.d.ts

@@ -1,4 +1,4 @@
-import { B as BankServiceWranglerConfig } from '../shared/bank.Dh_H_5rC.js';
+import { B as BankServiceWranglerConfig } from '../shared/bank.BJvgLwyZ.js';
 
 declare function defineBankServiceWrangler(config: BankServiceWranglerConfig): {
     vars: {
@@ -11,6 +11,8 @@ declare function defineBankServiceWrangler(config: BankServiceWranglerConfig): {
         CRON_BATCH_STATUSES: string;
         CRON_PAYMENTS_PROCESSING: string;
         BANK_AUTH_RECIPIENT: string;
+        DBUCS_BASE_URI: string;
+        DBUCS_USERNAME: string;
         REDIRECT_URI: string;
         ENCRYPTION_KEY: string;
         FINBRICKS_PRIVATE_KEY_PEM: string;

package/dist/shared/bank.B51e8oDT.mjs

@@ -0,0 +1,104 @@
+import { uuidv4 } from '@develit-io/backend-sdk';
+import { eq } from 'drizzle-orm';
+import { s as schema } from './bank.BUSlmr6r.mjs';
+import 'date-fns';
+import '@develit-io/general-codes';
+import 'jose';
+import './bank.qc8ALZwm.mjs';
+import { createHash } from 'node:crypto';
+
+const createPaymentCommand = (db, { payment }) => {
+  return {
+    command: db.insert(tables.payment).values({
+      ...payment,
+      creditorIban: payment.creditor.iban,
+      debtorIban: payment.debtor.iban
+    }).returning()
+  };
+};
+
+const upsertBatchCommand = (db, { batch }) => {
+  const id = batch.id || uuidv4();
+  const command = db.insert(tables.batch).values({
+    ...batch,
+    id
+  }).onConflictDoUpdate({
+    target: tables.batch.id,
+    set: {
+      ...batch
+    }
+  }).returning();
+  return {
+    id,
+    command
+  };
+};
+
+const getAccountByIdQuery = async (db, { accountId }) => {
+  return await db.select().from(tables.account).where(eq(tables.account.id, accountId)).get();
+};
+
+const getBatchByIdQuery = async (db, { batchId }) => {
+  return await db.select().from(tables.batch).where(eq(tables.batch.id, batchId)).get();
+};
+
+const getCredentialsByAccountId = async (db, encryptionKey, { accountId }) => {
+  const cred = await db.select().from(tables.accountCredentials).where(eq(tables.accountCredentials.accountId, accountId)).get();
+  return cred ? {
+    ...cred,
+    value: await decrypt(cred.value, encryptionKey)
+  } : void 0;
+};
+
+async function importAesKey(base64Key) {
+  const raw = Uint8Array.from(atob(base64Key), (c) => c.charCodeAt(0));
+  return await crypto.subtle.importKey("raw", raw, { name: "AES-GCM" }, false, [
+    "encrypt",
+    "decrypt"
+  ]);
+}
+async function encrypt(value, key) {
+  const encoder = new TextEncoder();
+  const iv = crypto.getRandomValues(new Uint8Array(12));
+  const ciphertext = await crypto.subtle.encrypt(
+    { name: "AES-GCM", iv },
+    key,
+    encoder.encode(value)
+  );
+  const combined = new Uint8Array(iv.length + ciphertext.byteLength);
+  combined.set(iv, 0);
+  combined.set(new Uint8Array(ciphertext), iv.length);
+  return btoa(String.fromCharCode(...combined));
+}
+async function decrypt(base64, key) {
+  const raw = Uint8Array.from(atob(base64), (c) => c.charCodeAt(0));
+  const iv = raw.slice(0, 12);
+  const ciphertext = raw.slice(12);
+  const decrypted = await crypto.subtle.decrypt(
+    { name: "AES-GCM", iv },
+    key,
+    ciphertext
+  );
+  return new TextDecoder().decode(decrypted);
+}
+function canonicalize(value) {
+  if (value === null || typeof value !== "object") return value;
+  if (Array.isArray(value)) {
+    return value.map(canonicalize);
+  }
+  const obj = value;
+  const sorted = Object.keys(obj).sort().reduce((acc, key) => {
+    acc[key] = canonicalize(obj[key]);
+    return acc;
+  }, {});
+  return sorted;
+}
+function checksum(input) {
+  const canonical = canonicalize(input);
+  const json = JSON.stringify(canonical);
+  return createHash("sha256").update(json).digest("hex");
+}
+
+const tables = schema;
+
+export { getAccountByIdQuery as a, getCredentialsByAccountId as b, checksum as c, createPaymentCommand as d, encrypt as e, getBatchByIdQuery as g, importAesKey as i, tables as t, upsertBatchCommand as u };

package/dist/shared/{bank.Dh_H_5rC.d.cts → bank.BJvgLwyZ.d.cts}

@@ -21,6 +21,8 @@ interface BankServiceEnvironmentConfig {
         CRON_BATCH_STATUSES: string;
         CRON_PAYMENTS_PROCESSING: string;
         BANK_AUTH_RECIPIENT: string;
+        DBUCS_BASE_URI: string;
+        DBUCS_USERNAME: string;
         REDIRECT_URI: string;
     };
 }

package/dist/shared/{bank.Dh_H_5rC.d.mts → bank.BJvgLwyZ.d.mts}

@@ -21,6 +21,8 @@ interface BankServiceEnvironmentConfig {
         CRON_BATCH_STATUSES: string;
         CRON_PAYMENTS_PROCESSING: string;
         BANK_AUTH_RECIPIENT: string;
+        DBUCS_BASE_URI: string;
+        DBUCS_USERNAME: string;
         REDIRECT_URI: string;
     };
 }