@hotmeshio/hotmesh 0.1.14 → 0.1.16

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

@@ -3,42 +3,15 @@ import { StoreService } from '../store';
 import { DependencyExport, ExportOptions, JobActionExport, JobExport } from '../../types/exporter';
 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
- */
 declare class ExporterService {
     appId: string;
     logger: ILogger;
     store: StoreService<RedisClient, RedisMulti>;
     symbols: Promise<Symbols> | Symbols;
     constructor(appId: string, store: StoreService<RedisClient, RedisMulti>, logger: ILogger);
-    /**
-     * Convert the job hash and dependency list into a JobExport object.
-     * This object contains various facets that describe the interaction
-     * in terms relevant to narrative storytelling.
-     */
     export(jobId: string, options?: ExportOptions): Promise<JobExport>;
-    /**
-     * Inflates the key from Redis, 3-character symbol
-     * into a human-readable JSON path, reflecting the
-     * tree-like structure of the unidimensional Hash
-     */
     inflateKey(key: string): string;
-    /**
-     * Inflates the job data from Redis into a JobExport 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, dependencyList: string[]): JobExport;
-    /**
-     * Inflates the dependency data from Redis into a JobExport object by
-     * organizing the dimensional isolate in sch a way asto interleave
-     * into a story
-     * @param data - the dependency data from Redis
-     * @returns - the organized dependency data
-     */
     inflateDependencyData(data: string[], actions: JobActionExport): DependencyExport[];
 }
 export { ExporterService };

package/build/services/exporter/index.js

@@ -4,21 +4,12 @@ exports.ExporterService = void 0;
 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
- */
 class ExporterService {
     constructor(appId, store, logger) {
         this.appId = appId;
         this.logger = logger;
         this.store = store;
     }
-    /**
-     * Convert the job hash and dependency list into a JobExport object.
-     * This object contains various facets that describe the interaction
-     * in terms relevant to narrative storytelling.
-     */
     async export(jobId, options = {}) {
         if (!this.symbols) {
             this.symbols = this.store.getAllSymbols();
@@ -29,22 +20,10 @@ class ExporterService {
         const jobExport = this.inflate(jobData, depData);
         return jobExport;
     }
-    /**
-     * Inflates the key from Redis, 3-character symbol
-     * into a human-readable JSON path, reflecting the
-     * tree-like structure of the unidimensional Hash
-     */
     inflateKey(key) {
         return key in this.symbols ? this.symbols[key] : key;
     }
-    /**
-     * Inflates the job data from Redis into a JobExport object
-     * @param jobHash - the job data from Redis
-     * @param dependencyList - the list of dependencies for the job
-     * @returns - the inflated job data
-     */
     inflate(jobHash, dependencyList) {
-        //the list of actions taken in the workflow and hook functions
         const actions = {
             hooks: {},
             main: {
@@ -58,7 +37,6 @@ class ExporterService {
         Object.entries(jobHash).forEach(([key, value]) => {
             const match = key.match(regex);
             if (match) {
-                //activity process state
                 const [_, letters, numbers] = match;
                 const path = this.inflateKey(letters);
                 const dimensions = `${numbers.replace(/,/g, '/')}`;
@@ -66,7 +44,6 @@ class ExporterService {
                 process[`${dimensions}/${path}`] = resolved;
             }
             else if (key.length === 3) {
-                //job state
                 process[this.inflateKey(key)] = serializer_1.SerializerService.fromString(value);
             }
         });
@@ -76,13 +53,6 @@ class ExporterService {
             status: jobHash[':'],
         };
     }
-    /**
-     * Inflates the dependency data from Redis into a JobExport object by
-     * organizing the dimensional isolate in sch a way asto interleave
-     * into a story
-     * @param data - the dependency data from Redis
-     * @returns - the organized dependency data
-     */
     inflateDependencyData(data, actions) {
         const hookReg = /([0-9,]+)-(\d+)$/;
         const flowReg = /-(\d+)$/;
@@ -94,7 +64,6 @@ class ExporterService {
             let type;
             let dimensionKey = '';
             if (match) {
-                //hook-originating dependency
                 const [_, dimension, counter] = match;
                 dimensionKey = dimension.split(',').join('/');
                 prefix = `${dimensionKey}[${counter}]`;
@@ -103,13 +72,11 @@ class ExporterService {
             else {
                 const match = jobId.match(flowReg);
                 if (match) {
-                    //main workflow-originating dependency
                     const [_, counter] = match;
                     prefix = `[${counter}]`;
                     type = 'flow';
                 }
                 else {
-                    //'other' types like signal cleanup
                     prefix = '/';
                     type = 'other';
                 }

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

@@ -5,11 +5,11 @@ import { WorkerService } from '../worker';
 import { JobState, JobData, JobOutput, JobStatus, JobInterruptOptions, ExtensionType } from '../../types/job';
 import { HotMeshConfig, HotMeshManifest } from '../../types/hotmesh';
 import { JobExport } from '../../types/exporter';
-import { JobMessageCallback, QuorumProfile, ThrottleOptions } from '../../types/quorum';
+import { JobMessageCallback, QuorumMessage, QuorumMessageCallback, QuorumProfile, ThrottleOptions } from '../../types/quorum';
 import { StringAnyType, StringStringType } from '../../types/serializer';
 import { JobStatsInput, GetStatsOptions, IdsResponse, StatsResponse } from '../../types/stats';
 import { StreamCode, StreamData, StreamDataResponse, StreamStatus } from '../../types/stream';
-declare class HotMeshService {
+declare class HotMesh {
     namespace: string;
     appId: string;
     guid: string;
@@ -20,10 +20,11 @@ declare class HotMeshService {
     static disconnecting: boolean;
     verifyAndSetNamespace(namespace?: string): void;
     verifyAndSetAppId(appId: string): void;
-    static init(config: HotMeshConfig): Promise<HotMeshService>;
+    static init(config: HotMeshConfig): Promise<HotMesh>;
     static guid(): string;
     initEngine(config: HotMeshConfig, logger: ILogger): Promise<void>;
     initQuorum(config: HotMeshConfig, engine: EngineService, logger: ILogger): Promise<void>;
+    constructor();
     doWork(config: HotMeshConfig, logger: ILogger): Promise<void>;
     pub(topic: string, data?: JobData, context?: JobState, extended?: ExtensionType): Promise<string>;
     sub(topic: string, callback: JobMessageCallback): Promise<void>;
@@ -34,6 +35,9 @@ declare class HotMeshService {
     add(streamData: StreamData | StreamDataResponse): Promise<string>;
     rollCall(delay?: number): Promise<QuorumProfile[]>;
     throttle(options: ThrottleOptions): Promise<boolean>;
+    pubQuorum(quorumMessage: QuorumMessage): Promise<boolean>;
+    subQuorum(callback: QuorumMessageCallback): Promise<void>;
+    unsubQuorum(callback: QuorumMessageCallback): Promise<void>;
     plan(path: string): Promise<HotMeshManifest>;
     deploy(pathOrYAML: string): Promise<HotMeshManifest>;
     activate(version: string, delay?: number): Promise<boolean>;
@@ -53,4 +57,4 @@ declare class HotMeshService {
     stop(): void;
     compress(terms: string[]): Promise<boolean>;
 }
-export { HotMeshService };
+export { HotMesh };

package/build/services/hotmesh/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HotMeshService = void 0;
+exports.HotMesh = void 0;
 const key_1 = require("../../modules/key");
 const utils_1 = require("../../modules/utils");
 const redis_1 = require("../connector/clients/redis");
@@ -12,12 +12,7 @@ const quorum_1 = require("../quorum");
 const router_1 = require("../router");
 const worker_1 = require("../worker");
 const enums_1 = require("../../modules/enums");
-class HotMeshService {
-    constructor() {
-        this.engine = null;
-        this.quorum = null;
-        this.workers = [];
-    }
+class HotMesh {
     verifyAndSetNamespace(namespace) {
         if (!namespace) {
             this.namespace = key_1.HMNS;
@@ -41,8 +36,8 @@ class HotMeshService {
         }
     }
     static async init(config) {
-        const instance = new HotMeshService();
-        instance.guid = (0, utils_1.guid)();
+        const instance = new HotMesh();
+        instance.guid = config.guid ?? (0, utils_1.guid)();
         instance.verifyAndSetNamespace(config.namespace);
         instance.verifyAndSetAppId(config.appId);
         instance.logger = new logger_1.LoggerService(config.appId, instance.guid, config.name || '', config.logLevel);
@@ -65,10 +60,14 @@ class HotMeshService {
             this.quorum = await quorum_1.QuorumService.init(this.namespace, this.appId, this.guid, config, engine, logger);
         }
     }
+    constructor() {
+        this.engine = null;
+        this.quorum = null;
+        this.workers = [];
+    }
     async doWork(config, logger) {
         this.workers = await worker_1.WorkerService.init(this.namespace, this.appId, this.guid, config, logger);
     }
-    // ************* PUB/SUB METHODS *************
     async pub(topic, data = {}, context, extended) {
         return await this.engine?.pub(topic, data, context, extended);
     }
@@ -90,7 +89,6 @@ class HotMeshService {
     async add(streamData) {
         return (await this.engine.add(streamData));
     }
-    // ************* QUORUM METHODS *************
     async rollCall(delay) {
         return await this.quorum?.rollCall(delay);
     }
@@ -118,7 +116,15 @@ class HotMeshService {
         await this.engine.store.setThrottleRate(throttleMessage);
         return await this.quorum?.pub(throttleMessage);
     }
-    // ************* COMPILER METHODS *************
+    async pubQuorum(quorumMessage) {
+        return await this.quorum?.pub(quorumMessage);
+    }
+    async subQuorum(callback) {
+        return await this.quorum?.sub(callback);
+    }
+    async unsubQuorum(callback) {
+        return await this.quorum?.unsub(callback);
+    }
     async plan(path) {
         return await this.engine?.plan(path);
     }
@@ -126,10 +132,8 @@ class HotMeshService {
         return await this.engine?.deploy(pathOrYAML);
     }
     async activate(version, delay) {
-        //activation is a quorum operation
         return await this.quorum?.activate(version, delay);
     }
-    // ************* REPORTER METHODS *************
     async export(jobId) {
         return await this.engine?.export(jobId);
     }
@@ -154,15 +158,12 @@ class HotMeshService {
     async resolveQuery(topic, query) {
         return await this.engine?.resolveQuery(topic, query);
     }
-    // ****************** `INTERRUPT` ACTIVE JOBS *****************
     async interrupt(topic, jobId, options = {}) {
         return await this.engine?.interrupt(topic, jobId, options);
     }
-    // ****************** `SCRUB` CLEAN COMPLETED JOBS *****************
     async scrub(jobId) {
         await this.engine?.scrub(jobId);
     }
-    // ****** `HOOK` ACTIVITY RE-ENTRY POINT ******
     async hook(topic, data, status, code) {
         return await this.engine?.hook(topic, data, status, code);
     }
@@ -188,5 +189,5 @@ class HotMeshService {
         return await this.engine?.compress(terms);
     }
 }
-exports.HotMeshService = HotMeshService;
-HotMeshService.disconnecting = false;
+exports.HotMesh = HotMesh;
+HotMesh.disconnecting = false;

package/build/services/logger/index.js

@@ -15,14 +15,12 @@ class LoggerService {
             level: this.logLevel,
             format: winston_1.format.combine(winston_1.format.colorize(), winston_1.format.timestamp(), winston_1.format.printf((info) => {
                 const { timestamp, level, message } = info;
-                // Extract the object from the `info` object's `Symbol(splat)` field
                 const symbols = Object.getOwnPropertySymbols(info);
                 const splatSymbol = symbols.find((symbol) => symbol.toString() === 'Symbol(splat)');
                 let splatData = {};
                 if (splatSymbol) {
                     splatData = info[splatSymbol][0] || {};
                 }
-                // Pass it to the `tagify` method
                 const tags = this.tagify(splatData);
                 return `${timestamp} [${level}] [${this.name || this.appId}:${this.instanceId}] ${message} ${tags}`;
             })),

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

@@ -7,22 +7,8 @@ declare class MapperService {
     constructor(rules: Record<string, unknown>, data: JobState);
     mapRules(): Record<string, unknown>;
     private traverseRules;
-    /**
-     * resolves a pipe expression of the form: { @pipe: [["{data.foo.bar}", 2, false, "hello world"]] }
-     * @param value
-     * @returns
-     */
     private pipe;
-    /**
-     * 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

@@ -27,28 +27,14 @@ class MapperService {
             return this.resolve(rules);
         }
     }
-    /**
-     * resolves a pipe expression of the form: { @pipe: [["{data.foo.bar}", 2, false, "hello world"]] }
-     * @param value
-     * @returns
-     */
     pipe(value) {
         const pipe = new pipe_1.Pipe(value, this.data);
         return pipe.process();
     }
-    /**
-     * resolves a mapping expression in the form: "{data.foo.bar}" or 2 or false or "hello world"
-     * @param value
-     * @returns
-     */
     resolve(value) {
         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/meshcall/index.d.ts

@@ -0,0 +1,21 @@
+import { HotMesh } from "../hotmesh";
+import { MeshCallConnectParams, MeshCallCronParams, MeshCallExecParams, MeshCallFlushParams, MeshCallInterruptParams } from "../../types/meshcall";
+import { RedisConfig } from "../../types";
+declare class MeshCall {
+    static workers: Map<string, HotMesh | Promise<HotMesh>>;
+    static engines: Map<string, HotMesh | Promise<HotMesh>>;
+    static connections: Map<string, any>;
+    constructor();
+    static findFirstMatching(workers: Map<string, (HotMesh | Promise<HotMesh>)>, namespace: string, config: RedisConfig): Promise<HotMesh | void>;
+    static getHotMeshClient: (namespace: string, connection: RedisConfig) => Promise<HotMesh>;
+    static verifyWorkflowActive(hotMesh: HotMesh, appId?: string, count?: number): Promise<boolean>;
+    static activateWorkflow(hotMesh: HotMesh, appId?: string, version?: string): Promise<void>;
+    static getInstance(namespace: string, redis: RedisConfig): Promise<HotMesh>;
+    static connect(params: MeshCallConnectParams): Promise<HotMesh>;
+    static exec<U>(params: MeshCallExecParams): Promise<U>;
+    static flush(params: MeshCallFlushParams): Promise<void>;
+    static cron(params: MeshCallCronParams): Promise<boolean>;
+    static interrupt(params: MeshCallInterruptParams): Promise<void>;
+    static shutdown(): Promise<void>;
+}
+export { MeshCall };

package/build/services/meshcall/index.js

@@ -0,0 +1,202 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MeshCall = void 0;
+const ms_1 = __importDefault(require("ms"));
+const hotmesh_1 = require("../hotmesh");
+const enums_1 = require("../../modules/enums");
+const utils_1 = require("../../modules/utils");
+const key_1 = require("../../modules/key");
+const factory_1 = require("./schemas/factory");
+class MeshCall {
+    constructor() { }
+    static async findFirstMatching(workers, namespace = key_1.HMNS, config) {
+        for (const [id, hotMeshInstance] of workers) {
+            if ((await hotMeshInstance).namespace === namespace) {
+                if (id.startsWith((0, utils_1.hashOptions)(config.options))) {
+                    return hotMeshInstance;
+                }
+            }
+        }
+    }
+    static async verifyWorkflowActive(hotMesh, appId = key_1.HMNS, count = 0) {
+        const app = await hotMesh.engine.store.getApp(appId);
+        const appVersion = app?.version;
+        if (isNaN(appVersion)) {
+            if (count > 10) {
+                throw new Error('Workflow failed to activate');
+            }
+            await (0, utils_1.sleepFor)(enums_1.HMSH_QUORUM_DELAY_MS * 2);
+            return await MeshCall.verifyWorkflowActive(hotMesh, appId, count + 1);
+        }
+        return true;
+    }
+    static async activateWorkflow(hotMesh, appId = key_1.HMNS, version = '1') {
+        const app = await hotMesh.engine.store.getApp(appId);
+        const appVersion = app?.version;
+        if (appVersion === version && !app.active) {
+            try {
+                await hotMesh.activate(version);
+            }
+            catch (error) {
+                hotMesh.engine.logger.error('durable-client-activate-err', { error });
+                throw error;
+            }
+        }
+        else if (isNaN(Number(appVersion)) || appVersion < version) {
+            try {
+                await hotMesh.deploy((0, factory_1.getWorkflowYAML)(appId));
+                await hotMesh.activate(version);
+            }
+            catch (error) {
+                hotMesh.engine.logger.error('durable-client-deploy-activate-err', {
+                    ...error,
+                });
+                throw error;
+            }
+        }
+    }
+    static async getInstance(namespace, redis) {
+        let hotMeshInstance = await MeshCall.findFirstMatching(MeshCall.workers, namespace, redis);
+        if (!hotMeshInstance) {
+            hotMeshInstance = await MeshCall.findFirstMatching(MeshCall.engines, namespace, redis);
+            if (!hotMeshInstance) {
+                hotMeshInstance = await MeshCall.getHotMeshClient(namespace, redis);
+            }
+        }
+        return hotMeshInstance;
+    }
+    static async connect(params) {
+        const targetNamespace = params.namespace ?? key_1.HMNS;
+        const optionsHash = (0, utils_1.hashOptions)(params.redis?.options);
+        const targetTopic = `${optionsHash}.${targetNamespace}.${params.topic}`;
+        const hotMeshWorker = await hotmesh_1.HotMesh.init({
+            guid: params.guid,
+            logLevel: params.logLevel ?? enums_1.HMSH_LOGLEVEL,
+            appId: params.namespace ?? key_1.HMNS,
+            engine: { redis: params.redis },
+            workers: [
+                {
+                    topic: params.topic,
+                    redis: params.redis,
+                    callback: async function (input) {
+                        const response = await params.callback.apply(this, input.data.args);
+                        return {
+                            metadata: { ...input.metadata },
+                            data: { response },
+                        };
+                    },
+                }
+            ],
+        });
+        MeshCall.workers.set(targetTopic, hotMeshWorker);
+        await MeshCall.activateWorkflow(hotMeshWorker, targetNamespace);
+        return hotMeshWorker;
+    }
+    static async exec(params) {
+        const TOPIC = `${params.namespace ?? key_1.HMNS}.call`;
+        const hotMeshInstance = await MeshCall.getInstance(params.namespace, params.redis);
+        let id = params.options?.id;
+        if (id) {
+            if (params.options?.flush) {
+                await hotMeshInstance.scrub(id);
+            }
+            else if (params.options?.ttl) {
+                try {
+                    const cached = await hotMeshInstance.getState(TOPIC, id);
+                    if (cached) {
+                        return cached.data.response;
+                    }
+                }
+                catch (error) {
+                }
+            }
+        }
+        else {
+            id = hotmesh_1.HotMesh.guid();
+        }
+        let expire = 1;
+        if (params.options?.ttl) {
+            expire = (0, ms_1.default)(params.options.ttl) / 1000;
+        }
+        const jobOutput = await hotMeshInstance.pubsub(TOPIC, { id, expire, topic: params.topic, args: params.args }, null, 30000);
+        return jobOutput?.data?.response;
+    }
+    static async flush(params) {
+        const hotMeshInstance = await MeshCall.getInstance(params.namespace, params.redis);
+        await hotMeshInstance.scrub(params.id);
+    }
+    static async cron(params) {
+        try {
+            await MeshCall.connect({
+                logLevel: params.logLevel,
+                guid: params.guid,
+                topic: params.topic,
+                redis: params.redis,
+                callback: params.callback,
+                namespace: params.namespace,
+            });
+            const TOPIC = `${params.namespace ?? key_1.HMNS}.cron`;
+            const hotMeshInstance = await MeshCall.getInstance(params.namespace, params.redis);
+            await hotMeshInstance.pub(TOPIC, {
+                id: params.options.id,
+                topic: params.topic,
+                args: params.args,
+                interval: params.options.interval,
+                maxCycles: params.options.maxCycles ?? 1000000000,
+                maxDuration: params.options.maxDuration,
+            });
+            return true;
+        }
+        catch (error) {
+            if (error.message.includes(`Duplicate job: ${params.options.id}`)) {
+                return false;
+            }
+            throw error;
+        }
+    }
+    static async interrupt(params) {
+        const hotMeshInstance = await MeshCall.getInstance(params.namespace, params.redis);
+        await hotMeshInstance.interrupt(`${params.namespace ?? key_1.HMNS}.cron`, params.options.id, { 'throw': false, expire: 60 });
+    }
+    static async shutdown() {
+        for (const [_, hotMeshInstance] of MeshCall.workers) {
+            (await hotMeshInstance).stop();
+        }
+        for (const [_, hotMeshInstance] of MeshCall.engines) {
+            (await hotMeshInstance).stop();
+        }
+        await hotmesh_1.HotMesh.stop();
+    }
+}
+exports.MeshCall = MeshCall;
+_a = MeshCall;
+MeshCall.workers = new Map();
+MeshCall.engines = new Map();
+MeshCall.connections = new Map();
+MeshCall.getHotMeshClient = async (namespace, connection) => {
+    const optionsHash = (0, utils_1.hashOptions)(connection.options);
+    const targetNS = namespace ?? key_1.HMNS;
+    const connectionNS = `${optionsHash}.${targetNS}`;
+    if (MeshCall.engines.has(connectionNS)) {
+        const hotMeshClient = await MeshCall.engines.get(connectionNS);
+        await _a.verifyWorkflowActive(hotMeshClient, targetNS);
+        return hotMeshClient;
+    }
+    const hotMeshClient = hotmesh_1.HotMesh.init({
+        appId: targetNS,
+        logLevel: enums_1.HMSH_LOGLEVEL,
+        engine: {
+            redis: {
+                class: connection.class,
+                options: connection.options,
+            },
+        },
+    });
+    MeshCall.engines.set(connectionNS, hotMeshClient);
+    await _a.activateWorkflow(await hotMeshClient, targetNS);
+    return hotMeshClient;
+};

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

@@ -0,0 +1,2 @@
+export declare const VERSION = "1";
+export declare const getWorkflowYAML: (appId?: string, version?: string) => string;