@hotmeshio/hotmesh 0.6.1 → 0.8.0

package/build/services/stream/providers/postgres/scout.d.ts

@@ -0,0 +1,68 @@
+import { ILogger } from '../../../logger';
+import { KeyType } from '../../../../modules/key';
+import { KeyStoreParams } from '../../../../types';
+import { PostgresClientType } from '../../../../types/postgres';
+import { ProviderClient } from '../../../../types/provider';
+/**
+ * Scout state manager for coordinating polling across multiple instances.
+ * Only one instance at a time should be the active scout.
+ */
+export declare class ScoutManager {
+    private client;
+    private appId;
+    private getTableName;
+    private mintKey;
+    private logger;
+    private isScout;
+    private shouldStopScout;
+    private pollCount;
+    private totalNotifications;
+    private scoutStartTime;
+    constructor(client: PostgresClientType & ProviderClient, appId: string, getTableName: () => string, mintKey: (type: KeyType, params: KeyStoreParams) => string, logger: ILogger);
+    /**
+     * Start the router scout polling loop.
+     * Winner polls frequently for visible messages, losers retry acquiring role less frequently.
+     */
+    startRouterScoutPoller(): void;
+    /**
+     * Stop the router scout polling loop and release the role.
+     */
+    stopRouterScoutPoller(): Promise<void>;
+    /**
+     * Check if this instance should act as the router scout.
+     */
+    private shouldScout;
+    /**
+     * Main polling loop for the router scout.
+     */
+    private pollForVisibleMessagesLoop;
+    /**
+     * Poll for visible messages and trigger notifications for any found.
+     */
+    private pollForVisibleMessages;
+    /**
+     * Reserve the router scout role using direct SQL.
+     */
+    private reserveRouterScoutRole;
+    /**
+     * Reserve a scout role for the specified type.
+     * Uses SET NX (set if not exists) with expiration to ensure only one instance holds the role.
+     */
+    private reserveScoutRole;
+    /**
+     * Release a scout role for the specified type.
+     */
+    private releaseScoutRole;
+    /**
+     * Get the router scout polling interval in milliseconds.
+     */
+    private getRouterScoutInterval;
+    /**
+     * Check if this instance is currently the scout.
+     */
+    isCurrentlyScout(): boolean;
+    /**
+     * Log polling metrics for this instance's scout tenure.
+     */
+    private logPollingMetrics;
+}

package/build/services/stream/providers/postgres/scout.js

@@ -0,0 +1,233 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScoutManager = void 0;
+const key_1 = require("../../../../modules/key");
+const utils_1 = require("../../../../modules/utils");
+const enums_1 = require("../../../../modules/enums");
+/**
+ * Scout state manager for coordinating polling across multiple instances.
+ * Only one instance at a time should be the active scout.
+ */
+class ScoutManager {
+    constructor(client, appId, getTableName, mintKey, logger) {
+        this.client = client;
+        this.appId = appId;
+        this.getTableName = getTableName;
+        this.mintKey = mintKey;
+        this.logger = logger;
+        this.isScout = false;
+        this.shouldStopScout = false;
+        // Polling metrics
+        this.pollCount = 0;
+        this.totalNotifications = 0;
+        this.scoutStartTime = null;
+    }
+    /**
+     * Start the router scout polling loop.
+     * Winner polls frequently for visible messages, losers retry acquiring role less frequently.
+     */
+    startRouterScoutPoller() {
+        this.shouldStopScout = false;
+        this.pollForVisibleMessagesLoop().catch((error) => {
+            this.logger.error('postgres-stream-router-scout-start-error', { error });
+        });
+        this.logger.debug('postgres-stream-router-scout-started', {
+            appId: this.appId,
+            pollInterval: this.getRouterScoutInterval(),
+            scoutInterval: enums_1.HMSH_ROUTER_SCOUT_INTERVAL_SECONDS,
+        });
+    }
+    /**
+     * Stop the router scout polling loop and release the role.
+     */
+    async stopRouterScoutPoller() {
+        this.shouldStopScout = true;
+        if (this.isScout) {
+            await this.releaseScoutRole('router');
+            this.isScout = false;
+        }
+        // Log polling metrics on shutdown
+        this.logPollingMetrics();
+    }
+    /**
+     * Check if this instance should act as the router scout.
+     */
+    async shouldScout() {
+        const wasScout = this.isScout;
+        const isScout = wasScout || (this.isScout = await this.reserveRouterScoutRole());
+        if (isScout) {
+            if (!wasScout) {
+                // First time becoming scout - set timeout to reset after interval and track start time
+                this.scoutStartTime = Date.now();
+                this.logger.info('postgres-stream-router-scout-role-acquired', {
+                    appId: this.appId,
+                });
+                setTimeout(() => {
+                    this.isScout = false;
+                    this.scoutStartTime = null;
+                }, enums_1.HMSH_ROUTER_SCOUT_INTERVAL_SECONDS * 1000);
+            }
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Main polling loop for the router scout.
+     */
+    async pollForVisibleMessagesLoop() {
+        while (!this.shouldStopScout) {
+            try {
+                if (await this.shouldScout()) {
+                    // We're the scout - poll for visible messages frequently
+                    await this.pollForVisibleMessages();
+                    // Sleep for the short polling interval
+                    await (0, utils_1.sleepFor)(this.getRouterScoutInterval());
+                }
+                else {
+                    // Not the scout - sleep longer before trying to acquire role again
+                    await (0, utils_1.sleepFor)(enums_1.HMSH_ROUTER_SCOUT_INTERVAL_SECONDS * 1000);
+                }
+            }
+            catch (error) {
+                this.logger.error('postgres-stream-router-scout-loop-error', { error });
+                await (0, utils_1.sleepFor)(1000); // Brief pause on error
+            }
+        }
+    }
+    /**
+     * Poll for visible messages and trigger notifications for any found.
+     */
+    async pollForVisibleMessages() {
+        try {
+            const tableName = this.getTableName();
+            const schemaName = tableName.split('.')[0];
+            const result = await this.client.query(`SELECT ${schemaName}.notify_visible_messages() as count`);
+            // Track polling metrics
+            this.pollCount++;
+            const notificationCount = result.rows[0]?.count || 0;
+            this.totalNotifications += notificationCount;
+            if (notificationCount > 0) {
+                this.logger.debug('postgres-stream-router-scout-notifications', {
+                    count: notificationCount,
+                    totalPolls: this.pollCount,
+                    totalNotifications: this.totalNotifications,
+                });
+            }
+        }
+        catch (error) {
+            // Log but don't throw - this is a background task
+            this.logger.debug('postgres-stream-router-scout-poll-error', {
+                error: error.message,
+            });
+        }
+    }
+    /**
+     * Reserve the router scout role using direct SQL.
+     */
+    async reserveRouterScoutRole() {
+        try {
+            return await this.reserveScoutRole('router', enums_1.HMSH_ROUTER_SCOUT_INTERVAL_SECONDS);
+        }
+        catch (error) {
+            this.logger.error('postgres-stream-router-scout-reserve-error', { error });
+            return false;
+        }
+    }
+    /**
+     * Reserve a scout role for the specified type.
+     * Uses SET NX (set if not exists) with expiration to ensure only one instance holds the role.
+     */
+    async reserveScoutRole(scoutType, delay = enums_1.HMSH_ROUTER_SCOUT_INTERVAL_SECONDS) {
+        try {
+            const key = this.mintKey(key_1.KeyType.WORK_ITEMS, {
+                appId: this.appId,
+                scoutType,
+            });
+            const value = `${scoutType}:${(0, utils_1.formatISODate)(new Date())}`;
+            const expirySeconds = delay - 1;
+            const tableName = this.getTableName().split('.')[0] + '.roles';
+            // Use INSERT ... ON CONFLICT to implement SET NX with expiration
+            // Only succeeds if key doesn't exist OR if existing entry has expired
+            const result = await this.client.query(`INSERT INTO ${tableName} (key, value, expiry)
+         VALUES ($1, $2, NOW() + INTERVAL '${expirySeconds} seconds')
+         ON CONFLICT (key) 
+         DO UPDATE SET 
+           value = EXCLUDED.value,
+           expiry = EXCLUDED.expiry
+         WHERE ${tableName}.expiry IS NULL OR ${tableName}.expiry <= NOW()
+         RETURNING key`, [key, value]);
+            return result.rows.length > 0;
+        }
+        catch (error) {
+            this.logger.error('postgres-stream-reserve-scout-error', {
+                scoutType,
+                error: error.message
+            });
+            return false;
+        }
+    }
+    /**
+     * Release a scout role for the specified type.
+     */
+    async releaseScoutRole(scoutType) {
+        try {
+            const key = this.mintKey(key_1.KeyType.WORK_ITEMS, {
+                appId: this.appId,
+                scoutType,
+            });
+            const tableName = this.getTableName().split('.')[0] + '.roles';
+            const result = await this.client.query(`DELETE FROM ${tableName} WHERE key = $1`, [key]);
+            return result.rowCount > 0;
+        }
+        catch (error) {
+            this.logger.error('postgres-stream-release-scout-error', {
+                scoutType,
+                error: error.message
+            });
+            return false;
+        }
+    }
+    /**
+     * Get the router scout polling interval in milliseconds.
+     */
+    getRouterScoutInterval() {
+        return enums_1.HMSH_ROUTER_SCOUT_INTERVAL_MS;
+    }
+    /**
+     * Check if this instance is currently the scout.
+     */
+    isCurrentlyScout() {
+        return this.isScout;
+    }
+    /**
+     * Log polling metrics for this instance's scout tenure.
+     */
+    logPollingMetrics() {
+        if (this.pollCount === 0) {
+            this.logger.debug('postgres-stream-router-scout-metrics', {
+                message: 'No polling occurred during this session',
+                appId: this.appId,
+            });
+            return;
+        }
+        const durationMs = this.scoutStartTime
+            ? Date.now() - this.scoutStartTime
+            : 0;
+        const durationMinutes = durationMs / 1000 / 60;
+        const qpm = durationMinutes > 0 ? this.pollCount / durationMinutes : 0;
+        const qps = durationMs > 0 ? this.pollCount / (durationMs / 1000) : 0;
+        this.logger.info('postgres-stream-router-scout-metrics', {
+            appId: this.appId,
+            totalPolls: this.pollCount,
+            totalNotifications: this.totalNotifications,
+            durationMs: Math.round(durationMs),
+            durationMinutes: durationMinutes.toFixed(2),
+            queriesPerMinute: qpm.toFixed(2),
+            queriesPerSecond: qps.toFixed(3),
+            avgNotificationsPerPoll: this.pollCount > 0
+                ? (this.totalNotifications / this.pollCount).toFixed(2)
+                : '0',
+        });
+    }
+}
+exports.ScoutManager = ScoutManager;

package/build/services/stream/providers/postgres/stats.d.ts

@@ -0,0 +1,49 @@
+import { ILogger } from '../../../logger';
+import { PostgresClientType } from '../../../../types/postgres';
+import { StreamConfig, StreamStats } from '../../../../types/stream';
+import { ProviderClient } from '../../../../types/provider';
+/**
+ * Get statistics for a specific stream.
+ * Returns message count and other metrics.
+ */
+export declare function getStreamStats(client: PostgresClientType & ProviderClient, tableName: string, streamName: string, logger: ILogger): Promise<StreamStats>;
+/**
+ * Get the depth (message count) for a specific stream.
+ */
+export declare function getStreamDepth(client: PostgresClientType & ProviderClient, tableName: string, streamName: string, logger: ILogger): Promise<number>;
+/**
+ * Get depths for multiple streams in a single query.
+ * More efficient than calling getStreamDepth multiple times.
+ */
+export declare function getStreamDepths(client: PostgresClientType & ProviderClient, tableName: string, streamNames: {
+    stream: string;
+}[], logger: ILogger): Promise<{
+    stream: string;
+    depth: number;
+}[]>;
+/**
+ * Trim (soft delete) messages from a stream based on age or count.
+ * Returns the number of messages expired.
+ */
+export declare function trimStream(client: PostgresClientType & ProviderClient, tableName: string, streamName: string, options: {
+    maxLen?: number;
+    maxAge?: number;
+    exactLimit?: boolean;
+}, logger: ILogger): Promise<number>;
+/**
+ * Check if notifications are enabled for the provider.
+ */
+export declare function isNotificationsEnabled(config?: StreamConfig): boolean;
+/**
+ * Get provider-specific feature flags and capabilities.
+ */
+export declare function getProviderSpecificFeatures(config?: StreamConfig): {
+    supportsBatching: boolean;
+    supportsDeadLetterQueue: boolean;
+    supportsOrdering: boolean;
+    supportsTrimming: boolean;
+    supportsRetry: boolean;
+    supportsNotifications: boolean;
+    maxMessageSize: number;
+    maxBatchSize: number;
+};

package/build/services/stream/providers/postgres/stats.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProviderSpecificFeatures = exports.isNotificationsEnabled = exports.trimStream = exports.getStreamDepths = exports.getStreamDepth = exports.getStreamStats = void 0;
+/**
+ * Get statistics for a specific stream.
+ * Returns message count and other metrics.
+ */
+async function getStreamStats(client, tableName, streamName, logger) {
+    try {
+        const res = await client.query(`SELECT COUNT(*) AS available_count 
+      FROM ${tableName} 
+      WHERE stream_name = $1 AND expired_at IS NULL`, [streamName]);
+        return {
+            messageCount: parseInt(res.rows[0].available_count, 10),
+        };
+    }
+    catch (error) {
+        logger.error(`postgres-stream-stats-error-${streamName}`, { error });
+        throw error;
+    }
+}
+exports.getStreamStats = getStreamStats;
+/**
+ * Get the depth (message count) for a specific stream.
+ */
+async function getStreamDepth(client, tableName, streamName, logger) {
+    const stats = await getStreamStats(client, tableName, streamName, logger);
+    return stats.messageCount;
+}
+exports.getStreamDepth = getStreamDepth;
+/**
+ * Get depths for multiple streams in a single query.
+ * More efficient than calling getStreamDepth multiple times.
+ */
+async function getStreamDepths(client, tableName, streamNames, logger) {
+    try {
+        const streams = streamNames.map((s) => s.stream);
+        const res = await client.query(`SELECT stream_name, COUNT(*) AS count
+       FROM ${tableName}
+       WHERE stream_name = ANY($1::text[])
+       GROUP BY stream_name`, [streams]);
+        const result = res.rows.map((row) => ({
+            stream: row.stream_name,
+            depth: parseInt(row.count, 10),
+        }));
+        return result;
+    }
+    catch (error) {
+        logger.error('postgres-stream-depth-error', { error });
+        throw error;
+    }
+}
+exports.getStreamDepths = getStreamDepths;
+/**
+ * Trim (soft delete) messages from a stream based on age or count.
+ * Returns the number of messages expired.
+ */
+async function trimStream(client, tableName, streamName, options, logger) {
+    try {
+        let expiredCount = 0;
+        if (options.maxLen !== undefined) {
+            const res = await client.query(`WITH to_expire AS (
+          SELECT id FROM ${tableName}
+          WHERE stream_name = $1
+          ORDER BY id ASC
+          OFFSET $2
+        )
+        UPDATE ${tableName}
+        SET expired_at = NOW()
+        WHERE id IN (SELECT id FROM to_expire)`, [streamName, options.maxLen]);
+            expiredCount += res.rowCount;
+        }
+        if (options.maxAge !== undefined) {
+            const res = await client.query(`UPDATE ${tableName}
+        SET expired_at = NOW()
+        WHERE stream_name = $1 AND created_at < NOW() - INTERVAL '${options.maxAge} milliseconds'`, [streamName]);
+            expiredCount += res.rowCount;
+        }
+        return expiredCount;
+    }
+    catch (error) {
+        logger.error(`postgres-stream-trim-error-${streamName}`, { error });
+        throw error;
+    }
+}
+exports.trimStream = trimStream;
+/**
+ * Check if notifications are enabled for the provider.
+ */
+function isNotificationsEnabled(config = {}) {
+    // Allow override via environment variable
+    if (process.env.HOTMESH_POSTGRES_DISABLE_NOTIFICATIONS === 'true') {
+        return false;
+    }
+    return config?.postgres?.enableNotifications !== false; // Default: true
+}
+exports.isNotificationsEnabled = isNotificationsEnabled;
+/**
+ * Get provider-specific feature flags and capabilities.
+ */
+function getProviderSpecificFeatures(config = {}) {
+    return {
+        supportsBatching: true,
+        supportsDeadLetterQueue: false,
+        supportsOrdering: true,
+        supportsTrimming: true,
+        supportsRetry: false,
+        supportsNotifications: isNotificationsEnabled(config),
+        maxMessageSize: 1024 * 1024,
+        maxBatchSize: 256,
+    };
+}
+exports.getProviderSpecificFeatures = getProviderSpecificFeatures;

package/build/services/sub/factory.js

@@ -2,10 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SubServiceFactory = void 0;
 const utils_1 = require("../../modules/utils");
-const redis_1 = require("./providers/redis/redis");
 const postgres_1 = require("./providers/postgres/postgres");
 const nats_1 = require("./providers/nats/nats");
-const ioredis_1 = require("./providers/redis/ioredis");
 class SubServiceFactory {
     static async init(providerSubClient, providerPubClient, namespace, appId, engineId, logger) {
         let service;
@@ -13,15 +11,9 @@ class SubServiceFactory {
         if (providerType === 'nats') {
             service = new nats_1.NatsSubService(providerSubClient, providerPubClient);
         }
-        else if (providerType === 'redis') {
-            service = new redis_1.RedisSubService(providerSubClient, providerPubClient);
-        }
         else if (providerType === 'postgres') {
             service = new postgres_1.PostgresSubService(providerSubClient, providerPubClient);
-        }
-        else {
-            service = new ioredis_1.IORedisSubService(providerSubClient, providerPubClient);
-        }
+        } //etc
         await service.init(namespace, appId, engineId, logger);
         return service;
     }

package/build/services/sub/index.d.ts

@@ -17,6 +17,6 @@ declare abstract class SubService<ClientProvider extends ProviderClient> {
     abstract unsubscribe(keyType: KeyType.QUORUM, appId: string, topic?: string): Promise<void>;
     abstract psubscribe(keyType: KeyType.QUORUM, callback: SubscriptionCallback, appId: string, topic?: string): Promise<void>;
     abstract punsubscribe(keyType: KeyType.QUORUM, appId: string, topic?: string): Promise<void>;
-    abstract publish(keyType: KeyType, message: Record<string, any>, appId: string, topic?: string): Promise<boolean>;
+    abstract publish(keyType: KeyType, message: Record<string, any>, appId: string, topic?: string, transaction?: ProviderTransaction): Promise<boolean>;
 }
 export { SubService };

package/build/services/sub/providers/postgres/postgres.d.ts

@@ -22,7 +22,7 @@ declare class PostgresSubService extends SubService<PostgresClientType & Provide
      * Should be called when the SubService instance is being destroyed.
      */
     cleanup(): Promise<void>;
-    publish(keyType: KeyType.QUORUM, message: Record<string, any>, appId: string, topic?: string): Promise<boolean>;
+    publish(keyType: KeyType.QUORUM, message: Record<string, any>, appId: string, topic?: string, transaction?: ProviderTransaction): Promise<boolean>;
     psubscribe(): Promise<void>;
     punsubscribe(): Promise<void>;
 }

package/build/services/sub/providers/postgres/postgres.js

@@ -135,7 +135,18 @@ class PostgresSubService extends index_1.SubService {
         // Stop listening to the safe topic if no more callbacks exist
         if (callbacks.size === 0) {
             clientSubscriptions.delete(safeKey);
-            await this.eventClient.query(`UNLISTEN "${safeKey}"`);
+            // Check if client is still connected before attempting to unlisten
+            if (!this.eventClient._ending && !this.eventClient._ended) {
+                try {
+                    await this.eventClient.query(`UNLISTEN "${safeKey}"`);
+                }
+                catch (err) {
+                    // Silently handle errors if client was closed during operation
+                    if (!err?.message?.includes('closed') && !err?.message?.includes('queryable')) {
+                        this.logger?.error(`Error unlistening from ${safeKey}:`, err);
+                    }
+                }
+            }
         }
         this.logger.debug(`postgres-unsubscribe`, {
             originalKey,
@@ -176,7 +187,7 @@ class PostgresSubService extends index_1.SubService {
             PostgresSubService.clientHandlers.delete(this.eventClient);
         }
     }
-    async publish(keyType, message, appId, topic) {
+    async publish(keyType, message, appId, topic, transaction) {
         const [originalKey, safeKey] = this.mintSafeKey(keyType, {
             appId,
             engineId: topic,
@@ -207,11 +218,47 @@ class PostgresSubService extends index_1.SubService {
                 jid,
             });
         }
-        // Publish the message using the safe topic
+        // Escape single quotes for SQL
         payload = payload.replace(/'/g, "''");
-        await this.storeClient.query(`NOTIFY "${safeKey}", '${payload}'`);
-        this.logger.debug(`postgres-publish`, { originalKey, safeKey });
-        return true;
+        // If transaction provided and has addCommand (KVSQL Multi pattern),
+        // add NOTIFY to transaction
+        if (transaction &&
+            typeof transaction.addCommand === 'function') {
+            // Add NOTIFY to transaction - will execute when transaction.exec() is called
+            transaction.addCommand(`NOTIFY "${safeKey}", '${payload}'`, [], 'void');
+            this.logger.debug(`postgres-publish-transactional`, {
+                originalKey,
+                safeKey
+            });
+            return true;
+        }
+        // Non-transactional publish - execute immediately
+        // Check if client is still connected before attempting to publish
+        if (this.storeClient._ending || this.storeClient._ended) {
+            this.logger?.debug('postgres-publish-skipped-closed-client', { appId, topic });
+            return false;
+        }
+        try {
+            await this.storeClient.query(`NOTIFY "${safeKey}", '${payload}'`);
+            this.logger.debug(`postgres-publish`, {
+                originalKey,
+                safeKey
+            });
+            return true;
+        }
+        catch (err) {
+            // Handle gracefully if client was closed during operation
+            if (err?.message?.includes('closed') || err?.message?.includes('queryable')) {
+                this.logger?.debug('postgres-publish-failed-closed-client', {
+                    originalKey,
+                    safeKey,
+                    error: err.message
+                });
+                return false;
+            }
+            // Re-throw other errors
+            throw err;
+        }
     }
     async psubscribe() {
         throw new Error('Pattern subscriptions are not supported in PostgreSQL');

package/build/services/task/index.d.ts

@@ -14,7 +14,7 @@ declare class TaskService {
     constructor(store: StoreService<ProviderClient, ProviderTransaction>, logger: ILogger);
     processWebHooks(hookEventCallback: HookInterface): Promise<void>;
     enqueueWorkItems(keys: string[]): Promise<void>;
-    registerJobForCleanup(jobId: string, inSeconds: number, options: JobCompletionOptions): Promise<void>;
+    registerJobForCleanup(jobId: string, inSeconds: number, options: JobCompletionOptions, transaction?: ProviderTransaction): Promise<void>;
     registerTimeHook(jobId: string, gId: string, activityId: string, type: WorkListTaskType, inSeconds: number, dad: string, transaction?: ProviderTransaction): Promise<void>;
     /**
      * Should this engine instance play the role of 'scout' on behalf

package/build/services/task/index.js

@@ -34,13 +34,9 @@ class TaskService {
     async enqueueWorkItems(keys) {
         await this.store.addTaskQueues(keys);
     }
-    async registerJobForCleanup(jobId, inSeconds = enums_1.HMSH_EXPIRE_DURATION, options) {
+    async registerJobForCleanup(jobId, inSeconds = enums_1.HMSH_EXPIRE_DURATION, options, transaction) {
         if (inSeconds > 0) {
-            await this.store.expireJob(jobId, inSeconds);
-            // const fromNow = Date.now() + inSeconds * 1000;
-            // const fidelityMS = HMSH_FIDELITY_SECONDS * 1000;
-            // const timeSlot = Math.floor(fromNow / fidelityMS) * fidelityMS;
-            // await this.store.registerDependenciesForCleanup(jobId, timeSlot, options);
+            await this.store.expireJob(jobId, inSeconds, transaction);
         }
     }
     async registerTimeHook(jobId, gId, activityId, type, inSeconds = enums_1.HMSH_FIDELITY_SECONDS, dad, transaction) {

package/build/services/worker/index.d.ts

@@ -23,6 +23,7 @@ declare class WorkerService {
     reporting: boolean;
     inited: string;
     rollCallInterval: NodeJS.Timeout;
+    retryPolicy: import('../../types/stream').RetryPolicy | undefined;
     /**
      * @private
      */

package/build/services/worker/index.js

@@ -38,6 +38,7 @@ class WorkerService {
                 service.topic = worker.topic;
                 service.config = config;
                 service.logger = logger;
+                service.retryPolicy = worker.retryPolicy;
                 await service.initStoreChannel(service, worker.store);
                 await service.initSubChannel(service, worker.sub, worker.pub ?? worker.store);
                 await service.subscribe.subscribe(key_1.KeyType.QUORUM, service.subscriptionHandler(), appId);
@@ -99,6 +100,7 @@ class WorkerService {
             reclaimDelay: worker.reclaimDelay,
             reclaimCount: worker.reclaimCount,
             throttle,
+            retryPolicy: worker.retryPolicy,
         }, this.stream, logger);
     }
     /**