@develit-services/bank 0.3.44 → 0.3.45

package/dist/shared/bank.Cj-oB02_.mjs

@@ -1,392 +0,0 @@
-import { t as tables, F as FinbricksConnector, M as MockConnector, E as ErsteConnector } from './bank.DFRS9oN5.mjs';
-import { uuidv4, first } from '@develit-io/backend-sdk';
-import { WorkflowEntrypoint } from 'cloudflare:workers';
-import { NonRetryableError } from 'cloudflare:workflows';
-import { drizzle } from 'drizzle-orm/d1';
-import { eq } from 'drizzle-orm';
-import 'jose';
-import '@develit-io/general-codes';
-import { createHash } from 'node:crypto';
-import { M as MockCobsConnector } from './bank.DhPfZ6b_.mjs';
-
-const createPaymentCommand = (db, { payment }) => {
-  return {
-    command: db.insert(tables.payment).values({
-      ...payment,
-      creditorIban: payment.creditor.iban,
-      debtorIban: payment.debtor.iban
-    }).returning()
-  };
-};
-
-const upsertBatchCommand = (db, { batch }) => {
-  const id = batch.id || uuidv4();
-  const command = db.insert(tables.batch).values({
-    ...batch,
-    id
-  }).onConflictDoUpdate({
-    target: tables.batch.id,
-    set: {
-      ...batch
-    }
-  }).returning();
-  return {
-    id,
-    command
-  };
-};
-
-const getAccountByIdQuery = async (db, { accountId }) => {
-  return await db.select().from(tables.account).where(eq(tables.account.id, accountId)).get();
-};
-
-const getBatchByIdQuery = async (db, { batchId }) => {
-  return await db.select().from(tables.batch).where(eq(tables.batch.id, batchId)).get();
-};
-
-const getCredentialsByAccountId = async (db, encryptionKey, { accountId }) => {
-  const cred = await db.select().from(tables.accountCredentials).where(eq(tables.accountCredentials.accountId, accountId)).get();
-  return cred ? {
-    ...cred,
-    value: await decrypt(cred.value, encryptionKey)
-  } : void 0;
-};
-
-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();
-  }
-};
-
-async function importAesKey(base64Key) {
-  const raw = Uint8Array.from(atob(base64Key), (c) => c.charCodeAt(0));
-  return await crypto.subtle.importKey("raw", raw, { name: "AES-GCM" }, false, [
-    "encrypt",
-    "decrypt"
-  ]);
-}
-async function encrypt(value, key) {
-  const encoder = new TextEncoder();
-  const iv = crypto.getRandomValues(new Uint8Array(12));
-  const ciphertext = await crypto.subtle.encrypt(
-    { name: "AES-GCM", iv },
-    key,
-    encoder.encode(value)
-  );
-  const combined = new Uint8Array(iv.length + ciphertext.byteLength);
-  combined.set(iv, 0);
-  combined.set(new Uint8Array(ciphertext), iv.length);
-  return btoa(String.fromCharCode(...combined));
-}
-async function decrypt(base64, key) {
-  const raw = Uint8Array.from(atob(base64), (c) => c.charCodeAt(0));
-  const iv = raw.slice(0, 12);
-  const ciphertext = raw.slice(12);
-  const decrypted = await crypto.subtle.decrypt(
-    { name: "AES-GCM", iv },
-    key,
-    ciphertext
-  );
-  return new TextDecoder().decode(decrypted);
-}
-function canonicalize(value) {
-  if (value === null || typeof value !== "object") return value;
-  if (Array.isArray(value)) {
-    return value.map(canonicalize);
-  }
-  const obj = value;
-  const sorted = Object.keys(obj).sort().reduce((acc, key) => {
-    acc[key] = canonicalize(obj[key]);
-    return acc;
-  }, {});
-  return sorted;
-}
-function checksum(input) {
-  const canonical = canonicalize(input);
-  const json = JSON.stringify(canonical);
-  return createHash("sha256").update(json).digest("hex");
-}
-
-const PROCESS_BATCH_WORKFLOW_EVENTS = {
-  batchAuthorized: "batch-authorized"
-};
-function pushToQueue(queue, message) {
-  if (!Array.isArray(message)) return queue.send(message, { contentType: "v8" });
-  return queue.sendBatch(
-    message.map((m) => ({
-      body: m,
-      contentType: "v8"
-    }))
-  );
-}
-class BankProcessBatch extends WorkflowEntrypoint {
-  async run(event, step) {
-    const { batchId } = event.payload;
-    const db = drizzle(this.env.BANK_D1, { schema: tables });
-    const batch = await step.do("load batch", async () => {
-      const batch2 = await getBatchByIdQuery(db, { batchId });
-      if (!batch2) {
-        throw new NonRetryableError(`Batch not found`);
-      }
-      if (batch2.status === "SIGNED")
-        throw new NonRetryableError(`Batch already signed`);
-      return batch2;
-    });
-    await step.do("lock batch", async () => {
-      const paymentsChecksum = checksum(batch.payments);
-      if (batch.paymentsChecksum && batch.paymentsChecksum !== paymentsChecksum)
-        throw new NonRetryableError(
-          `Batch payments have been modified externally, manual review needed`
-        );
-      if (batch.status === "FAILED")
-        throw new NonRetryableError(
-          `Batch is in FAILED status and cannot be processed, manual review needed`
-        );
-      if (batch.status === "OPEN" || batch.status === "FULL") {
-        const updatedBatch = await upsertBatchCommand(db, {
-          batch: {
-            ...batch,
-            status: "PROCESSING",
-            paymentsChecksum
-          }
-        }).command.execute().then(first);
-        return { status: updatedBatch.status };
-      }
-      return { status: batch.status };
-    });
-    const preparedPayments = await step.do(
-      "prepare payments",
-      {
-        retries: { limit: 5, delay: 2e3, backoff: "constant" },
-        timeout: "30 seconds"
-      },
-      async () => {
-        const account = await getAccountByIdQuery(db, {
-          accountId: batch.accountId
-        });
-        if (!account) {
-          throw new NonRetryableError(`Account not found: ${batch.accountId}`);
-        }
-        const encryptionKey = await importAesKey(this.env.ENCRYPTION_KEY);
-        const credentials = await getCredentialsByAccountId(db, encryptionKey, {
-          accountId: account.id
-        });
-        if (!credentials) {
-          throw new NonRetryableError(
-            `No credentials found for account: ${account.id}`
-          );
-        }
-        if (credentials.expiresAt < /* @__PURE__ */ new Date()) {
-          throw new NonRetryableError(
-            `Credentials have expired for account: ${account.id}`
-          );
-        }
-        const connector = initiateConnector({
-          env: this.env,
-          bank: account.connectorKey,
-          connectedAccounts: [
-            {
-              ...account,
-              iban: account.iban,
-              token: credentials.value
-            }
-          ]
-        });
-        const preparedPayments2 = [];
-        for (const payment of batch.payments) {
-          const prepared = await connector.preparePayment(payment);
-          if (prepared) {
-            preparedPayments2.push(prepared);
-          }
-        }
-        return preparedPayments2;
-      }
-    );
-    const batchResult = await step.do(
-      "initiate batch from payments",
-      {
-        retries: { limit: 5, delay: 2e3, backoff: "constant" },
-        timeout: "30 seconds"
-      },
-      async () => {
-        if (batch.batchPaymentInitiatedAt) {
-          return {
-            authorizationUrls: batch.authorizationUrls,
-            initializedPayments: preparedPayments.map((p) => ({
-              ...p,
-              status: "INITIALIZED"
-            })),
-            metadata: batch.metadata
-          };
-        }
-        const account = await getAccountByIdQuery(db, {
-          accountId: batch.accountId
-        });
-        if (!account) {
-          throw new NonRetryableError(`Account not found: ${batch.accountId}`);
-        }
-        const encryptionKey = await importAesKey(this.env.ENCRYPTION_KEY);
-        const credentials = await getCredentialsByAccountId(db, encryptionKey, {
-          accountId: account.id
-        });
-        if (!credentials) {
-          throw new NonRetryableError(
-            `No credentials found for account: ${account.id}`
-          );
-        }
-        if (credentials.expiresAt < /* @__PURE__ */ new Date()) {
-          throw new NonRetryableError(
-            `Credentials have expired for account: ${account.id}`
-          );
-        }
-        const connector = initiateConnector({
-          env: this.env,
-          bank: account.connectorKey,
-          connectedAccounts: [
-            {
-              ...account,
-              iban: account.iban,
-              token: credentials.value
-            }
-          ]
-        });
-        const result = await connector.initiateBatchFromPayments({
-          batchId: batch.id,
-          payments: preparedPayments
-        });
-        const {
-          authorizationUrls,
-          payments: initializedPayments,
-          metadata
-        } = result;
-        if (!authorizationUrls || authorizationUrls.length === 0) {
-          throw new Error("Failed to retrieve authorization URLs");
-        }
-        return {
-          authorizationUrls,
-          initializedPayments,
-          metadata
-        };
-      }
-    );
-    await step.do("update batch and payments to initialized", async () => {
-      const upsertBatch = upsertBatchCommand(db, {
-        batch: {
-          ...batch,
-          authorizationUrls: batchResult.authorizationUrls,
-          metadata: batchResult.metadata,
-          status: "READY_TO_SIGN",
-          batchPaymentInitiatedAt: /* @__PURE__ */ new Date()
-        }
-      }).command;
-      await upsertBatch.execute();
-      return {
-        status: "READY_TO_SIGN",
-        paymentsInitialized: batchResult.initializedPayments.length
-      };
-    });
-    await step.do("send authorization email", async () => {
-      await pushToQueue(this.env.NOTIFICATIONS_QUEUE, {
-        type: "email",
-        payload: {
-          email: {
-            to: [this.env.BANK_AUTH_RECIPIENT],
-            subject: "Payment Authorization",
-            text: Array.isArray(batchResult.authorizationUrls) ? batchResult.authorizationUrls[0] || "No Authorization URL" : batchResult.authorizationUrls || "No Authorization URL"
-          }
-        },
-        metadata: {
-          initiator: {
-            service: "bank"
-          }
-        }
-      });
-      return { emailSent: true };
-    });
-    const authorizationEvent = await step.waitForEvent(
-      "wait for batch authorization",
-      {
-        type: "batch-authorized",
-        timeout: "3 days"
-      }
-    );
-    await step.do("handle authorization result", async () => {
-      const authPayload = authorizationEvent.payload;
-      const updatedBatch = await upsertBatchCommand(db, {
-        batch: {
-          ...batch,
-          status: authPayload.authorized ? "SIGNED" : "SIGNATURE_FAILED"
-        }
-      }).command.execute().then(first);
-      return { updatedBatch };
-    });
-  }
-}
-
-export { BankProcessBatch as B, PROCESS_BATCH_WORKFLOW_EVENTS as P, getCredentialsByAccountId as a, initiateConnector as b, createPaymentCommand as c, encrypt as e, getAccountByIdQuery as g, importAesKey as i, upsertBatchCommand as u };

package/dist/shared/bank.ClRIj2Ma.cjs

@@ -1,11 +0,0 @@
-'use strict';
-
-const database_schema = require('./bank.C335-raZ.cjs');
-
-class MockCobsConnector extends database_schema.FinbricksConnector {
-  constructor(config) {
-    super("MOCK_COBS", config);
-  }
-}
-
-exports.MockCobsConnector = MockCobsConnector;

package/dist/shared/bank.DhPfZ6b_.mjs

@@ -1,9 +0,0 @@
-import { F as FinbricksConnector } from './bank.DFRS9oN5.mjs';
-
-class MockCobsConnector extends FinbricksConnector {
-  constructor(config) {
-    super("MOCK_COBS", config);
-  }
-}
-
-export { MockCobsConnector as M };