@develit-services/bank 0.2.4 → 0.3.0

package/dist/export/worker.mjs

@@ -1,17 +1,19 @@
 import { uuidv4, bankAccountMetadataSchema, workflowInstanceStatusSchema, develitWorker, createInternalError, first, action, service } from '@develit-io/backend-sdk';
 import { WorkerEntrypoint } from 'cloudflare:workers';
 import { drizzle } from 'drizzle-orm/d1';
-import { t as tables, c as INSTRUCTION_PRIORITIES, C as CHARGE_BEARERS, P as PAYMENT_TYPES, g as CONNECTOR_KEYS, B as BATCH_STATUSES, d as PAYMENT_STATUSES, e as PAYMENT_DIRECTIONS, i as accountInsertSchema, M as MockConnector, F as FinbricksConnector, E as ErsteConnector } from '../shared/bank.DXn9jD0Q.mjs';
+import { t as tables, c as INSTRUCTION_PRIORITIES, C as CHARGE_BEARERS, P as PAYMENT_TYPES, g as CONNECTOR_KEYS, B as BATCH_STATUSES, d as PAYMENT_STATUSES, e as PAYMENT_DIRECTIONS, i as accountInsertSchema, M as MockConnector, F as FinbricksConnector, E as ErsteConnector } from '../shared/bank.lZMrqjVR.mjs';
 import 'jose';
 import { CURRENCY_CODES } from '@develit-io/general-codes';
 import { z } from 'zod';
-import { e as encrypt, i as importAesKey, g as getCredentialsByAccountId, a as initiateConnector, c as createPaymentCommand } from '../shared/bank.BvUtf1S3.mjs';
+import { e as encrypt, P as PROCESS_BATCH_WORKFLOW_EVENTS, i as importAesKey, a as getCredentialsByAccountId, b as initiateConnector, u as upsertBatchCommand, c as createPaymentCommand, g as getAccountByIdQuery } from '../shared/bank.mZtcXaJo.mjs';
 import { eq, inArray, and, sql, asc, desc, gte, lte } from 'drizzle-orm';
 import 'drizzle-orm/sqlite-core';
 import 'date-fns';
 import 'drizzle-zod';
 import 'drizzle-orm/relations';
-import '../shared/bank.DKtu6cfY.mjs';
+import 'node:crypto';
+import 'cloudflare:workflows';
+import '../shared/bank.CthUj-ff.mjs';
 
 const upsertAccountCommand = (db, { account }) => {
   const id = account.id || uuidv4();
@@ -27,29 +29,6 @@ const upsertAccountCommand = (db, { account }) => {
   };
 };
 
-const updatePaymentCommand = (db, { payment }) => {
-  return {
-    command: db.update(tables.payment).set(payment).where(eq(tables.payment.id, payment.id)).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 createOneTimeTokenCommand = (db, {
   ott,
   refId,
@@ -67,6 +46,12 @@ const createOneTimeTokenCommand = (db, {
   return { id, command };
 };
 
+const updateAccountCommand = (db, { account }) => {
+  return {
+    command: db.update(tables.account).set({ ...account }).where(eq(tables.account.id, account.id)).returning()
+  };
+};
+
 const expireOneTimeTokenCommand = (db, {
   ott
 }) => {
@@ -98,6 +83,15 @@ const deleteAccountCredentialsCommand = (db, { accountId }) => {
   };
 };
 
+const deletePaymentsByAccountCommand = (db, { accountId }) => {
+  const command = db.update(tables.payment).set({
+    deletedAt: /* @__PURE__ */ new Date()
+  }).where(eq(tables.payment.accountId, accountId));
+  return {
+    command
+  };
+};
+
 const getAccountByIbanQuery = async (db, { iban }) => {
   return await db.select().from(tables.account).where(eq(tables.account.iban, iban)).get();
 };
@@ -116,13 +110,7 @@ const getAllAccountsQuery = async (db) => {
 };
 
 const getAllPendingBatchesQuery = (db) => {
-  return db.select().from(tables.batch).where(
-    inArray(tables.batch.status, [
-      "PROCESSING",
-      "READY_TO_SIGN",
-      "WAITING_FOR_PROCESSING"
-    ])
-  );
+  return db.select().from(tables.batch).where(inArray(tables.batch.status, ["READY_TO_SIGN"]));
 };
 
 const buildMultiFilterConditions = (column, value) => {
@@ -152,6 +140,7 @@ const getPaymentsWithPaginationQuery = async (db, {
   limit,
   page,
   sort,
+  ids,
   filterPaymentAccountId,
   filterPaymentAmount,
   filterPaymentCurrency,
@@ -176,7 +165,8 @@ const getPaymentsWithPaginationQuery = async (db, {
     buildMultiFilterConditions(
       tables.payment.direction,
       filterPaymentyDirection
-    )
+    ),
+    buildMultiFilterConditions(tables.payment.id, ids)
   );
   const sortColumn = resolveColumn(tables.payment, sort.column);
   const [{ totalCount }] = await db.select({
@@ -224,11 +214,6 @@ const getOttQuery = async (db, { ott }) => {
   return await db.select().from(tables.ott).where(eq(tables.ott.oneTimeToken, ott)).get();
 };
 
-const getPaymentByRefIdQuery = async (db, { refId }) => {
-  const payment = await db.select().from(tables.payment).where(eq(tables.payment.refId, refId)).limit(1).get();
-  return payment;
-};
-
 const seperateSupportedPayments = (mappedPayments, accounts) => {
   const [supportedPayments, unsupportedPayments] = mappedPayments.reduce(
     ([valid, invalid], payment) => {
@@ -305,8 +290,43 @@ const getBatchesInputSchema = z.object({
 });
 
 const processBatchInputSchema = z.object({
-  connectorKey: z.enum(CONNECTOR_KEYS),
-  batch: z.custom()
+  batchId: z.uuid()
+});
+z.object({
+  instanceId: z.string(),
+  details: workflowInstanceStatusSchema
+});
+
+const processBatchStatusInputSchema = z.object({
+  batchId: z.uuid()
+});
+z.object({
+  instanceId: z.string(),
+  details: workflowInstanceStatusSchema
+});
+
+const processBatchRestartInputSchema = z.object({
+  batchId: z.uuid()
+});
+z.object({
+  instanceId: z.string(),
+  details: workflowInstanceStatusSchema
+});
+
+const batchAuthorizedEventPayloadSchema = z.object({
+  authorized: z.boolean()
+});
+const processBatchEventInputSchema = z.discriminatedUnion("eventType", [
+  z.object({
+    batchId: z.uuid(),
+    eventType: z.literal(PROCESS_BATCH_WORKFLOW_EVENTS.batchAuthorized),
+    payload: batchAuthorizedEventPayloadSchema
+  })
+  // Future event types can be added here as new objects in the array
+]);
+z.object({
+  success: z.boolean(),
+  message: z.string()
 });
 
 const ALLOWED_PAYMENT_FILTERS = {
@@ -325,6 +345,7 @@ const getPaymentsInputSchema = z.object({
     column: z.enum(["createdAt", "updatedAt", "amount"]),
     direction: z.enum(["asc", "desc"])
   }),
+  ids: z.array(z.uuid()).optional(),
   [ALLOWED_PAYMENT_FILTERS.ACCOUNT_ID]: z.union([z.uuid(), z.uuid().array()]).optional(),
   [ALLOWED_PAYMENT_FILTERS.AMOUNT]: z.union([z.number(), z.number().array()]).optional(),
   [ALLOWED_PAYMENT_FILTERS.CURRENCY]: z.union([z.enum(CURRENCY_CODES), z.enum(CURRENCY_CODES).array()]).optional(),
@@ -369,6 +390,10 @@ const updateAccountInputSchema = z.object({
   account: accountInsertSchema
 });
 
+const disconnectAccountInputSchema = z.object({
+  accountId: z.uuid()
+});
+
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __decorateClass = (decorators, target, key, kind) => {
@@ -567,11 +592,27 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
       });
       return command;
     });
-    console.log("Updated batches", finalBatches);
     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: PROCESS_BATCH_WORKFLOW_EVENTS.batchAuthorized,
+            payload: {
+              authorized: batch.status === "SIGNED"
+            }
+          });
+        }
+      } catch (_) {
+        console.log(
+          `No workflow instance found for batch ${batch.id}, skipping.`
+        );
+      }
+    }
     console.log("Batch update completed");
   }
   async addPaymentsToBatch({
@@ -673,122 +714,62 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
   async processBatch(input) {
     return this.handleAction(
       { data: input, schema: processBatchInputSchema },
-      {},
-      async ({ batch, connectorKey }) => {
-        await upsertBatchCommand(this.db, {
-          batch: {
-            ...batch,
-            status: "PROCESSING"
+      { successMessage: "Batch processing workflow started" },
+      async ({ batchId }) => {
+        const instance = await this.env.PROCESS_BATCH_WORKFLOW.create({
+          id: batchId,
+          params: {
+            batchId
           }
-        }).command.execute();
-        await this._initiateBankConnector({ connectorKey });
-        if (!this.bankConnector) {
-          await upsertBatchCommand(this.db, {
-            batch: {
-              ...batch,
-              status: "FAILED"
-            }
-          }).command.execute();
-          throw createInternalError(null, {
-            message: `\u274C Failed to initialize ${connectorKey} bank connector`
-          });
-        }
-        this.log({
-          message: `\u2705 Bank connector initialized successfully for account ${connectorKey}`
         });
-        const preparedBatch = {
-          retriedPayments: [],
-          newlyPreparedPayments: [],
-          failedPayments: []
+        return {
+          instanceId: instance.id,
+          details: await instance.status()
         };
-        for (const payment of batch.payments) {
-          const existingPayment = await getPaymentByRefIdQuery(this.db, {
-            refId: payment.refId
-          });
-          if (existingPayment) {
-            preparedBatch.retriedPayments.push({
-              ...existingPayment,
-              status: "PREPARED"
-            });
-            this.log({
-              message: `\u2705 Payment ${existingPayment.id} already exists`
-            });
-            continue;
-          }
-          const newlyPreparedPayment = await this.bankConnector.preparePayment(payment);
-          if (!newlyPreparedPayment) {
-            preparedBatch.failedPayments.push({ ...payment, status: "FAILED" });
-            continue;
-          }
-          preparedBatch.newlyPreparedPayments.push(newlyPreparedPayment);
-        }
-        await Promise.all([
-          [
-            ...preparedBatch.failedPayments,
-            ...preparedBatch.newlyPreparedPayments
-          ].map(
-            (p) => createPaymentCommand(this.db, { payment: p }).command.execute()
-          )
-        ]);
-        await upsertBatchCommand(this.db, {
-          batch: {
-            ...batch,
-            status: "PREPARED"
-          }
-        }).command.execute();
-        const { authorizationUrls, payments, metadata } = await this.bankConnector.initiateBatchFromPayments({
-          payments: [
-            ...preparedBatch.newlyPreparedPayments,
-            ...preparedBatch.retriedPayments
-          ]
-        });
-        console.log(authorizationUrls, "AUTH URIS FROM BANK");
-        if (!authorizationUrls.length) {
-          this.logError({ message: "Failed to retrieve signing URI" });
-          await upsertBatchCommand(this.db, {
-            batch: {
-              ...batch,
-              status: "FAILED"
-            }
-          }).command.execute();
-          return;
-        }
-        const { command: upsertBatch } = upsertBatchCommand(this.db, {
-          batch: {
-            ...batch,
-            payments,
-            metadata,
-            status: "READY_TO_SIGN",
-            authorizationUrls,
-            batchPaymentInitiatedAt: /* @__PURE__ */ new Date()
-          }
-        });
-        const updatePayments = payments.map(
-          (payment) => updatePaymentCommand(this.db, {
-            payment: { ...payment, status: "INITIALIZED" }
-          }).command
-        );
-        await this.db.batch([upsertBatch, ...updatePayments]);
-        this.log({
-          message: "Authorization Urls for batch to create",
-          authorizationUrl: authorizationUrls[0]
-        });
-        await this.pushToQueue(this.env.NOTIFICATIONS_QUEUE, {
-          type: "email",
-          payload: {
-            email: {
-              to: [this.env.BANK_AUTH_RECIPIENT],
-              subject: "Payment Authorization",
-              text: authorizationUrls[0] || "No Authorization Url"
-            }
-          },
-          metadata: {
-            initiator: {
-              service: this.name
-            }
-          }
+      }
+    );
+  }
+  async processBatchStatus(input) {
+    return this.handleAction(
+      { data: input, schema: processBatchStatusInputSchema },
+      { successMessage: "Batch processing workflow status retrieved" },
+      async ({ batchId }) => {
+        const instance = await this.env.PROCESS_BATCH_WORKFLOW.get(batchId);
+        return {
+          instanceId: instance.id,
+          details: await instance.status()
+        };
+      }
+    );
+  }
+  async processBatchRestart(input) {
+    return this.handleAction(
+      { data: input, schema: processBatchRestartInputSchema },
+      { successMessage: "Batch processing workflow restarted" },
+      async ({ batchId }) => {
+        const instance = await this.env.PROCESS_BATCH_WORKFLOW.get(batchId);
+        await instance.restart();
+        return {
+          instanceId: instance.id,
+          details: await instance.status()
+        };
+      }
+    );
+  }
+  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
         });
-        this.logOutput({ message: "Batch successfully processed" });
+        return {
+          success: true,
+          message: `Event '${eventType}' sent to workflow instance ${batchId}`
+        };
       }
     );
   }
@@ -1027,6 +1008,64 @@ let BankServiceBase = class extends develitWorker(WorkerEntrypoint) {
       }
     );
   }
+  async disconnectAccount(input) {
+    return this.handleAction(
+      { data: input, schema: disconnectAccountInputSchema },
+      { successMessage: "Account disconnected successfully" },
+      async ({ accountId }) => {
+        const account = await getAccountByIdQuery(this.db, { accountId });
+        if (!account) {
+          throw createInternalError(null, {
+            message: "Account not found",
+            code: "ACCOUNT_NOT_FOUND",
+            status: 404
+          });
+        }
+        try {
+          const instance = await this.env.SYNC_ACCOUNT_PAYMENTS_WORKFLOW.get(accountId);
+          await instance.terminate();
+        } catch (error) {
+          this.log({
+            message: "No workflow instance found for account, skipping termination.",
+            error
+          });
+        }
+        const { command: updateAccount } = updateAccountCommand(this.db, {
+          account: {
+            ...account,
+            id: accountId,
+            status: "DISABLED"
+          }
+        });
+        const { command: deleteCredentials } = deleteAccountCredentialsCommand(
+          this.db,
+          {
+            accountId
+          }
+        );
+        const { command: deletePayments } = deletePaymentsByAccountCommand(
+          this.db,
+          {
+            accountId
+          }
+        );
+        const [updatedAccountResult] = await this.db.batch([
+          updateAccount,
+          deleteCredentials,
+          deletePayments
+        ]);
+        const updatedAccount = first(updatedAccountResult);
+        if (!updatedAccount) {
+          throw createInternalError(null, {
+            message: "Account not updated",
+            code: "DB-B-0?",
+            status: 404
+          });
+        }
+        return updatedAccount;
+      }
+    );
+  }
   async getBatches(input) {
     return this.handleAction(
       { data: input, schema: getBatchesInputSchema },
@@ -1079,6 +1118,9 @@ __decorateClass([
 __decorateClass([
   action("update-account")
 ], BankServiceBase.prototype, "updateAccount", 1);
+__decorateClass([
+  action("disconnectAccount")
+], BankServiceBase.prototype, "disconnectAccount", 1);
 __decorateClass([
   action("getBatches")
 ], BankServiceBase.prototype, "getBatches", 1);

package/dist/export/workflows.cjs

@@ -3,9 +3,9 @@
 const cloudflare_workers = require('cloudflare:workers');
 const cloudflare_workflows = require('cloudflare:workflows');
 const d1 = require('drizzle-orm/d1');
-const database_schema = require('../shared/bank.NdqOkgpd.cjs');
+const database_schema = require('../shared/bank.CpcK1Dse.cjs');
 const backendSdk = require('@develit-io/backend-sdk');
-const encryption = require('../shared/bank.CHS79KTx.cjs');
+const processBatch_workflow = require('../shared/bank.CIJDq7GL.cjs');
 const drizzleOrm = require('drizzle-orm');
 require('drizzle-orm/sqlite-core');
 require('date-fns');
@@ -13,7 +13,8 @@ require('jose');
 require('@develit-io/general-codes');
 require('drizzle-zod');
 require('drizzle-orm/relations');
-require('../shared/bank.CyinOg3r.cjs');
+require('node:crypto');
+require('../shared/bank.BGuS_o9V.cjs');
 
 const updateAccountLastSyncCommand = (db, {
   lastSyncAt,
@@ -29,10 +30,6 @@ const updateAccountLastSyncCommand = (db, {
   };
 };
 
-const getAccountByIdQuery = async (db, { accountId }) => {
-  return await db.select().from(database_schema.tables.account).where(drizzleOrm.eq(database_schema.tables.account.id, accountId)).get();
-};
-
 function pushToQueue(queue, message) {
   if (!Array.isArray(message)) return queue.send(message, { contentType: "v8" });
   return queue.sendBatch(
@@ -42,14 +39,14 @@ function pushToQueue(queue, message) {
     }))
   );
 }
-class SyncAccountPaymentsWorkflow extends cloudflare_workers.WorkflowEntrypoint {
+class BankSyncAccountPaymentsWorkflow extends cloudflare_workers.WorkflowEntrypoint {
   async run(event, step) {
     const { accountId } = event.payload;
     const db = d1.drizzle(this.env.BANK_D1, { schema: database_schema.tables });
     while (true) {
       const now = /* @__PURE__ */ new Date();
       const account = await step.do("load account", async () => {
-        const account2 = await getAccountByIdQuery(db, { accountId });
+        const account2 = await processBatch_workflow.getAccountByIdQuery(db, { accountId });
         if (!account2) {
           throw new cloudflare_workflows.NonRetryableError(`Bank account not found: ${accountId}`);
         }
@@ -66,8 +63,8 @@ class SyncAccountPaymentsWorkflow extends cloudflare_workers.WorkflowEntrypoint
           timeout: "30 seconds"
         },
         async () => {
-          const encryptionKey = await encryption.importAesKey(this.env.ENCRYPTION_KEY);
-          const credentials = await encryption.getCredentialsByAccountId(
+          const encryptionKey = await processBatch_workflow.importAesKey(this.env.ENCRYPTION_KEY);
+          const credentials = await processBatch_workflow.getCredentialsByAccountId(
             db,
             encryptionKey,
             { accountId }
@@ -82,7 +79,7 @@ class SyncAccountPaymentsWorkflow extends cloudflare_workers.WorkflowEntrypoint
               `Credentials have expired for account: ${accountId}`
             );
           }
-          const connector = encryption.initiateConnector({
+          const connector = processBatch_workflow.initiateConnector({
             env: this.env,
             bank: account.connectorKey,
             connectedAccounts: [
@@ -114,7 +111,7 @@ class SyncAccountPaymentsWorkflow extends cloudflare_workers.WorkflowEntrypoint
           async () => {
             const eventsToEmit = [];
             const createCommands = paymentsToInsert.map(
-              (p) => encryption.createPaymentCommand(db, { payment: p.parsed }).command
+              (p) => processBatch_workflow.createPaymentCommand(db, { payment: p.parsed }).command
             );
             eventsToEmit.push(
               ...paymentsToInsert.map((p) => ({
@@ -167,4 +164,5 @@ class SyncAccountPaymentsWorkflow extends cloudflare_workers.WorkflowEntrypoint
   }
 }
 
-exports.SyncAccountPaymentsWorkflow = SyncAccountPaymentsWorkflow;
+exports.BankProcessBatchWorkflow = processBatch_workflow.BankProcessBatchWorkflow;
+exports.BankSyncAccountPaymentsWorkflow = BankSyncAccountPaymentsWorkflow;

package/dist/export/workflows.d.cts

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

package/dist/export/workflows.d.mts

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

package/dist/export/workflows.d.ts

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

package/dist/export/workflows.mjs

@@ -1,9 +1,10 @@
 import { WorkflowEntrypoint } from 'cloudflare:workers';
 import { NonRetryableError } from 'cloudflare:workflows';
 import { drizzle } from 'drizzle-orm/d1';
-import { t as tables } from '../shared/bank.DXn9jD0Q.mjs';
+import { t as tables } from '../shared/bank.lZMrqjVR.mjs';
 import { asNonEmpty } from '@develit-io/backend-sdk';
-import { i as importAesKey, g as getCredentialsByAccountId, a as initiateConnector, c as createPaymentCommand } from '../shared/bank.BvUtf1S3.mjs';
+import { g as getAccountByIdQuery, i as importAesKey, a as getCredentialsByAccountId, b as initiateConnector, c as createPaymentCommand } from '../shared/bank.mZtcXaJo.mjs';
+export { B as BankProcessBatchWorkflow } from '../shared/bank.mZtcXaJo.mjs';
 import { eq } from 'drizzle-orm';
 import 'drizzle-orm/sqlite-core';
 import 'date-fns';
@@ -11,7 +12,8 @@ import 'jose';
 import '@develit-io/general-codes';
 import 'drizzle-zod';
 import 'drizzle-orm/relations';
-import '../shared/bank.DKtu6cfY.mjs';
+import 'node:crypto';
+import '../shared/bank.CthUj-ff.mjs';
 
 const updateAccountLastSyncCommand = (db, {
   lastSyncAt,
@@ -27,10 +29,6 @@ const updateAccountLastSyncCommand = (db, {
   };
 };
 
-const getAccountByIdQuery = async (db, { accountId }) => {
-  return await db.select().from(tables.account).where(eq(tables.account.id, accountId)).get();
-};
-
 function pushToQueue(queue, message) {
   if (!Array.isArray(message)) return queue.send(message, { contentType: "v8" });
   return queue.sendBatch(
@@ -40,7 +38,7 @@ function pushToQueue(queue, message) {
     }))
   );
 }
-class SyncAccountPaymentsWorkflow extends WorkflowEntrypoint {
+class BankSyncAccountPaymentsWorkflow extends WorkflowEntrypoint {
   async run(event, step) {
     const { accountId } = event.payload;
     const db = drizzle(this.env.BANK_D1, { schema: tables });
@@ -165,4 +163,4 @@ class SyncAccountPaymentsWorkflow extends WorkflowEntrypoint {
   }
 }
 
-export { SyncAccountPaymentsWorkflow };
+export { BankSyncAccountPaymentsWorkflow };

package/dist/export/wrangler.cjs

@@ -37,9 +37,14 @@ function defineBankServiceWrangler(config) {
     ],
     workflows: [
       {
-        name: `${project}-sync-account-payments`,
+        name: `${project}-bank-sync-account-payments`,
         binding: "SYNC_ACCOUNT_PAYMENTS_WORKFLOW",
-        class_name: "SyncAccountPaymentsWorkflow"
+        class_name: "BankSyncAccountPaymentsWorkflow"
+      },
+      {
+        name: `${project}-bank-process-batch`,
+        binding: "PROCESS_BATCH_WORKFLOW",
+        class_name: "BankProcessBatchWorkflow"
       }
     ],
     queues: {