@hotmeshio/hotmesh 0.0.51 → 0.0.53

package/build/services/engine/index.js

@@ -305,6 +305,7 @@ class EngineService {
                 streamData.status = stream_1.StreamStatus.ERROR;
                 streamData.data = error;
                 streamData.code = error.code;
+                streamData.stack = error.stack;
             }
             else if (emit) {
                 streamData.status = stream_1.StreamStatus.PENDING;
@@ -330,7 +331,9 @@ class EngineService {
     }
     // ****************** `INTERRUPT` ACTIVE JOBS *****************
     async interrupt(topic, jobId, options = {}) {
+        //immediately interrupt the job, going directly to the data source
         await this.store.interrupt(topic, jobId, options);
+        //now that the job is interrupted, we can clean up
         const context = await this.getState(topic, jobId);
         const completionOpts = {
             interrupt: options.descend,

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

@@ -1,9 +1,8 @@
 import { ILogger } from '../logger';
 import { StoreService } from '../store';
-import { StringStringType, Symbols } from "../../types/serializer";
-import { RedisClient, RedisMulti } from '../../types/redis';
 import { DependencyExport, ExportOptions, JobActionExport, JobExport } from '../../types/exporter';
-import { SerializerService } from '../serializer';
+import { RedisClient, RedisMulti } from '../../types/redis';
+import { StringStringType, Symbols } from "../../types/serializer";
 /**
  * Downloads job data from Redis (hscan, hmget, hgetall)
  * Expands process data and includes dependency list
@@ -11,7 +10,6 @@ import { SerializerService } from '../serializer';
 declare class ExporterService {
     appId: string;
     logger: ILogger;
-    serializer: SerializerService;
     store: StoreService<RedisClient, RedisMulti>;
     symbols: Promise<Symbols> | Symbols;
     constructor(appId: string, store: StoreService<RedisClient, RedisMulti>, logger: ILogger);

package/build/services/exporter/index.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExporterService = void 0;
-const serializer_1 = require("../serializer");
-const utils_1 = require("../../modules/utils");
 const key_1 = require("../../modules/key");
+const utils_1 = require("../../modules/utils");
+const serializer_1 = require("../serializer");
 /**
  * Downloads job data from Redis (hscan, hmget, hgetall)
  * Expands process data and includes dependency list
@@ -13,7 +13,6 @@ class ExporterService {
         this.appId = appId;
         this.logger = logger;
         this.store = store;
-        this.serializer = new serializer_1.SerializerService();
     }
     /**
      * Convert the job hash and dependency list into a JobExport object.
@@ -63,12 +62,12 @@ class ExporterService {
                 const [_, letters, numbers] = match;
                 const path = this.inflateKey(letters);
                 const dimensions = `${numbers.replace(/,/g, '/')}`;
-                const resolved = this.serializer.fromString(value);
+                const resolved = serializer_1.SerializerService.fromString(value);
                 process[`${dimensions}/${path}`] = resolved;
             }
             else if (key.length === 3) {
                 //job state
-                process[this.inflateKey(key)] = this.serializer.fromString(value);
+                process[this.inflateKey(key)] = serializer_1.SerializerService.fromString(value);
             }
         });
         return {

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

@@ -8,17 +8,21 @@ declare class MapperService {
     mapRules(): Record<string, unknown>;
     private traverseRules;
     /**
-     * resolve a pipe expression of the form: { @pipe: [["{data.foo.bar}", 2, false, "hello world"]] }
+     * resolves a pipe expression of the form: { @pipe: [["{data.foo.bar}", 2, false, "hello world"]] }
      * @param value
      * @returns
      */
     private pipe;
     /**
-     * resolve a simple mapping expression in the form: "{data.foo.bar}" or 2 or false or "hello world"
+     * resolves a mapping expression in the form: "{data.foo.bar}" or 2 or false or "hello world"
      * @param value
      * @returns
      */
     private resolve;
+    /**
+     * Evaluates a transition rule against the current job state and incoming Stream message
+     * to determine which (if any) transition should be taken.
+     */
     static evaluate(transitionRule: TransitionRule | boolean, context: JobState, code: StreamCode): boolean;
 }
 export { MapperService };

package/build/services/mapper/index.js

@@ -28,7 +28,7 @@ class MapperService {
         }
     }
     /**
-     * resolve a pipe expression of the form: { @pipe: [["{data.foo.bar}", 2, false, "hello world"]] }
+     * resolves a pipe expression of the form: { @pipe: [["{data.foo.bar}", 2, false, "hello world"]] }
      * @param value
      * @returns
      */
@@ -37,7 +37,7 @@ class MapperService {
         return pipe.process();
     }
     /**
-     * resolve a simple mapping expression in the form: "{data.foo.bar}" or 2 or false or "hello world"
+     * resolves a mapping expression in the form: "{data.foo.bar}" or 2 or false or "hello world"
      * @param value
      * @returns
      */
@@ -45,6 +45,10 @@ class MapperService {
         const pipe = new pipe_1.Pipe([[value]], this.data);
         return pipe.process();
     }
+    /**
+     * Evaluates a transition rule against the current job state and incoming Stream message
+     * to determine which (if any) transition should be taken.
+     */
     static evaluate(transitionRule, context, code) {
         if (typeof transitionRule === 'boolean') {
             return transitionRule;

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

@@ -2,23 +2,15 @@ declare class ArrayHandler {
     get(array: any[], index: number): any;
     length(array: any[]): any;
     concat(array1: any[], array2: any[]): any[];
-    every(array: any[], callback: (value: any, index: number, array: any[]) => boolean): boolean;
-    filter(array: any[], callback: (value: any, index: number, array: any[]) => boolean): any[];
-    find(array: any[], callback: (value: any, index: number, array: any[]) => boolean): any;
-    findIndex(array: any[], callback: (value: any, index: number, array: any[]) => boolean): number;
-    forEach(array: any[], callback: (value: any, index: number, array: any[]) => void): void;
     indexOf(array: any[], searchElement: any, fromIndex?: number): number;
     join(array: any[], separator: string): string;
     lastIndexOf(array: any[], searchElement: any, fromIndex?: number): number;
-    map(array: any[], callback: (value: any, index: number, array: any[]) => any): any[];
     pop(array: any[]): any;
-    push(array: any[], ...items: any[]): number;
-    reduce(array: any[], callback: (accumulator: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue?: any): any;
+    push(array: any[], ...items: any[]): any[];
     reverse(array: any[]): any[];
     shift(array: any[]): any;
     slice(array: any[], start?: number, end?: number): any[];
-    some(array: any[], callback: (value: any, index: number, array: any[]) => boolean): boolean;
-    sort(array: any[], compareFunction?: (a: any, b: any) => number): any[];
+    sort(array: any[], order?: 'ASCENDING' | 'DESCENDING'): any[];
     splice(array: any[], start: number, deleteCount?: number, ...items: any[]): any[];
     unshift(array: any[], ...items: any[]): number;
 }

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

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ArrayHandler = void 0;
 class ArrayHandler {
     get(array, index) {
-        return array[index];
+        return array?.[index || 0];
     }
     length(array) {
         return array?.length;
@@ -11,21 +11,6 @@ class ArrayHandler {
     concat(array1, array2) {
         return array1.concat(array2);
     }
-    every(array, callback) {
-        return array.every(callback);
-    }
-    filter(array, callback) {
-        return array.filter(callback);
-    }
-    find(array, callback) {
-        return array.find(callback);
-    }
-    findIndex(array, callback) {
-        return array.findIndex(callback);
-    }
-    forEach(array, callback) {
-        array.forEach(callback);
-    }
     indexOf(array, searchElement, fromIndex) {
         return array.indexOf(searchElement, fromIndex);
     }
@@ -35,17 +20,12 @@ class ArrayHandler {
     lastIndexOf(array, searchElement, fromIndex) {
         return array.lastIndexOf(searchElement, fromIndex);
     }
-    map(array, callback) {
-        return array.map(callback);
-    }
     pop(array) {
         return array.pop();
     }
     push(array, ...items) {
-        return array.push(...items);
-    }
-    reduce(array, callback, initialValue) {
-        return array.reduce(callback, initialValue);
+        array.push(...items);
+        return array;
     }
     reverse(array) {
         return array.reverse();
@@ -56,11 +36,33 @@ class ArrayHandler {
     slice(array, start, end) {
         return array.slice(start, end);
     }
-    some(array, callback) {
-        return array.some(callback);
-    }
-    sort(array, compareFunction) {
-        return array.sort(compareFunction);
+    sort(array, order = 'ASCENDING') {
+        return array.sort((a, b) => {
+            if (order === 'ASCENDING') {
+                if (a === b)
+                    return 0;
+                if (a === null || a === undefined)
+                    return -1;
+                if (b === null || b === undefined)
+                    return 1;
+                if (typeof a === 'string' && typeof b === 'string') {
+                    return a.localeCompare(b);
+                }
+                return a < b ? -1 : 1;
+            }
+            else {
+                if (a === b)
+                    return 0;
+                if (a === null || a === undefined)
+                    return 1;
+                if (b === null || b === undefined)
+                    return -1;
+                if (typeof a === 'string' && typeof b === 'string') {
+                    return b.localeCompare(a);
+                }
+                return a > b ? -1 : 1;
+            }
+        });
     }
     splice(array, start, deleteCount, ...items) {
         return array.splice(start, deleteCount, ...items);

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

@@ -6,5 +6,6 @@ declare class ConditionalHandler {
     less_than(value1: number, value2: number): boolean;
     greater_than_or_equal(value1: number, value2: number): boolean;
     less_than_or_equal(value1: number, value2: number): boolean;
+    nullish(value1: any, value2: any): any;
 }
 export { ConditionalHandler };

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

@@ -23,5 +23,8 @@ class ConditionalHandler {
     less_than_or_equal(value1, value2) {
         return value1 <= value2;
     }
+    nullish(value1, value2) {
+        return value1 ?? value2;
+    }
 }
 exports.ConditionalHandler = ConditionalHandler;

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

@@ -46,6 +46,7 @@ declare class DateHandler {
     setHours(date: DateInput, hours: number, minutes?: number, seconds?: number, ms?: number): number;
     toDateString(date: DateInput): string;
     toISOString(date: DateInput): string;
+    toISOXString(date?: DateInput): string;
     toJSON(date: DateInput): string;
     toLocaleDateString(date: DateInput, locales?: string | string[], options?: Intl.DateTimeFormatOptions): string;
     toLocaleString(date: DateInput, locales?: string | string[], options?: Intl.DateTimeFormatOptions): string;

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DateHandler = void 0;
+const utils_1 = require("../../../modules/utils");
 class DateHandler {
     /**
      * It is so common in mapping operations to use a string (ISO) date as input. This helper
@@ -142,6 +143,9 @@ class DateHandler {
     toISOString(date) {
         return DateHandler.getDateInstance(date).toISOString();
     }
+    toISOXString(date) {
+        return (0, utils_1.formatISODate)(date ? DateHandler.getDateInstance(date) : new Date());
+    }
     toJSON(date) {
         return DateHandler.getDateInstance(date).toJSON();
     }

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

@@ -3,6 +3,7 @@ import { BitwiseHandler } from './bitwise';
 import { ConditionalHandler } from './conditional';
 import { DateHandler } from './date';
 import { JsonHandler } from './json';
+import { LogicalHandler } from './logical';
 import { MathHandler } from './math';
 import { NumberHandler } from './number';
 import { ObjectHandler } from './object';
@@ -15,6 +16,7 @@ declare const _default: {
     conditional: ConditionalHandler;
     date: DateHandler;
     json: JsonHandler;
+    logical: LogicalHandler;
     math: MathHandler;
     number: NumberHandler;
     object: ObjectHandler;

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

@@ -5,6 +5,7 @@ const bitwise_1 = require("./bitwise");
 const conditional_1 = require("./conditional");
 const date_1 = require("./date");
 const json_1 = require("./json");
+const logical_1 = require("./logical");
 const math_1 = require("./math");
 const number_1 = require("./number");
 const object_1 = require("./object");
@@ -17,6 +18,7 @@ exports.default = {
     conditional: new conditional_1.ConditionalHandler(),
     date: new date_1.DateHandler(),
     json: new json_1.JsonHandler(),
+    logical: new logical_1.LogicalHandler(),
     math: new math_1.MathHandler(),
     number: new number_1.NumberHandler(),
     object: new object_1.ObjectHandler(),

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

@@ -0,0 +1,5 @@
+declare class LogicalHandler {
+    and(firstValue: boolean, secondValue: boolean): boolean;
+    or(firstValue: boolean, secondValue: boolean): boolean;
+}
+export { LogicalHandler };

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogicalHandler = void 0;
+class LogicalHandler {
+    and(firstValue, secondValue) {
+        return firstValue && secondValue;
+    }
+    or(firstValue, secondValue) {
+        return firstValue || secondValue;
+    }
+}
+exports.LogicalHandler = LogicalHandler;

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

@@ -1,4 +1,7 @@
 declare class ObjectHandler {
+    get(obj: object, prop: string | symbol): any;
+    set(obj: object, prop: string | symbol, value: any): any;
+    create(...args: any[]): object;
     keys(obj: object): string[];
     values(obj: object): any[];
     entries(obj: object): [string, any][];

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

@@ -2,29 +2,47 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ObjectHandler = void 0;
 class ObjectHandler {
+    get(obj, prop) {
+        return obj?.[prop];
+    }
+    set(obj, prop, value) {
+        if (!obj)
+            obj = {};
+        obj[prop] = value;
+        return obj;
+    }
+    create(...args) {
+        const obj = {};
+        if (args.length === 0)
+            return obj;
+        for (let i = 0; i < args.length; i += 2) {
+            obj[args[i]] = args[i + 1];
+        }
+        return obj;
+    }
     keys(obj) {
-        return Object.keys(obj);
+        return obj && Object.keys(obj) || [];
     }
     values(obj) {
-        return Object.values(obj);
+        return obj && Object.values(obj) || [];
     }
     entries(obj) {
-        return Object.entries(obj);
+        return obj && Object.entries(obj) || [];
     }
     fromEntries(iterable) {
         return Object.fromEntries(iterable);
     }
     assign(target, ...sources) {
-        return Object.assign(target, ...sources);
+        return Object.assign(target || {}, ...sources);
     }
     getOwnPropertyNames(obj) {
-        return Object.getOwnPropertyNames(obj);
+        return Object.getOwnPropertyNames(obj || {});
     }
     getOwnPropertySymbols(obj) {
-        return Object.getOwnPropertySymbols(obj);
+        return Object.getOwnPropertySymbols(obj || {});
     }
     getOwnPropertyDescriptor(obj, prop) {
-        return Object.getOwnPropertyDescriptor(obj, prop);
+        return Object.getOwnPropertyDescriptor(obj || {}, prop);
     }
     defineProperty(obj, prop, descriptor) {
         return Object.defineProperty(obj, prop, descriptor);

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

@@ -1,10 +1,12 @@
 import { JobState, JobData } from '../../types/job';
-import { PipeItem, PipeItems, Pipe as PipeType } from '../../types/pipe';
+import { PipeContext, PipeItem, PipeItems, Pipe as PipeType } from '../../types/pipe';
 declare class Pipe {
     rules: PipeType;
     jobData: JobData;
-    constructor(rules: PipeType, jobData: JobData);
+    context: PipeContext;
+    constructor(rules: PipeType, jobData: JobData, context?: PipeContext);
     private isPipeType;
+    private isreduceType;
     static isPipeObject(obj: {
         [key: string]: unknown;
     } | PipeItem): boolean;
@@ -15,15 +17,30 @@ declare class Pipe {
      * loop through each PipeItem row in this Pipe, resolving and transforming line by line
      * @returns {any} the result of the pipe
      */
-    process(): any;
+    process(resolved?: unknown[] | null): any;
+    /**
+     * Transforms iterable `input` into a single value. Vars $output, $item, $key
+     * and $input are available. The final statement in the iterator (the reduction)
+     * is assumed to be the return value. A default $output object may be provided
+     * to the iterator by placing the the second cell of the preceding row. Otherwise,
+     * construct the object during first run and ensure it is the first cell of the
+     * last row of the iterator, so it is returned as the $output for the next cycle
+     * @param {unknown[]} input
+     * @returns {unknown}
+     * @private
+     */
+    reduce(input: Array<unknown[]>): unknown;
     private processRow;
     static resolveFunction(functionName: string): any;
     processCells(cells: PipeItems): unknown[];
     private isFunction;
+    private isContextVariable;
     private isMappable;
     resolveCellValue(currentCell: PipeItem): unknown;
     private getNestedProperty;
     resolveMappableValue(currentCell: string): unknown;
+    resolveContextValue(currentCell: string): unknown;
+    resolveContextTerm(currentCell: string): string;
     resolveFunctionTerm(currentCell: string): string;
     resolveMapTerm(currentCell: string): string;
 }

package/build/services/pipe/index.js

@@ -6,13 +6,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Pipe = void 0;
 const functions_1 = __importDefault(require("./functions"));
 class Pipe {
-    constructor(rules, jobData) {
+    constructor(rules, jobData, context) {
         this.rules = rules;
         this.jobData = jobData;
+        this.context = context;
     }
     isPipeType(currentRow) {
         return !Array.isArray(currentRow) && '@pipe' in currentRow;
     }
+    isreduceType(currentRow) {
+        return !Array.isArray(currentRow) && '@reduce' in currentRow;
+    }
     static isPipeObject(obj) {
         return typeof obj === 'object' && obj !== null && !Array.isArray(obj) && '@pipe' in obj;
     }
@@ -30,36 +34,81 @@ class Pipe {
      * loop through each PipeItem row in this Pipe, resolving and transforming line by line
      * @returns {any} the result of the pipe
      */
-    process() {
-        let resolved = this.processCells(this.rules[0]);
+    process(resolved = null) {
+        let index = 0;
+        if (!(resolved || this.isPipeType(this.rules[0]) || this.isreduceType(this.rules[0]))) {
+            resolved = this.processCells(this.rules[0]); // Add type assertion
+            index = 1;
+        }
         const len = this.rules.length;
-        for (let i = 1; i < len; i++) {
-            resolved = this.processRow(this.rules[i], resolved, []);
+        const subPipeQueue = [];
+        for (let i = index; i < len; i++) {
+            resolved = this.processRow(this.rules[i], resolved, subPipeQueue);
         }
         return resolved[0];
     }
+    /**
+     * Transforms iterable `input` into a single value. Vars $output, $item, $key
+     * and $input are available. The final statement in the iterator (the reduction)
+     * is assumed to be the return value. A default $output object may be provided
+     * to the iterator by placing the the second cell of the preceding row. Otherwise,
+     * construct the object during first run and ensure it is the first cell of the
+     * last row of the iterator, so it is returned as the $output for the next cycle
+     * @param {unknown[]} input
+     * @returns {unknown}
+     * @private
+     */
+    reduce(input) {
+        let resolved = input[1] ?? null;
+        if (Array.isArray(input[0])) {
+            for (let index = 0; index < input[0].length; index++) {
+                this.context = { $input: input[0], $output: resolved, $item: input[0][index], $key: index.toString(), $index: index };
+                resolved = this.process([resolved]);
+            }
+        }
+        else {
+            let index = -1;
+            for (let $key in input[0]) {
+                index++;
+                this.context = { $input: input[0], $output: resolved, $item: input[0][$key], $key, $index: index };
+                resolved = this.process([resolved]);
+            }
+        }
+        return [resolved];
+    }
     processRow(currentRow, resolvedPriorRow, subPipeQueue) {
-        if (this.isPipeType(currentRow)) {
-            //currentRow is a recursive subPipe
-            const subPipe = new Pipe(currentRow['@pipe'], this.jobData);
+        if (resolvedPriorRow && this.isreduceType(currentRow)) {
+            //reduce the resolvedPriorRow and return the output from the reducer
+            const subPipe = new Pipe(currentRow['@reduce'], this.jobData);
+            const reduced = subPipe.reduce(resolvedPriorRow);
+            return reduced;
+        }
+        else if (this.isPipeType(currentRow)) {
+            //process subPipe and push to subPipeQueue; echo resolvedPriorRow
+            const subPipe = new Pipe(currentRow['@pipe'], this.jobData, this.context);
             subPipeQueue.push(subPipe.process());
-            //return prior row as if nothing happened
             return resolvedPriorRow;
         }
         else {
+            //pivot the subPipeQueue into the arguments array (resolvedPriorRow)
             if (subPipeQueue.length > 0) {
-                //if items in subPipeQueue, flush and use as resolvedPriorRow
                 resolvedPriorRow = [...subPipeQueue];
                 subPipeQueue.length = 0;
             }
-            else if (!resolvedPriorRow) {
+            if (!resolvedPriorRow) {
                 //if no prior row, use current row as prior row
-                return [].concat(this.processCells([...currentRow]));
+                return [].concat(this.processCells(Array.isArray(currentRow) ? [...currentRow] : []));
             }
             else {
-                const [functionName, ...params] = currentRow;
+                const [functionName, ...params] = currentRow; // Add type assertion
                 //use resolved values from prior row (n - 1) as input params to cell 1 function
-                const resolvedValue = Pipe.resolveFunction(functionName)(...resolvedPriorRow);
+                let resolvedValue;
+                if (this.isContextVariable(functionName)) {
+                    resolvedValue = this.resolveContextValue(functionName);
+                }
+                else {
+                    resolvedValue = Pipe.resolveFunction(functionName)(...resolvedPriorRow);
+                }
                 //resolve remaining cells in row and return concatenated with resolvedValue
                 return [resolvedValue].concat(this.processCells([...params]));
             }
@@ -80,14 +129,21 @@ class Pipe {
     }
     processCells(cells) {
         const resolved = [];
-        for (const currentCell of cells) {
-            resolved.push(this.resolveCellValue(currentCell));
+        if (Array.isArray(cells)) {
+            for (const currentCell of cells) {
+                resolved.push(this.resolveCellValue(currentCell));
+            }
         }
         return resolved;
     }
     isFunction(currentCell) {
         return typeof currentCell === 'string' && currentCell.startsWith('{@') && currentCell.endsWith('}');
     }
+    isContextVariable(currentCell) {
+        if (typeof currentCell === 'string' && currentCell.endsWith('}')) {
+            return currentCell.startsWith('{$item') || currentCell.startsWith('{$key') || currentCell.startsWith('{$index') || currentCell.startsWith('{$input') || currentCell.startsWith('{$output');
+        }
+    }
     isMappable(currentCell) {
         return typeof currentCell === 'string' && currentCell.startsWith('{') && currentCell.endsWith('}');
     }
@@ -96,6 +152,9 @@ class Pipe {
             const fn = Pipe.resolveFunction(currentCell);
             return fn.call();
         }
+        else if (this.isContextVariable(currentCell)) {
+            return this.resolveContextValue(currentCell);
+        }
         else if (this.isMappable(currentCell)) {
             return this.resolveMappableValue(currentCell);
         }
@@ -118,6 +177,13 @@ class Pipe {
         const term = this.resolveMapTerm(currentCell);
         return this.getNestedProperty(this.jobData, term);
     }
+    resolveContextValue(currentCell) {
+        const term = this.resolveContextTerm(currentCell);
+        return this.getNestedProperty(this.context, term);
+    }
+    resolveContextTerm(currentCell) {
+        return currentCell.substring(1, currentCell.length - 1);
+    }
     resolveFunctionTerm(currentCell) {
         return currentCell.substring(2, currentCell.length - 1);
     }