@hotmeshio/hotmesh 0.6.1 → 0.8.0

package/.claude/settings.local.json

@@ -0,0 +1,7 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(npx tsc:*)"
+    ]
+  }
+}

package/README.md

@@ -1,189 +1,226 @@
 # HotMesh
 
-**Integrate AI automation into your current stack — without breaking it**
-
 ![beta release](https://img.shields.io/badge/release-beta-blue.svg)
 
-HotMesh modernizes existing business systems by introducing a durable workflow layer that connects AI, automation, and human-in-the-loop steps — **without replacing your current stack**.
-Each process runs with persistent memory in Postgres, surviving retries, crashes, and human delays.
-
-```bash
-npm install @hotmeshio/hotmesh
-```
-
----
-
-## What It Solves
-
-Modernization often stalls where systems meet people and AI.
-HotMesh builds a **durable execution bridge** across those seams — linking your database, APIs, RPA, and AI agents into one recoverable process.
-
-* **AI that can fail safely** — retries, resumable state, and confidence tracking
-* **Human steps that don’t block** — pause for days, resume instantly
-* **Legacy systems that stay connected** — SQL and RPA coexist seamlessly
-* **Full visibility** — query workflows and outcomes directly in SQL
-
----
-
-## Core Model
+Run durable workflows on Postgres. No servers, no queues, just your database.
 
-### Entity — the Business Process Record
 
-Every workflow writes to a durable JSON document in Postgres called an **Entity**.
-It becomes the shared memory between APIs, RPA jobs, LLM agents, and human operators.
+## Common Use Cases
 
-```ts
-const e = await MemFlow.workflow.entity();
+### 1. Pipeline Database
+Transform Postgres into a durable pipeline processor. Orchestrate long-running, multi-step pipelines transactionally and durably.
 
-// initialize from a source event
-await e.set({
-  caseId: "A42",
-  stage: "verification",
-  retries: 0,
-  notes: []
-});
+### 2. Temporal You Own
+Get the power of Temporal without the infrastructure. HotMesh includes MemFlow, a Temporal-compatible API that runs directly on your Postgres database. No app server required.
 
-// AI step adds structured output
-await e.merge({
-  aiSummary: { result: "Verified coverage", confidence: 0.93 },
-  stage: "approval",
-});
+### 3. Distributed State Machine
+Build resilient, stateful applications where every component can [fail and recover](https://github.com/hotmeshio/sdk-typescript/blob/main/services/collator/README.md). HotMesh manages state transitions, retries, and coordination.
 
-// human operator review
-await e.append("notes", { reviewer: "ops1", comment: "ok to proceed" });
+### 4. Workflow-as-Code Platform
+Choose your style: procedural workflows with MemFlow's Temporal API, or functional workflows with HotMesh's YAML syntax.
 
-// maintain counters
-await e.increment("retries", 1);
+## Installation
 
-// retrieve current process state
-const data = await e.get();
+```bash
+npm install @hotmeshio/hotmesh
 ```
 
-**Minimal surface contract**
+## Two ways to write workflows
 
-| Command       | Purpose                            |
-| ------------- | ---------------------------------- |
-| `set()`       | Initialize workflow state          |
-| `merge()`     | Update any JSON path               |
-| `append()`    | Add entries to lists (logs, notes) |
-| `increment()` | Maintain counters or metrics       |
-| `get()`       | Retrieve current state             |
+Both approaches reuse your activity functions:
 
-Entities are stored in plain SQL tables, directly queryable:
+```typescript
+// activities.ts (shared between both approaches)
+export async function checkInventory(itemId: string): Promise<number> {
+  return getInventoryCount(itemId);
+}
 
-```sql
-SELECT id, context->>'stage', context->'aiSummary'->>'result'
-FROM my_app.jobs
-WHERE entity = 'claims-review'
-  AND context->>'stage' != 'complete';
-```
+export async function reserveItem(itemId: string, quantity: number): Promise<string> {
+  return createReservation(itemId, quantity);
+}
 
----
+export async function notifyBackorder(itemId: string): Promise<void> {
+  await sendBackorderEmail(itemId);
+}
+```
 
-### Hook — Parallel Work Units
+### Option 1: Code (Temporal-compatible API)
+
+```typescript
+// workflows.ts
+import { MemFlow } from '@hotmeshio/hotmesh';
+import * as activities from './activities';
+
+export async function orderWorkflow(itemId: string, qty: number) {
+  const { checkInventory, reserveItem, notifyBackorder } = 
+    MemFlow.workflow.proxyActivities<typeof activities>({
+      taskQueue: 'inventory-tasks'
+    });
+  
+  const available = await checkInventory(itemId);
+  
+  if (available >= qty) {
+    return await reserveItem(itemId, qty);
+  } else {
+    await notifyBackorder(itemId);
+    return 'backordered';
+  }
+}
 
-Hooks are stateless functions that operate on the shared Entity.
-Each hook executes independently (API, RPA, or AI), retrying automatically until success.
+// main.ts
+const connection = {
+  class: Postgres,
+  options: { connectionString: 'postgresql://localhost:5432/mydb' }
+};
+
+await MemFlow.registerActivityWorker({
+  connection,
+  taskQueue: 'inventory-tasks'
+}, activities, 'inventory-activities');
+
+await MemFlow.Worker.create({
+  connection,
+  taskQueue: 'orders',
+  workflow: orderWorkflow
+});
 
-```ts
-await MemFlow.workflow.execHook({
-  workflowName: "verifyCoverage",
-  args: ["A42"]
+const client = new MemFlow.Client({ connection });
+const handle = await client.workflow.start({
+  args: ['item-123', 5],
+  taskQueue: 'orders',
+  workflowName: 'orderWorkflow',
+  workflowId: 'order-456'
 });
-```
 
-To run independent work in parallel, use a **batch execution** pattern:
-
-```ts
-// Run independent research perspectives in parallel using batch execution
-await MemFlow.workflow.execHookBatch([
-  {
-    key: 'optimistic',
-    options: {
-      taskQueue: 'agents',
-      workflowName: 'optimisticPerspective',
-      args: [query],
-      signalId: 'optimistic-complete'
-    }
-  },
-  {
-    key: 'skeptical',
-    options: {
-      taskQueue: 'agents',
-      workflowName: 'skepticalPerspective',
-      args: [query],
-      signalId: 'skeptical-complete'
-    }
-  }
-]);
+const result = await handle.result();
 ```
 
-Each hook runs in its own recoverable context, allowing AI, API, and RPA agents to operate independently while writing to the same durable Entity.
-
----
-
-## Example — AI-Assisted Claims Review
+### Option 2: YAML (functional approach)
+
+```yaml
+# order.yaml
+activities:
+  trigger:
+    type: trigger
+    
+  checkInventory:
+    type: worker
+    topic: inventory.check
+    
+  reserveItem:
+    type: worker
+    topic: inventory.reserve
+    
+  notifyBackorder:
+    type: worker
+    topic: inventory.backorder.notify
+    
+transitions:
+  trigger:
+    - to: checkInventory
+    
+  checkInventory:
+    - to: reserveItem
+      conditions:
+        match:
+          - expected: true
+            actual:
+              '@pipe':
+                - ['{checkInventory.output.data.availableQty}', '{trigger.output.data.requestedQty}']
+                - ['{@conditional.gte}']
+    
+    - to: notifyBackorder
+      conditions:
+        match:
+          - expected: false
+            actual:
+              '@pipe':
+                - ['{checkInventory.output.data.availableQty}', '{trigger.output.data.requestedQty}']
+                - ['{@conditional.gte}']
+```
 
-```ts
-export async function claimsWorkflow(caseId: string) {
-  const e = await MemFlow.workflow.entity();
-  await e.set({ caseId, stage: "intake", approved: false });
+```typescript
+// main.ts (reuses same activities.ts)
+import * as activities from './activities';
 
-  // Run verification and summarization in parallel
-  await MemFlow.workflow.execHookBatch([
+const hotMesh = await HotMesh.init({
+  appId: 'orders',
+  engine: { connection },
+  workers: [
+    {
+      topic: 'inventory.check',
+      connection,
+      callback: async (data) => {
+        const availableQty = await activities.checkInventory(data.data.itemId);
+        return { metadata: { ...data.metadata }, data: { availableQty } };
+      }
+    },
     {
-      key: 'verifyCoverage',
-      options: {
-        taskQueue: 'agents',
-        workflowName: 'verifyCoverage',
-        args: [caseId],
-        signalId: 'verify-complete'
+      topic: 'inventory.reserve',
+      connection,
+      callback: async (data) => {
+        const reservationId = await activities.reserveItem(data.data.itemId, data.data.quantity);
+        return { metadata: { ...data.metadata }, data: { reservationId } };
       }
     },
     {
-      key: 'generateSummary',
-      options: {
-        taskQueue: 'agents',
-        workflowName: 'generateSummary',
-        args: [caseId],
-        signalId: 'summary-complete'
+      topic: 'inventory.backorder.notify',
+      connection,
+      callback: async (data) => {
+        await activities.notifyBackorder(data.data.itemId);
+        return { metadata: { ...data.metadata } };
       }
     }
-  ]);
+  ]
+});
 
-  // Wait for human sign-off
-  const approval = await MemFlow.workflow.waitFor("human-approval");
-  await e.merge({ approved: approval === true, stage: "complete" });
+await hotMesh.deploy('./order.yaml');
+await hotMesh.activate('1');
 
-  return await e.get();
-}
+const result = await hotMesh.pubsub('order.requested', {
+  itemId: 'item-123',
+  requestedQty: 5
+});
 ```
 
-This bridges:
+Both compile to the same distributed execution model.
 
-* an existing insurance or EHR system (status + audit trail)
-* LLM agents for data validation and summarization
-* a human reviewer for final sign-off
+## Core features
 
-—all within one recoverable workflow record.
+- **Durable execution** - Survives crashes, retries automatically
+- **No infrastructure** - Runs on your existing Postgres
+- **Temporal compatible** - Drop-in replacement for many use cases
+- **Distributed** - Every client participates in execution
+- **Observable** - Full execution history in your database
 
----
+## Common patterns
 
-## Why It Fits Integration Work
+**Long-running workflows**
 
-HotMesh is purpose-built for **incremental modernization**.
+```typescript
+await sleep('30 days');
+await sendFollowUp();
+```
 
-| Need                          | What HotMesh Provides                    |
-| ----------------------------- | ---------------------------------------- |
-| Tie AI into legacy apps       | Durable SQL bridge with full visibility  |
-| Keep human review steps       | Wait-for-signal workflows                |
-| Handle unstable APIs          | Built-in retries and exponential backoff |
-| Trace process across systems  | Unified JSON entity per workflow         |
-| Store long-running AI results | Durable state for agents and automations |
+**Parallel execution**
 
----
+```typescript
+const results = await Promise.all([
+  processPayment(),
+  updateInventory(),
+  notifyWarehouse()
+]);
+```
+
+**Child workflows**
+
+```typescript
+const childHandle = await startChild(validateOrder, { args: [orderId] });
+const validation = await childHandle.result();
+```
 
 ## License
 
-Apache 2.0 — free to build, integrate, and deploy.
-Do not resell the core engine as a hosted service.
+HotMesh is licensed under the Apache License, Version 2.0.
+
+You may use, modify, and distribute HotMesh in accordance with the license, including as part of your own applications and services. However, offering HotMesh itself as a standalone, hosted commercial orchestration service (or a substantially similar service) requires prior written permission from the author.

package/build/index.d.ts

@@ -16,9 +16,7 @@ import * as Enums from './modules/enums';
 import * as KeyStore from './modules/key';
 import { ConnectorService as Connector } from './services/connector/factory';
 import { PostgresConnection as ConnectorPostgres } from './services/connector/providers/postgres';
-import { RedisConnection as ConnectorIORedis } from './services/connector/providers/ioredis';
-import { RedisConnection as ConnectorRedis } from './services/connector/providers/redis';
 import { NatsConnection as ConnectorNATS } from './services/connector/providers/nats';
 export { Connector, //factory
-ConnectorIORedis, ConnectorNATS, ConnectorPostgres, ConnectorRedis, HotMesh, HotMeshConfig, MeshCall, MemFlow, Client, Connection, proxyActivities, Search, Entity, Worker, workflow, WorkflowHandle, Enums, Errors, Utils, KeyStore, };
+ConnectorNATS, ConnectorPostgres, HotMesh, HotMeshConfig, MeshCall, MemFlow, Client, Connection, proxyActivities, Search, Entity, Worker, workflow, WorkflowHandle, Enums, Errors, Utils, KeyStore, };
 export * as Types from './types';

package/build/index.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Types = exports.KeyStore = exports.Utils = exports.Errors = exports.Enums = exports.WorkflowHandle = exports.workflow = exports.Worker = exports.Entity = exports.Search = exports.proxyActivities = exports.Connection = exports.Client = exports.MemFlow = exports.MeshCall = exports.HotMesh = exports.ConnectorRedis = exports.ConnectorPostgres = exports.ConnectorNATS = exports.ConnectorIORedis = exports.Connector = void 0;
+exports.Types = exports.KeyStore = exports.Utils = exports.Errors = exports.Enums = exports.WorkflowHandle = exports.workflow = exports.Worker = exports.Entity = exports.Search = exports.proxyActivities = exports.Connection = exports.Client = exports.MemFlow = exports.MeshCall = exports.HotMesh = exports.ConnectorPostgres = exports.ConnectorNATS = exports.Connector = void 0;
 const hotmesh_1 = require("./services/hotmesh");
 Object.defineProperty(exports, "HotMesh", { enumerable: true, get: function () { return hotmesh_1.HotMesh; } });
 const meshcall_1 = require("./services/meshcall");
@@ -58,10 +58,6 @@ const factory_1 = require("./services/connector/factory");
 Object.defineProperty(exports, "Connector", { enumerable: true, get: function () { return factory_1.ConnectorService; } });
 const postgres_1 = require("./services/connector/providers/postgres");
 Object.defineProperty(exports, "ConnectorPostgres", { enumerable: true, get: function () { return postgres_1.PostgresConnection; } });
-const ioredis_1 = require("./services/connector/providers/ioredis");
-Object.defineProperty(exports, "ConnectorIORedis", { enumerable: true, get: function () { return ioredis_1.RedisConnection; } });
-const redis_1 = require("./services/connector/providers/redis");
-Object.defineProperty(exports, "ConnectorRedis", { enumerable: true, get: function () { return redis_1.RedisConnection; } });
 const nats_1 = require("./services/connector/providers/nats");
 Object.defineProperty(exports, "ConnectorNATS", { enumerable: true, get: function () { return nats_1.NatsConnection; } });
 exports.Types = __importStar(require("./types"));

package/build/modules/enums.d.ts

@@ -106,6 +106,8 @@ export declare const HMSH_XPENDING_COUNT: number;
 export declare const HMSH_EXPIRE_DURATION: number;
 export declare const HMSH_FIDELITY_SECONDS: number;
 export declare const HMSH_SCOUT_INTERVAL_SECONDS: number;
+export declare const HMSH_ROUTER_SCOUT_INTERVAL_SECONDS: number;
+export declare const HMSH_ROUTER_SCOUT_INTERVAL_MS: number;
 export declare const HMSH_GUID_SIZE: number;
 /**
  * Default task queue name used when no task queue is specified
@@ -117,6 +119,11 @@ export declare const DEFAULT_TASK_QUEUE = "default";
  * PostgreSQL hard limit is 8000 bytes; default 7500 provides safety margin.
  */
 export declare const HMSH_NOTIFY_PAYLOAD_LIMIT: number;
+/**
+ * PostgreSQL LISTEN/NOTIFY fallback polling interval in milliseconds.
+ * Used when LISTEN/NOTIFY is unavailable or fails. Default 30 seconds.
+ */
+export declare const HMSH_ROUTER_POLL_FALLBACK_INTERVAL: number;
 /**
  * Serializer compression threshold. When a stringified object exceeds this size
  * in bytes, it will be gzipped and base64 encoded (with /b prefix) to reduce

package/build/modules/enums.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HMSH_SERIALIZER_COMPRESSION_THRESHOLD = exports.HMSH_NOTIFY_PAYLOAD_LIMIT = exports.DEFAULT_TASK_QUEUE = exports.HMSH_GUID_SIZE = exports.HMSH_SCOUT_INTERVAL_SECONDS = exports.HMSH_FIDELITY_SECONDS = exports.HMSH_EXPIRE_DURATION = exports.HMSH_XPENDING_COUNT = exports.HMSH_XCLAIM_COUNT = exports.HMSH_XCLAIM_DELAY_MS = exports.HMSH_BLOCK_TIME_MS = exports.HMSH_MEMFLOW_EXP_BACKOFF = exports.HMSH_MEMFLOW_MAX_INTERVAL = exports.HMSH_MEMFLOW_MAX_ATTEMPTS = exports.HMSH_GRADUATED_INTERVAL_MS = exports.HMSH_MAX_TIMEOUT_MS = exports.HMSH_MAX_RETRIES = exports.MAX_DELAY = exports.MAX_STREAM_RETRIES = exports.INITIAL_STREAM_BACKOFF = exports.MAX_STREAM_BACKOFF = exports.HMSH_EXPIRE_JOB_SECONDS = exports.HMSH_OTT_WAIT_TIME = exports.HMSH_DEPLOYMENT_PAUSE = exports.HMSH_DEPLOYMENT_DELAY = exports.HMSH_ACTIVATION_MAX_RETRY = exports.HMSH_QUORUM_DELAY_MS = exports.HMSH_QUORUM_ROLLCALL_CYCLES = exports.HMSH_STATUS_UNKNOWN = exports.HMSH_CODE_MEMFLOW_RETRYABLE = exports.HMSH_CODE_MEMFLOW_FATAL = exports.HMSH_CODE_MEMFLOW_MAXED = exports.HMSH_CODE_MEMFLOW_TIMEOUT = exports.HMSH_CODE_MEMFLOW_WAIT = exports.HMSH_CODE_MEMFLOW_PROXY = exports.HMSH_CODE_MEMFLOW_CHILD = exports.HMSH_CODE_MEMFLOW_ALL = exports.HMSH_CODE_MEMFLOW_SLEEP = exports.HMSH_CODE_UNACKED = exports.HMSH_CODE_TIMEOUT = exports.HMSH_CODE_UNKNOWN = exports.HMSH_CODE_INTERRUPT = exports.HMSH_CODE_NOTFOUND = exports.HMSH_CODE_PENDING = exports.HMSH_CODE_SUCCESS = exports.HMSH_IS_CLUSTER = exports.HMSH_SIGNAL_EXPIRE = exports.HMSH_TELEMETRY = exports.HMSH_LOGLEVEL = void 0;
+exports.HMSH_NOTIFY_PAYLOAD_LIMIT = exports.DEFAULT_TASK_QUEUE = exports.HMSH_GUID_SIZE = exports.HMSH_ROUTER_SCOUT_INTERVAL_MS = exports.HMSH_ROUTER_SCOUT_INTERVAL_SECONDS = exports.HMSH_SCOUT_INTERVAL_SECONDS = exports.HMSH_FIDELITY_SECONDS = exports.HMSH_EXPIRE_DURATION = exports.HMSH_XPENDING_COUNT = exports.HMSH_XCLAIM_COUNT = exports.HMSH_XCLAIM_DELAY_MS = exports.HMSH_BLOCK_TIME_MS = exports.HMSH_MEMFLOW_EXP_BACKOFF = exports.HMSH_MEMFLOW_MAX_INTERVAL = exports.HMSH_MEMFLOW_MAX_ATTEMPTS = exports.HMSH_GRADUATED_INTERVAL_MS = exports.HMSH_MAX_TIMEOUT_MS = exports.HMSH_MAX_RETRIES = exports.MAX_DELAY = exports.MAX_STREAM_RETRIES = exports.INITIAL_STREAM_BACKOFF = exports.MAX_STREAM_BACKOFF = exports.HMSH_EXPIRE_JOB_SECONDS = exports.HMSH_OTT_WAIT_TIME = exports.HMSH_DEPLOYMENT_PAUSE = exports.HMSH_DEPLOYMENT_DELAY = exports.HMSH_ACTIVATION_MAX_RETRY = exports.HMSH_QUORUM_DELAY_MS = exports.HMSH_QUORUM_ROLLCALL_CYCLES = exports.HMSH_STATUS_UNKNOWN = exports.HMSH_CODE_MEMFLOW_RETRYABLE = exports.HMSH_CODE_MEMFLOW_FATAL = exports.HMSH_CODE_MEMFLOW_MAXED = exports.HMSH_CODE_MEMFLOW_TIMEOUT = exports.HMSH_CODE_MEMFLOW_WAIT = exports.HMSH_CODE_MEMFLOW_PROXY = exports.HMSH_CODE_MEMFLOW_CHILD = exports.HMSH_CODE_MEMFLOW_ALL = exports.HMSH_CODE_MEMFLOW_SLEEP = exports.HMSH_CODE_UNACKED = exports.HMSH_CODE_TIMEOUT = exports.HMSH_CODE_UNKNOWN = exports.HMSH_CODE_INTERRUPT = exports.HMSH_CODE_NOTFOUND = exports.HMSH_CODE_PENDING = exports.HMSH_CODE_SUCCESS = exports.HMSH_IS_CLUSTER = exports.HMSH_SIGNAL_EXPIRE = exports.HMSH_TELEMETRY = exports.HMSH_LOGLEVEL = void 0;
+exports.HMSH_SERIALIZER_COMPRESSION_THRESHOLD = exports.HMSH_ROUTER_POLL_FALLBACK_INTERVAL = void 0;
 /**
  * Determines the log level for the application. The default is 'info'.
  */
@@ -129,6 +130,15 @@ exports.HMSH_FIDELITY_SECONDS = process.env.HMSH_FIDELITY_SECONDS
         ? TEST_FIDELITY_SECONDS
         : BASE_FIDELITY_SECONDS;
 exports.HMSH_SCOUT_INTERVAL_SECONDS = parseInt(process.env.HMSH_SCOUT_INTERVAL_SECONDS, 10) || 60;
+// ROUTER SCOUT - polls for visible messages when LISTEN/NOTIFY is insufficient
+exports.HMSH_ROUTER_SCOUT_INTERVAL_SECONDS = parseInt(process.env.HMSH_ROUTER_SCOUT_INTERVAL_SECONDS, 10) || 60;
+const BASE_ROUTER_SCOUT_INTERVAL_MS = 7000;
+const TEST_ROUTER_SCOUT_INTERVAL_MS = 7000;
+exports.HMSH_ROUTER_SCOUT_INTERVAL_MS = process.env.HMSH_ROUTER_SCOUT_INTERVAL_MS
+    ? parseInt(process.env.HMSH_ROUTER_SCOUT_INTERVAL_MS, 10)
+    : process.env.NODE_ENV === 'test'
+        ? TEST_ROUTER_SCOUT_INTERVAL_MS
+        : BASE_ROUTER_SCOUT_INTERVAL_MS;
 // UTILS
 exports.HMSH_GUID_SIZE = Math.min(parseInt(process.env.HMSH_GUID_SIZE, 10) || 22, 32);
 /**
@@ -141,6 +151,11 @@ exports.DEFAULT_TASK_QUEUE = 'default';
  * PostgreSQL hard limit is 8000 bytes; default 7500 provides safety margin.
  */
 exports.HMSH_NOTIFY_PAYLOAD_LIMIT = parseInt(process.env.HMSH_NOTIFY_PAYLOAD_LIMIT, 10) || 7500;
+/**
+ * PostgreSQL LISTEN/NOTIFY fallback polling interval in milliseconds.
+ * Used when LISTEN/NOTIFY is unavailable or fails. Default 30 seconds.
+ */
+exports.HMSH_ROUTER_POLL_FALLBACK_INTERVAL = parseInt(process.env.HOTMESH_POSTGRES_FALLBACK_INTERVAL, 10) || 30000;
 /**
  * Serializer compression threshold. When a stringified object exceeds this size
  * in bytes, it will be gzipped and base64 encoded (with /b prefix) to reduce

package/build/modules/utils.d.ts

@@ -97,6 +97,33 @@ export declare function isValidCron(cronExpression: string): boolean;
  * used by the `ms` npm package as the input.
  */
 export declare const s: (input: string) => number;
+/**
+ * Normalizes retry policy configuration to a consistent format.
+ * Converts maximumInterval to seconds and applies defaults.
+ *
+ * @param policy - Retry policy to normalize
+ * @param defaults - Default values to use if not specified
+ * @returns Normalized retry policy with numeric values
+ *
+ * @example
+ * ```typescript
+ * const normalized = normalizeRetryPolicy({
+ *   maximumAttempts: 5,
+ *   backoffCoefficient: 2,
+ *   maximumInterval: '300s',
+ * });
+ * // Returns: { max_retry_attempts: 5, backoff_coefficient: 2, maximum_interval_seconds: 300 }
+ * ```
+ */
+export declare function normalizeRetryPolicy(policy?: import('../types/stream').RetryPolicy, defaults?: {
+    maximumAttempts: number;
+    backoffCoefficient: number;
+    maximumInterval: number;
+}): {
+    max_retry_attempts: number;
+    backoff_coefficient: number;
+    maximum_interval_seconds: number;
+};
 /**
  * @private
  */

package/build/modules/utils.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.arrayToHash = exports.isStreamMessage = exports.parseStreamMessage = exports.s = exports.isValidCron = exports.restoreHierarchy = exports.getValueByPath = exports.getIndexedHash = exports.getSymVal = exports.getSymKey = exports.formatISODate = exports.getTimeSeries = exports.getSubscriptionTopic = exports.findSubscriptionForTrigger = exports.findTopKey = exports.matchesStatus = exports.matchesStatusCode = exports.polyfill = exports.identifyProvider = exports.XSleepFor = exports.sleepImmediate = exports.sleepFor = exports.guid = exports.deterministicRandom = exports.deepCopy = exports.getSystemHealth = exports.hashOptions = void 0;
+exports.arrayToHash = exports.isStreamMessage = exports.parseStreamMessage = exports.normalizeRetryPolicy = exports.s = exports.isValidCron = exports.restoreHierarchy = exports.getValueByPath = exports.getIndexedHash = exports.getSymVal = exports.getSymKey = exports.formatISODate = exports.getTimeSeries = exports.getSubscriptionTopic = exports.findSubscriptionForTrigger = exports.findTopKey = exports.matchesStatus = exports.matchesStatusCode = exports.polyfill = exports.identifyProvider = exports.XSleepFor = exports.sleepImmediate = exports.sleepFor = exports.guid = exports.deterministicRandom = exports.deepCopy = exports.getSystemHealth = exports.hashOptions = void 0;
 const os_1 = __importDefault(require("os"));
 const crypto_1 = require("crypto");
 const nanoid_1 = require("nanoid");
@@ -79,42 +79,14 @@ function identifyProvider(provider) {
     else if (provider.toString().toLowerCase().includes('nats')) {
         return 'nats';
     }
-    else if ('defineCommand' in prototype ||
-        Object.keys(prototype).includes('multi')) {
-        return 'ioredis';
-    }
-    else if (Object.keys(prototype).includes('Multi')) {
-        return 'redis';
-    }
-    if (provider.constructor) {
-        if (provider.constructor.name === 'Redis' ||
-            provider.constructor.name === 'EventEmitter') {
-            if ('hset' in provider) {
-                return 'ioredis';
-            }
-        }
-        else if (provider.constructor.name === 'ProviderClient' ||
-            provider.constructor.name === 'Commander') {
-            if ('HSET' in provider) {
-                return 'redis';
-            }
-        }
-    }
-    let type = null;
     if (Object.keys(provider).includes('connection') ||
         !isNaN(provider.totalCount) && !isNaN(provider.idleCount)) {
-        type = 'postgres';
-    }
-    else if (Object.keys(provider).includes('Pipeline')) {
-        type = 'ioredis';
-    }
-    else if (Object.keys(provider).includes('createClient')) {
-        type = 'redis';
+        return 'postgres';
     }
     else if (prototype.constructor.toString().includes('NatsConnectionImpl')) {
-        type = 'nats';
+        return 'nats';
     }
-    return type;
+    return null;
 }
 exports.identifyProvider = identifyProvider;
 /**
@@ -316,6 +288,57 @@ const s = (input) => {
     return (0, ms_1.default)(input) / 1000;
 };
 exports.s = s;
+/**
+ * Normalizes retry policy configuration to a consistent format.
+ * Converts maximumInterval to seconds and applies defaults.
+ *
+ * @param policy - Retry policy to normalize
+ * @param defaults - Default values to use if not specified
+ * @returns Normalized retry policy with numeric values
+ *
+ * @example
+ * ```typescript
+ * const normalized = normalizeRetryPolicy({
+ *   maximumAttempts: 5,
+ *   backoffCoefficient: 2,
+ *   maximumInterval: '300s',
+ * });
+ * // Returns: { max_retry_attempts: 5, backoff_coefficient: 2, maximum_interval_seconds: 300 }
+ * ```
+ */
+function normalizeRetryPolicy(policy, defaults = {
+    maximumAttempts: 3,
+    backoffCoefficient: 10,
+    maximumInterval: 120,
+}) {
+    if (!policy) {
+        return {
+            max_retry_attempts: defaults.maximumAttempts,
+            backoff_coefficient: defaults.backoffCoefficient,
+            maximum_interval_seconds: defaults.maximumInterval,
+        };
+    }
+    const maxAttempts = policy.maximumAttempts ?? defaults.maximumAttempts;
+    const backoffCoeff = policy.backoffCoefficient ?? defaults.backoffCoefficient;
+    let maxIntervalSeconds;
+    if (policy.maximumInterval !== undefined) {
+        if (typeof policy.maximumInterval === 'string') {
+            maxIntervalSeconds = (0, exports.s)(policy.maximumInterval);
+        }
+        else {
+            maxIntervalSeconds = policy.maximumInterval;
+        }
+    }
+    else {
+        maxIntervalSeconds = defaults.maximumInterval;
+    }
+    return {
+        max_retry_attempts: maxAttempts,
+        backoff_coefficient: backoffCoeff,
+        maximum_interval_seconds: maxIntervalSeconds,
+    };
+}
+exports.normalizeRetryPolicy = normalizeRetryPolicy;
 /**
  * @private
  */