@develit-services/bank 5.7.1 → 5.9.0

package/dist/export/workflows.mjs

@@ -1,14 +1,14 @@
 import { first, uuidv4, asNonEmpty } from '@develit-io/backend-sdk';
-import { G as tables, H as relations, v as toBatchedPaymentFromPaymentRequest, z as toPreparedPayment, m as isPaymentCompleted } from '../shared/bank.BVXtqHnq.mjs';
+import { G as tables, H as relations, v as toBatchedPaymentFromPaymentRequest, z as toPreparedPayment, m as isPaymentCompleted } from '../shared/bank.kz-PKVi5.mjs';
 import { i as isBatchAuthorized, b as isBatchFailed, d as isBatchProcessing } from '../shared/bank.XqSw509X.mjs';
-import { eq, and, inArray } from 'drizzle-orm';
-import { g as getBatchByIdQuery, a as getPaymentRequestsByBatchIdQuery, c as checksum, u as upsertBatchCommand, b as getAccountByIdQuery, d as createCredentialsResolver, i as initiateConnector, e as updatePaymentRequestStatusCommand, f as createPaymentCommand } from '../shared/bank.DLU1sOBm.mjs';
+import { sql, and, eq, inArray } from 'drizzle-orm';
+import { g as getBatchByIdQuery, a as getPaymentRequestsByBatchIdQuery, c as checksum, u as upsertBatchCommand, b as getAccountByIdQuery, d as createCredentialsResolver, i as initiateConnector, e as updatePaymentRequestStatusCommand, f as isSupersededBy, h as createPaymentCommand, r as resolveIterationBudget } from '../shared/bank.DAjqsBQN.mjs';
 import { WorkflowEntrypoint } from 'cloudflare:workers';
 import { NonRetryableError } from 'cloudflare:workflows';
 import { drizzle } from 'drizzle-orm/d1';
 import 'node:crypto';
 import 'date-fns';
-import '../shared/bank.BzDNLxB_.mjs';
+import '../shared/bank.BT7HayCV.mjs';
 import 'drizzle-orm/sqlite-core';
 import '@develit-io/general-codes';
 import 'jose';
@@ -18,12 +18,17 @@ import 'drizzle-orm/zod';
 const updateAccountLastSyncCommand = (db, {
   lastSyncAt,
   accountId,
-  lastSyncMetadata
+  lastSyncMetadata,
+  seenInstanceId
 }) => {
+  const markerUnchanged = seenInstanceId === void 0 ? void 0 : (
+    // IS instead of = so a null marker compares equal to null.
+    sql`json_extract(${tables.account.lastSyncMetadata}, '$.instanceId') IS ${seenInstanceId}`
+  );
   const command = db.update(tables.account).set({
     lastSyncAt,
     lastSyncMetadata
-  }).where(eq(tables.account.id, accountId)).returning();
+  }).where(and(eq(tables.account.id, accountId), markerUnchanged)).returning();
   return {
     command
   };
@@ -338,6 +343,72 @@ function getStepCount(ctx) {
   return ctx.step?.count ?? 0;
 }
 
+const MAX_CATCH_UP_WINDOW_MS = 7 * 24 * 60 * 60 * 1e3;
+function resolveSyncWindow(lastSyncAt, nowMs, maxWindowMs) {
+  const openEnded = {
+    dateFrom: lastSyncAt,
+    dateTo: new Date(Math.max(nowMs, lastSyncAt.getTime())),
+    isCatchUp: false
+  };
+  if (!Number.isFinite(maxWindowMs) || maxWindowMs <= 0) return openEnded;
+  const clippedToMs = lastSyncAt.getTime() + maxWindowMs;
+  if (clippedToMs >= nowMs) return openEnded;
+  return {
+    dateFrom: lastSyncAt,
+    dateTo: new Date(clippedToMs),
+    isCatchUp: true
+  };
+}
+
+const STEP_RESULT_BYTE_CEILING = 800 * 1024;
+class StepResultTooLargeError extends NonRetryableError {
+}
+function guardStepResultSize(value, ceilingBytes = STEP_RESULT_BYTE_CEILING) {
+  const bytes = new TextEncoder().encode(JSON.stringify(value)).byteLength;
+  if (bytes > ceilingBytes) {
+    const count = Array.isArray(value) ? value.length : 1;
+    throw new StepResultTooLargeError(
+      `Fetched ${count} payments (${bytes} bytes), over the ${ceilingBytes} byte step result ceiling`
+    );
+  }
+}
+function rethrowFetchError(err) {
+  if (err instanceof NonRetryableError) throw err;
+  const message = err instanceof Error ? err.message : typeof err === "object" && err !== null && "message" in err ? String(err.message) : JSON.stringify(err);
+  throw new Error(message);
+}
+
+const MIN_CATCH_UP_WINDOW_MS = 6 * 60 * 60 * 1e3;
+async function fetchBoundedByWindow({
+  window,
+  fetchWindow,
+  guardResult,
+  minWindowMs,
+  onNarrowed
+}) {
+  let current = window;
+  while (true) {
+    const result = await fetchWindow(current);
+    try {
+      guardResult(result);
+      return { result, window: current };
+    } catch (tooLarge) {
+      if (!(tooLarge instanceof StepResultTooLargeError)) throw tooLarge;
+      const halvedSpanMs = Math.floor(
+        (current.dateTo.getTime() - current.dateFrom.getTime()) / 2
+      );
+      if (halvedSpanMs < minWindowMs) throw tooLarge;
+      current = {
+        dateFrom: current.dateFrom,
+        dateTo: new Date(current.dateFrom.getTime() + halvedSpanMs),
+        // Stops short of the original target, so another pass is needed.
+        isCatchUp: true
+      };
+      onNarrowed?.(current);
+    }
+  }
+}
+
 async function pushToQueue(queue, message) {
   if (!Array.isArray(message)) {
     await queue.send(message, { contentType: "v8" });
@@ -352,7 +423,8 @@ async function pushToQueue(queue, message) {
 }
 class BankSyncAccountPayments extends WorkflowEntrypoint {
   async run(event, step) {
-    const { accountId } = event.payload;
+    const { accountId, maxIterations } = event.payload;
+    const iterationBudget = resolveIterationBudget(maxIterations);
     const db = drizzle(this.env.BANK_D1, { schema: tables, relations });
     const logger = createWorkflowLogger(event.instanceId);
     if (!accountId) {
@@ -362,8 +434,7 @@ class BankSyncAccountPayments extends WorkflowEntrypoint {
       "capture workflow start time",
       async () => Date.now()
     );
-    while (true) {
-      const now = /* @__PURE__ */ new Date();
+    for (let iteration = 0; iteration < iterationBudget; iteration++) {
       const account = await step.do("load account", async () => {
         const account2 = await getAccountByIdQuery(db, { accountId });
         if (!account2) {
@@ -371,10 +442,49 @@ class BankSyncAccountPayments extends WorkflowEntrypoint {
         }
         return account2;
       });
+      if (!account.syncEnabled) {
+        logger.info("sync.disabled", {
+          accountId,
+          instanceId: event.instanceId,
+          iteration
+        });
+        return;
+      }
       if (!account.lastSyncAt) {
         throw new Error(`lastSyncedAt is not set for account: ${accountId}`);
       }
-      const payments = await step.do(
+      if (isSupersededBy(
+        event.instanceId,
+        account.lastSyncMetadata?.instanceId,
+        accountId
+      )) {
+        logger.info("sync.superseded", {
+          accountId,
+          instanceId: event.instanceId,
+          supersededBy: account.lastSyncMetadata?.instanceId,
+          iteration
+        });
+        return;
+      }
+      const lastSyncAtMs = account.lastSyncAt.getTime();
+      const windowMs = await step.do("resolve sync window", async () => {
+        const window = resolveSyncWindow(
+          new Date(lastSyncAtMs),
+          Date.now(),
+          MAX_CATCH_UP_WINDOW_MS
+        );
+        return {
+          dateFromMs: window.dateFrom.getTime(),
+          dateToMs: window.dateTo.getTime(),
+          isCatchUp: window.isCatchUp
+        };
+      });
+      const syncWindow = {
+        dateFrom: new Date(windowMs.dateFromMs),
+        dateTo: new Date(windowMs.dateToMs),
+        isCatchUp: windowMs.isCatchUp
+      };
+      const fetched = await step.do(
         "fetch bank payments",
         {
           retries: { limit: 5, delay: "2 minutes", backoff: "exponential" },
@@ -403,42 +513,88 @@ class BankSyncAccountPayments extends WorkflowEntrypoint {
                 }
               ]
             });
-            const result = await connector.getAllAccountPayments({
-              account,
-              filter: { dateFrom: account.lastSyncAt }
-            });
+            const fetchWindow = async (window) => {
+              const result = await connector.getAllAccountPayments({
+                account,
+                filter: {
+                  dateFrom: window.dateFrom,
+                  dateTo: window.dateTo
+                }
+              });
+              const identifiable = result.filter(
+                (p) => p.parsed.bankRefId?.trim()
+              );
+              const skipped = result.length - identifiable.length;
+              if (skipped > 0) {
+                logger.warn("payments.fetch.skipped_blank_bank_ref", {
+                  accountId,
+                  connectorKey: account.connectorKey,
+                  skipped
+                });
+              }
+              return Promise.all(
+                identifiable.map(async (p) => ({
+                  parsed: {
+                    ...p.parsed,
+                    id: await deriveV4PaymentId(p.parsed)
+                  }
+                }))
+              );
+            };
+            let bounded;
+            try {
+              bounded = await fetchBoundedByWindow({
+                window: syncWindow,
+                fetchWindow,
+                guardResult: guardStepResultSize,
+                minWindowMs: MIN_CATCH_UP_WINDOW_MS,
+                onNarrowed: (narrowed) => logger.warn("payments.fetch.window-narrowed", {
+                  accountId,
+                  connectorKey: account.connectorKey,
+                  dateFrom: narrowed.dateFrom.toISOString(),
+                  dateTo: narrowed.dateTo.toISOString()
+                })
+              });
+            } catch (err) {
+              if (err instanceof StepResultTooLargeError) {
+                logger.error("payments.fetch.result-too-large", {
+                  accountId,
+                  connectorKey: account.connectorKey,
+                  dateFrom: syncWindow.dateFrom.toISOString(),
+                  dateTo: syncWindow.dateTo.toISOString()
+                });
+              }
+              throw err;
+            }
             logger.info("payments.fetch.completed", {
               accountId,
               connectorKey: account.connectorKey,
-              paymentsCount: result.length
+              paymentsCount: bounded.result.length
             });
-            const identifiable = result.filter(
-              (p) => p.parsed.bankRefId?.trim()
-            );
-            const skipped = result.length - identifiable.length;
-            if (skipped > 0) {
-              logger.warn("payments.fetch.skipped_blank_bank_ref", {
-                accountId,
-                connectorKey: account.connectorKey,
-                skipped
-              });
-            }
-            return Promise.all(
-              identifiable.map(async (p) => ({
-                parsed: { ...p.parsed, id: await deriveV4PaymentId(p.parsed) }
-              }))
-            );
+            return {
+              payments: bounded.result,
+              windowMs: {
+                dateFromMs: bounded.window.dateFrom.getTime(),
+                dateToMs: bounded.window.dateTo.getTime(),
+                isCatchUp: bounded.window.isCatchUp
+              }
+            };
           } catch (err) {
-            const message = err instanceof Error ? err.message : typeof err === "object" && err !== null && "message" in err ? String(err.message) : JSON.stringify(err);
             logger.error("payments.fetch.failed", {
               accountId,
               connectorKey: account.connectorKey,
-              error: message
+              error: err instanceof Error ? err.message : String(err)
             });
-            throw new Error(message);
+            rethrowFetchError(err);
           }
         }
       );
+      const payments = fetched.payments;
+      const effectiveWindow = {
+        dateFrom: new Date(fetched.windowMs.dateFromMs),
+        dateTo: new Date(fetched.windowMs.dateToMs),
+        isCatchUp: fetched.windowMs.isCatchUp
+      };
       const paymentsToProcess = payments.filter(
         (p) => isPaymentCompleted(p.parsed)
       );
@@ -513,6 +669,7 @@ class BankSyncAccountPayments extends WorkflowEntrypoint {
             }))
           );
           const lastSyncMetadata = {
+            instanceId: event.instanceId,
             payments: payments.length,
             paymentsToProcess: paymentsToProcess.length,
             paymentsInserted: paymentsToInsert.length,
@@ -529,15 +686,27 @@ class BankSyncAccountPayments extends WorkflowEntrypoint {
           };
           const updateLastSyncCommand = updateAccountLastSyncCommand(db, {
             accountId: account.id,
-            lastSyncAt: now,
-            lastSyncMetadata
+            // End of the window just fetched, not `now`: while catching up the
+            // window stops short of now, and advancing past it would skip every
+            // payment in the gap.
+            lastSyncAt: effectiveWindow.dateTo,
+            lastSyncMetadata,
+            seenInstanceId: account.lastSyncMetadata?.instanceId ?? null
           }).command;
+          let syncStateRows;
           if (createCommands.length) {
-            await db.batch(
+            const [updateResult] = await db.batch(
               asNonEmpty([updateLastSyncCommand, ...createCommands])
             );
+            syncStateRows = updateResult;
           } else {
-            await updateLastSyncCommand;
+            syncStateRows = await updateLastSyncCommand;
+          }
+          if (syncStateRows.length === 0) {
+            logger.info("sync.write-superseded", {
+              accountId,
+              instanceId: event.instanceId
+            });
           }
           if (eventsToEmit.length) {
             await pushToQueue(
@@ -547,14 +716,16 @@ class BankSyncAccountPayments extends WorkflowEntrypoint {
           }
           return {
             ...lastSyncMetadata,
-            newLastSyncAt: now
+            newLastSyncAt: effectiveWindow.dateTo
           };
         }
       );
-      await step.sleep(
-        "Sleep for next sync",
-        `${account.syncIntervalS} seconds`
-      );
+      if (!effectiveWindow.isCatchUp) {
+        await step.sleep(
+          "Sleep for next sync",
+          `${account.syncIntervalS} seconds`
+        );
+      }
     }
   }
 }

package/dist/service.d.cts

@@ -17,6 +17,9 @@ interface BankServiceVariables {
     DBUCS_TX_AUTH_URI: string;
     REDIRECT_URI: string;
     SYNC_WORKFLOW_RESET_AFTER_ITERATIONS: string;
+    CRON_SYNC_WORKFLOW_DISPATCH: string;
+    SYNC_DISPATCH_ACCOUNT_IDS: string;
+    SYNC_WORKFLOW_MAX_ITERATIONS: string;
     [key: string]: string | number | boolean;
 }
 declare const BANK_SERVICE_BINDINGS: {

package/dist/service.d.mts

@@ -17,6 +17,9 @@ interface BankServiceVariables {
     DBUCS_TX_AUTH_URI: string;
     REDIRECT_URI: string;
     SYNC_WORKFLOW_RESET_AFTER_ITERATIONS: string;
+    CRON_SYNC_WORKFLOW_DISPATCH: string;
+    SYNC_DISPATCH_ACCOUNT_IDS: string;
+    SYNC_WORKFLOW_MAX_ITERATIONS: string;
     [key: string]: string | number | boolean;
 }
 declare const BANK_SERVICE_BINDINGS: {

package/dist/service.d.ts

@@ -17,6 +17,9 @@ interface BankServiceVariables {
     DBUCS_TX_AUTH_URI: string;
     REDIRECT_URI: string;
     SYNC_WORKFLOW_RESET_AFTER_ITERATIONS: string;
+    CRON_SYNC_WORKFLOW_DISPATCH: string;
+    SYNC_DISPATCH_ACCOUNT_IDS: string;
+    SYNC_WORKFLOW_MAX_ITERATIONS: string;
     [key: string]: string | number | boolean;
 }
 declare const BANK_SERVICE_BINDINGS: {

package/dist/shared/{bank.BzDNLxB_.mjs → bank.BT7HayCV.mjs}

@@ -75,6 +75,10 @@ const account = sqliteTable(
     status: text("status", { enum: ACCOUNT_STATUSES }).$type().notNull(),
     bankRefId: text("bank_ref_id").notNull(),
     batchSizeLimit: integer("batch_size_limit").notNull().default(50),
+    // Ops toggle ("should this account sync?"), separate from `status`:
+    // DISABLED is owned by disconnect (deletes credentials) and status also
+    // gates payments, so neither can express "stop syncing only".
+    syncEnabled: integer("sync_enabled", { mode: "boolean" }).notNull().default(true),
     syncIntervalS: integer("sync_interval_s").notNull().default(600),
     lastSyncAt: integer("last_sync_at", { mode: "timestamp_ms" }),
     lastSyncMetadata: text("last_sync_metadata", {

package/dist/shared/{bank.BUzoc8p6.d.cts → bank.Bhh_O_5-.d.mts}

@@ -1,4 +1,4 @@
-import { e as CurrencyCode, S as BankCode, a2 as CountryCode, P as PaymentRequestSelectType } from './bank.BQwwtIR4.cjs';
+import { e as CurrencyCode, S as BankCode, a2 as CountryCode, P as PaymentRequestSelectType } from './bank.mkq4IlpC.mjs';
 import { z } from 'zod';
 
 type ReferenceType = `${'VS' | 'SS' | 'KS'}:${number}`;

package/dist/shared/{bank.DZ3Ow4bP.d.mts → bank.BhyIbhvK.d.cts}

@@ -1,4 +1,4 @@
-import { e as CurrencyCode, S as BankCode, a2 as CountryCode, P as PaymentRequestSelectType } from './bank.BQwwtIR4.mjs';
+import { e as CurrencyCode, S as BankCode, a2 as CountryCode, P as PaymentRequestSelectType } from './bank.mkq4IlpC.cjs';
 import { z } from 'zod';
 
 type ReferenceType = `${'VS' | 'SS' | 'KS'}:${number}`;

package/dist/shared/{bank.CBpXmaTL.d.ts → bank.Bnc_DoG4.d.ts}

@@ -1,4 +1,4 @@
-import { e as CurrencyCode, S as BankCode, a2 as CountryCode, P as PaymentRequestSelectType } from './bank.BQwwtIR4.js';
+import { e as CurrencyCode, S as BankCode, a2 as CountryCode, P as PaymentRequestSelectType } from './bank.mkq4IlpC.js';
 import { z } from 'zod';
 
 type ReferenceType = `${'VS' | 'SS' | 'KS'}:${number}`;

package/dist/shared/{bank.CQjuudum.cjs → bank.BsWBG0gb.cjs}

@@ -2,7 +2,7 @@
 
 const backendSdk = require('@develit-io/backend-sdk');
 const dateFns = require('date-fns');
-const database_schema = require('./bank.9Yw4KHyl.cjs');
+const database_schema = require('./bank.Ca3jzmIb.cjs');
 const drizzleOrm = require('drizzle-orm');
 const jose = require('jose');
 const zod = require('zod');

package/dist/shared/{bank.9Yw4KHyl.cjs → bank.Ca3jzmIb.cjs}

@@ -77,6 +77,10 @@ const account = sqliteCore.sqliteTable(
     status: sqliteCore.text("status", { enum: ACCOUNT_STATUSES }).$type().notNull(),
     bankRefId: sqliteCore.text("bank_ref_id").notNull(),
     batchSizeLimit: sqliteCore.integer("batch_size_limit").notNull().default(50),
+    // Ops toggle ("should this account sync?"), separate from `status`:
+    // DISABLED is owned by disconnect (deletes credentials) and status also
+    // gates payments, so neither can express "stop syncing only".
+    syncEnabled: sqliteCore.integer("sync_enabled", { mode: "boolean" }).notNull().default(true),
     syncIntervalS: sqliteCore.integer("sync_interval_s").notNull().default(600),
     lastSyncAt: sqliteCore.integer("last_sync_at", { mode: "timestamp_ms" }),
     lastSyncMetadata: sqliteCore.text("last_sync_metadata", {

package/dist/shared/{bank.DLU1sOBm.mjs → bank.DAjqsBQN.mjs}

@@ -1,12 +1,39 @@
 import { sql, and, eq, isNull } from 'drizzle-orm';
-import { G as tables, b as FinbricksConnector, J as buildEndToEndId, c as MockConnector, D as DbuConnector, C as CsobConnector, K as KBConnector, M as MockCobsConnector, E as ErsteConnector } from './bank.BVXtqHnq.mjs';
+import { G as tables, b as FinbricksConnector, J as buildEndToEndId, c as MockConnector, D as DbuConnector, C as CsobConnector, K as KBConnector, M as MockCobsConnector, E as ErsteConnector } from './bank.kz-PKVi5.mjs';
 import { uuidv4 } from '@develit-io/backend-sdk';
-import './bank.BzDNLxB_.mjs';
+import './bank.BT7HayCV.mjs';
 import 'date-fns';
 import 'jose';
 import '@develit-io/general-codes';
 import { createHash } from 'node:crypto';
 
+function parseInstanceWindow(instanceId, accountId) {
+  const prefix = `${accountId}-`;
+  if (!instanceId.startsWith(prefix)) return -1;
+  const suffix = instanceId.slice(prefix.length);
+  if (!/^\d+$/.test(suffix)) return -1;
+  return Number(suffix);
+}
+function resolveCurrentSyncInstanceId(accountId, recordedInstanceId) {
+  return recordedInstanceId ?? accountId;
+}
+function isSupersededBy(myInstanceId, recordedInstanceId, accountId) {
+  if (recordedInstanceId == null) return false;
+  return parseInstanceWindow(recordedInstanceId, accountId) > parseInstanceWindow(myInstanceId, accountId);
+}
+
+function normalizeBudget(value) {
+  if (!Number.isFinite(value) || value < 1) return void 0;
+  return Math.floor(value);
+}
+function parseIterationBudgetParam(value) {
+  return normalizeBudget(Number(value?.trim() || Number.NaN));
+}
+function resolveIterationBudget(maxIterations) {
+  if (maxIterations == null) return Number.POSITIVE_INFINITY;
+  return normalizeBudget(maxIterations) ?? Number.POSITIVE_INFINITY;
+}
+
 const createPaymentCommand = (db, { payment }) => {
   return {
     command: db.insert(tables.payment).values({
@@ -359,4 +386,4 @@ const initiateConnector = async ({
   }
 };
 
-export { getPaymentRequestsByBatchIdQuery as a, getAccountByIdQuery as b, checksum as c, createCredentialsResolver as d, updatePaymentRequestStatusCommand as e, createPaymentCommand as f, getBatchByIdQuery as g, encrypt as h, initiateConnector as i, importAesKey as j, upsertBatchCommand as u };
+export { getPaymentRequestsByBatchIdQuery as a, getAccountByIdQuery as b, checksum as c, createCredentialsResolver as d, updatePaymentRequestStatusCommand as e, isSupersededBy as f, getBatchByIdQuery as g, createPaymentCommand as h, initiateConnector as i, encrypt as j, resolveCurrentSyncInstanceId as k, importAesKey as l, parseIterationBudgetParam as p, resolveIterationBudget as r, upsertBatchCommand as u };

package/dist/shared/{bank.B0DNtuUM.cjs → bank.DBTtRCcf.cjs}

@@ -1,14 +1,41 @@
 'use strict';
 
 const drizzleOrm = require('drizzle-orm');
-const paymentDirection = require('./bank.CQjuudum.cjs');
+const paymentDirection = require('./bank.BsWBG0gb.cjs');
 const backendSdk = require('@develit-io/backend-sdk');
-require('./bank.9Yw4KHyl.cjs');
+require('./bank.Ca3jzmIb.cjs');
 require('date-fns');
 require('jose');
 require('@develit-io/general-codes');
 const node_crypto = require('node:crypto');
 
+function parseInstanceWindow(instanceId, accountId) {
+  const prefix = `${accountId}-`;
+  if (!instanceId.startsWith(prefix)) return -1;
+  const suffix = instanceId.slice(prefix.length);
+  if (!/^\d+$/.test(suffix)) return -1;
+  return Number(suffix);
+}
+function resolveCurrentSyncInstanceId(accountId, recordedInstanceId) {
+  return recordedInstanceId ?? accountId;
+}
+function isSupersededBy(myInstanceId, recordedInstanceId, accountId) {
+  if (recordedInstanceId == null) return false;
+  return parseInstanceWindow(recordedInstanceId, accountId) > parseInstanceWindow(myInstanceId, accountId);
+}
+
+function normalizeBudget(value) {
+  if (!Number.isFinite(value) || value < 1) return void 0;
+  return Math.floor(value);
+}
+function parseIterationBudgetParam(value) {
+  return normalizeBudget(Number(value?.trim() || Number.NaN));
+}
+function resolveIterationBudget(maxIterations) {
+  if (maxIterations == null) return Number.POSITIVE_INFINITY;
+  return normalizeBudget(maxIterations) ?? Number.POSITIVE_INFINITY;
+}
+
 const createPaymentCommand = (db, { payment }) => {
   return {
     command: db.insert(paymentDirection.tables.payment).values({
@@ -370,5 +397,9 @@ exports.getBatchByIdQuery = getBatchByIdQuery;
 exports.getPaymentRequestsByBatchIdQuery = getPaymentRequestsByBatchIdQuery;
 exports.importAesKey = importAesKey;
 exports.initiateConnector = initiateConnector;
+exports.isSupersededBy = isSupersededBy;
+exports.parseIterationBudgetParam = parseIterationBudgetParam;
+exports.resolveCurrentSyncInstanceId = resolveCurrentSyncInstanceId;
+exports.resolveIterationBudget = resolveIterationBudget;
 exports.updatePaymentRequestStatusCommand = updatePaymentRequestStatusCommand;
 exports.upsertBatchCommand = upsertBatchCommand;

package/dist/shared/{bank.BVXtqHnq.mjs → bank.kz-PKVi5.mjs}

@@ -1,6 +1,6 @@
 import { uuidv4, createInternalError, bicSchema, useResult, structuredAddressSchema } from '@develit-io/backend-sdk';
 import { format, parseISO } from 'date-fns';
-import { s as schema, h as account, i as accountCredentials, o as ott } from './bank.BzDNLxB_.mjs';
+import { s as schema, h as account, i as accountCredentials, o as ott } from './bank.BT7HayCV.mjs';
 import { defineRelations, and, not, inArray, isNull } from 'drizzle-orm';
 import { importPKCS8, SignJWT } from 'jose';
 import { z } from 'zod';

package/dist/shared/{bank.BQwwtIR4.d.ts → bank.mkq4IlpC.d.cts}

@@ -27,6 +27,8 @@ interface LastSyncMetadata {
     eventsEmitted: number;
     iterationCount?: number;
     workflowStartedAt?: number;
+    /** Which instance wrote this sync — lets an older sibling detect it was superseded. */
+    instanceId?: string;
 }
 type ConnectorConfig = Record<string, string | number | boolean | null>;
 
@@ -1040,6 +1042,22 @@ declare const accountInsertSchema: drizzle_orm_zod.BuildSchema<"insert", {
         identity: undefined;
         generated: undefined;
     }, {}>;
+    syncEnabled: drizzle_orm_sqlite_core.SQLiteColumn<{
+        name: string;
+        tableName: "account";
+        dataType: "boolean";
+        data: boolean;
+        driverParam: number;
+        notNull: true;
+        hasDefault: true;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: undefined;
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}>;
     syncIntervalS: drizzle_orm_sqlite_core.SQLiteColumn<{
         name: string;
         tableName: "account";
@@ -1745,6 +1763,22 @@ declare const accountUpdateSchema: drizzle_orm_zod.BuildSchema<"update", {
         identity: undefined;
         generated: undefined;
     }, {}>;
+    syncEnabled: drizzle_orm_sqlite_core.SQLiteColumn<{
+        name: string;
+        tableName: "account";
+        dataType: "boolean";
+        data: boolean;
+        driverParam: number;
+        notNull: true;
+        hasDefault: true;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: undefined;
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}>;
     syncIntervalS: drizzle_orm_sqlite_core.SQLiteColumn<{
         name: string;
         tableName: "account";
@@ -2450,6 +2484,22 @@ declare const accountSelectSchema: drizzle_orm_zod.BuildSchema<"select", {
         identity: undefined;
         generated: undefined;
     }, {}>;
+    syncEnabled: drizzle_orm_sqlite_core.SQLiteColumn<{
+        name: string;
+        tableName: "account";
+        dataType: "boolean";
+        data: boolean;
+        driverParam: number;
+        notNull: true;
+        hasDefault: true;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: undefined;
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}>;
     syncIntervalS: drizzle_orm_sqlite_core.SQLiteColumn<{
         name: string;
         tableName: "account";
@@ -3606,7 +3656,7 @@ declare const payment: drizzle_orm_sqlite_core.SQLiteTableWithColumns<{
             name: string;
             tableName: "payment";
             dataType: "string enum";
-            data: "PROCESSING" | "PENDING" | "BOOKED" | "CANCELLED" | "REJECTED" | "SCHEDULED" | "HOLD" | "INFO";
+            data: "PROCESSING" | "BOOKED" | "REJECTED" | "PENDING" | "CANCELLED" | "SCHEDULED" | "HOLD" | "INFO";
             driverParam: string;
             notNull: true;
             hasDefault: false;
@@ -4110,7 +4160,7 @@ declare const paymentRequest: drizzle_orm_sqlite_core.SQLiteTableWithColumns<{
             name: string;
             tableName: "payment_request";
             dataType: "string enum";
-            data: "AUTHORIZED" | "COMPLETED" | "BOOKED" | "REJECTED" | "OPENED" | "SETTLED" | "CLOSED";
+            data: "AUTHORIZED" | "COMPLETED" | "OPENED" | "BOOKED" | "SETTLED" | "REJECTED" | "CLOSED";
             driverParam: string;
             notNull: true;
             hasDefault: false;
@@ -4810,6 +4860,22 @@ declare const account: drizzle_orm_sqlite_core.SQLiteTableWithColumns<{
             identity: undefined;
             generated: undefined;
         }, {}>;
+        syncEnabled: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: string;
+            tableName: "account";
+            dataType: "boolean";
+            data: boolean;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
         syncIntervalS: drizzle_orm_sqlite_core.SQLiteColumn<{
             name: string;
             tableName: "account";