@hotmeshio/hotmesh 0.3.32 → 0.4.1

package/build/services/memflow/exporter.js

@@ -0,0 +1,215 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExporterService = void 0;
+const utils_1 = require("../../modules/utils");
+const serializer_1 = require("../serializer");
+class ExporterService {
+    constructor(appId, store, logger) {
+        this.appId = appId;
+        this.logger = logger;
+        this.store = store;
+    }
+    /**
+     * Convert the job hash from its compiles format into a MemFlowJobExport object with
+     * facets that describe the workflow in terms relevant to narrative storytelling.
+     */
+    async export(jobId, options = {}) {
+        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, options);
+        return jobExport;
+    }
+    /**
+     * Inflates the job data from Redis into a MemFlowJobExport object
+     * @param jobHash - the job data from Redis
+     * @param dependencyList - the list of dependencies for the job
+     * @returns - the inflated job data
+     */
+    inflate(jobHash, options) {
+        const timeline = [];
+        const state = {};
+        const data = {};
+        const transitionsObject = {};
+        const regex = /^([a-zA-Z]{3}),(\d+(?:,\d+)*)/;
+        Object.entries(jobHash).forEach(([key, value]) => {
+            const match = key.match(regex);
+            if (match) {
+                //transitions
+                this.inflateTransition(match, value, transitionsObject);
+            }
+            else if (key.startsWith('_')) {
+                //data
+                data[key.substring(1)] = value;
+            }
+            else if (key.startsWith('-')) {
+                //timeline
+                const keyParts = this.keyToObject(key);
+                timeline.push({
+                    ...keyParts,
+                    key,
+                    value: this.resolveValue(value, options.values),
+                });
+            }
+            else if (key.length === 3) {
+                //state
+                state[this.inflateKey(key)] = serializer_1.SerializerService.fromString(value);
+            }
+        });
+        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];
+                }
+            });
+        }
+        else {
+            result = { ...fullObject };
+        }
+        if (block && block.length > 0) {
+            block.forEach((field) => {
+                if (field in result) {
+                    delete result[field];
+                }
+            });
+        }
+        return result;
+    }
+    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}`;
+            const target = transitionsObject[targetName];
+            if (!target) {
+                transitionsObject[targetName] = {
+                    activity,
+                    dimensions,
+                    created: isCreate ? value : null,
+                    updated: isUpdate ? value : null,
+                };
+            }
+            else {
+                target[isCreate ? 'created' : 'updated'] = value;
+            }
+        }
+    }
+    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/{meshflow → memflow}/handle.d.ts

@@ -1,5 +1,5 @@
 import { HotMesh } from '../hotmesh';
-import { MeshFlowJobExport, ExportOptions } from '../../types/exporter';
+import { MemFlowJobExport, ExportOptions } from '../../types/exporter';
 import { JobInterruptOptions } from '../../types/job';
 import { StreamError } from '../../types/stream';
 import { ExporterService } from './exporter';
@@ -7,7 +7,7 @@ import { ExporterService } from './exporter';
  * The WorkflowHandleService provides methods to interact with a running
  * workflow. This includes exporting the workflow, sending signals, and
  * querying the state of the workflow. It is instanced/accessed via the
- * MeshFlow.Client class.
+ * MemFlow.Client class.
  *
  * @example
  * ```typescript
@@ -43,11 +43,11 @@ export declare class WorkflowHandleService {
     /**
      * Exports the workflow state to a JSON object.
      */
-    export(options?: ExportOptions): Promise<MeshFlowJobExport>;
+    export(options?: ExportOptions): Promise<MemFlowJobExport>;
     /**
      * Sends a signal to the workflow. This is a way to send
      * a message to a workflow that is paused due to having
-     * executed `MeshFlow.workflow.waitFor`. The workflow
+     * executed `MemFlow.workflow.waitFor`. The workflow
      * will awaken if no other signals are pending.
      */
     signal(signalId: string, data: Record<any, any>): Promise<void>;

package/build/services/{meshflow → memflow}/handle.js

@@ -6,7 +6,7 @@ const exporter_1 = require("./exporter");
  * The WorkflowHandleService provides methods to interact with a running
  * workflow. This includes exporting the workflow, sending signals, and
  * querying the state of the workflow. It is instanced/accessed via the
- * MeshFlow.Client class.
+ * MemFlow.Client class.
  *
  * @example
  * ```typescript
@@ -46,7 +46,7 @@ class WorkflowHandleService {
     /**
      * Sends a signal to the workflow. This is a way to send
      * a message to a workflow that is paused due to having
-     * executed `MeshFlow.workflow.waitFor`. The workflow
+     * executed `MemFlow.workflow.waitFor`. The workflow
      * will awaken if no other signals are pending.
      */
     async signal(signalId, data) {

package/build/services/{meshflow → memflow}/index.d.ts

@@ -1,12 +1,13 @@
-import { ContextType } from '../../types/meshflow';
+import { ContextType } from '../../types/memflow';
 import { ClientService } from './client';
 import { ConnectionService } from './connection';
 import { Search } from './search';
+import { Context } from './context';
 import { WorkerService } from './worker';
 import { WorkflowService } from './workflow';
 import { WorkflowHandleService } from './handle';
 /**
- * The MeshFlow service is a collection of services that
+ * The MemFlow service is a collection of services that
  * emulate Temporal's capabilities, but instead are
  * backed by Postgres or Redis/ValKey. The following lifecycle example
  * demonstrates how to start a new workflow, subscribe
@@ -14,7 +15,7 @@ import { WorkflowHandleService } from './handle';
  *
  * @example
  * ```typescript
- * import { Client, Worker, MeshFlow, HotMesh } from '@hotmeshio/hotmesh';
+ * import { Client, Worker, MemFlow, HotMesh } from '@hotmeshio/hotmesh';
  * import { Client as Postgres} from 'pg';
  * import * as workflows from './workflows';
  *
@@ -27,7 +28,7 @@ import { WorkflowHandleService } from './handle';
  *     }
  *   }
  *   taskQueue: 'default',
- *   namespace: 'meshflow',
+ *   namespace: 'memflow',
  *   workflow: workflows.example,
  *   options: {
  *     backoffCoefficient: 2,
@@ -52,7 +53,7 @@ import { WorkflowHandleService } from './handle';
  *   taskQueue: 'default',
  *   workflowName: 'example',
  *   workflowId: HotMesh.guid(),
- *   namespace: 'meshflow',
+ *   namespace: 'memflow',
  * });
  *
  * //4) subscribe to the eventual result
@@ -60,21 +61,21 @@ import { WorkflowHandleService } from './handle';
  * //logs '¡Hola, HotMesh!'
  *
  * //5) Shutdown (typically on sigint)
- * await MeshFlow.shutdown();
+ * await MemFlow.shutdown();
  * ```
  */
-declare class MeshFlowClass {
+declare class MemFlowClass {
     /**
      * @private
      */
     constructor();
     /**
-     * The MeshFlow `Client` service is functionally
+     * The MemFlow `Client` service is functionally
      * equivalent to the Temporal `Client` service.
      */
     static Client: typeof ClientService;
     /**
-     * The MeshFlow `Connection` service is functionally
+     * The MemFlow `Connection` service is functionally
      * equivalent to the Temporal `Connection` service.
      */
     static Connection: typeof ConnectionService;
@@ -82,20 +83,24 @@ declare class MeshFlowClass {
      * @private
      */
     static Search: typeof Search;
+    /**
+     * @private
+     */
+    static Context: typeof Context;
     /**
      * The Handle provides methods to interact with a running
      * workflow. This includes exporting the workflow, sending signals, and
      * querying the state of the workflow. An instance of the Handle service
-     * is typically accessed via the MeshFlow.Client class (workflow.getHandle).
+     * is typically accessed via the MemFlow.Client class (workflow.getHandle).
      */
     static Handle: typeof WorkflowHandleService;
     /**
-     * The MeshFlow `Worker` service is functionally
+     * The MemFlow `Worker` service is functionally
      * equivalent to the Temporal `Worker` service.
      */
     static Worker: typeof WorkerService;
     /**
-     * The MeshFlow `workflow` service is functionally
+     * The MemFlow `workflow` service is functionally
      * equivalent to the Temporal `Workflow` service
      * with additional methods for managing workflows,
      * including: `execChild`, `waitFor`, `sleep`, etc
@@ -107,5 +112,5 @@ declare class MeshFlowClass {
      */
     static shutdown(): Promise<void>;
 }
-export { MeshFlowClass as MeshFlow };
+export { MemFlowClass as MemFlow };
 export type { ContextType };

package/build/services/{meshflow → memflow}/index.js

@@ -1,15 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MeshFlow = void 0;
+exports.MemFlow = void 0;
 const hotmesh_1 = require("../hotmesh");
 const client_1 = require("./client");
 const connection_1 = require("./connection");
 const search_1 = require("./search");
+const context_1 = require("./context");
 const worker_1 = require("./worker");
 const workflow_1 = require("./workflow");
 const handle_1 = require("./handle");
 /**
- * The MeshFlow service is a collection of services that
+ * The MemFlow service is a collection of services that
  * emulate Temporal's capabilities, but instead are
  * backed by Postgres or Redis/ValKey. The following lifecycle example
  * demonstrates how to start a new workflow, subscribe
@@ -17,7 +18,7 @@ const handle_1 = require("./handle");
  *
  * @example
  * ```typescript
- * import { Client, Worker, MeshFlow, HotMesh } from '@hotmeshio/hotmesh';
+ * import { Client, Worker, MemFlow, HotMesh } from '@hotmeshio/hotmesh';
  * import { Client as Postgres} from 'pg';
  * import * as workflows from './workflows';
  *
@@ -30,7 +31,7 @@ const handle_1 = require("./handle");
  *     }
  *   }
  *   taskQueue: 'default',
- *   namespace: 'meshflow',
+ *   namespace: 'memflow',
  *   workflow: workflows.example,
  *   options: {
  *     backoffCoefficient: 2,
@@ -55,7 +56,7 @@ const handle_1 = require("./handle");
  *   taskQueue: 'default',
  *   workflowName: 'example',
  *   workflowId: HotMesh.guid(),
- *   namespace: 'meshflow',
+ *   namespace: 'memflow',
  * });
  *
  * //4) subscribe to the eventual result
@@ -63,10 +64,10 @@ const handle_1 = require("./handle");
  * //logs '¡Hola, HotMesh!'
  *
  * //5) Shutdown (typically on sigint)
- * await MeshFlow.shutdown();
+ * await MemFlow.shutdown();
  * ```
  */
-class MeshFlowClass {
+class MemFlowClass {
     /**
      * @private
      */
@@ -76,42 +77,46 @@ class MeshFlowClass {
      * Include in your signal handlers to ensure a clean shutdown.
      */
     static async shutdown() {
-        await MeshFlowClass.Client.shutdown();
-        await MeshFlowClass.Worker.shutdown();
+        await MemFlowClass.Client.shutdown();
+        await MemFlowClass.Worker.shutdown();
         await hotmesh_1.HotMesh.stop();
     }
 }
-exports.MeshFlow = MeshFlowClass;
+exports.MemFlow = MemFlowClass;
 /**
- * The MeshFlow `Client` service is functionally
+ * The MemFlow `Client` service is functionally
  * equivalent to the Temporal `Client` service.
  */
-MeshFlowClass.Client = client_1.ClientService;
+MemFlowClass.Client = client_1.ClientService;
 /**
- * The MeshFlow `Connection` service is functionally
+ * The MemFlow `Connection` service is functionally
  * equivalent to the Temporal `Connection` service.
  */
-MeshFlowClass.Connection = connection_1.ConnectionService;
+MemFlowClass.Connection = connection_1.ConnectionService;
 /**
  * @private
  */
-MeshFlowClass.Search = search_1.Search;
+MemFlowClass.Search = search_1.Search;
+/**
+ * @private
+ */
+MemFlowClass.Context = context_1.Context;
 /**
  * The Handle provides methods to interact with a running
  * workflow. This includes exporting the workflow, sending signals, and
  * querying the state of the workflow. An instance of the Handle service
- * is typically accessed via the MeshFlow.Client class (workflow.getHandle).
+ * is typically accessed via the MemFlow.Client class (workflow.getHandle).
  */
-MeshFlowClass.Handle = handle_1.WorkflowHandleService;
+MemFlowClass.Handle = handle_1.WorkflowHandleService;
 /**
- * The MeshFlow `Worker` service is functionally
+ * The MemFlow `Worker` service is functionally
  * equivalent to the Temporal `Worker` service.
  */
-MeshFlowClass.Worker = worker_1.WorkerService;
+MemFlowClass.Worker = worker_1.WorkerService;
 /**
- * The MeshFlow `workflow` service is functionally
+ * The MemFlow `workflow` service is functionally
  * equivalent to the Temporal `Workflow` service
  * with additional methods for managing workflows,
  * including: `execChild`, `waitFor`, `sleep`, etc
  */
-MeshFlowClass.workflow = workflow_1.WorkflowService;
+MemFlowClass.workflow = workflow_1.WorkflowService;

package/build/services/{meshflow → memflow}/schemas/factory.d.ts

@@ -1,5 +1,5 @@
 /**
- *********** HOTMESH 'MESHFLOW' MODULE APPLICATION GRAPH **********
+ *********** HOTMESH 'MEMFLOW' MODULE APPLICATION GRAPH **********
  *
  * This HotMesh application spec uses 50 activities and 25 transitions
  * to model and emulate the Temporal Application & Query servers using
@@ -18,10 +18,10 @@
  * * Master Data Management systems
  */
 declare const APP_VERSION = "4";
-declare const APP_ID = "meshflow";
+declare const APP_ID = "memflow";
 /**
- * returns a new meshflow workflow schema
- * @param {string} app - app name (e.g., 'meshflow')
+ * returns a new memflow workflow schema
+ * @param {string} app - app name (e.g., 'memflow')
  * @param {string} version - number as string (e.g., '1')
  * @returns {string} HotMesh App YAML
  */

package/build/services/{meshflow → memflow}/schemas/factory.js

@@ -1,6 +1,6 @@
 "use strict";
 /**
- *********** HOTMESH 'MESHFLOW' MODULE APPLICATION GRAPH **********
+ *********** HOTMESH 'MEMFLOW' MODULE APPLICATION GRAPH **********
  *
  * This HotMesh application spec uses 50 activities and 25 transitions
  * to model and emulate the Temporal Application & Query servers using
@@ -22,11 +22,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.APP_ID = exports.APP_VERSION = exports.getWorkflowYAML = void 0;
 const APP_VERSION = '4';
 exports.APP_VERSION = APP_VERSION;
-const APP_ID = 'meshflow';
+const APP_ID = 'memflow';
 exports.APP_ID = APP_ID;
 /**
- * returns a new meshflow workflow schema
- * @param {string} app - app name (e.g., 'meshflow')
+ * returns a new memflow workflow schema
+ * @param {string} app - app name (e.g., 'memflow')
  * @param {string} version - number as string (e.g., '1')
  * @returns {string} HotMesh App YAML
  */
@@ -37,7 +37,7 @@ const getWorkflowYAML = (app, version) => {
   graphs:
 
     ###################################################
-    #         THE MESHFLOW-REENTRANT-WORKFLOW         #
+    #         THE MEMFLOW-REENTRANT-WORKFLOW         #
     #                                                 #
     - subscribes: ${app}.execute
       publishes: ${app}.executed

package/build/services/{meshflow → memflow}/search.d.ts

@@ -1,6 +1,6 @@
 import { HotMesh } from '../hotmesh';
 import { SearchService } from '../search';
-import { WorkflowSearchOptions } from '../../types/meshflow';
+import { WorkflowSearchOptions } from '../../types/memflow';
 /**
  * The Search module provides methods for reading and
  * writing record data to a workflow. The instance

package/build/services/{meshflow → memflow}/search.js

@@ -105,7 +105,7 @@ class Search {
                 await searchService.createSearchIndex(`${search.index}`, prefixes, schema);
             }
             catch (error) {
-                hotMeshClient.engine.logger.info('meshflow-client-search-err', {
+                hotMeshClient.engine.logger.info('memflow-client-search-err', {
                     error,
                 });
             }
@@ -123,7 +123,7 @@ class Search {
             return await searchService.listSearchIndexes();
         }
         catch (error) {
-            hotMeshClient.engine.logger.info('meshflow-client-search-list-err', {
+            hotMeshClient.engine.logger.info('memflow-client-search-list-err', {
                 error,
             });
             return [];
@@ -192,7 +192,7 @@ class Search {
             return value;
         }
         catch (error) {
-            this.hotMeshClient.logger.error('meshflow-search-get-error', {
+            this.hotMeshClient.logger.error('memflow-search-get-error', {
                 error,
             });
             return '';
@@ -227,7 +227,7 @@ class Search {
             return returnValues;
         }
         catch (error) {
-            this.hotMeshClient.logger.error('meshflow-search-mget-error', {
+            this.hotMeshClient.logger.error('memflow-search-mget-error', {
                 error,
             });
             return [];

package/build/services/{meshflow → memflow}/worker.d.ts

@@ -1,17 +1,17 @@
 import { HotMesh } from '../hotmesh';
-import { Connection, Registry, WorkerConfig, WorkerOptions } from '../../types/meshflow';
+import { Connection, Registry, WorkerConfig, WorkerOptions } from '../../types/memflow';
 /**
  * The *Worker* service Registers worker functions and connects them to the mesh,
  * using the target backend provider/s (Redis, Postgres, NATS, etc).
  *
  * @example
  * ```typescript
- * import { MeshFlow } from '@hotmeshio/hotmesh';
+ * import { MemFlow } from '@hotmeshio/hotmesh';
  * import { Client as Postgres } from 'pg';
  * import * as workflows from './workflows';
  *
  * async function run() {
- *   const worker = await MeshFlow.Worker.create({
+ *   const worker = await MemFlow.Worker.create({
  *     connection: {
  *       class: Postgres,
  *       options: { connectionString: 'postgres://user:password@localhost:5432/db' }
@@ -63,12 +63,12 @@ export declare class WorkerService {
      *
      * @example
      * ```typescript
-     * import { MeshFlow } from '@hotmeshio/hotmesh';
+     * import { MemFlow } from '@hotmeshio/hotmesh';
      * import { Client as Postgres } from 'pg';
      * import * as workflows from './workflows';
      *
      * async function run() {
-     *   const worker = await MeshFlow.Worker.create({
+     *   const worker = await MemFlow.Worker.create({
      *     connection: {
      *       class: Postgres,
      *       options: {