@hotmeshio/hotmesh 0.0.53 → 0.0.54

package/build/modules/errors.d.ts

@@ -1,5 +1,6 @@
 import { ActivityDuplex } from "../types/activity";
 import { CollationFaultType, CollationStage } from "../types/collator";
+import { DurableChildErrorType, DurableProxyErrorType, DurableSleepErrorType, DurableWaitForAllErrorType, DurableWaitForErrorType } from "../types/error";
 declare class GetStateError extends Error {
     jobId: string;
     code: number;
@@ -14,12 +15,7 @@ declare class DurableWaitForError extends Error {
     workflowId: string;
     index: number;
     workflowDimension: string;
-    constructor(params: {
-        signalId: string;
-        index: number;
-        workflowDimension: string;
-        workflowId: string;
-    });
+    constructor(params: DurableWaitForErrorType);
 }
 declare class DurableProxyError extends Error {
     activityName: string;
@@ -34,19 +30,7 @@ declare class DurableProxyError extends Error {
     workflowDimension: string;
     workflowId: string;
     workflowTopic: string;
-    constructor(params: {
-        arguments: string[];
-        activityName: string;
-        backoffCoefficient?: number;
-        index: number;
-        maximumAttempts?: number;
-        maximumInterval?: number;
-        originJobId: string | null;
-        parentWorkflowId: string;
-        workflowDimension: string;
-        workflowId: string;
-        workflowTopic: string;
-    });
+    constructor(params: DurableProxyErrorType);
 }
 declare class DurableChildError extends Error {
     await: boolean;
@@ -61,19 +45,7 @@ declare class DurableChildError extends Error {
     parentWorkflowId: string;
     workflowId: string;
     workflowTopic: string;
-    constructor(params: {
-        arguments: string[];
-        await?: boolean;
-        backoffCoefficient?: number;
-        index: number;
-        maximumAttempts?: number;
-        maximumInterval?: number;
-        originJobId: string | null;
-        parentWorkflowId: string;
-        workflowDimension: string;
-        workflowId: string;
-        workflowTopic: string;
-    });
+    constructor(params: DurableChildErrorType);
 }
 declare class DurableWaitForAllError extends Error {
     items: any[];
@@ -85,16 +57,7 @@ declare class DurableWaitForAllError extends Error {
     parentWorkflowId: string;
     workflowId: string;
     workflowTopic: string;
-    constructor(params: {
-        items: string[];
-        workflowId: string;
-        workflowTopic: string;
-        parentWorkflowId: string;
-        originJobId: string | null;
-        size: number;
-        index: number;
-        workflowDimension: string;
-    });
+    constructor(params: DurableWaitForAllErrorType);
 }
 declare class DurableSleepError extends Error {
     workflowId: string;
@@ -102,12 +65,7 @@ declare class DurableSleepError extends Error {
     duration: number;
     index: number;
     workflowDimension: string;
-    constructor(params: {
-        duration: number;
-        index: number;
-        workflowDimension: string;
-        workflowId: string;
-    });
+    constructor(params: DurableSleepErrorType);
 }
 declare class DurableTimeoutError extends Error {
     code: number;

package/build/modules/errors.js

@@ -18,7 +18,7 @@ class SetStateError extends Error {
 exports.SetStateError = SetStateError;
 class DurableWaitForError extends Error {
     constructor(params) {
-        super(`Durable WaitFor Error [${params.workflowId}]`);
+        super(`WaitFor Interruption`);
         this.signalId = params.signalId;
         this.index = params.index;
         this.workflowDimension = params.workflowDimension;
@@ -28,7 +28,7 @@ class DurableWaitForError extends Error {
 exports.DurableWaitForError = DurableWaitForError;
 class DurableProxyError extends Error {
     constructor(params) {
-        super(`Durable Proxy Activity Error [${params.parentWorkflowId}] => [${params.workflowId}]`);
+        super(`ProxyActivity Interruption`);
         this.arguments = params.arguments;
         this.workflowId = params.workflowId;
         this.workflowTopic = params.workflowTopic;
@@ -46,7 +46,7 @@ class DurableProxyError extends Error {
 exports.DurableProxyError = DurableProxyError;
 class DurableChildError extends Error {
     constructor(params) {
-        super(`Durable Child Error [${params.parentWorkflowId}] => [${params.workflowId}]`);
+        super(`ExecChild Interruption`);
         this.arguments = params.arguments;
         this.workflowId = params.workflowId;
         this.workflowTopic = params.workflowTopic;
@@ -64,7 +64,7 @@ class DurableChildError extends Error {
 exports.DurableChildError = DurableChildError;
 class DurableWaitForAllError extends Error {
     constructor(params) {
-        super(`Durable Wait for All Error [${params.parentWorkflowId}] => [${params.workflowId}]`);
+        super(`Collation Interruption`);
         this.items = params.items;
         this.size = params.size;
         this.workflowId = params.workflowId;
@@ -79,7 +79,7 @@ class DurableWaitForAllError extends Error {
 exports.DurableWaitForAllError = DurableWaitForAllError;
 class DurableSleepError extends Error {
     constructor(params) {
-        super(`Durable Sleep Error [${params.workflowId}]`);
+        super(`SleepFor Interruption`);
         this.duration = params.duration;
         this.workflowId = params.workflowId;
         this.index = params.index;

package/build/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hotmeshio/hotmesh",
-    "version": "0.0.53",
+    "version": "0.0.54",
     "description": "Unbreakable Workflows",
     "main": "./build/index.js",
     "types": "./build/index.d.ts",

package/build/services/activities/hook.js

@@ -65,7 +65,11 @@ class Hook extends activity_1.Activity {
      * does this activity use a time-hook or web-hook
      */
     doesHook() {
-        return !!(this.config.hook?.topic || this.config.sleep);
+        if (this.config.sleep) {
+            const duration = pipe_1.Pipe.resolve(this.config.sleep, this.context);
+            return !isNaN(duration) && Number(duration) > 0;
+        }
+        return !!this.config.hook?.topic;
     }
     async doHook(telemetry) {
         const multi = this.store.getMulti();

package/build/services/activities/trigger.d.ts

@@ -1,12 +1,15 @@
 import { Activity } from './activity';
 import { EngineService } from '../engine';
 import { ActivityData, ActivityMetadata, ActivityType, TriggerActivity } from '../../types/activity';
-import { JobState } from '../../types/job';
+import { JobState, ExtensionType } from '../../types/job';
 import { RedisMulti } from '../../types/redis';
 declare class Trigger extends Activity {
     config: TriggerActivity;
     constructor(config: ActivityType, data: ActivityData, metadata: ActivityMetadata, hook: ActivityData | null, engine: EngineService, context?: JobState);
-    process(): Promise<string>;
+    process(options?: ExtensionType): Promise<string>;
+    safeKey(key: string): string;
+    bindSearchData(options?: ExtensionType): void;
+    bindMarkerData(options?: ExtensionType): void;
     setStatus(amount: number): Promise<void>;
     execAdjacentParent(): Promise<void>;
     createInputContext(): Partial<JobState>;

package/build/services/activities/trigger.js

@@ -13,7 +13,7 @@ class Trigger extends activity_1.Activity {
     constructor(config, data, metadata, hook, engine, context) {
         super(config, data, metadata, hook, engine, context);
     }
-    async process() {
+    async process(options) {
         this.logger.debug('trigger-process', { subscribes: this.config.subscribes });
         let telemetry;
         try {
@@ -26,6 +26,8 @@ class Trigger extends activity_1.Activity {
             await this.setStateNX();
             this.adjacencyList = await this.filterAdjacent();
             await this.setStatus(this.adjacencyList.length);
+            this.bindSearchData(options);
+            this.bindMarkerData(options);
             const multi = this.store.getMulti();
             await this.setState(multi);
             await this.setStats(multi);
@@ -61,6 +63,25 @@ class Trigger extends activity_1.Activity {
             this.logger.debug('trigger-process-end', { subscribes: this.config.subscribes, jid: this.context.metadata.jid, gid: this.context.metadata.gid });
         }
     }
+    safeKey(key) {
+        return `_${key}`;
+    }
+    bindSearchData(options) {
+        if (options?.search) {
+            Object.keys(options.search).forEach((key) => {
+                this.context.data[this.safeKey(key)] = options.search[key].toString();
+            });
+        }
+    }
+    bindMarkerData(options) {
+        if (options?.marker) {
+            Object.keys(options.marker).forEach((key) => {
+                if (key.startsWith('-')) {
+                    this.context.data[key] = options.marker[key].toString();
+                }
+            });
+        }
+    }
     async setStatus(amount) {
         this.context.metadata.js = amount;
     }

package/build/services/durable/client.js

@@ -103,14 +103,7 @@ class ClientService {
                     maximumInterval: (0, ms_1.default)(options.config?.maximumInterval || enums_1.HMSH_DURABLE_MAX_INTERVAL) / 1000,
                 };
                 const context = { metadata: { trc, spn }, data: {} };
-                const jobId = await hotMeshClient.pub(`${options.namespace ?? factory_1.APP_ID}.execute`, payload, context);
-                // Seed search data
-                if (jobId && options.search?.data) {
-                    const searchSessionId = `-search-0`;
-                    const search = new search_1.Search(jobId, hotMeshClient, searchSessionId);
-                    const entries = Object.entries(options.search.data).flat();
-                    await search.set(...entries);
-                }
+                const jobId = await hotMeshClient.pub(`${options.namespace ?? factory_1.APP_ID}.execute`, payload, context, { search: options?.search?.data, marker: options?.marker });
                 return new handle_1.WorkflowHandleService(hotMeshClient, workflowTopic, jobId);
             },
             /**

package/build/services/durable/exporter.d.ts

@@ -1,6 +1,6 @@
 import { ILogger } from '../logger';
 import { StoreService } from '../store';
-import { ExportOptions, DurableJobExport } from '../../types/exporter';
+import { ExportOptions, DurableJobExport, TimelineType, TransitionType, ExportFields } from '../../types/exporter';
 import { RedisClient, RedisMulti } from '../../types/redis';
 import { StringStringType, Symbols } from "../../types/serializer";
 declare class ExporterService {
@@ -8,33 +8,44 @@ declare class ExporterService {
     logger: ILogger;
     store: StoreService<RedisClient, RedisMulti>;
     symbols: Promise<Symbols> | Symbols;
+    private static symbols;
     constructor(appId: string, store: StoreService<RedisClient, RedisMulti>, logger: ILogger);
     /**
      * Convert the job hash from its compiles format into a DurableJobExport object with
      * facets that describe the workflow in terms relevant to narrative storytelling.
      */
     export(jobId: string, options?: ExportOptions): Promise<DurableJobExport>;
+    /**
+     * Inflates the job data from Redis into a DurableJobExport object
+     * @param jobHash - the job data from Redis
+     * @param dependencyList - the list of dependencies for the job
+     * @returns - the inflated job data
+     */
+    inflate(jobHash: StringStringType, options: ExportOptions): DurableJobExport;
+    resolveValue(raw: string, withValues: boolean): Record<string, any> | string | number | null;
     /**
      * Inflates the key from Redis, 3-character symbol
      * into a human-readable JSON path, reflecting the
      * tree-like structure of the unidimensional Hash
+     * @private
      */
     inflateKey(key: string): string;
+    filterFields(fullObject: DurableJobExport, block?: ExportFields[], allow?: ExportFields[]): Partial<DurableJobExport>;
+    inflateTransition(match: RegExpMatchArray, value: string, transitionsObject: Record<string, TransitionType>): void;
+    sortEntriesByCreated(obj: {
+        [key: string]: TransitionType;
+    }): TransitionType[];
     /**
-     * Inflates the dependency data from Redis into a DurableJobExport object by
-     * organizing the dimensional isolate in sch a way asto interleave
-     * into a story
-     * @param data - the dependency data from Redis
-     * @returns - the organized dependency data
+     * marker names are overloaded with details like sequence, type, etc
      */
-    inflateDependencyData(data: string[]): Record<string, any>[];
+    keyToObject(key: string): {
+        index: number;
+        dimension?: string;
+        secondary?: number;
+    };
     /**
-     * Inflates the job data from Redis into a DurableJobExport object
-     * @param jobHash - the job data from Redis
-     * @param dependencyList - the list of dependencies for the job
-     * @returns - the inflated job data
+     * idem list has a complicated sort order based on indexes and dimensions
      */
-    inflate(jobHash: StringStringType): DurableJobExport;
-    inflateProcess(match: RegExpMatchArray, value: string, replay: Record<string, Record<string, any>>): void;
+    sortParts(parts: TimelineType[]): TimelineType[];
 }
 export { ExporterService };

package/build/services/durable/exporter.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExporterService = void 0;
-const key_1 = require("../../modules/key");
 const utils_1 = require("../../modules/utils");
 const serializer_1 = require("../serializer");
 class ExporterService {
@@ -15,174 +14,122 @@ class ExporterService {
      * facets that describe the workflow in terms relevant to narrative storytelling.
      */
     async export(jobId, options = {}) {
-        if (!this.symbols) {
-            this.symbols = this.store.getAllSymbols();
-            this.symbols = await this.symbols;
+        if (!ExporterService.symbols.has(this.appId)) {
+            const symbols = this.store.getAllSymbols();
+            ExporterService.symbols.set(this.appId, await symbols);
         }
         const jobData = await this.store.getRaw(jobId);
-        const jobExport = this.inflate(jobData /*, depData*/);
+        const jobExport = this.inflate(jobData, options);
         return jobExport;
     }
-    /**
-     * Inflates the key from Redis, 3-character symbol
-     * into a human-readable JSON path, reflecting the
-     * tree-like structure of the unidimensional Hash
-     */
-    inflateKey(key) {
-        if (key in this.symbols) {
-            const path = this.symbols[key];
-            const parts = path.split('/');
-            return parts.join('/');
-        }
-        return key;
-    }
-    /**
-     * Inflates the dependency data from Redis into a DurableJobExport object by
-     * organizing the dimensional isolate in sch a way asto interleave
-     * into a story
-     * @param data - the dependency data from Redis
-     * @returns - the organized dependency data
-     */
-    inflateDependencyData(data) {
-        return data.map((dependency, index) => {
-            const [action, topic, gid, dimension, ...jid] = dependency.split(key_1.VALSEP);
-            const job_id = jid.join(key_1.VALSEP);
-            return {
-                index,
-                action,
-                topic,
-                gid,
-                dimension,
-                job_id,
-            };
-        });
-    }
     /**
      * Inflates the job data from Redis into a DurableJobExport object
      * @param jobHash - the job data from Redis
      * @param dependencyList - the list of dependencies for the job
      * @returns - the inflated job data
      */
-    inflate(jobHash) {
-        const idempotents = [];
+    inflate(jobHash, options) {
+        const timeline = [];
         const state = {};
         const data = {};
-        const other = [];
-        const replay = {};
+        const transitionsObject = {};
         const regex = /^([a-zA-Z]{3}),(\d+(?:,\d+)*)/;
         Object.entries(jobHash).forEach(([key, value]) => {
             const match = key.match(regex);
             if (match) {
-                //activity process state
-                this.inflateProcess(match, value, replay);
+                //transitions
+                this.inflateTransition(match, value, transitionsObject);
             }
             else if (key.length === 3) {
-                //job state
+                //state
                 state[this.inflateKey(key)] = serializer_1.SerializerService.fromString(value);
             }
             else if (key.startsWith('_')) {
-                //job data
+                //data
                 data[key.substring(1)] = value;
             }
             else if (key.startsWith('-')) {
-                //actions with side effect (replayable)
-                idempotents.push({
+                //timeline
+                const keyParts = this.keyToObject(key); //key parts have meaning
+                timeline.push({
+                    ...keyParts,
                     key,
-                    value: serializer_1.SerializerService.fromString(value),
-                    parts: extractParts(key),
+                    value: this.resolveValue(value, options.values),
                 });
             }
-            else {
-                //collator guids, etc
-                other.push([null, key, value]);
-            }
         });
-        const sortEntriesByCreated = (obj) => {
-            const entriesArray = Object.values(obj);
-            entriesArray.sort((a, b) => {
-                return (a.created || a.updated).localeCompare(b.created || b.updated);
-            });
-            return entriesArray;
-        };
-        /**
-         * idem list has a complicated sort order based on indexes and dimensions
-         */
-        const sortParts = (parts) => {
-            return parts.sort((a, b) => {
-                const { dimension: aDim, index: aIdx, secondary: aSec } = a.parts;
-                const { dimension: bDim, index: bIdx, secondary: bSec } = b.parts;
-                if (aDim === undefined && bDim !== undefined)
-                    return -1;
-                if (aDim !== undefined && bDim === undefined)
-                    return 1;
-                if (aDim !== undefined && bDim !== undefined) {
-                    if (aDim < bDim)
-                        return -1;
-                    if (aDim > bDim)
-                        return 1;
-                }
-                if (aIdx < bIdx)
-                    return -1;
-                if (aIdx > bIdx)
-                    return 1;
-                if (aSec === undefined && bSec !== undefined)
-                    return -1;
-                if (aSec !== undefined && bSec === undefined)
-                    return 1;
-                if (aSec !== undefined && bSec !== undefined) {
-                    if (aSec < bSec)
-                        return -1;
-                    if (aSec > bSec)
-                        return 1;
+        return this.filterFields({
+            data: (0, utils_1.restoreHierarchy)(data),
+            state: Object.entries((0, utils_1.restoreHierarchy)(state))[0][1],
+            status: parseInt(jobHash[':'], 10),
+            timeline: this.sortParts(timeline),
+            transitions: this.sortEntriesByCreated(transitionsObject),
+        }, options.block, options.allow);
+    }
+    resolveValue(raw, withValues) {
+        const resolved = serializer_1.SerializerService.fromString(raw);
+        if (withValues !== false) {
+            return resolved;
+        }
+        if (resolved && typeof resolved === 'object') {
+            if ('data' in resolved) {
+                resolved.data = {};
+            }
+            if ('$error' in resolved) {
+                resolved.$error = {};
+            }
+        }
+        return resolved;
+    }
+    /**
+     * Inflates the key from Redis, 3-character symbol
+     * into a human-readable JSON path, reflecting the
+     * tree-like structure of the unidimensional Hash
+     * @private
+     */
+    inflateKey(key) {
+        const symbols = ExporterService.symbols.get(this.appId);
+        if (key in symbols) {
+            const path = symbols[key];
+            const parts = path.split('/');
+            return parts.join('/');
+        }
+        return key;
+    }
+    filterFields(fullObject, block = [], allow = []) {
+        let result = {};
+        if (allow && allow.length > 0) {
+            allow.forEach(field => {
+                if (field in fullObject) {
+                    result[field] = fullObject[field];
                 }
-                return 0;
             });
-        };
-        function extractParts(key) {
-            function extractDimension(label) {
-                const parts = label.split(',');
-                if (parts.length > 1) {
-                    parts.shift();
-                    return parts.join(',');
+        }
+        else {
+            result = { ...fullObject };
+        }
+        if (block && block.length > 0) {
+            block.forEach(field => {
+                if (field in result) {
+                    delete result[field];
                 }
-            }
-            const parts = key.split('-');
-            if (parts.length === 4) {
-                //-proxy-5-     -search-1-1-
-                return {
-                    index: parseInt(parts[2], 10),
-                    dimension: extractDimension(parts[1]),
-                };
-            }
-            else {
-                //-search,0,0-1-1-    -proxy,0,0-1-
-                return {
-                    index: parseInt(parts[2], 10),
-                    secondary: parseInt(parts[3], 10),
-                    dimension: extractDimension(parts[1]),
-                };
-            }
+            });
         }
-        return {
-            data: (0, utils_1.restoreHierarchy)(data),
-            idempotents: sortParts(idempotents),
-            state: Object.entries((0, utils_1.restoreHierarchy)(state))[0][1],
-            status: jobHash[':'],
-            replay: sortEntriesByCreated(replay),
-        };
+        return result;
     }
-    inflateProcess(match, value, replay) {
+    inflateTransition(match, value, transitionsObject) {
         const [_, letters, dimensions] = match;
         const path = this.inflateKey(letters);
         const parts = path.split('/');
         const activity = parts[0];
         const isCreate = path.endsWith('/output/metadata/ac');
         const isUpdate = path.endsWith('/output/metadata/au');
+        //for now only export activity start/stop; activity data would also be interesting
         if (isCreate || isUpdate) {
             const targetName = `${activity},${dimensions}`;
-            let target = replay[targetName];
+            let target = transitionsObject[targetName];
             if (!target) {
-                replay[targetName] = {
+                transitionsObject[targetName] = {
                     activity,
                     dimensions,
                     created: isCreate ? value : null,
@@ -194,5 +141,76 @@ class ExporterService {
             }
         }
     }
+    sortEntriesByCreated(obj) {
+        const entriesArray = Object.values(obj);
+        entriesArray.sort((a, b) => {
+            return (a.created || a.updated).localeCompare(b.created || b.updated);
+        });
+        return entriesArray;
+    }
+    /**
+     * marker names are overloaded with details like sequence, type, etc
+     */
+    keyToObject(key) {
+        function extractDimension(label) {
+            const parts = label.split(',');
+            if (parts.length > 1) {
+                parts.shift();
+                return parts.join(',');
+            }
+        }
+        const parts = key.split('-');
+        if (parts.length === 4) {
+            //-proxy-5-     -search-1-1-
+            return {
+                index: parseInt(parts[2], 10),
+                dimension: extractDimension(parts[1]),
+            };
+        }
+        else {
+            //-search,0,0-1-1-    -proxy,0,0-1-
+            return {
+                index: parseInt(parts[2], 10),
+                secondary: parseInt(parts[3], 10),
+                dimension: extractDimension(parts[1]),
+            };
+        }
+    }
+    /**
+     * idem list has a complicated sort order based on indexes and dimensions
+     */
+    sortParts(parts) {
+        return parts.sort((a, b) => {
+            const { dimension: aDim, index: aIdx, secondary: aSec } = a;
+            const { dimension: bDim, index: bIdx, secondary: bSec } = b;
+            if (aDim === undefined && bDim !== undefined)
+                return -1;
+            if (aDim !== undefined && bDim === undefined)
+                return 1;
+            if (aDim !== undefined && bDim !== undefined) {
+                if (aDim < bDim)
+                    return -1;
+                if (aDim > bDim)
+                    return 1;
+            }
+            if (aIdx < bIdx)
+                return -1;
+            if (aIdx > bIdx)
+                return 1;
+            if (aSec === undefined && bSec !== undefined)
+                return -1;
+            if (aSec !== undefined && bSec === undefined)
+                return 1;
+            if (aSec !== undefined && bSec !== undefined) {
+                if (aSec < bSec)
+                    return -1;
+                if (aSec > bSec)
+                    return 1;
+            }
+            return 0;
+        });
+    }
+    ;
 }
 exports.ExporterService = ExporterService;
+ExporterService.symbols = new Map();

package/build/services/durable/handle.d.ts

@@ -1,6 +1,6 @@
 import { ExporterService } from './exporter';
 import { HotMeshService as HotMesh } from '../hotmesh';
-import { DurableJobExport } from '../../types/exporter';
+import { DurableJobExport, ExportOptions } from '../../types/exporter';
 import { JobInterruptOptions } from '../../types/job';
 import { StreamError } from '../../types/stream';
 export declare class WorkflowHandleService {
@@ -9,7 +9,7 @@ export declare class WorkflowHandleService {
     workflowTopic: string;
     workflowId: string;
     constructor(hotMesh: HotMesh, workflowTopic: string, workflowId: string);
-    export(): Promise<DurableJobExport>;
+    export(options?: ExportOptions): Promise<DurableJobExport>;
     /**
      * Sends a signal to the workflow. This is a way to send
      * a message to a workflow that is paused due to having

package/build/services/durable/handle.js

@@ -9,8 +9,8 @@ class WorkflowHandleService {
         this.hotMesh = hotMesh;
         this.exporter = new exporter_1.ExporterService(this.hotMesh.appId, this.hotMesh.engine.store, this.hotMesh.engine.logger);
     }
-    async export() {
-        return this.exporter.export(this.workflowId);
+    async export(options) {
+        return this.exporter.export(this.workflowId, options);
     }
     /**
      * Sends a signal to the workflow. This is a way to send