@hotmeshio/hotmesh 0.14.7 → 0.14.9

package/build/services/durable/worker.js

@@ -377,15 +377,13 @@ class WorkerService {
                     //use code 599 as a proxy for all retryable errors
                     // (basically anything not 596, 597, 598)
                     return {
-                        status: stream_1.StreamStatus.SUCCESS,
+                        status: stream_1.StreamStatus.ERROR,
                         code: 599,
                         metadata: { ...data.metadata },
                         data: {
-                            $error: {
-                                message: err.message,
-                                stack: err.stack,
-                                code: enums_1.HMSH_CODE_DURABLE_RETRYABLE,
-                            },
+                            message: err.message,
+                            stack: err.stack,
+                            code: enums_1.HMSH_CODE_DURABLE_RETRYABLE,
                         },
                     };
                 }
@@ -607,15 +605,13 @@ class WorkerService {
                     //use code 599 as a proxy for all retryable errors
                     // (basically anything not 596, 597, 598)
                     return {
-                        status: stream_1.StreamStatus.SUCCESS,
+                        status: stream_1.StreamStatus.ERROR,
                         code: enums_1.HMSH_CODE_DURABLE_RETRYABLE,
                         metadata: { ...data.metadata },
                         data: {
-                            $error: {
-                                message: err.message,
-                                stack: err.stack,
-                                timestamp: (0, utils_1.formatISODate)(new Date()),
-                            },
+                            message: err.message,
+                            stack: err.stack,
+                            code: enums_1.HMSH_CODE_DURABLE_RETRYABLE,
                         },
                     };
                 }
@@ -963,9 +959,24 @@ class WorkerService {
                     }, telemetry_3.SpanStatusCode.ERROR, err.message);
                 }
                 isProcessing = true;
+                const errorCode = err.code || new errors_1.DurableRetryError(err.message).code;
+                if (errorCode === enums_1.HMSH_CODE_DURABLE_RETRYABLE) {
+                    // Retryable errors use status: ERROR so the engine-level
+                    // retry mechanism (handleRetry + _streamRetryConfig) kicks in
+                    return withPatchMarkers({
+                        status: stream_1.StreamStatus.ERROR,
+                        code: errorCode,
+                        metadata: { ...data.metadata },
+                        data: {
+                            message: err.message,
+                            stack: err.stack,
+                            code: errorCode,
+                        },
+                    });
+                }
                 return withPatchMarkers({
                     status: stream_1.StreamStatus.SUCCESS,
-                    code: err.code || new errors_1.DurableRetryError(err.message).code,
+                    code: errorCode,
                     metadata: { ...data.metadata },
                     data: {
                         $error: {
@@ -973,7 +984,7 @@ class WorkerService {
                             type: err.name,
                             name: err.name,
                             stack: err.stack,
-                            code: err.code || new errors_1.DurableRetryError(err.message).code,
+                            code: errorCode,
                         },
                     },
                 });

package/build/services/pipe/functions/cron.d.ts

@@ -1,4 +1,3 @@
-import { ILogger } from '../../../types/logger';
 /**
  * Provides cron-related utility functions based on the
  * [cron](https://en.wikipedia.org/wiki/Cron) format for use
@@ -8,16 +7,14 @@ import { ILogger } from '../../../types/logger';
  * Invoked in mapping rules using `{@cron.<method>}` syntax.
  */
 declare class CronHandler {
-    static logger: ILogger;
     /**
-     * Safely calculates the delay in seconds until the next execution
-     * of a cron job. Calculates the next date and time (per the system
-     * clock) that satisfies the cron expression, then returns the value
-     * in seconds from now. Fails silently and returns `-1` if the cron
-     * expression is invalid or the next execution time is in the past.
+     * Calculates the delay in seconds until the next execution
+     * of a cron job. Throws on invalid expressions rather than
+     * degrading silently.
      *
      * @param {string} cronExpression - The cron expression to parse (e.g. `'0 0 * * *'`)
-     * @returns {number} The delay in seconds until the next cron job execution (minimum `HMSH_FIDELITY_SECONDS`), or `-1` on error
+     * @returns {number} The delay in seconds until the next cron job execution (minimum `HMSH_FIDELITY_SECONDS`)
+     * @throws {Error} If the cron expression is invalid
      * @example
      * ```yaml
      * cron_next_result:

package/build/services/pipe/functions/cron.js

@@ -4,7 +4,6 @@ exports.CronHandler = void 0;
 const cron_parser_1 = require("cron-parser");
 const enums_1 = require("../../../modules/enums");
 const utils_1 = require("../../../modules/utils");
-const logger_1 = require("../../logger");
 /**
  * Provides cron-related utility functions based on the
  * [cron](https://en.wikipedia.org/wiki/Cron) format for use
@@ -15,14 +14,13 @@ const logger_1 = require("../../logger");
  */
 class CronHandler {
     /**
-     * Safely calculates the delay in seconds until the next execution
-     * of a cron job. Calculates the next date and time (per the system
-     * clock) that satisfies the cron expression, then returns the value
-     * in seconds from now. Fails silently and returns `-1` if the cron
-     * expression is invalid or the next execution time is in the past.
+     * Calculates the delay in seconds until the next execution
+     * of a cron job. Throws on invalid expressions rather than
+     * degrading silently.
      *
      * @param {string} cronExpression - The cron expression to parse (e.g. `'0 0 * * *'`)
-     * @returns {number} The delay in seconds until the next cron job execution (minimum `HMSH_FIDELITY_SECONDS`), or `-1` on error
+     * @returns {number} The delay in seconds until the next cron job execution (minimum `HMSH_FIDELITY_SECONDS`)
+     * @throws {Error} If the cron expression is invalid
      * @example
      * ```yaml
      * cron_next_result:
@@ -32,28 +30,17 @@ class CronHandler {
      * ```
      */
     nextDelay(cronExpression) {
-        try {
-            if (!(0, utils_1.isValidCron)(cronExpression)) {
-                return -1;
-            }
-            const interval = (0, cron_parser_1.parseExpression)(cronExpression, { utc: true });
-            const nextDate = interval.next().toDate();
-            const now = new Date();
-            const delay = (nextDate.getTime() - now.getTime()) / 1000;
-            if (delay <= 0) {
-                return -1;
-            }
-            if (delay < enums_1.HMSH_FIDELITY_SECONDS) {
-                return enums_1.HMSH_FIDELITY_SECONDS;
-            }
-            const iDelay = Math.round(delay);
-            return iDelay;
+        if (!(0, utils_1.isValidCron)(cronExpression)) {
+            throw new Error(`Invalid cron expression: ${cronExpression}`);
         }
-        catch (error) {
-            CronHandler.logger.error('Error calculating next cron job execution  delay:', { error });
-            return -1;
+        const interval = (0, cron_parser_1.parseExpression)(cronExpression, { utc: true });
+        const nextDate = interval.next().toDate();
+        const now = new Date();
+        const delay = (nextDate.getTime() - now.getTime()) / 1000;
+        if (delay <= 0) {
+            return enums_1.HMSH_FIDELITY_SECONDS;
         }
+        return Math.max(Math.round(delay), enums_1.HMSH_FIDELITY_SECONDS);
     }
 }
 exports.CronHandler = CronHandler;
-CronHandler.logger = new logger_1.LoggerService('hotmesh', 'cron');

package/build/services/router/consumption/index.js

@@ -585,14 +585,23 @@ class ConsumptionManager {
                 // Extract retry policy with priority:
                 // 1. Use message-level _streamRetryConfig (from database columns or previous retry)
                 // 2. Fall back to router-level retry (from worker config)
-                const retry = input._streamRetryConfig
+                const streamRetryConfig = input._streamRetryConfig;
+                const retry = streamRetryConfig
                     ? {
-                        maximumAttempts: input._streamRetryConfig.max_retry_attempts,
-                        backoffCoefficient: input._streamRetryConfig.backoff_coefficient,
-                        maximumInterval: input._streamRetryConfig.maximum_interval_seconds,
+                        maximumAttempts: streamRetryConfig.max_retry_attempts,
+                        backoffCoefficient: streamRetryConfig.backoff_coefficient,
+                        maximumInterval: streamRetryConfig.maximum_interval_seconds,
+                        initialInterval: streamRetryConfig.initialInterval ?? input.data?.initialInterval ?? 1,
                     }
                     : this.retry;
-                return await this.errorHandler.handleRetry(input, output, this.publishMessage.bind(this), retry);
+                return await this.errorHandler.handleRetry(input, output, this.publishMessage.bind(this), retry, (topic, delayMs) => {
+                    // Schedule a targeted NOTIFY so the consumer wakes up
+                    // when the visibility-delayed retry message becomes visible
+                    if (typeof this.stream.scheduleStreamNotify === 'function') {
+                        const streamKey = this.stream.mintKey(key_1.KeyType.STREAMS, { topic });
+                        this.stream.scheduleStreamNotify(streamKey, delayMs);
+                    }
+                });
             }
             else if (typeof output.metadata !== 'object') {
                 output.metadata = { ...input.metadata, guid: (0, utils_1.guid)() };

package/build/services/router/error-handling/index.d.ts

@@ -4,5 +4,5 @@ export declare class ErrorHandler {
     structureUnhandledError(input: StreamData, err: Error): StreamDataResponse;
     structureUnacknowledgedError(input: StreamData): StreamDataResponse;
     structureError(input: StreamData, output: StreamDataResponse): StreamDataResponse;
-    handleRetry(input: StreamData, output: StreamDataResponse, publishMessage: (topic: string, streamData: StreamData | StreamDataResponse) => Promise<string>, retry?: RetryPolicy): Promise<string>;
+    handleRetry(input: StreamData, output: StreamDataResponse, publishMessage: (topic: string, streamData: StreamData | StreamDataResponse) => Promise<string>, retry?: RetryPolicy, onRetryScheduled?: (topic: string, delayMs: number) => void): Promise<string>;
 }

package/build/services/router/error-handling/index.js

@@ -14,16 +14,11 @@ class ErrorHandler {
             const maxInterval = typeof retry.maximumInterval === 'string'
                 ? parseInt(retry.maximumInterval)
                 : (retry.maximumInterval || 120);
-            // Check if we can retry (next attempt would be attempt #tryCount+2, must be <= maxAttempts)
-            // tryCount=0 is 1st attempt, tryCount=1 is 2nd attempt, etc.
-            // So after tryCount, we've made (tryCount + 1) attempts
-            // We can retry if (tryCount + 1) < maxAttempts
+            const initialIntervalS = retry.initialInterval || 1;
             if ((tryCount + 1) < maxAttempts) {
-                // Exponential backoff: min(coefficient^(try+1), maxInterval)
-                // First retry (after try=0): coefficient^1
-                // Second retry (after try=1): coefficient^2, etc.
-                const backoffSeconds = Math.min(Math.pow(backoffCoeff, tryCount + 1), maxInterval);
-                return [true, backoffSeconds * 1000]; // Convert to milliseconds
+                // Exponential backoff: min(initialInterval * coefficient^(try+1), maxInterval)
+                const backoffSeconds = Math.min(initialIntervalS * Math.pow(backoffCoeff, tryCount + 1), maxInterval);
+                return [true, backoffSeconds * 1000];
             }
             return [false, 0];
         }
@@ -101,7 +96,7 @@ class ErrorHandler {
             data,
         };
     }
-    async handleRetry(input, output, publishMessage, retry) {
+    async handleRetry(input, output, publishMessage, retry, onRetryScheduled) {
         const [shouldRetry, timeout] = this.shouldRetry(input, output, retry);
         if (shouldRetry) {
             // Only sleep if no retry (legacy behavior for backward compatibility)
@@ -126,7 +121,13 @@ class ErrorHandler {
             // Track retry attempt count in database
             const currentAttempt = input._retryAttempt || 0;
             newMessage._retryAttempt = currentAttempt + 1;
-            return (await publishMessage(input.metadata.topic, newMessage));
+            const messageId = (await publishMessage(input.metadata.topic, newMessage));
+            // Schedule a targeted NOTIFY so the consumer wakes up when
+            // the visibility-delayed message becomes visible
+            if (retry && timeout > 0 && onRetryScheduled) {
+                onRetryScheduled(input.metadata.topic, timeout);
+            }
+            return messageId;
         }
         else {
             const structuredError = this.structureError(input, output);

package/build/services/store/providers/postgres/exporter-sql.d.ts

@@ -15,6 +15,10 @@ export declare const GET_JOB_ATTRIBUTES = "\n  SELECT symbol || dimension AS fie
  * Matches all activity jobs for the given workflow and extracts their input arguments.
  */
 export declare const GET_ACTIVITY_INPUTS = "\n  SELECT j.key, ja.value\n  FROM {schema}.jobs j\n  JOIN {schema}.jobs_attributes ja ON ja.job_id = j.id\n  WHERE j.key LIKE $1\n    AND ja.symbol = $2 AND ja.dimension = $3\n";
+/**
+ * Fetch activity inputs from worker_streams for direct worker proxyer activities.
+ */
+export declare const GET_PROXYER_STREAM_INPUTS = "\n  SELECT message\n  FROM {schema}.worker_streams\n  WHERE jid = $1\n    AND aid IN ('proxyer', 'collator_proxyer', 'signaler_proxyer')\n  ORDER BY created_at, id\n";
 /**
  * Fetch all worker stream messages for a job AND its child activities.
  * Child activity jobs use the pattern: -{parentJobId}-$activityName-N

package/build/services/store/providers/postgres/exporter-sql.js

@@ -4,7 +4,7 @@
  * These queries support the exporter's input enrichment and direct query features.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildChildWorkflowInputsQuery = exports.GET_STREAM_HISTORY_BY_JID_AND_AID = exports.GET_STREAM_HISTORY_BY_JID_AND_TYPE = exports.GET_STREAM_HISTORY_BY_JID = exports.GET_ACTIVITY_INPUTS = exports.GET_JOB_ATTRIBUTES = exports.GET_JOB_BY_KEY = void 0;
+exports.buildChildWorkflowInputsQuery = exports.GET_STREAM_HISTORY_BY_JID_AND_AID = exports.GET_STREAM_HISTORY_BY_JID_AND_TYPE = exports.GET_STREAM_HISTORY_BY_JID = exports.GET_PROXYER_STREAM_INPUTS = exports.GET_ACTIVITY_INPUTS = exports.GET_JOB_ATTRIBUTES = exports.GET_JOB_BY_KEY = void 0;
 /**
  * Fetch job record by key.
  */
@@ -34,6 +34,16 @@ exports.GET_ACTIVITY_INPUTS = `
   WHERE j.key LIKE $1
     AND ja.symbol = $2 AND ja.dimension = $3
 `;
+/**
+ * Fetch activity inputs from worker_streams for direct worker proxyer activities.
+ */
+exports.GET_PROXYER_STREAM_INPUTS = `
+  SELECT message
+  FROM {schema}.worker_streams
+  WHERE jid = $1
+    AND aid IN ('proxyer', 'collator_proxyer', 'signaler_proxyer')
+  ORDER BY created_at, id
+`;
 /**
  * Fetch all worker stream messages for a job AND its child activities.
  * Child activity jobs use the pattern: -{parentJobId}-$activityName-N

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

@@ -1442,6 +1442,30 @@ class PostgresStoreService extends __1.StoreService {
                 // Skip unparseable values
             }
         }
+        // If no results from legacy approach, try direct worker approach:
+        // extract arguments from proxyer messages in worker_streams
+        if (byNameIndex.size === 0) {
+            const { GET_PROXYER_STREAM_INPUTS } = await Promise.resolve().then(() => __importStar(require('./exporter-sql')));
+            const streamSql = GET_PROXYER_STREAM_INPUTS.replace(/{schema}/g, schemaName);
+            const streamResult = await this.pgClient.query(streamSql, [workflowId]);
+            for (const row of streamResult.rows) {
+                try {
+                    const msg = typeof row.message === 'string' ? JSON.parse(row.message) : row.message;
+                    const data = msg?.data;
+                    if (data?.activityName && data?.arguments) {
+                        const activityName = data.activityName;
+                        const wfId = data.workflowId || '';
+                        const idxMatch = wfId.match(/-(\d+)$/);
+                        const execIndex = idxMatch ? idxMatch[1] : '0';
+                        byNameIndex.set(`${activityName}:${execIndex}`, data.arguments);
+                        byJobId.set(wfId, data.arguments);
+                    }
+                }
+                catch {
+                    // Skip unparseable messages
+                }
+            }
+        }
         return { byJobId, byNameIndex };
     }
     /**

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

@@ -58,6 +58,12 @@ declare class PostgresStreamService extends StreamService<PostgresClientType & P
      * added to the transaction for atomic execution.
      */
     publishMessages(streamName: string, messages: string[], options?: PublishMessageConfig): Promise<string[] | ProviderTransaction>;
+    /**
+     * Schedule a NOTIFY for a worker stream after a delay. Used to wake up
+     * consumers when a visibility-delayed retry message becomes visible,
+     * avoiding the need to wait for the scout's fallback poll.
+     */
+    scheduleStreamNotify(streamName: string, delayMs: number): void;
     _publishMessages(streamName: string, messages: string[], options?: PublishMessageConfig): {
         sql: string;
         params: any[];

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

@@ -174,6 +174,31 @@ class PostgresStreamService extends index_1.StreamService {
         const target = this.resolveStreamTarget(streamName);
         return Messages.publishMessages(this.streamClient, target.tableName, target.streamName, target.isEngine, messages, options, this.logger);
     }
+    /**
+     * Schedule a NOTIFY for a worker stream after a delay. Used to wake up
+     * consumers when a visibility-delayed retry message becomes visible,
+     * avoiding the need to wait for the scout's fallback poll.
+     */
+    scheduleStreamNotify(streamName, delayMs) {
+        const target = this.resolveStreamTarget(streamName);
+        const prefix = target.isEngine ? 'eng_' : 'wrk_';
+        let channelName = `${prefix}${target.streamName}`;
+        if (channelName.length > 63) {
+            channelName = channelName.substring(0, 63);
+        }
+        const payload = JSON.stringify({
+            stream_name: target.streamName,
+            table_type: target.isEngine ? 'engine' : 'worker',
+        });
+        setTimeout(async () => {
+            try {
+                await this.streamClient.query(`SELECT pg_notify($1, $2)`, [channelName, payload]);
+            }
+            catch {
+                // Best-effort; the scout fallback will pick it up
+            }
+        }, delayMs);
+    }
     _publishMessages(streamName, messages, options) {
         const target = this.resolveStreamTarget(streamName);
         return Messages.buildPublishSQL(target.tableName, target.streamName, target.isEngine, messages, options);

package/build/services/virtual/index.js

@@ -320,11 +320,13 @@ class Virtual {
         if ((0, utils_1.isValidCron)(params.options.interval)) {
             //cron syntax
             cron = params.options.interval;
-            const nextDelay = new cron_1.CronHandler().nextDelay(cron);
-            delay = nextDelay > 0 ? nextDelay : undefined;
+            delay = new cron_1.CronHandler().nextDelay(cron);
         }
         else {
             const seconds = (0, utils_1.s)(params.options.interval);
+            if (isNaN(seconds)) {
+                throw new Error(`Invalid cron/interval expression: ${params.options.interval}`);
+            }
             interval = Math.max(seconds, enums_1.HMSH_FIDELITY_SECONDS);
             delay = params.options.delay ? (0, utils_1.s)(params.options.delay) : undefined;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hotmeshio/hotmesh",
-  "version": "0.14.7",
+  "version": "0.14.9",
   "description": "Durable Workflow",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",