@hotmeshio/hotmesh 0.0.8 → 0.0.10

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

@@ -1,131 +0,0 @@
-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

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

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

@@ -1,70 +0,0 @@
-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

@@ -1,24 +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;
-    /**
-     * 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

@@ -1,72 +0,0 @@
-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()) {
-            if (!transitionRule.match) {
-                return true;
-            }
-            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

@@ -1,24 +0,0 @@
-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

@@ -1,66 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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 };