@hotmeshio/hotmesh 0.0.52 → 0.0.54

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

@@ -15,7 +15,7 @@ import { TaskService } from '../task';
 import { AppVID } from '../../types/app';
 import { ActivityType } from '../../types/activity';
 import { CacheMode } from '../../types/cache';
-import { JobState, JobData, JobMetadata, JobOutput, JobStatus, JobInterruptOptions, JobCompletionOptions } from '../../types/job';
+import { JobState, JobData, JobMetadata, JobOutput, JobStatus, JobInterruptOptions, JobCompletionOptions, ExtensionType } from '../../types/job';
 import { HotMeshApps, HotMeshConfig, HotMeshManifest, HotMeshSettings } from '../../types/hotmesh';
 import { JobMessageCallback } from '../../types/quorum';
 import { RedisClient, RedisMulti } from '../../types/redis';
@@ -72,7 +72,7 @@ declare class EngineService {
     hook(topic: string, data: JobData, status?: StreamStatus, code?: StreamCode): Promise<string>;
     hookTime(jobId: string, gId: string, topicOrActivity: string, type?: WorkListTaskType): Promise<string | void>;
     hookAll(hookTopic: string, data: JobData, keyResolver: JobStatsInput, queryFacets?: string[]): Promise<string[]>;
-    pub(topic: string, data: JobData, context?: JobState): Promise<string>;
+    pub(topic: string, data: JobData, context?: JobState, extended?: ExtensionType): Promise<string>;
     sub(topic: string, callback: JobMessageCallback): Promise<void>;
     unsub(topic: string): Promise<void>;
     psub(wild: string, callback: JobMessageCallback): Promise<void>;

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,
@@ -405,10 +408,10 @@ class EngineService {
     }
     // ********************** PUB/SUB ENTRY POINT **********************
     //publish (returns just the job id)
-    async pub(topic, data, context) {
+    async pub(topic, data, context, extended) {
         const activityHandler = await this.initActivity(topic, data, context);
         if (activityHandler) {
-            return await activityHandler.process();
+            return await activityHandler.process(extended);
         }
         else {
             throw new Error(`unable to process activity for topic ${topic}`);

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/hotmesh/index.d.ts

@@ -2,7 +2,7 @@ import { EngineService } from '../engine';
 import { ILogger } from '../logger';
 import { QuorumService } from '../quorum';
 import { WorkerService } from '../worker';
-import { JobState, JobData, JobOutput, JobStatus, JobInterruptOptions } from '../../types/job';
+import { JobState, JobData, JobOutput, JobStatus, JobInterruptOptions, ExtensionType } from '../../types/job';
 import { HotMeshConfig, HotMeshManifest } from '../../types/hotmesh';
 import { JobMessageCallback, QuorumProfile, ThrottleOptions } from '../../types/quorum';
 import { JobStatsInput, GetStatsOptions, IdsResponse, StatsResponse } from '../../types/stats';
@@ -25,7 +25,7 @@ declare class HotMeshService {
     initEngine(config: HotMeshConfig, logger: ILogger): Promise<void>;
     initQuorum(config: HotMeshConfig, engine: EngineService, logger: ILogger): Promise<void>;
     doWork(config: HotMeshConfig, logger: ILogger): Promise<void>;
-    pub(topic: string, data?: JobData, context?: JobState): Promise<string>;
+    pub(topic: string, data?: JobData, context?: JobState, extended?: ExtensionType): Promise<string>;
     sub(topic: string, callback: JobMessageCallback): Promise<void>;
     unsub(topic: string): Promise<void>;
     psub(wild: string, callback: JobMessageCallback): Promise<void>;

package/build/services/hotmesh/index.js

@@ -68,8 +68,8 @@ class HotMeshService {
         this.workers = await worker_1.WorkerService.init(this.namespace, this.appId, this.guid, config, logger);
     }
     // ************* PUB/SUB METHODS *************
-    async pub(topic, data = {}, context) {
-        return await this.engine?.pub(topic, data, context);
+    async pub(topic, data = {}, context, extended) {
+        return await this.engine?.pub(topic, data, context, extended);
     }
     async sub(topic, callback) {
         return await this.engine?.sub(topic, callback);

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;
 }