@develit-services/bank 0.0.44 → 0.1.1

package/dist/shared/bank.DJ9d1yaR.mjs

@@ -0,0 +1,269 @@
+import { WorkflowEntrypoint } from 'cloudflare:workers';
+import { NonRetryableError } from 'cloudflare:workflows';
+import { drizzle } from 'drizzle-orm/d1';
+import { t as tables, F as FinbricksConnector, M as MockConnector, E as ErsteConnector, v as getPaymentDirection } from './bank.RUV2HUFo.mjs';
+import '@develit-io/backend-sdk';
+import { eq, inArray } from 'drizzle-orm';
+import { M as MockCobsConnector } from './bank.8lAQLFNI.mjs';
+import 'jose';
+import '@develit-io/general-codes';
+
+const createPaymentCommand = (db, { payment }) => {
+  return {
+    command: db.insert(tables.payment).values(payment).returning()
+  };
+};
+
+const updatePaymentCommand = (db, { payment }) => {
+  return {
+    command: db.update(tables.payment).set(payment).where(eq(tables.payment.id, payment.id)).returning()
+  };
+};
+
+const updateAccountLastSyncCommand = (db, { lastSyncedAt, accountId }) => {
+  const command = db.update(tables.account).set({
+    lastSyncedAt
+  }).where(eq(tables.account.id, accountId)).returning();
+  return {
+    command
+  };
+};
+
+const getAccountByIdQuery = async (db, { accountId }) => {
+  return await db.select().from(tables.account).where(eq(tables.account.id, accountId)).get();
+};
+
+const getCredentialsByAccountId = async (db, { accountId }) => {
+  const cred = await db.select().from(tables.accountCredentials).where(eq(tables.accountCredentials.accountId, accountId)).get();
+  return cred;
+};
+
+const getPaymentsByBankRefIdsQuery = async (db, { ids }) => {
+  return await db.select().from(tables.payment).where(inArray(tables.payment.bankRefId, ids));
+};
+
+class CreditasConnector extends FinbricksConnector {
+  constructor(config) {
+    super("CREDITAS", config);
+  }
+}
+
+class FioConnector extends FinbricksConnector {
+  constructor(config) {
+    super("FIO", config);
+  }
+}
+
+class MonetaConnector extends FinbricksConnector {
+  constructor(config) {
+    super("MONETA", config);
+  }
+}
+
+const initiateConnector = ({
+  bank,
+  env,
+  connectedAccounts
+}) => {
+  switch (bank) {
+    case "ERSTE":
+      return new ErsteConnector({
+        API_KEY: env.ERSTE_API_KEY,
+        CLIENT_ID: env.ERSTE_CLIENT_ID,
+        CLIENT_SECRET: env.ERSTE_CLIENT_SECRET,
+        REDIRECT_URI: env.REDIRECT_URI,
+        AUTH_URI: env.ERSTE_AUTH_URI,
+        PAYMENTS_URI: env.ERSTE_PAYMENTS_URI,
+        ACCOUNTS_URI: env.ERSTE_ACCOUNTS_URI,
+        connectedAccounts
+      });
+    case "CREDITAS":
+      return new CreditasConnector({
+        BASE_URI: env.FINBRICKS_BASE_URI,
+        MERCHANT_ID: env.FINBRICKS_MERCHANT_ID,
+        PRIVATE_KEY_PEM: env.FINBRICKS_PRIVATE_KEY_PEM,
+        REDIRECT_URI: env.REDIRECT_URI,
+        connectedAccounts
+      });
+    case "MOCK_COBS":
+      return new MockCobsConnector({
+        BASE_URI: env.FINBRICKS_BASE_URI,
+        MERCHANT_ID: env.FINBRICKS_MERCHANT_ID,
+        PRIVATE_KEY_PEM: env.FINBRICKS_PRIVATE_KEY_PEM,
+        REDIRECT_URI: env.REDIRECT_URI,
+        connectedAccounts
+      });
+    case "FIO":
+      return new FioConnector({
+        BASE_URI: env.FINBRICKS_BASE_URI,
+        MERCHANT_ID: env.FINBRICKS_MERCHANT_ID,
+        PRIVATE_KEY_PEM: env.FINBRICKS_PRIVATE_KEY_PEM,
+        REDIRECT_URI: env.REDIRECT_URI,
+        connectedAccounts
+      });
+    case "MONETA":
+      return new MonetaConnector({
+        BASE_URI: env.FINBRICKS_BASE_URI,
+        MERCHANT_ID: env.FINBRICKS_MERCHANT_ID,
+        PRIVATE_KEY_PEM: env.FINBRICKS_PRIVATE_KEY_PEM,
+        REDIRECT_URI: env.REDIRECT_URI,
+        connectedAccounts
+      });
+    default:
+      return new MockConnector();
+  }
+};
+
+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 SyncAccountPaymentsWorkflow extends WorkflowEntrypoint {
+  async run(event, step) {
+    const { accountId } = event.payload;
+    const db = drizzle(this.env.BANK_D1, { schema: tables });
+    while (true) {
+      const account = await step.do("load account", async () => {
+        const account2 = await getAccountByIdQuery(db, { accountId });
+        if (!account2) {
+          throw new NonRetryableError(`Bank account not found: ${accountId}`);
+        }
+        return account2;
+      });
+      if (!account.lastSyncedAt) {
+        throw new NonRetryableError(
+          `lastSyncedAt is not set for account: ${accountId}`
+        );
+      }
+      const credentials = await step.do(
+        "load account credentials",
+        async () => {
+          const credentials2 = await getCredentialsByAccountId(db, { accountId });
+          if (!credentials2) {
+            throw new NonRetryableError(
+              `No credentials found for account: ${accountId}`
+            );
+          }
+          return credentials2;
+        }
+      );
+      const connector = await step.do(
+        `init ${account.connectorKey} connector`,
+        async () => {
+          return initiateConnector({
+            env: this.env,
+            bank: account.connectorKey,
+            connectedAccounts: [
+              {
+                ...account,
+                iban: account.iban,
+                token: credentials.value
+              }
+            ]
+          });
+        }
+      );
+      const payments = await step.do(
+        "fetch bank payments",
+        {
+          retries: { limit: 5, delay: 2e3, backoff: "constant" },
+          timeout: "30 seconds"
+        },
+        async () => {
+          const fetched = await connector.getAllAccountPayments({
+            environment: this.env.ENVIRONMENT,
+            db,
+            account,
+            filter: { dateFrom: account.lastSyncedAt }
+          });
+          return fetched.map((p) => ({
+            ...p,
+            direction: getPaymentDirection(p, account.iban)
+          }));
+        }
+      );
+      if (payments.length === 0) {
+        return { status: "no_new_payments" };
+      }
+      const bankRefIds = payments.map((payment) => payment.bankRefId).filter(Boolean);
+      const existing = await step.do("load existing payments", async () => {
+        return await getPaymentsByBankRefIdsQuery(db, {
+          ids: bankRefIds
+        });
+      });
+      const paymentsToUpdate = payments.filter(
+        (p) => existing.some((e) => e.bankRefId === p.bankRefId)
+      );
+      if (paymentsToUpdate.length)
+        await step.do("update existing payments", async () => {
+          const commands = paymentsToUpdate.map(
+            (p) => updatePaymentCommand(db, { payment: p }).command
+          );
+          await db.batch([commands[0], ...commands.slice(1)]);
+          await pushToQueue(
+            this.env.QUEUE_BUS_QUEUE,
+            paymentsToUpdate.map((p) => ({
+              eventType: "BANK_PAYMENT",
+              eventSignal: "paymentUpdated",
+              bankPayment: p,
+              metadata: {
+                correlationId: p.correlationId,
+                entityId: p.id,
+                idempotencySuffix: p.status,
+                timestamp: (/* @__PURE__ */ new Date()).toDateString()
+              }
+            }))
+          );
+        });
+      const paymentsToCreate = payments.filter(
+        (p) => !existing.some((e) => e.bankRefId === p.bankRefId)
+      );
+      if (paymentsToCreate.length)
+        await step.do("create new payments", async () => {
+          const commands = paymentsToCreate.map(
+            (p) => createPaymentCommand(db, { payment: p }).command
+          );
+          await db.batch([commands[0], ...commands.slice(1)]);
+          await pushToQueue(
+            this.env.QUEUE_BUS_QUEUE,
+            paymentsToCreate.map((p) => ({
+              eventType: "BANK_PAYMENT",
+              eventSignal: "paymentCreated",
+              bankPayment: p,
+              metadata: {
+                correlationId: p.correlationId,
+                entityId: p.id,
+                timestamp: (/* @__PURE__ */ new Date()).toDateString()
+              }
+            }))
+          );
+        });
+      await step.do("determine new lastSyncedAt", async () => {
+        const latest = payments.reduce((current, p) => {
+          return new Date(p.createdAt).getTime() > new Date(current.createdAt).getTime() ? p : current;
+        }, payments[0]);
+        await updateAccountLastSyncCommand(db, {
+          accountId: account.id,
+          lastSyncedAt: latest.createdAt
+        }).command.execute();
+        return latest.createdAt;
+      });
+      await step.sleep(
+        "Sleep for next sync",
+        `${account.syncIntervalS} seconds`
+      );
+    }
+  }
+}
+
+const workflows = {
+  __proto__: null,
+  SyncAccountPaymentsWorkflow: SyncAccountPaymentsWorkflow
+};
+
+export { SyncAccountPaymentsWorkflow as S, updateAccountLastSyncCommand as a, getCredentialsByAccountId as b, createPaymentCommand as c, getPaymentsByBankRefIdsQuery as g, initiateConnector as i, updatePaymentCommand as u, workflows as w };

package/dist/shared/bank.DOJ8gbXQ.cjs

@@ -0,0 +1,278 @@
+'use strict';
+
+const cloudflare_workers = require('cloudflare:workers');
+const cloudflare_workflows = require('cloudflare:workflows');
+const d1 = require('drizzle-orm/d1');
+const database_schema = require('./bank.UfRkUN2y.cjs');
+require('@develit-io/backend-sdk');
+const drizzleOrm = require('drizzle-orm');
+const mockCobs_connector = require('./bank.DISsqBb6.cjs');
+require('jose');
+require('@develit-io/general-codes');
+
+const createPaymentCommand = (db, { payment }) => {
+  return {
+    command: db.insert(database_schema.tables.payment).values(payment).returning()
+  };
+};
+
+const updatePaymentCommand = (db, { payment }) => {
+  return {
+    command: db.update(database_schema.tables.payment).set(payment).where(drizzleOrm.eq(database_schema.tables.payment.id, payment.id)).returning()
+  };
+};
+
+const updateAccountLastSyncCommand = (db, { lastSyncedAt, accountId }) => {
+  const command = db.update(database_schema.tables.account).set({
+    lastSyncedAt
+  }).where(drizzleOrm.eq(database_schema.tables.account.id, accountId)).returning();
+  return {
+    command
+  };
+};
+
+const getAccountByIdQuery = async (db, { accountId }) => {
+  return await db.select().from(database_schema.tables.account).where(drizzleOrm.eq(database_schema.tables.account.id, accountId)).get();
+};
+
+const getCredentialsByAccountId = async (db, { accountId }) => {
+  const cred = await db.select().from(database_schema.tables.accountCredentials).where(drizzleOrm.eq(database_schema.tables.accountCredentials.accountId, accountId)).get();
+  return cred;
+};
+
+const getPaymentsByBankRefIdsQuery = async (db, { ids }) => {
+  return await db.select().from(database_schema.tables.payment).where(drizzleOrm.inArray(database_schema.tables.payment.bankRefId, ids));
+};
+
+class CreditasConnector extends database_schema.FinbricksConnector {
+  constructor(config) {
+    super("CREDITAS", config);
+  }
+}
+
+class FioConnector extends database_schema.FinbricksConnector {
+  constructor(config) {
+    super("FIO", config);
+  }
+}
+
+class MonetaConnector extends database_schema.FinbricksConnector {
+  constructor(config) {
+    super("MONETA", config);
+  }
+}
+
+const initiateConnector = ({
+  bank,
+  env,
+  connectedAccounts
+}) => {
+  switch (bank) {
+    case "ERSTE":
+      return new database_schema.ErsteConnector({
+        API_KEY: env.ERSTE_API_KEY,
+        CLIENT_ID: env.ERSTE_CLIENT_ID,
+        CLIENT_SECRET: env.ERSTE_CLIENT_SECRET,
+        REDIRECT_URI: env.REDIRECT_URI,
+        AUTH_URI: env.ERSTE_AUTH_URI,
+        PAYMENTS_URI: env.ERSTE_PAYMENTS_URI,
+        ACCOUNTS_URI: env.ERSTE_ACCOUNTS_URI,
+        connectedAccounts
+      });
+    case "CREDITAS":
+      return new CreditasConnector({
+        BASE_URI: env.FINBRICKS_BASE_URI,
+        MERCHANT_ID: env.FINBRICKS_MERCHANT_ID,
+        PRIVATE_KEY_PEM: env.FINBRICKS_PRIVATE_KEY_PEM,
+        REDIRECT_URI: env.REDIRECT_URI,
+        connectedAccounts
+      });
+    case "MOCK_COBS":
+      return new mockCobs_connector.MockCobsConnector({
+        BASE_URI: env.FINBRICKS_BASE_URI,
+        MERCHANT_ID: env.FINBRICKS_MERCHANT_ID,
+        PRIVATE_KEY_PEM: env.FINBRICKS_PRIVATE_KEY_PEM,
+        REDIRECT_URI: env.REDIRECT_URI,
+        connectedAccounts
+      });
+    case "FIO":
+      return new FioConnector({
+        BASE_URI: env.FINBRICKS_BASE_URI,
+        MERCHANT_ID: env.FINBRICKS_MERCHANT_ID,
+        PRIVATE_KEY_PEM: env.FINBRICKS_PRIVATE_KEY_PEM,
+        REDIRECT_URI: env.REDIRECT_URI,
+        connectedAccounts
+      });
+    case "MONETA":
+      return new MonetaConnector({
+        BASE_URI: env.FINBRICKS_BASE_URI,
+        MERCHANT_ID: env.FINBRICKS_MERCHANT_ID,
+        PRIVATE_KEY_PEM: env.FINBRICKS_PRIVATE_KEY_PEM,
+        REDIRECT_URI: env.REDIRECT_URI,
+        connectedAccounts
+      });
+    default:
+      return new database_schema.MockConnector();
+  }
+};
+
+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 SyncAccountPaymentsWorkflow 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 account = await step.do("load account", async () => {
+        const account2 = await getAccountByIdQuery(db, { accountId });
+        if (!account2) {
+          throw new cloudflare_workflows.NonRetryableError(`Bank account not found: ${accountId}`);
+        }
+        return account2;
+      });
+      if (!account.lastSyncedAt) {
+        throw new cloudflare_workflows.NonRetryableError(
+          `lastSyncedAt is not set for account: ${accountId}`
+        );
+      }
+      const credentials = await step.do(
+        "load account credentials",
+        async () => {
+          const credentials2 = await getCredentialsByAccountId(db, { accountId });
+          if (!credentials2) {
+            throw new cloudflare_workflows.NonRetryableError(
+              `No credentials found for account: ${accountId}`
+            );
+          }
+          return credentials2;
+        }
+      );
+      const connector = await step.do(
+        `init ${account.connectorKey} connector`,
+        async () => {
+          return initiateConnector({
+            env: this.env,
+            bank: account.connectorKey,
+            connectedAccounts: [
+              {
+                ...account,
+                iban: account.iban,
+                token: credentials.value
+              }
+            ]
+          });
+        }
+      );
+      const payments = await step.do(
+        "fetch bank payments",
+        {
+          retries: { limit: 5, delay: 2e3, backoff: "constant" },
+          timeout: "30 seconds"
+        },
+        async () => {
+          const fetched = await connector.getAllAccountPayments({
+            environment: this.env.ENVIRONMENT,
+            db,
+            account,
+            filter: { dateFrom: account.lastSyncedAt }
+          });
+          return fetched.map((p) => ({
+            ...p,
+            direction: database_schema.getPaymentDirection(p, account.iban)
+          }));
+        }
+      );
+      if (payments.length === 0) {
+        return { status: "no_new_payments" };
+      }
+      const bankRefIds = payments.map((payment) => payment.bankRefId).filter(Boolean);
+      const existing = await step.do("load existing payments", async () => {
+        return await getPaymentsByBankRefIdsQuery(db, {
+          ids: bankRefIds
+        });
+      });
+      const paymentsToUpdate = payments.filter(
+        (p) => existing.some((e) => e.bankRefId === p.bankRefId)
+      );
+      if (paymentsToUpdate.length)
+        await step.do("update existing payments", async () => {
+          const commands = paymentsToUpdate.map(
+            (p) => updatePaymentCommand(db, { payment: p }).command
+          );
+          await db.batch([commands[0], ...commands.slice(1)]);
+          await pushToQueue(
+            this.env.QUEUE_BUS_QUEUE,
+            paymentsToUpdate.map((p) => ({
+              eventType: "BANK_PAYMENT",
+              eventSignal: "paymentUpdated",
+              bankPayment: p,
+              metadata: {
+                correlationId: p.correlationId,
+                entityId: p.id,
+                idempotencySuffix: p.status,
+                timestamp: (/* @__PURE__ */ new Date()).toDateString()
+              }
+            }))
+          );
+        });
+      const paymentsToCreate = payments.filter(
+        (p) => !existing.some((e) => e.bankRefId === p.bankRefId)
+      );
+      if (paymentsToCreate.length)
+        await step.do("create new payments", async () => {
+          const commands = paymentsToCreate.map(
+            (p) => createPaymentCommand(db, { payment: p }).command
+          );
+          await db.batch([commands[0], ...commands.slice(1)]);
+          await pushToQueue(
+            this.env.QUEUE_BUS_QUEUE,
+            paymentsToCreate.map((p) => ({
+              eventType: "BANK_PAYMENT",
+              eventSignal: "paymentCreated",
+              bankPayment: p,
+              metadata: {
+                correlationId: p.correlationId,
+                entityId: p.id,
+                timestamp: (/* @__PURE__ */ new Date()).toDateString()
+              }
+            }))
+          );
+        });
+      await step.do("determine new lastSyncedAt", async () => {
+        const latest = payments.reduce((current, p) => {
+          return new Date(p.createdAt).getTime() > new Date(current.createdAt).getTime() ? p : current;
+        }, payments[0]);
+        await updateAccountLastSyncCommand(db, {
+          accountId: account.id,
+          lastSyncedAt: latest.createdAt
+        }).command.execute();
+        return latest.createdAt;
+      });
+      await step.sleep(
+        "Sleep for next sync",
+        `${account.syncIntervalS} seconds`
+      );
+    }
+  }
+}
+
+const workflows = {
+  __proto__: null,
+  SyncAccountPaymentsWorkflow: SyncAccountPaymentsWorkflow
+};
+
+exports.SyncAccountPaymentsWorkflow = SyncAccountPaymentsWorkflow;
+exports.createPaymentCommand = createPaymentCommand;
+exports.getCredentialsByAccountId = getCredentialsByAccountId;
+exports.getPaymentsByBankRefIdsQuery = getPaymentsByBankRefIdsQuery;
+exports.initiateConnector = initiateConnector;
+exports.updateAccountLastSyncCommand = updateAccountLastSyncCommand;
+exports.updatePaymentCommand = updatePaymentCommand;
+exports.workflows = workflows;