@hotmeshio/hotmesh 0.0.4 → 0.0.5

package/build/esm/services/hotmesh/index.js

@@ -0,0 +1,131 @@
+import { v4 as uuidv4 } from 'uuid';
+import { PSNS } from '../../modules/key';
+import { EngineService } from '../engine';
+import { LoggerService } from '../logger';
+import { StreamSignaler } from '../signaler/stream';
+import { QuorumService } from '../quorum';
+import { WorkerService } from '../worker';
+import { ConnectorService } from '../connector';
+class HotMeshService {
+    constructor() {
+        this.engine = null;
+        this.quorum = null;
+        this.workers = [];
+    }
+    verifyAndSetNamespace(namespace) {
+        if (!namespace) {
+            this.namespace = PSNS;
+        }
+        else if (!namespace.match(/^[A-Za-z0-9-]+$/)) {
+            throw new Error(`config.namespace [${namespace}] is invalid`);
+        }
+        else {
+            this.namespace = namespace;
+        }
+    }
+    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;
+        }
+    }
+    static async init(config) {
+        const instance = new HotMeshService();
+        instance.guid = uuidv4();
+        instance.verifyAndSetNamespace(config.namespace);
+        instance.verifyAndSetAppId(config.appId);
+        instance.logger = new 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.initWorkers(config, instance.logger);
+        return instance;
+    }
+    async initEngine(config, logger) {
+        if (config.engine) {
+            await ConnectorService.initRedisClients(config.engine.redis?.class, config.engine.redis?.options, config.engine);
+            this.engine = await EngineService.init(this.namespace, this.appId, this.guid, config, logger);
+        }
+    }
+    async initQuorum(config, engine, logger) {
+        if (engine) {
+            this.quorum = await QuorumService.init(this.namespace, this.appId, this.guid, config, engine, logger);
+        }
+    }
+    async initWorkers(config, logger) {
+        this.workers = await 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 sub(topic, callback) {
+        return await this.engine?.sub(topic, callback);
+    }
+    async unsub(topic) {
+        return await this.engine?.unsub(topic);
+    }
+    async psub(wild, callback) {
+        return await this.engine?.psub(wild, callback);
+    }
+    async punsub(wild) {
+        return await this.engine?.punsub(wild);
+    }
+    async pubsub(topic, data = {}, context, timeout) {
+        return await this.engine?.pubsub(topic, data, context, timeout);
+    }
+    async add(streamData) {
+        return await this.engine.add(streamData);
+    }
+    // ************* COMPILER METHODS *************
+    async plan(path) {
+        return await this.engine?.plan(path);
+    }
+    async deploy(pathOrYAML) {
+        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 getStats(topic, query) {
+        return await this.engine?.getStats(topic, query);
+    }
+    async getStatus(jobId) {
+        return this.engine?.getStatus(jobId);
+    }
+    async getState(topic, jobId) {
+        return this.engine?.getState(topic, jobId);
+    }
+    async getIds(topic, query, queryFacets = []) {
+        return await this.engine?.getIds(topic, query, queryFacets);
+    }
+    async resolveQuery(topic, query) {
+        return await this.engine?.resolveQuery(topic, query);
+    }
+    // ****************** `SCRUB` CLEAN COMPLETED JOBS *****************
+    async scrub(jobId) {
+        await this.engine?.scrub(jobId);
+    }
+    // ****** `HOOK` ACTIVITY RE-ENTRY POINT ******
+    async hook(topic, data, dad) {
+        //return collation int
+        return await this.engine?.hook(topic, data, dad);
+    }
+    async hookAll(hookTopic, data, query, queryFacets = []) {
+        return await this.engine?.hookAll(hookTopic, data, query, queryFacets);
+    }
+    async stop() {
+        await StreamSignaler.stopConsuming();
+        this.engine?.task.cancelCleanup();
+    }
+    async compress(terms) {
+        return await this.engine?.compress(terms);
+    }
+}
+export { HotMeshService };

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

@@ -0,0 +1,17 @@
+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;
+    tagify(obj: Record<string, unknown>): string;
+}
+export { LoggerService, ILogger };

package/build/esm/services/logger/index.js

@@ -0,0 +1,70 @@
+import { createLogger, transports, format } from '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() {
+        return createLogger({
+            level: this.logLevel,
+            format: format.combine(format.colorize(), format.timestamp(), 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}`;
+            })),
+            transports: [new transports.Console()],
+        });
+    }
+    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);
+    }
+    tagify(obj) {
+        if (!obj) {
+            return '';
+        }
+        const tags = [];
+        try {
+            Object.entries(obj).forEach(([key, val]) => {
+                let value = val;
+                if (typeof val === 'function') {
+                    val = val();
+                }
+                if (val instanceof Date) {
+                    value = val.toISOString();
+                }
+                else if (typeof val === 'object' && val !== null) {
+                    value = JSON.stringify(val);
+                }
+                else {
+                    value = value ? value.toString() : value;
+                }
+                tags.push(`${key}:${value}`);
+            });
+        }
+        catch (err) {
+            this.error('tagify-error', err);
+        }
+        return tags.join(' ');
+    }
+}
+export { LoggerService };

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

@@ -0,0 +1,24 @@
+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;
+    /**
+     * resolve 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"
+     * @param value
+     * @returns
+     */
+    private resolve;
+    static evaluate(transitionRule: TransitionRule | boolean, context: JobState, code: StreamCode): boolean;
+}
+export { MapperService };

package/build/esm/services/mapper/index.js

@@ -0,0 +1,69 @@
+import { Pipe } from '../pipe';
+class MapperService {
+    constructor(rules, data) {
+        this.rules = rules;
+        this.data = data;
+    }
+    mapRules() {
+        return this.traverseRules(this.rules);
+    }
+    traverseRules(rules) {
+        if (typeof rules === 'object' && '@pipe' in rules) {
+            return this.pipe(rules['@pipe']);
+        }
+        if (typeof rules === 'object' && rules !== null) {
+            const mappedRules = {};
+            for (const key in rules) {
+                if (Object.prototype.hasOwnProperty.call(rules, key)) {
+                    mappedRules[key] = this.traverseRules(rules[key]);
+                }
+            }
+            return mappedRules;
+        }
+        else {
+            return this.resolve(rules);
+        }
+    }
+    /**
+     * resolve a pipe expression of the form: { @pipe: [["{data.foo.bar}", 2, false, "hello world"]] }
+     * @param value
+     * @returns
+     */
+    pipe(value) {
+        const pipe = new Pipe(value, this.data);
+        return pipe.process();
+    }
+    /**
+     * resolve a simple mapping expression in the form: "{data.foo.bar}" or 2 or false or "hello world"
+     * @param value
+     * @returns
+     */
+    resolve(value) {
+        const pipe = new Pipe([[value]], this.data);
+        return pipe.process();
+    }
+    static evaluate(transitionRule, context, code) {
+        if (typeof transitionRule === 'boolean') {
+            return transitionRule;
+        }
+        if (code.toString() === (transitionRule.code || 200).toString()) {
+            const orGate = transitionRule.gate === 'or';
+            let allAreTrue = true;
+            let someAreTrue = false;
+            transitionRule.match.forEach(({ expected, actual }) => {
+                if ((orGate && !someAreTrue) || (!orGate && allAreTrue)) {
+                    const result = Pipe.resolve(actual, context) === expected;
+                    if (orGate && result) {
+                        someAreTrue = true;
+                    }
+                    else if (!orGate && !result) {
+                        allAreTrue = false;
+                    }
+                }
+            });
+            return orGate ? someAreTrue : allAreTrue;
+        }
+        return false;
+    }
+}
+export { MapperService };

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

@@ -0,0 +1,24 @@
+declare class ArrayHandler {
+    get(array: any[], index: number): 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;
+    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[];
+    splice(array: any[], start: number, deleteCount?: number, ...items: any[]): any[];
+    unshift(array: any[], ...items: any[]): number;
+}
+export { ArrayHandler };

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

@@ -0,0 +1,66 @@
+class ArrayHandler {
+    get(array, index) {
+        return array[index];
+    }
+    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);
+    }
+    join(array, separator) {
+        return array.join(separator);
+    }
+    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);
+    }
+    reverse(array) {
+        return array.reverse();
+    }
+    shift(array) {
+        return array.shift();
+    }
+    slice(array, start, end) {
+        return array.slice(start, end);
+    }
+    some(array, callback) {
+        return array.some(callback);
+    }
+    sort(array, compareFunction) {
+        return array.sort(compareFunction);
+    }
+    splice(array, start, deleteCount, ...items) {
+        return array.splice(start, deleteCount, ...items);
+    }
+    unshift(array, ...items) {
+        return array.unshift(...items);
+    }
+}
+export { ArrayHandler };

package/build/esm/services/pipe/functions/bitwise.d.ts

@@ -0,0 +1,9 @@
+declare class BitwiseHandler {
+    and(a: number, b: number): number;
+    or(a: number, b: number): number;
+    xor(a: number, b: number): number;
+    leftShift(a: number, b: number): number;
+    rightShift(a: number, b: number): number;
+    unsignedRightShift(a: number, b: number): number;
+}
+export { BitwiseHandler };

package/build/esm/services/pipe/functions/bitwise.js

@@ -0,0 +1,21 @@
+class BitwiseHandler {
+    and(a, b) {
+        return a & b;
+    }
+    or(a, b) {
+        return a | b;
+    }
+    xor(a, b) {
+        return a ^ b;
+    }
+    leftShift(a, b) {
+        return a << b;
+    }
+    rightShift(a, b) {
+        return a >> b;
+    }
+    unsignedRightShift(a, b) {
+        return a >>> b;
+    }
+}
+export { BitwiseHandler };

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

@@ -0,0 +1,10 @@
+declare class ConditionalHandler {
+    ternary(condition: boolean, valueIfTrue: any, valueIfFalse: any): any;
+    equality(value1: any, value2: any): boolean;
+    strict_equality(value1: any, value2: any): boolean;
+    greater_than(value1: number, value2: number): boolean;
+    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;
+}
+export { ConditionalHandler };

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

@@ -0,0 +1,24 @@
+class ConditionalHandler {
+    ternary(condition, valueIfTrue, valueIfFalse) {
+        return condition ? valueIfTrue : valueIfFalse;
+    }
+    equality(value1, value2) {
+        return value1 == value2;
+    }
+    strict_equality(value1, value2) {
+        return value1 === value2;
+    }
+    greater_than(value1, value2) {
+        return value1 > value2;
+    }
+    less_than(value1, value2) {
+        return value1 < value2;
+    }
+    greater_than_or_equal(value1, value2) {
+        return value1 >= value2;
+    }
+    less_than_or_equal(value1, value2) {
+        return value1 <= value2;
+    }
+}
+export { ConditionalHandler };

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

@@ -0,0 +1,57 @@
+type DateInput = Date | string | number;
+declare class DateHandler {
+    /**
+     * It is so common in mapping operations to use a string (ISO) date as input. This helper
+     * method allows for a more-concise mapping ruleset by avoiding date initialization boilerplate
+     * code and instead handles the ISO, Milliseconds, and ECMAScript Date input types.
+     * @param input
+     * @returns
+     */
+    static getDateInstance(input: DateInput): Date;
+    fromISOString(isoString: string): Date;
+    now(): number;
+    parse(dateString: string): number;
+    getDate(date: DateInput): number;
+    getDay(date: DateInput): number;
+    getFullYear(date: DateInput): number;
+    getHours(date: DateInput): number;
+    getMilliseconds(date: DateInput): number;
+    getMinutes(date: DateInput): number;
+    getMonth(date: DateInput): number;
+    getSeconds(date: DateInput): number;
+    getTime(date: DateInput): number;
+    getTimezoneOffset(date: DateInput): number;
+    getUTCDate(date: DateInput): number;
+    getUTCDay(date: DateInput): number;
+    getUTCFullYear(date: DateInput): number;
+    getUTCHours(date: DateInput): number;
+    getUTCMilliseconds(date: DateInput): number;
+    getUTCMinutes(date: DateInput): number;
+    getUTCMonth(date: DateInput): number;
+    getUTCSeconds(date: DateInput): number;
+    setMilliseconds(date: DateInput, ms: number): number;
+    setMinutes(date: DateInput, minutes: number, seconds?: number, ms?: number): number;
+    setMonth(date: DateInput, month: number, day?: number): number;
+    setSeconds(date: DateInput, seconds: number, ms?: number): number;
+    setTime(date: DateInput, time: number): number;
+    setUTCDate(date: DateInput, day: number): number;
+    setUTCFullYear(date: DateInput, year: number, month?: number, day?: number): number;
+    setUTCHours(date: DateInput, hours: number, minutes?: number, seconds?: number, ms?: number): number;
+    setUTCMilliseconds(date: DateInput, ms: number): number;
+    setUTCMinutes(date: DateInput, minutes: number, seconds?: number, ms?: number): number;
+    setUTCMonth(date: DateInput, month: number, day?: number): number;
+    setUTCSeconds(date: DateInput, seconds: number, ms?: number): number;
+    setDate(date: DateInput, day: number): number;
+    setFullYear(date: DateInput, year: number, month?: number, day?: number): number;
+    setHours(date: DateInput, hours: number, minutes?: number, seconds?: number, ms?: number): number;
+    toDateString(date: DateInput): string;
+    toISOString(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;
+    toLocaleTimeString(date: DateInput, locales?: string | string[], options?: Intl.DateTimeFormatOptions): string;
+    toString(date: DateInput): string;
+    UTC(year: number, month: number, date?: number, hours?: number, minutes?: number, seconds?: number, ms?: number): number;
+    valueOf(date: DateInput): number;
+}
+export { DateHandler };