@hotmeshio/hotmesh 0.3.31 → 0.4.0

package/build/services/hotmesh/index.js

@@ -1,479 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HotMesh = void 0;
-const key_1 = require("../../modules/key");
-const utils_1 = require("../../modules/utils");
-const factory_1 = require("../connector/factory");
-const engine_1 = require("../engine");
-const logger_1 = require("../logger");
-const quorum_1 = require("../quorum");
-const router_1 = require("../router");
-const worker_1 = require("../worker");
-const enums_1 = require("../../modules/enums");
-/**
- * This example shows the full lifecycle of a HotMesh engine instance,
- * including: initialization, deployment, activation and execution.
- *
- * Engine routers are self-managing, but subscribe to the 'quorum' channel
- * to establish consensus as necessary for distributed processing.
- * Completed workflows are always soft-deleted with a configurable
- * retention period.
- *
- * @example
- * ```typescript
- * import { Client as Postgres } from 'pg';
- * import { HotMesh } from '@hotmeshio/hotmesh';
- *
- * const hotMesh = await HotMesh.init({
- *   appId: 'abc',
- *   engine: {
- *     connection: {
- *       class: Postgres,
- *       options: {
- *         connectionString: 'postgresql://usr:pwd@localhost:5432/db',
- *       }
- *     }
- *   }
- * });
- *
- * await hotMesh.deploy(`
- * app:
- *   id: abc
- *   version: '1'
- *   graphs:
- *     - subscribes: abc.test
- *       activities:
- *         t1:
- *           type: trigger
- * `);
- *
- * await hotMesh.activate('1');
- *
- * await hotMesh.pubsub('abc.test');
- *
- * await HotMesh.stop();
- * ```
- */
-class HotMesh {
-    /**
-     * @private
-     */
-    verifyAndSetNamespace(namespace) {
-        if (!namespace) {
-            this.namespace = key_1.HMNS;
-        }
-        else if (!namespace.match(/^[A-Za-z0-9-]+$/)) {
-            throw new Error(`config.namespace [${namespace}] is invalid`);
-        }
-        else {
-            this.namespace = namespace;
-        }
-    }
-    /**
-     * @private
-     */
-    verifyAndSetAppId(appId) {
-        if (!appId?.match(/^[A-Za-z0-9-]+$/)) {
-            throw new Error(`config.appId [${appId}] is invalid`);
-        }
-        else if (appId === 'a') {
-            throw new Error(`config.appId [${appId}] is reserved`);
-        }
-        else {
-            this.appId = appId;
-        }
-    }
-    /**
-     * Instance initializer. Workers are configured
-     * similarly to the engine, but as an array with
-     * multiple worker objects.
-     *
-     * @example
-     * ```typescript
-     * const config: HotMeshConfig = {
-     *   appId: 'myapp',
-     *   engine: {
-     *     connection: {
-     *       class: Postgres,
-     *       options: {
-     *         connectionString: 'postgresql://usr:pwd@localhost:5432/db',
-     *       }
-     *     }
-     *   },
-     *   workers [...]
-     * };
-     * const hotMesh = await HotMesh.init(config);
-     * ```
-     */
-    static async init(config) {
-        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);
-        await instance.initEngine(config, instance.logger);
-        await instance.initQuorum(config, instance.engine, instance.logger);
-        await instance.doWork(config, instance.logger);
-        return instance;
-    }
-    /**
-     * returns a guid using the same core guid
-     * generator used by the HotMesh (nanoid)
-     */
-    static guid() {
-        return (0, utils_1.guid)();
-    }
-    /**
-     * @private
-     */
-    async initEngine(config, logger) {
-        if (config.engine) {
-            //connections that are 'readonly' transfer
-            //this property directly to the engine,
-            //and ALWAYS take precendence.
-            if (config.engine.connection.readonly) {
-                config.engine.readonly = true;
-            }
-            await factory_1.ConnectorService.initClients(config.engine);
-            this.engine = await engine_1.EngineService.init(this.namespace, this.appId, this.guid, config, logger);
-        }
-    }
-    /**
-     * @private
-     */
-    async initQuorum(config, engine, logger) {
-        if (engine) {
-            this.quorum = await quorum_1.QuorumService.init(this.namespace, this.appId, this.guid, config, engine, logger);
-        }
-    }
-    /**
-     * @private
-     */
-    constructor() {
-        /**
-         * @private
-         */
-        this.engine = null;
-        /**
-         * @private
-         */
-        this.quorum = null;
-        /**
-         * @private
-         */
-        this.workers = [];
-    }
-    /**
-     * @private
-     */
-    async doWork(config, logger) {
-        this.workers = await worker_1.WorkerService.init(this.namespace, this.appId, this.guid, config, logger);
-    }
-    // ************* PUB/SUB METHODS *************
-    /**
-     * Starts a workflow
-     * @example
-     * ```typescript
-     * await hotMesh.pub('a.b.c', { key: 'value' });
-     * ```
-     */
-    async pub(topic, data = {}, context, extended) {
-        return await this.engine?.pub(topic, data, context, extended);
-    }
-    /**
-     * Subscribe (listen) to all output and interim emissions of a single
-     * workflow topic. NOTE: Postgres does not support patterned
-     * unsubscription, so this method is not supported for Postgres.
-     *
-     * @example
-     * ```typescript
-     * await hotMesh.psub('a.b.c', (topic, message) => {
-     *  console.log(message);
-     * });
-     * ```
-     */
-    async sub(topic, callback) {
-        return await this.engine?.sub(topic, callback);
-    }
-    /**
-     * Stop listening in on a single workflow topic
-     */
-    async unsub(topic) {
-        return await this.engine?.unsub(topic);
-    }
-    /**
-     * Listen to all output and interim emissions of a workflow topic
-     * matching a wildcard pattern.
-     * @example
-     * ```typescript
-     * await hotMesh.psub('a.b.c*', (topic, message) => {
-     *  console.log(message);
-     * });
-     * ```
-     */
-    async psub(wild, callback) {
-        return await this.engine?.psub(wild, callback);
-    }
-    /**
-     * Patterned unsubscribe. NOTE: Postgres does not support patterned
-     * unsubscription, so this method is not supported for Postgres.
-     */
-    async punsub(wild) {
-        return await this.engine?.punsub(wild);
-    }
-    /**
-     * Starts a workflow and awaits the response
-     * @example
-     * ```typescript
-     * await hotMesh.pubsub('a.b.c', { key: 'value' });
-     * ```
-     */
-    async pubsub(topic, data = {}, context, timeout) {
-        return await this.engine?.pubsub(topic, data, context, timeout);
-    }
-    /**
-     * Add a transition message to the workstream, resuming leg 2 of a paused
-     * reentrant activity (e.g., await, worker, hook)
-     */
-    async add(streamData) {
-        return (await this.engine.add(streamData));
-    }
-    // ************* QUORUM METHODS *************
-    /**
-     * Request a roll call from the quorum (engine and workers)
-     */
-    async rollCall(delay) {
-        return await this.quorum?.rollCall(delay);
-    }
-    /**
-     * Sends a throttle message to the quorum (engine and/or workers)
-     * to limit the rate of processing. Pass `-1` to throttle indefinitely.
-     * The value must be a non-negative integer and not exceed `MAX_DELAY` ms.
-     *
-     * When throttling is set, the quorum will pause for the specified time
-     * before processing the next message. Target specific engines and
-     * workers by passing a `guid` and/or `topic`. Pass no arguments to
-     * throttle the entire quorum.
-     *
-     * In this example, all processing has been paused indefinitely for
-     * the entire quorum. This is equivalent to an emergency stop.
-     *
-     * HotMesh is a stateless sequence engine, so the throttle can be adjusted up
-     * and down with no loss of data.
-     *
-     *
-     * @example
-     * ```typescript
-     * await hotMesh.throttle({ throttle: -1 });
-     * ```
-     */
-    async throttle(options) {
-        let throttle;
-        if (options.throttle === -1) {
-            throttle = enums_1.MAX_DELAY;
-        }
-        else {
-            throttle = options.throttle;
-        }
-        if (!Number.isInteger(throttle) || throttle < 0 || throttle > enums_1.MAX_DELAY) {
-            throw new Error(`Throttle must be a non-negative integer and not exceed ${enums_1.MAX_DELAY} ms; send -1 to throttle indefinitely`);
-        }
-        const throttleMessage = {
-            type: 'throttle',
-            throttle: throttle,
-        };
-        if (options.guid) {
-            throttleMessage.guid = options.guid;
-        }
-        if (options.topic !== undefined) {
-            throttleMessage.topic = options.topic;
-        }
-        await this.engine.store.setThrottleRate(throttleMessage);
-        return await this.quorum?.pub(throttleMessage);
-    }
-    /**
-     * Publish a message to the quorum (engine and/or workers)
-     */
-    async pubQuorum(quorumMessage) {
-        return await this.quorum?.pub(quorumMessage);
-    }
-    /**
-     * Subscribe to quorum events (engine and workers)
-     */
-    async subQuorum(callback) {
-        return await this.quorum?.sub(callback);
-    }
-    /**
-     * Unsubscribe from quorum events (engine and workers)
-     */
-    async unsubQuorum(callback) {
-        return await this.quorum?.unsub(callback);
-    }
-    // ************* LIFECYCLE METHODS *************
-    /**
-     * Preview changes and provide an analysis of risk
-     * prior to deployment
-     * @private
-     */
-    async plan(path) {
-        return await this.engine?.plan(path);
-    }
-    /**
-     * When the app YAML descriptor file is ready, the `deploy` function can be called.
-     * This function is responsible for merging all referenced YAML source
-     * files and writing the JSON output to the file system and to the provider backend. It
-     * is also possible to embed the YAML in-line as a string.
-     *
-     * *The version will not be active until activation is explicitly called.*
-     */
-    async deploy(pathOrYAML) {
-        return await this.engine?.deploy(pathOrYAML);
-    }
-    /**
-     * Once the app YAML file is deployed to the provider backend, the `activate` function can be
-     * called to enable it for the entire quorum at the same moment.
-     *
-     * The approach is to establish the coordinated health of the system through series
-     * of call/response exchanges. Once it is established that the quorum is healthy,
-     * the quorum is instructed to run their engine in `no-cache` mode, ensuring
-     * that the provider backend is consulted for the active app version each time a
-     * call is processed. This ensures that all engines are running the same version
-     * of the app, switching over at the same moment and then enabling `cache` mode
-     * to improve performance.
-     *
-     * *Add a delay for the quorum to reach consensus if traffic is busy, but
-     * also consider throttling traffic flow to an acceptable level.*
-     */
-    async activate(version, delay) {
-        return await this.quorum?.activate(version, delay);
-    }
-    /**
-     * Returns the job state as a JSON object, useful
-     * for understanding dependency chains
-     */
-    async export(jobId) {
-        return await this.engine?.export(jobId);
-    }
-    /**
-     * Returns all data (HGETALL) for a job.
-     */
-    async getRaw(jobId) {
-        return await this.engine?.getRaw(jobId);
-    }
-    /**
-     * Reporter-related method to get the status of a job
-     * @private
-     */
-    async getStats(topic, query) {
-        return await this.engine?.getStats(topic, query);
-    }
-    /**
-     * Returns the status of a job. This is a numeric
-     * semaphore value that indicates the job's state.
-     * Any non-positive value indicates a completed job.
-     * Jobs with a value of `-1` are pending and will
-     * automatically be scrubbed after a set period.
-     * Jobs a value around -1billion have been interrupted
-     * and will be scrubbed after a set period. Jobs with
-     * a value of 0 completed normally. Jobs with a
-     * positive value are still running.
-     */
-    async getStatus(jobId) {
-        return this.engine?.getStatus(jobId);
-    }
-    /**
-     * Returns the job state (data and metadata) for a job.
-     */
-    async getState(topic, jobId) {
-        return this.engine?.getState(topic, jobId);
-    }
-    /**
-     * Returns searchable/queryable data for a job. In this
-     * example a literal field is also searched (the colon
-     * is used to track job status and is a reserved field;
-     * it can be read but not written).
-     *
-     * @example
-     * ```typescript
-     * const fields = ['fred', 'barney', '":"'];
-     * const queryState = await hotMesh.getQueryState('123', fields);
-     * //returns { fred: 'flintstone', barney: 'rubble', ':': '1' }
-     * ```
-     */
-    async getQueryState(jobId, fields) {
-        return await this.engine?.getQueryState(jobId, fields);
-    }
-    /**
-     * @private
-     */
-    async getIds(topic, query, queryFacets = []) {
-        return await this.engine?.getIds(topic, query, queryFacets);
-    }
-    /**
-     * @private
-     */
-    async resolveQuery(topic, query) {
-        return await this.engine?.resolveQuery(topic, query);
-    }
-    /**
-     * Interrupt an active job
-     */
-    async interrupt(topic, jobId, options = {}) {
-        return await this.engine?.interrupt(topic, jobId, options);
-    }
-    /**
-     * Immediately deletes (DEL) a completed job from the system.
-     *
-     * *Scrubbed jobs must be complete with a non-positive `status` value*
-     */
-    async scrub(jobId) {
-        await this.engine?.scrub(jobId);
-    }
-    /**
-     * Re/entry point for an active job. This is used to resume a paused job
-     * and close the reentry point or leave it open for subsequent reentry.
-     * Because `hooks` are public entry points, they include a `topic`
-     * which is established in the app YAML file.
-     *
-     * When this method is called, a hook rule will be located to establish
-     * the exact activity and activity dimension for reentry.
-     */
-    async hook(topic, data, status, code) {
-        return await this.engine?.hook(topic, data, status, code);
-    }
-    /**
-     * @private
-     */
-    async hookAll(hookTopic, data, query, queryFacets = []) {
-        return await this.engine?.hookAll(hookTopic, data, query, queryFacets);
-    }
-    /**
-     * Stop all points of presence, workers and engines
-     */
-    static async stop() {
-        if (!this.disconnecting) {
-            this.disconnecting = true;
-            await router_1.Router.stopConsuming();
-            await factory_1.ConnectorService.disconnectAll();
-        }
-    }
-    /**
-     * Stop this point of presence, workers and engines
-     */
-    stop() {
-        this.engine?.taskService.cancelCleanup();
-        this.quorum?.stop();
-        this.workers?.forEach((worker) => {
-            worker.stop();
-        });
-    }
-    /**
-     * @private
-     * @deprecated
-     */
-    async compress(terms) {
-        return await this.engine?.compress(terms);
-    }
-}
-exports.HotMesh = HotMesh;
-HotMesh.disconnecting = false;

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

@@ -1,16 +0,0 @@
-import { Logger } from 'winston';
-import { ILogger } from '../../types/logger';
-declare class LoggerService implements ILogger {
-    private appId;
-    private instanceId;
-    private name;
-    private logLevel;
-    private logger;
-    constructor(appId?: string, instanceId?: string, name?: string, logLevel?: string, customLogger?: Logger);
-    private createDefaultLogger;
-    info(message: string, ...meta: any[]): void;
-    error(message: string, ...meta: any[]): void;
-    warn(message: string, ...meta: any[]): void;
-    debug(message: string, ...meta: any[]): void;
-}
-export { LoggerService, ILogger };

package/build/services/logger/index.js

@@ -1,54 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LoggerService = void 0;
-const winston_1 = require("winston");
-class LoggerService {
-    constructor(appId = 'appId', instanceId = 'instanceId', name = 'name', logLevel = 'info', customLogger) {
-        this.appId = appId;
-        this.instanceId = instanceId;
-        this.name = name;
-        this.logLevel = logLevel;
-        this.logger = customLogger || this.createDefaultLogger();
-    }
-    createDefaultLogger() {
-        // Custom format to ensure error objects include message and stack
-        const errorFormat = (0, winston_1.format)((info) => {
-            if (info.error instanceof Error) {
-                return {
-                    ...info,
-                    error: {
-                        message: info.error.message,
-                        stack: info.error.stack,
-                    },
-                };
-            }
-            return info;
-        });
-        return (0, winston_1.createLogger)({
-            level: this.logLevel,
-            format: winston_1.format.combine(winston_1.format.timestamp(), winston_1.format.errors({ stack: true }), errorFormat(), (0, winston_1.format)((info) => {
-                info.ts = info.timestamp;
-                delete info.timestamp;
-                return info;
-            })(), winston_1.format.json()),
-            transports: [new winston_1.transports.Console()],
-            defaultMeta: {
-                app: this.name || this.appId,
-                id: this.instanceId,
-            },
-        });
-    }
-    info(message, ...meta) {
-        this.logger.info(message, ...meta);
-    }
-    error(message, ...meta) {
-        this.logger.error(message, ...meta);
-    }
-    warn(message, ...meta) {
-        this.logger.warn(message, ...meta);
-    }
-    debug(message, ...meta) {
-        this.logger.debug(message, ...meta);
-    }
-}
-exports.LoggerService = LoggerService;

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

@@ -1,28 +0,0 @@
-import { JobState } from '../../types/job';
-import { TransitionRule } from '../../types/transition';
-import { StreamCode } from '../../types';
-declare class MapperService {
-    private rules;
-    private data;
-    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

@@ -1 +0,0 @@
-'use strict';const n=b;(function(c,d){const m=b,e=c();while(!![]){try{const f=-parseInt(m(0x151))/0x1*(-parseInt(m(0x156))/0x2)+-parseInt(m(0x13e))/0x3*(-parseInt(m(0x143))/0x4)+parseInt(m(0x144))/0x5+-parseInt(m(0x148))/0x6*(-parseInt(m(0x14b))/0x7)+-parseInt(m(0x153))/0x8*(-parseInt(m(0x14d))/0x9)+-parseInt(m(0x13b))/0xa*(-parseInt(m(0x154))/0xb)+-parseInt(m(0x150))/0xc;if(f===d)break;else e['push'](e['shift']());}catch(g){e['push'](e['shift']());}}}(a,0x2526d));function b(c,d){const e=a();return b=function(f,g){f=f-0x13a;let h=e[f];return h;},b(c,d);}Object[n(0x146)](exports,n(0x15b),{'value':!0x0}),exports[n(0x159)]=void 0x0;const pipe_1=require(n(0x15c));function a(){const v=['traverseRules','200914JtmmsA','Pipe','gate','MapperService','pipe','__esModule','../pipe','resolve','code','30XfIDUb','boolean','prototype','3kzztlI','object','evaluate','isArray','data','528QlKjoZ','1120070AmJqJz','rules','defineProperty','match','126sSsapn','toString','includes','26173teSZZN','hasOwnProperty','312651yYJWex','call','mapRules','7563432WrdJOh','1ngDPwr','process','32yIEHOf','881397EPzKrm'];a=function(){return v;};return a();}class MapperService{constructor(c,d){const o=n;this[o(0x145)]=c,this['data']=d;}[n(0x14f)](){const p=n;return this[p(0x155)](this[p(0x145)]);}[n(0x155)](c){const q=n;if(q(0x13f)==typeof c&&'@pipe'in c)return this[q(0x15a)](c['@pipe']);if(q(0x13f)==typeof c&&null!==c){const d={};for(const f in c)Object[q(0x13d)][q(0x14c)][q(0x14e)](c,f)&&(d[f]=this[q(0x155)](c[f]));return d;}return this[q(0x15d)](c);}[n(0x15a)](c){const r=n;return new pipe_1[(r(0x157))](c,this[r(0x142)])[r(0x152)]();}[n(0x15d)](c){const s=n;return new pipe_1['Pipe']([[c]],this[s(0x142)])[s(0x152)]();}static[n(0x140)](c,d,f){const t=n;if(t(0x13c)==typeof c)return c;if(Array[t(0x141)](c[t(0x13a)])&&c[t(0x13a)][t(0x14a)](f||0xc8)||f['toString']()===(c[t(0x13a)]||0xc8)[t(0x149)]()){if(!c[t(0x147)])return!0x0;const g='or'===c[t(0x158)];let h=!0x0,i=!0x1;return c[t(0x147)]['forEach'](({expected:j,actual:k})=>{const u=t;if(g&&!i||!g&&h){const l=pipe_1[u(0x157)][u(0x15d)](k,d)===j;g&&l?i=!0x0:g||l||(h=!0x1);}}),g?i:h;}return!0x1;}}exports['MapperService']=MapperService;