@develit-services/bank 0.3.44 → 0.3.46

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.C335-raZ.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.DwyrLcKu.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.ClRIj2Ma.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) => {
@@ -261,7 +260,9 @@ const getAuthUriInputSchema = zod.z.object({
 
 const authorizeAccountInputSchema = zod.z.object({
   ott: zod.z.string(),
-  urlParams: zod.z.string()
+  urlParams: zod.z.string(),
+  syncIntervalS: zod.z.number().int().positive().optional(),
+  startSync: zod.z.boolean().optional()
 });
 
 const simulateDepositInputSchema = zod.z.object({
@@ -315,20 +316,12 @@ 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
-]);
+const updateBatchStatusesInputSchema = zod.z.object({
+  batchId: zod.z.uuid().optional()
+}).optional();
 zod.z.object({
-  success: zod.z.boolean(),
-  message: zod.z.string()
+  processed: zod.z.number(),
+  statusChanged: zod.z.number()
 });
 
 const ALLOWED_PAYMENT_FILTERS = {
@@ -411,14 +404,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 +424,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 +550,97 @@ 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;
     }
-    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 {
+      batchId: batch.id,
+      previousStatus,
+      currentStatus,
+      statusChanged
+      // eventSent,
+    };
+  }
+  async updateBatchStatuses(input) {
+    return this.handleAction(
+      { data: input, schema: updateBatchStatusesInputSchema },
+      { successMessage: "Batch statuses updated" },
+      async (validatedInput) => {
+        let pendingBatches;
+        if (validatedInput?.batchId) {
+          const batch = await encryption.getBatchByIdQuery(this.db, {
+            batchId: validatedInput.batchId
           });
-          return {
-            ...batch,
-            status: newStatus
-          };
-        })
-      );
-      finalBatches.push(...updatedBatches);
-    }
-    const updateBatchesCommands = finalBatches.map((batch) => {
-      const { command } = processBatch_workflow.upsertBatchCommand(this.db, {
-        batch: {
-          ...batch
+          if (!batch) {
+            throw backendSdk.createInternalError(null, {
+              message: `Batch not found: ${validatedInput.batchId}`,
+              code: "DB-B-007",
+              status: 404
+            });
+          }
+          pendingBatches = [batch];
+        } else {
+          pendingBatches = await getAllPendingBatchesQuery(this.db);
         }
-      });
-      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"
-            }
+        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: "FAILED",
+                statusReason: "ACCOUNT_NOT_FOUND"
+              }
+            }).command.execute();
+            continue;
+          }
+          const batches = batchesByConnector.get(account.connectorKey) || [];
+          batches.push(batch);
+          batchesByConnector.set(account.connectorKey, batches);
+        }
+        const allResults = [];
+        for (const [connectorKey, batches] of batchesByConnector) {
+          console.log(
+            `Initializing ${connectorKey} connector for ${batches.length} batches`
+          );
+          const connector = await this._initiateBankConnector({
+            connectorKey
           });
+          for (const batch of batches) {
+            const result = await this._resolveSingleBatch(batch, connector);
+            if (result) {
+              allResults.push(result);
+            }
+          }
         }
-      } catch (_) {
+        const changedCount = allResults.filter((r) => r.statusChanged).length;
         console.log(
-          `No workflow instance found for batch ${batch.id}, skipping.`
+          `Batch update completed: ${changedCount} status change(s) detected`
         );
+        return {
+          processed: allResults.length,
+          statusChanged: changedCount
+        };
       }
-    }
-    console.log("Batch update completed");
+    );
   }
   async addPaymentsToBatch({
     paymentsToBatch
@@ -699,7 +718,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 +783,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 +801,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 +815,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 };
       }
     );
@@ -819,7 +824,7 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
     return this.handleAction(
       { data: input, schema: authorizeAccountInputSchema },
       { successMessage: "Erste code saved." },
-      async ({ ott, urlParams }) => {
+      async ({ ott, urlParams, syncIntervalS, startSync }) => {
         const ottRow = await getOttQuery(this.db, {
           ott
         });
@@ -837,10 +842,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");
@@ -849,7 +854,7 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
         );
         const upsertAccounts = accounts.map(
           (acc) => upsertAccountCommand(this.db, {
-            account: acc
+            account: syncIntervalS ? { ...acc, syncIntervalS } : acc
           }).command
         );
         const deleteCredentials = alreadyExistingAccounts.map(
@@ -857,7 +862,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, {
@@ -881,6 +886,19 @@ let BankServiceBase = class extends backendSdk.develitWorker(cloudflare_workers.
             code: "DB-B-003",
             status: 404
           });
+        if (startSync) {
+          for (const account of fetchedAccounts) {
+            const { error } = await this.syncAccount({
+              accountId: account.id
+            });
+            if (error) {
+              this.logError({
+                message: `Failed to auto-start sync workflow for account ${account.id}`,
+                error
+              });
+            }
+          }
+        }
         return {
           accounts: fetchedAccounts
         };
@@ -934,7 +952,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 +1039,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",