@hotmeshio/hotmesh 0.0.55 → 0.0.57

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

@@ -10,42 +10,20 @@ declare class ExporterService {
     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[];
-    /**
-     * marker names are overloaded with details like sequence, type, etc
-     */
     keyToObject(key: string): {
         index: number;
         dimension?: string;
         secondary?: number;
     };
-    /**
-     * idem list has a complicated sort order based on indexes and dimensions
-     */
     sortParts(parts: TimelineType[]): TimelineType[];
 }
 export { ExporterService };

package/build/services/durable/exporter.js

@@ -9,10 +9,6 @@ class ExporterService {
         this.logger = logger;
         this.store = store;
     }
-    /**
-     * Convert the job hash from its compiles format into a DurableJobExport 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();
@@ -22,12 +18,6 @@ class ExporterService {
         const jobExport = this.inflate(jobData, options);
         return jobExport;
     }
-    /**
-     * 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, options) {
         const timeline = [];
         const state = {};
@@ -37,20 +27,16 @@ class ExporterService {
         Object.entries(jobHash).forEach(([key, value]) => {
             const match = key.match(regex);
             if (match) {
-                //transitions
                 this.inflateTransition(match, value, transitionsObject);
             }
             else if (key.length === 3) {
-                //state
                 state[this.inflateKey(key)] = serializer_1.SerializerService.fromString(value);
             }
             else if (key.startsWith('_')) {
-                //data
                 data[key.substring(1)] = value;
             }
             else if (key.startsWith('-')) {
-                //timeline
-                const keyParts = this.keyToObject(key); //key parts have meaning
+                const keyParts = this.keyToObject(key);
                 timeline.push({
                     ...keyParts,
                     key,
@@ -81,12 +67,6 @@ class ExporterService {
         }
         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) {
@@ -124,7 +104,6 @@ class ExporterService {
         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 = transitionsObject[targetName];
@@ -148,9 +127,6 @@ class ExporterService {
         });
         return entriesArray;
     }
-    /**
-     * marker names are overloaded with details like sequence, type, etc
-     */
     keyToObject(key) {
         function extractDimension(label) {
             const parts = label.split(',');
@@ -161,14 +137,12 @@ class ExporterService {
         }
         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),
@@ -176,9 +150,6 @@ class ExporterService {
             };
         }
     }
-    /**
-     * 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;

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

@@ -10,47 +10,11 @@ export declare class WorkflowHandleService {
     workflowId: string;
     constructor(hotMesh: HotMesh, workflowTopic: string, workflowId: string);
     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
-     * executed `Durable.workflow.waitFor`. The workflow
-     * will awaken if no other signals are pending.
-     */
     signal(signalId: string, data: Record<any, any>): Promise<void>;
-    /**
-     * Returns the job state of the workflow. If the workflow has completed
-     * this is also the job output. If the workflow is still running, this
-     * is the current state of the job, but it may change depending upon
-     * the activities that remain.
-     */
     state(metadata?: boolean): Promise<Record<string, any>>;
-    /**
-     * Returns the current search state of the workflow. This is
-     * different than the job state or individual activity state.
-     * Search state represents name/value pairs that were added
-     * to the workflow. As the workflow is stored in a Redis hash,
-     * this is a way to store additional data that is indexed
-     * and searchable using the RediSearch module.
-     */
     queryState(fields: string[]): Promise<Record<string, any>>;
-    /**
-     * Returns the current status of the workflow. This is a semaphore
-     * value that represents the current state of the workflow, where
-     * 0 is complete and a negative value represents that the flow was
-     * interrupted.
-     */
     status(): Promise<number>;
-    /**
-     * Interrupts a running workflow. Standard Job Completion tasks will
-     * run. Subscribers will be notified and the job hash will be expired.
-     */
     interrupt(options?: JobInterruptOptions): Promise<string>;
-    /**
-     * Waits for the workflow to complete and returns the result. If
-     * the workflow response includes an error, this method will rethrow
-     * the error, including the stack trace if available.
-     * Wrap calls in a try/catch as necessary to avoid unhandled exceptions.
-     */
     result<T>(config?: {
         state?: boolean;
         throwOnError?: boolean;

package/build/services/durable/handle.js

@@ -12,21 +12,9 @@ class WorkflowHandleService {
     async export(options) {
         return this.exporter.export(this.workflowId, options);
     }
-    /**
-     * Sends a signal to the workflow. This is a way to send
-     * a message to a workflow that is paused due to having
-     * executed `Durable.workflow.waitFor`. The workflow
-     * will awaken if no other signals are pending.
-     */
     async signal(signalId, data) {
         await this.hotMesh.hook(`${this.hotMesh.appId}.wfs.signal`, { id: signalId, data });
     }
-    /**
-     * Returns the job state of the workflow. If the workflow has completed
-     * this is also the job output. If the workflow is still running, this
-     * is the current state of the job, but it may change depending upon
-     * the activities that remain.
-     */
     async state(metadata = false) {
         const state = await this.hotMesh.getState(`${this.hotMesh.appId}.execute`, this.workflowId);
         if (!state.data && state.metadata.err) {
@@ -34,56 +22,25 @@ class WorkflowHandleService {
         }
         return metadata ? state : state.data;
     }
-    /**
-     * Returns the current search state of the workflow. This is
-     * different than the job state or individual activity state.
-     * Search state represents name/value pairs that were added
-     * to the workflow. As the workflow is stored in a Redis hash,
-     * this is a way to store additional data that is indexed
-     * and searchable using the RediSearch module.
-     */
     async queryState(fields) {
         return await this.hotMesh.getQueryState(this.workflowId, fields);
     }
-    /**
-     * Returns the current status of the workflow. This is a semaphore
-     * value that represents the current state of the workflow, where
-     * 0 is complete and a negative value represents that the flow was
-     * interrupted.
-     */
     async status() {
         return await this.hotMesh.getStatus(this.workflowId);
     }
-    /**
-     * Interrupts a running workflow. Standard Job Completion tasks will
-     * run. Subscribers will be notified and the job hash will be expired.
-     */
     async interrupt(options) {
         return await this.hotMesh.interrupt(`${this.hotMesh.appId}.execute`, this.workflowId, options);
     }
-    /**
-     * Waits for the workflow to complete and returns the result. If
-     * the workflow response includes an error, this method will rethrow
-     * the error, including the stack trace if available.
-     * Wrap calls in a try/catch as necessary to avoid unhandled exceptions.
-     */
     async result(config) {
         const topic = `${this.hotMesh.appId}.executed.${this.workflowId}`;
         let isResolved = false;
         return new Promise(async (resolve, reject) => {
-            /**
-             * rejects/resolves the promise based on the `throwOnError`
-             * default behavior is to throw if error
-             */
             const safeReject = (err) => {
                 if (config?.throwOnError === false) {
                     return resolve(err);
                 }
                 reject(err);
             };
-            /**
-             * Common completion function that unsubscribes from the topic/returns
-             */
             const complete = async (response, err) => {
                 if (isResolved)
                     return;
@@ -106,7 +63,6 @@ class WorkflowHandleService {
                 }
                 resolve(response);
             };
-            //more expensive; fetches the entire job, not just the `status`
             if (config?.state) {
                 const state = await this.hotMesh.getState(`${this.hotMesh.appId}.execute`, this.workflowId);
                 if (state?.data?.done && !state.data?.$error) {
@@ -119,7 +75,6 @@ class WorkflowHandleService {
                     return complete(null, JSON.parse(state.metadata.err));
                 }
             }
-            //subscribe to 'done' topic
             this.hotMesh.sub(topic, async (_topic, state) => {
                 this.hotMesh.unsub(topic);
                 if (state.data.done && !state.data?.$error) {
@@ -133,7 +88,6 @@ class WorkflowHandleService {
                     return await complete(null, error);
                 }
             });
-            //check state in case completed during wiring
             const status = await this.hotMesh.getStatus(this.workflowId);
             if (status <= 0) {
                 await complete();

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

@@ -10,10 +10,6 @@ export declare const Durable: {
     Search: typeof Search;
     Worker: typeof WorkerService;
     workflow: typeof WorkflowService;
-    /**
-     * Shutdown everything. All connections, workers, and clients will be closed.
-     * Include in your signal handlers to ensure a clean shutdown.
-     */
     shutdown(): Promise<void>;
 };
 export type { ContextType };

package/build/services/durable/index.js

@@ -13,10 +13,6 @@ exports.Durable = {
     Search: search_1.Search,
     Worker: worker_1.WorkerService,
     workflow: workflow_1.WorkflowService,
-    /**
-     * Shutdown everything. All connections, workers, and clients will be closed.
-     * Include in your signal handlers to ensure a clean shutdown.
-     */
     async shutdown() {
         await client_1.ClientService.shutdown();
         await worker_1.WorkerService.shutdown();

package/build/services/durable/schemas/factory.d.ts

@@ -1,33 +1,4 @@
-/**
- *********** HOTMESH 'DURABLE' MODULE APPLICATION GRAPH **********
- *
- * This HotMesh application spec uses 50 activities and 25 transitions
- * to model and emulate the Temporal Application & Query servers using
- * Redis as the backend.
- *
- * It's particularly useful for organizations with high-speed, high-volume
- * use cases as it uses in-memory Redis Streams for transactional,
- * workflow processing, while adhering to Temporal's developer-friendly syntax.
- *
- * This YAML file can also serve as a useful starting point for building
- * Integration/BPM/Workflow servers in general (MuleSoft, etc) without the need
- * for a physical application server.
- *
- * Possible use cases include:
- * * Orchestration servers
- * * Integration servers
- * * BPMN engines
- * * Reentrant process servers
- * * Service Meshes
- * * Master Data Management systems
- */
 declare const APP_VERSION = "1";
 declare const APP_ID = "durable";
-/**
- * returns a new durable workflow schema
- * @param {string} app - app name (e.g., 'durable')
- * @param {string} version - number as string (e.g., '1')
- * @returns {string} HotMesh App YAML
- */
 declare const getWorkflowYAML: (app: string, version: string) => string;
 export { getWorkflowYAML, APP_VERSION, APP_ID, };

package/build/services/durable/schemas/factory.js

@@ -1,39 +1,10 @@
 "use strict";
-/**
- *********** HOTMESH 'DURABLE' MODULE APPLICATION GRAPH **********
- *
- * This HotMesh application spec uses 50 activities and 25 transitions
- * to model and emulate the Temporal Application & Query servers using
- * Redis as the backend.
- *
- * It's particularly useful for organizations with high-speed, high-volume
- * use cases as it uses in-memory Redis Streams for transactional,
- * workflow processing, while adhering to Temporal's developer-friendly syntax.
- *
- * This YAML file can also serve as a useful starting point for building
- * Integration/BPM/Workflow servers in general (MuleSoft, etc) without the need
- * for a physical application server.
- *
- * Possible use cases include:
- * * Orchestration servers
- * * Integration servers
- * * BPMN engines
- * * Reentrant process servers
- * * Service Meshes
- * * Master Data Management systems
- */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.APP_ID = exports.APP_VERSION = exports.getWorkflowYAML = void 0;
 const APP_VERSION = '1';
 exports.APP_VERSION = APP_VERSION;
 const APP_ID = 'durable';
 exports.APP_ID = APP_ID;
-/**
- * returns a new durable workflow schema
- * @param {string} app - app name (e.g., 'durable')
- * @param {string} version - number as string (e.g., '1')
- * @returns {string} HotMesh App YAML
- */
 const getWorkflowYAML = (app, version) => {
     return `app:
   id: ${app}

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

@@ -8,51 +8,16 @@ export declare class Search {
     searchSessionIndex: number;
     hotMeshClient: HotMesh;
     store: StoreService<RedisClient, RedisMulti> | null;
+    cachedFields: Record<string, string>;
     constructor(workflowId: string, hotMeshClient: HotMesh, searchSessionId: string);
     safeKey(key: string): string;
-    /**
-     * For those deployments with a redis stack backend (with the FT module),
-     * this method will configure the search index for the workflow. For all
-     * others, this method will exit/fail gracefully and not index
-     * the fields in the HASH. However, all values are still available
-     * in the HASH.
-     */
     static configureSearchIndex(hotMeshClient: HotMesh, search?: WorkflowSearchOptions): Promise<void>;
-    /**
-     * For those deployments with a redis stack backend (with the FT module),
-     * this method will list all search indexes.
-     * @param {HotMesh} hotMeshClient - the hotmesh client
-     * @returns {Promise<string[]>} - the list of search indexes
-     */
     static listSearchIndexes(hotMeshClient: HotMesh): Promise<string[]>;
-    /**
-     * increments the index to return a unique search session guid when
-     * calling any method that produces side effects (changes the value)
-     */
     getSearchSessionGuid(): string;
-    /**
-     * Sets the fields listed in args. Returns the
-     * count of new fields that were set (does not
-     * count fields that were updated)
-     */
     set(...args: string[]): Promise<number>;
     get(key: string): Promise<string>;
     mget(...args: string[]): Promise<string[]>;
-    /**
-     * Deletes the fields listed in args. Returns the
-     * count of fields that were deleted.
-     */
     del(...args: string[]): Promise<number | void>;
-    /**
-     * Increments the value of a field by the given amount. Returns the
-     * new value of the field after the increment. Can be
-     * used to decrement the value of a field by specifying a negative.
-     */
     incr(key: string, val: number): Promise<number>;
-    /**
-     * Multiplies the value of a field by the given amount. Returns the
-     * new value of the field after the multiplication. NOTE:
-     * this is exponential multiplication.
-     */
     mult(key: string, val: number): Promise<number>;
 }

package/build/services/durable/search.js

@@ -6,6 +6,7 @@ const storage_1 = require("../../modules/storage");
 class Search {
     constructor(workflowId, hotMeshClient, searchSessionId) {
         this.searchSessionIndex = 0;
+        this.cachedFields = {};
         const keyParams = {
             appId: hotMeshClient.appId,
             jobId: workflowId
@@ -16,25 +17,30 @@ class Search {
         this.store = hotMeshClient.engine.store;
     }
     safeKey(key) {
+        if (key.startsWith('"')) {
+            return key.slice(1, -1);
+        }
         return `_${key}`;
     }
-    /**
-     * For those deployments with a redis stack backend (with the FT module),
-     * this method will configure the search index for the workflow. For all
-     * others, this method will exit/fail gracefully and not index
-     * the fields in the HASH. However, all values are still available
-     * in the HASH.
-     */
     static async configureSearchIndex(hotMeshClient, search) {
         if (search?.schema) {
             const store = hotMeshClient.engine.store;
             const schema = [];
             for (const [key, value] of Object.entries(search.schema)) {
-                //prefix with a comma (avoids collisions with hotmesh reserved words)
-                schema.push(`_${key}`);
-                schema.push(value.type);
-                if (value.sortable) {
-                    schema.push('SORTABLE');
+                if (value.indexed !== false) {
+                    schema.push(value.fieldName ? `${value.fieldName.toString()}` : `_${key}`);
+                    schema.push(value.type ? value.type : 'TEXT');
+                    if (value.noindex) {
+                        schema.push('NOINDEX');
+                    }
+                    else {
+                        if (value.nostem && value.type === 'TEXT') {
+                            schema.push('NOSTEM');
+                        }
+                        if (value.sortable) {
+                            schema.push('SORTABLE');
+                        }
+                    }
                 }
             }
             try {
@@ -51,12 +57,6 @@ class Search {
             }
         }
     }
-    /**
-     * For those deployments with a redis stack backend (with the FT module),
-     * this method will list all search indexes.
-     * @param {HotMesh} hotMeshClient - the hotmesh client
-     * @returns {Promise<string[]>} - the list of search indexes
-     */
     static async listSearchIndexes(hotMeshClient) {
         try {
             const store = hotMeshClient.engine.store;
@@ -68,40 +68,36 @@ class Search {
             return [];
         }
     }
-    /**
-     * increments the index to return a unique search session guid when
-     * calling any method that produces side effects (changes the value)
-     */
     getSearchSessionGuid() {
-        //return the search session as it would exist in the search session index
         return `${this.searchSessionId}-${this.searchSessionIndex++}-`;
     }
-    /**
-     * Sets the fields listed in args. Returns the
-     * count of new fields that were set (does not
-     * count fields that were updated)
-     */
     async set(...args) {
         const ssGuid = this.getSearchSessionGuid();
         const store = storage_1.asyncLocalStorage.getStore();
         const replay = store?.get('replay') ?? {};
-        if (ssGuid in replay) {
-            return Number(replay[ssGuid]);
-        }
         const safeArgs = [];
         for (let i = 0; i < args.length; i += 2) {
-            const key = this.safeKey(args[i]);
+            const keyName = args[i];
+            delete this.cachedFields[keyName];
+            const key = this.safeKey(keyName);
             const value = args[i + 1].toString();
             safeArgs.push(key, value);
         }
+        if (ssGuid in replay) {
+            return Number(replay[ssGuid]);
+        }
         const fieldCount = await this.store.exec('HSET', this.jobId, ...safeArgs);
-        //no need to wait; set this interim value in the replay
         this.store.exec('HSET', this.jobId, ssGuid, fieldCount.toString());
         return Number(fieldCount);
     }
     async get(key) {
         try {
-            return await this.store.exec('HGET', this.jobId, this.safeKey(key));
+            if (key in this.cachedFields) {
+                return this.cachedFields[key];
+            }
+            const value = await this.store.exec('HGET', this.jobId, this.safeKey(key));
+            this.cachedFields[key] = value;
+            return value;
         }
         catch (error) {
             this.hotMeshClient.logger.error('durable-search-get-error', { ...error });
@@ -109,45 +105,55 @@ class Search {
         }
     }
     async mget(...args) {
+        let isCached = true;
+        const values = [];
         const safeArgs = [];
         for (let i = 0; i < args.length; i++) {
+            if (isCached && args[i] in this.cachedFields) {
+                values.push(this.cachedFields[args[i]]);
+            }
+            else {
+                isCached = false;
+            }
             safeArgs.push(this.safeKey(args[i]));
         }
         try {
-            return await this.store.exec('HMGET', this.jobId, ...safeArgs);
+            if (isCached) {
+                return values;
+            }
+            const returnValues = await this.store.exec('HMGET', this.jobId, ...safeArgs);
+            returnValues.forEach((value, index) => {
+                if (value !== null) {
+                    this.cachedFields[args[index]] = value;
+                }
+            });
+            return returnValues;
         }
         catch (error) {
             this.hotMeshClient.logger.error('durable-search-mget-error', { ...error });
             return [];
         }
     }
-    /**
-     * Deletes the fields listed in args. Returns the
-     * count of fields that were deleted.
-     */
     async del(...args) {
         const ssGuid = this.getSearchSessionGuid();
         const store = storage_1.asyncLocalStorage.getStore();
         const replay = store?.get('replay') ?? {};
-        if (ssGuid in replay) {
-            return Number(replay[ssGuid]);
-        }
         const safeArgs = [];
         for (let i = 0; i < args.length; i++) {
-            safeArgs.push(this.safeKey(args[i]));
+            const keyName = args[i];
+            delete this.cachedFields[keyName];
+            safeArgs.push(this.safeKey(keyName));
+        }
+        if (ssGuid in replay) {
+            return Number(replay[ssGuid]);
         }
         const response = await this.store.exec('HDEL', this.jobId, ...safeArgs);
         const formattedResponse = isNaN(response) ? 0 : Number(response);
-        //no need to wait; set this interim value in the replay
         this.store.exec('HSET', this.jobId, ssGuid, formattedResponse.toString());
         return formattedResponse;
     }
-    /**
-     * Increments the value of a field by the given amount. Returns the
-     * new value of the field after the increment. Can be
-     * used to decrement the value of a field by specifying a negative.
-     */
     async incr(key, val) {
+        delete this.cachedFields[key];
         const ssGuid = this.getSearchSessionGuid();
         const store = storage_1.asyncLocalStorage.getStore();
         const replay = store?.get('replay') ?? {};
@@ -155,16 +161,11 @@ class Search {
             return Number(replay[ssGuid]);
         }
         const num = await this.store.exec('HINCRBYFLOAT', this.jobId, this.safeKey(key), val.toString());
-        //no need to wait; set this interim value in the replay
         this.store.exec('HSET', this.jobId, ssGuid, num.toString());
         return Number(num);
     }
-    /**
-     * Multiplies the value of a field by the given amount. Returns the
-     * new value of the field after the multiplication. NOTE:
-     * this is exponential multiplication.
-     */
     async mult(key, val) {
+        delete this.cachedFields[key];
         const ssGuid = this.getSearchSessionGuid();
         const store = storage_1.asyncLocalStorage.getStore();
         const replay = store?.get('replay') ?? {};
@@ -175,7 +176,6 @@ class Search {
         if (ssGuidValue === 1) {
             const log = Math.log(val);
             const logTotal = await this.store.exec('HINCRBYFLOAT', this.jobId, this.safeKey(key), log.toString());
-            //no need to wait; set this interim value in the replay
             this.store.exec('HSET', this.jobId, ssGuid, logTotal.toString());
             return Math.exp(Number(logTotal));
         }