@develit-services/bank 0.3.43 → 0.3.45

package/dist/database/schema.cjs

@@ -1,15 +1,15 @@
 'use strict';
 
-const database_schema = require('../shared/bank.CLF9wee9.cjs');
+const database_schema = require('../shared/bank.CpwLFudl.cjs');
 require('@develit-io/backend-sdk');
 require('drizzle-orm/sqlite-core');
 require('date-fns');
+require('drizzle-orm/relations');
+require('@develit-io/general-codes');
 require('drizzle-orm');
 require('jose');
-require('@develit-io/general-codes');
-require('drizzle-zod');
-require('drizzle-orm/relations');
 require('node:crypto');
+require('drizzle-zod');
 
 
 

package/dist/database/schema.d.cts

@@ -1,4 +1,4 @@
-export { a9 as account, aa as accountCredentials, a5 as batch, a8 as ott, a6 as payment, a7 as paymentRelations } from '../shared/bank.xrXNjWCo.cjs';
+export { a9 as account, aa as accountCredentials, a5 as batch, a8 as ott, a6 as payment, a7 as paymentRelations } from '../shared/bank.BEL1HIxZ.cjs';
 import 'zod';
 import 'drizzle-zod';
 import 'drizzle-orm/sqlite-core';

package/dist/database/schema.d.mts

@@ -1,4 +1,4 @@
-export { a9 as account, aa as accountCredentials, a5 as batch, a8 as ott, a6 as payment, a7 as paymentRelations } from '../shared/bank.xrXNjWCo.mjs';
+export { a9 as account, aa as accountCredentials, a5 as batch, a8 as ott, a6 as payment, a7 as paymentRelations } from '../shared/bank.BEL1HIxZ.mjs';
 import 'zod';
 import 'drizzle-zod';
 import 'drizzle-orm/sqlite-core';

package/dist/database/schema.d.ts

@@ -1,4 +1,4 @@
-export { a9 as account, aa as accountCredentials, a5 as batch, a8 as ott, a6 as payment, a7 as paymentRelations } from '../shared/bank.xrXNjWCo.js';
+export { a9 as account, aa as accountCredentials, a5 as batch, a8 as ott, a6 as payment, a7 as paymentRelations } from '../shared/bank.BEL1HIxZ.js';
 import 'zod';
 import 'drizzle-zod';
 import 'drizzle-orm/sqlite-core';

package/dist/database/schema.mjs

@@ -1,10 +1,10 @@
-export { y as account, z as accountCredentials, r as batch, x as ott, v as payment, w as paymentRelations } from '../shared/bank.YiArmBW2.mjs';
+export { t as account, u as accountCredentials, n as batch, r as ott, p as payment, q as paymentRelations } from '../shared/bank.D-3fzX63.mjs';
 import '@develit-io/backend-sdk';
 import 'drizzle-orm/sqlite-core';
 import 'date-fns';
+import 'drizzle-orm/relations';
+import '@develit-io/general-codes';
 import 'drizzle-orm';
 import 'jose';
-import '@develit-io/general-codes';
-import 'drizzle-zod';
-import 'drizzle-orm/relations';
 import 'node:crypto';
+import 'drizzle-zod';

package/dist/export/worker.cjs

@@ -3,24 +3,23 @@
 const backendSdk = require('@develit-io/backend-sdk');
 const cloudflare_workers = require('cloudflare:workers');
 const d1 = require('drizzle-orm/d1');
-const database_schema = require('../shared/bank.CLF9wee9.cjs');
-require('jose');
-const generalCodes = require('@develit-io/general-codes');
+const drizzle = require('../shared/bank.CPYfE-Ei.cjs');
 const zod = require('zod');
-const processBatch_workflow = require('../shared/bank.ChffLgyT.cjs');
+const database_schema = require('../shared/bank.CpwLFudl.cjs');
+const generalCodes = require('@develit-io/general-codes');
+require('date-fns');
 const drizzleOrm = require('drizzle-orm');
+require('jose');
+require('node:crypto');
+const encryption = require('../shared/bank.D0a-MZon.cjs');
 require('drizzle-orm/sqlite-core');
-require('date-fns');
-require('drizzle-zod');
 require('drizzle-orm/relations');
-require('node:crypto');
-require('cloudflare:workflows');
-require('../shared/bank.DfE0M5H3.cjs');
+require('drizzle-zod');
 
 const upsertAccountCommand = (db, { account }) => {
   const id = account.id || backendSdk.uuidv4();
-  const command = db.insert(database_schema.tables.account).values({ ...account, id }).onConflictDoUpdate({
-    target: database_schema.tables.account.iban,
+  const command = db.insert(drizzle.tables.account).values({ ...account, id }).onConflictDoUpdate({
+    target: drizzle.tables.account.iban,
     set: {
       ...account
     }
@@ -38,7 +37,7 @@ const createOneTimeTokenCommand = (db, {
 }) => {
   const id = backendSdk.uuidv4();
   const expiresAt = new Date(Date.now() + 1e3 * 60 * 60) ;
-  const command = db.insert(database_schema.tables.ott).values({
+  const command = db.insert(drizzle.tables.ott).values({
     id,
     oneTimeToken: ott,
     tokenType,
@@ -50,7 +49,7 @@ const createOneTimeTokenCommand = (db, {
 
 const updateAccountCommand = (db, { account }) => {
   return {
-    command: db.update(database_schema.tables.account).set({ ...account }).where(drizzleOrm.eq(database_schema.tables.account.id, account.id)).returning()
+    command: db.update(drizzle.tables.account).set({ ...account }).where(drizzleOrm.eq(drizzle.tables.account.id, account.id)).returning()
   };
 };
 
@@ -58,16 +57,16 @@ const expireOneTimeTokenCommand = (db, {
   ott
 }) => {
   return {
-    command: db.update(database_schema.tables.ott).set({
+    command: db.update(drizzle.tables.ott).set({
       expiresAt: /* @__PURE__ */ new Date()
-    }).where(drizzleOrm.eq(database_schema.tables.ott.oneTimeToken, ott))
+    }).where(drizzleOrm.eq(drizzle.tables.ott.oneTimeToken, ott))
   };
 };
 
 const createAccountCredentialsCommand = async (db, encryptionKey, { credentials }) => {
   const id = credentials.id || backendSdk.uuidv4();
-  const encryptedValue = await processBatch_workflow.encrypt(credentials.value, encryptionKey);
-  const command = db.insert(database_schema.tables.accountCredentials).values({
+  const encryptedValue = await encryption.encrypt(credentials.value, encryptionKey);
+  const command = db.insert(drizzle.tables.accountCredentials).values({
     ...credentials,
     id,
     value: encryptedValue
@@ -79,29 +78,29 @@ const createAccountCredentialsCommand = async (db, encryptionKey, { credentials
 };
 
 const deleteAccountCredentialsCommand = (db, { accountId }) => {
-  const command = db.delete(database_schema.tables.accountCredentials).where(drizzleOrm.eq(database_schema.tables.accountCredentials.accountId, accountId));
+  const command = db.delete(drizzle.tables.accountCredentials).where(drizzleOrm.eq(drizzle.tables.accountCredentials.accountId, accountId));
   return {
     command
   };
 };
 
 const deletePaymentsByAccountCommand = (db, { accountId }) => {
-  const command = db.update(database_schema.tables.payment).set({
+  const command = db.update(drizzle.tables.payment).set({
     deletedAt: /* @__PURE__ */ new Date()
-  }).where(drizzleOrm.eq(database_schema.tables.payment.accountId, accountId));
+  }).where(drizzleOrm.eq(drizzle.tables.payment.accountId, accountId));
   return {
     command
   };
 };
 
 const getAccountByIbanQuery = async (db, { iban }) => {
-  return await db.select().from(database_schema.tables.account).where(drizzleOrm.eq(database_schema.tables.account.iban, iban)).get();
+  return await db.select().from(drizzle.tables.account).where(drizzleOrm.eq(drizzle.tables.account.iban, iban)).get();
 };
 
 const getAllAccountsQuery = async (db) => {
-  const accountsWithExpiration = await db.select().from(database_schema.tables.account).leftJoin(
-    database_schema.tables.accountCredentials,
-    drizzleOrm.eq(database_schema.tables.accountCredentials.accountId, database_schema.tables.account.id)
+  const accountsWithExpiration = await db.select().from(drizzle.tables.account).leftJoin(
+    drizzle.tables.accountCredentials,
+    drizzleOrm.eq(drizzle.tables.accountCredentials.accountId, drizzle.tables.account.id)
   );
   return accountsWithExpiration.map(({ account, account_credentials }) => {
     return {
@@ -112,7 +111,7 @@ const getAllAccountsQuery = async (db) => {
 };
 
 const getAllPendingBatchesQuery = (db) => {
-  return db.select().from(database_schema.tables.batch).where(drizzleOrm.inArray(database_schema.tables.batch.status, ["READY_TO_SIGN"]));
+  return db.select().from(drizzle.tables.batch).where(drizzleOrm.inArray(drizzle.tables.batch.status, ["READY_TO_SIGN"]));
 };
 
 const buildMultiFilterConditions = (column, value) => {
@@ -153,28 +152,28 @@ const getPaymentsWithPaginationQuery = async (db, {
 }) => {
   const whereConditions = drizzleOrm.and(
     buildMultiFilterConditions(
-      database_schema.tables.payment.accountId,
+      drizzle.tables.payment.accountId,
       filterPaymentAccountId
     ),
-    buildMultiFilterConditions(database_schema.tables.payment.amount, filterPaymentAmount),
-    buildMultiFilterConditions(database_schema.tables.payment.currency, filterPaymentCurrency),
+    buildMultiFilterConditions(drizzle.tables.payment.amount, filterPaymentAmount),
+    buildMultiFilterConditions(drizzle.tables.payment.currency, filterPaymentCurrency),
     buildRangeFilterConditions(
-      database_schema.tables.payment.createdAt,
+      drizzle.tables.payment.createdAt,
       filterPaymentDateFrom,
       filterPaymentDateTo
     ),
-    buildMultiFilterConditions(database_schema.tables.payment.status, filterPaymentStatus),
+    buildMultiFilterConditions(drizzle.tables.payment.status, filterPaymentStatus),
     buildMultiFilterConditions(
-      database_schema.tables.payment.direction,
+      drizzle.tables.payment.direction,
       filterPaymentyDirection
     ),
-    buildMultiFilterConditions(database_schema.tables.payment.id, ids)
+    buildMultiFilterConditions(drizzle.tables.payment.id, ids)
   );
-  const sortColumn = resolveColumn(database_schema.tables.payment, sort.column);
+  const sortColumn = resolveColumn(drizzle.tables.payment, sort.column);
   const [{ totalCount }] = await db.select({
     totalCount: drizzleOrm.sql`count(*)`
-  }).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));
+  }).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));
   return {
     payments,
     totalCount
@@ -189,14 +188,14 @@ const getBatchesQuery = async (db, {
   filterBatchStatus
 }) => {
   const whereConditions = drizzleOrm.and(
-    buildMultiFilterConditions(database_schema.tables.batch.accountId, filterBatchAccountId),
-    buildMultiFilterConditions(database_schema.tables.batch.status, filterBatchStatus)
+    buildMultiFilterConditions(drizzle.tables.batch.accountId, filterBatchAccountId),
+    buildMultiFilterConditions(drizzle.tables.batch.status, filterBatchStatus)
   );
-  const sortColumn = resolveColumn(database_schema.tables.batch, sort.column);
+  const sortColumn = resolveColumn(drizzle.tables.batch, sort.column);
   const [{ totalCount }] = await db.select({
     totalCount: drizzleOrm.sql`count(*)`
-  }).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));
+  }).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));
   return {
     batches,
     totalCount
@@ -204,16 +203,16 @@ const getBatchesQuery = async (db, {
 };
 
 const getAccountOpenBatchesQuery = async (db, { accountId }) => {
-  return await db.select().from(database_schema.tables.batch).where(
+  return await db.select().from(drizzle.tables.batch).where(
     drizzleOrm.and(
-      drizzleOrm.eq(database_schema.tables.batch.accountId, accountId),
-      drizzleOrm.eq(database_schema.tables.batch.status, "OPEN")
+      drizzleOrm.eq(drizzle.tables.batch.accountId, accountId),
+      drizzleOrm.eq(drizzle.tables.batch.status, "OPEN")
     )
   );
 };
 
 const getOttQuery = async (db, { ott }) => {
-  return await db.select().from(database_schema.tables.ott).where(drizzleOrm.eq(database_schema.tables.ott.oneTimeToken, ott)).get();
+  return await db.select().from(drizzle.tables.ott).where(drizzleOrm.eq(drizzle.tables.ott.oneTimeToken, ott)).get();
 };
 
 const seperateSupportedPayments = (mappedPayments, accounts) => {
@@ -315,22 +314,6 @@ zod.z.object({
   details: backendSdk.workflowInstanceStatusSchema
 });
 
-const batchAuthorizedEventPayloadSchema = zod.z.object({
-  authorized: zod.z.boolean()
-});
-const processBatchEventInputSchema = zod.z.discriminatedUnion("eventType", [
-  zod.z.object({
-    batchId: zod.z.uuid(),
-    eventType: zod.z.literal(processBatch_workflow.PROCESS_BATCH_WORKFLOW_EVENTS.batchAuthorized),
-    payload: batchAuthorizedEventPayloadSchema
-  })
-  // Future event types can be added here as new objects in the array
-]);
-zod.z.object({
-  success: zod.z.boolean(),
-  message: zod.z.string()
-});
-
 const ALLOWED_PAYMENT_FILTERS = {
   ACCOUNT_ID: "filterPaymentAccountId",
   AMOUNT: "filterPaymentAmount",
@@ -411,14 +394,18 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
     super(ctx, env);
     this.allowedProviders = [];
     this.allowedProviders = config.allowedProviders;
-    this.db = d1.drizzle(this.env.BANK_D1, { schema: database_schema.tables });
+    this.db = d1.drizzle(this.env.BANK_D1, { schema: drizzle.tables });
   }
   async _getAccounts() {
     return await getAllAccountsQuery(this.db);
   }
+  async _getConnectedAccounts() {
+    const accounts = await this._getAccounts();
+    return accounts.filter((acc) => acc.status !== "DISABLED");
+  }
   async _initiateBankConnector({
     connectorKey,
-    withAuth
+    skipAccounts
   }) {
     if (!this.allowedProviders.includes(connectorKey)) {
       throw backendSdk.createInternalError(null, {
@@ -427,55 +414,45 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
         status: 400
       });
     }
-    const accounts = await this._getAccounts();
-    const accountsForConnector = accounts.filter(
-      (acc) => acc.connectorKey === connectorKey && acc.status !== "DISABLED"
-    );
-    const encryptionKey = await processBatch_workflow.importAesKey(this.env.ENCRYPTION_KEY);
-    const accountsWithCredentials = await Promise.all(
-      accountsForConnector.map(async (acc) => {
-        const credentials = await processBatch_workflow.getCredentialsByAccountId(
-          this.db,
-          encryptionKey,
-          {
-            accountId: acc.id
+    let connectedAccounts = [];
+    if (!skipAccounts) {
+      const encryptionKey = await encryption.importAesKey(this.env.ENCRYPTION_KEY);
+      const accounts = await this._getConnectedAccounts();
+      const accountsForConnector = accounts.filter(
+        (acc) => acc.connectorKey === connectorKey
+      );
+      connectedAccounts = await Promise.all(
+        accountsForConnector.map(async (acc) => {
+          const credentials = await encryption.getCredentialsByAccountId(
+            this.db,
+            encryptionKey,
+            {
+              accountId: acc.id
+            }
+          );
+          if (!credentials) {
+            throw backendSdk.createInternalError(null, {
+              message: `No credentials found for account ${acc.id}`,
+              code: "DB-B-001",
+              status: 404
+            });
           }
-        );
-        if (!credentials) {
-          throw backendSdk.createInternalError(null, {
-            message: `No credentials found for account ${acc.id}`,
-            code: "DB-B-001",
-            status: 404
-          });
-        }
-        return {
-          currency: acc.currency,
-          iban: acc.iban,
-          token: credentials.value,
-          id: acc.id,
-          connectorKey: acc.connectorKey
-        };
-      })
-    );
-    this.bankConnector = processBatch_workflow.initiateConnector({
+          return {
+            currency: acc.currency,
+            iban: acc.iban,
+            token: credentials.value,
+            id: acc.id,
+            connectorKey: acc.connectorKey
+          };
+        })
+      );
+    }
+    const connector = encryption.initiateConnector({
       bank: connectorKey,
-      connectedAccounts: accountsWithCredentials,
+      connectedAccounts,
       env: this.env
     });
-    if (!withAuth) return;
-    await this.bankConnector.authenticate();
-  }
-  _accountFetchInterval(connectorKey) {
-    switch (connectorKey) {
-      case "ERSTE":
-        return database_schema.ErsteConnector.FETCH_INTERVAL;
-      case "FINBRICKS":
-        return database_schema.FinbricksConnector.FETCH_INTERVAL;
-      case "MOCK":
-        return database_schema.MockConnector.FETCH_INTERVAL;
-      default:
-        return 0;
-    }
+    return connector;
   }
   async getPayments(input) {
     return this.handleAction(
@@ -563,65 +540,85 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
       await this.updateBatchStatuses();
     }
   }
-  async updateBatchStatuses() {
-    const pendingBatches = await getAllPendingBatchesQuery(this.db);
-    const uniqueConnectors = /* @__PURE__ */ new Set();
-    const accounts = await this._getAccounts();
-    for (const batch of pendingBatches) {
-      const connectorKey = accounts.find(
-        (acc) => acc.id === batch.accountId
-      ).connectorKey;
-      if (!uniqueConnectors.has(connectorKey)) {
-        uniqueConnectors.add(connectorKey);
+  async _resolveSingleBatch(batch, connector) {
+    const previousStatus = batch.status;
+    const currentStatus = await connector.getBatchStatus({
+      batchId: batch.id
+    });
+    let statusChanged = false;
+    if (previousStatus !== currentStatus) {
+      await encryption.upsertBatchCommand(this.db, {
+        batch: {
+          ...batch,
+          status: currentStatus
+        }
+      }).command.execute();
+      statusChanged = true;
+    }
+    return {
+      batchId: batch.id,
+      previousStatus,
+      currentStatus,
+      statusChanged
+      // eventSent,
+    };
+  }
+  async updateBatchStatuses(input) {
+    let pendingBatches;
+    if (input?.batchId) {
+      const batch = await encryption.getBatchByIdQuery(this.db, { batchId: input.batchId });
+      if (!batch) {
+        throw backendSdk.createInternalError(null, {
+          message: `Batch not found: ${input.batchId}`,
+          code: "DB-B-007",
+          status: 404
+        });
       }
+      pendingBatches = [batch];
+    } else {
+      pendingBatches = await getAllPendingBatchesQuery(this.db);
     }
-    const finalBatches = [];
-    for (const connectorKey of uniqueConnectors) {
-      const accs = accounts.filter((acc) => acc.connectorKey === connectorKey);
-      const updatedBatches = await Promise.all(
-        accs.map(async (account) => {
-          const batch = pendingBatches.find((acc) => acc.id === account.id);
-          const newStatus = await this.bankConnector.getBatchStatus({
-            batchId: batch.id
-          });
-          return {
+    const accounts = await this._getConnectedAccounts();
+    console.log(`Processing ${pendingBatches.length} pending batche(s)`);
+    const batchesByConnector = /* @__PURE__ */ new Map();
+    for (const batch of pendingBatches) {
+      const account = accounts.find((acc) => acc.id === batch.accountId);
+      if (!account) {
+        this.logError({
+          message: `Account not found for batch ${batch.id}, skipping`
+        });
+        await encryption.upsertBatchCommand(this.db, {
+          batch: {
             ...batch,
-            status: newStatus
-          };
-        })
-      );
-      finalBatches.push(...updatedBatches);
+            status: "FAILED",
+            statusReason: "ACCOUNT_NOT_FOUND"
+          }
+        }).command.execute();
+        continue;
+      }
+      const batches = batchesByConnector.get(account.connectorKey) || [];
+      batches.push(batch);
+      batchesByConnector.set(account.connectorKey, batches);
     }
-    const updateBatchesCommands = finalBatches.map((batch) => {
-      const { command } = processBatch_workflow.upsertBatchCommand(this.db, {
-        batch: {
-          ...batch
-        }
+    const allResults = [];
+    for (const [connectorKey, batches] of batchesByConnector) {
+      console.log(
+        `Initializing ${connectorKey} connector for ${batches.length} batches`
+      );
+      const connector = await this._initiateBankConnector({
+        connectorKey
       });
-      return command;
-    });
-    await this.db.batch([
-      updateBatchesCommands[0],
-      ...updateBatchesCommands.slice(1)
-    ]);
-    for (const batch of finalBatches) {
-      try {
-        const instance = await this.env.PROCESS_BATCH_WORKFLOW.get(batch.id);
-        if (batch.status === "SIGNED" || batch.status === "SIGNATURE_FAILED") {
-          instance.sendEvent({
-            type: processBatch_workflow.PROCESS_BATCH_WORKFLOW_EVENTS.batchAuthorized,
-            payload: {
-              authorized: batch.status === "SIGNED"
-            }
-          });
+      for (const batch of batches) {
+        const result = await this._resolveSingleBatch(batch, connector);
+        if (result) {
+          allResults.push(result);
         }
-      } catch (_) {
-        console.log(
-          `No workflow instance found for batch ${batch.id}, skipping.`
-        );
       }
     }
-    console.log("Batch update completed");
+    const changedCount = allResults.filter((r) => r.statusChanged).length;
+    console.log(
+      `Batch update completed: ${changedCount} status change(s) detected.`
+    );
   }
   async addPaymentsToBatch({
     paymentsToBatch
@@ -699,7 +696,7 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
         this.log({
           message: availableBatch ? `\u{1F504} Found existing OPEN batches for account ${acc.id}, merging ${availableBatch.payments.length} existing + ${newPayments.length} new payments` : `\u2728 Creating new batch for account ${acc.id} with ${newPayments.length} payments`
         });
-        const { command } = processBatch_workflow.upsertBatchCommand(this.db, {
+        const { command } = encryption.upsertBatchCommand(this.db, {
           batch: availableBatch ? {
             ...availableBatch,
             payments: [...availableBatch.payments, ...newPayments]
@@ -764,23 +761,6 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
       }
     );
   }
-  async processBatchEvent(input) {
-    return this.handleAction(
-      { data: input, schema: processBatchEventInputSchema },
-      { successMessage: "Event sent to batch processing workflow" },
-      async ({ batchId, eventType, payload }) => {
-        const instance = await this.env.PROCESS_BATCH_WORKFLOW.get(batchId);
-        await instance.sendEvent({
-          type: eventType,
-          payload
-        });
-        return {
-          success: true,
-          message: `Event '${eventType}' sent to workflow instance ${batchId}`
-        };
-      }
-    );
-  }
   async queue(b) {
     await this.handleAction(
       null,
@@ -799,7 +779,10 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
       { data: input, schema: getAuthUriInputSchema },
       { successMessage: "Auth URI obtained." },
       async ({ connectorKey }) => {
-        await this._initiateBankConnector({ connectorKey, withAuth: false });
+        const connector = await this._initiateBankConnector({
+          connectorKey,
+          skipAccounts: true
+        });
         const ott = backendSdk.uuidv4();
         const { command: createOneTimeToken } = createOneTimeTokenCommand(
           this.db,
@@ -810,7 +793,7 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
           }
         );
         await createOneTimeToken.execute();
-        const uri = await this.bankConnector.getAuthUri({ ott });
+        const uri = await connector.getAuthUri({ ott });
         return { uri };
       }
     );
@@ -837,10 +820,10 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
             status: 400
           });
         }
-        await this._initiateBankConnector({
+        const connector = await this._initiateBankConnector({
           connectorKey: ottRow.refId
         });
-        const { credentials, accounts } = await this.bankConnector.authorizeAccount({
+        const { credentials, accounts } = await connector.authorizeAccount({
           urlParams
         });
         console.log("Bank connector initiated");
@@ -857,7 +840,7 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
             accountId: acc.id
           }).command
         );
-        const encryptionKey = await processBatch_workflow.importAesKey(this.env.ENCRYPTION_KEY);
+        const encryptionKey = await encryption.importAesKey(this.env.ENCRYPTION_KEY);
         const createAccountCredentials = (await Promise.all(
           credentials.map(
             async (cr) => createAccountCredentialsCommand(this.db, encryptionKey, {
@@ -934,7 +917,7 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
           debtor,
           debtorIban: debtor.iban
         };
-        const { command } = processBatch_workflow.createPaymentCommand(this.db, { payment });
+        const { command } = encryption.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, {
@@ -1021,7 +1004,7 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
       { data: input, schema: disconnectAccountInputSchema },
       { successMessage: "Account disconnected successfully" },
       async ({ accountId }) => {
-        const account = await processBatch_workflow.getAccountByIdQuery(this.db, { accountId });
+        const account = await encryption.getAccountByIdQuery(this.db, { accountId });
         if (!account) {
           throw backendSdk.createInternalError(null, {
             message: "Account not found",