@hotmeshio/hotmesh 0.0.8 → 0.0.10

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

@@ -1,66 +0,0 @@
-class StringHandler {
-    split(input, delimiter) {
-        return input.split(delimiter);
-    }
-    charAt(input, index) {
-        return input.charAt(index);
-    }
-    concat(...strings) {
-        return strings.join('');
-    }
-    includes(input, searchString, position) {
-        return input.includes(searchString, position);
-    }
-    indexOf(input, searchString, fromIndex) {
-        return input.indexOf(searchString, fromIndex);
-    }
-    lastIndexOf(input, searchString, fromIndex) {
-        return input.lastIndexOf(searchString, fromIndex);
-    }
-    slice(input, start, end) {
-        return input.slice(start, end);
-    }
-    toLowerCase(input) {
-        return input.toLowerCase();
-    }
-    toUpperCase(input) {
-        return input.toUpperCase();
-    }
-    trim(input) {
-        return input.trim();
-    }
-    trimStart(input) {
-        return input.trimStart();
-    }
-    trimEnd(input) {
-        return input.trimEnd();
-    }
-    padStart(input, maxLength, padString) {
-        return input.padStart(maxLength, padString);
-    }
-    padEnd(input, maxLength, padString) {
-        return input.padEnd(maxLength, padString);
-    }
-    replace(input, searchValue, replaceValue) {
-        return input.replace(searchValue, replaceValue);
-    }
-    search(input, regexp) {
-        return input.search(regexp);
-    }
-    substring(input, start, end) {
-        return input.substring(start, end);
-    }
-    startsWith(str, searchString, position) {
-        return str.startsWith(searchString, position);
-    }
-    endsWith(str, searchString, length) {
-        return str.endsWith(searchString, length);
-    }
-    repeat(str, count) {
-        if (count < 0 || count === Infinity) {
-            throw new RangeError('Invalid repeat count. Must be a positive finite number.');
-        }
-        return str.repeat(count);
-    }
-}
-export { StringHandler };

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

@@ -1,12 +0,0 @@
-declare class SymbolHandler {
-    null(): null;
-    undefined(): undefined;
-    whitespace(): string;
-    object(): object;
-    array(): any[];
-    posInfinity(): number;
-    negInfinity(): number;
-    NaN(): number;
-    date(): Date;
-}
-export { SymbolHandler };

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

@@ -1,30 +0,0 @@
-class SymbolHandler {
-    null() {
-        return null;
-    }
-    undefined() {
-        return undefined;
-    }
-    whitespace() {
-        return ' ';
-    }
-    object() {
-        return {};
-    }
-    array() {
-        return [];
-    }
-    posInfinity() {
-        return Infinity;
-    }
-    negInfinity() {
-        return -Infinity;
-    }
-    NaN() {
-        return NaN;
-    }
-    date() {
-        return new Date();
-    }
-}
-export { SymbolHandler };

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

@@ -1,7 +0,0 @@
-declare class UnaryHandler {
-    not(value: boolean): boolean;
-    positive(value: number): number;
-    negative(value: number): number;
-    bitwise_not(value: number): number;
-}
-export { UnaryHandler };

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

@@ -1,15 +0,0 @@
-class UnaryHandler {
-    not(value) {
-        return !value;
-    }
-    positive(value) {
-        return +value;
-    }
-    negative(value) {
-        return -value;
-    }
-    bitwise_not(value) {
-        return ~value;
-    }
-}
-export { UnaryHandler };

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

@@ -1,30 +0,0 @@
-import { JobState, JobData } from '../../types/job';
-import { PipeItem, PipeItems, Pipe as PipeType } from '../../types/pipe';
-declare class Pipe {
-    rules: PipeType;
-    jobData: JobData;
-    constructor(rules: PipeType, jobData: JobData);
-    private isPipeType;
-    static isPipeObject(obj: {
-        [key: string]: unknown;
-    } | PipeItem): boolean;
-    static resolve(unresolved: {
-        [key: string]: unknown;
-    } | PipeItem, context: Partial<JobState>): any;
-    /**
-     * loop through each PipeItem row in this Pipe, resolving and transforming line by line
-     * @returns {any} the result of the pipe
-     */
-    process(): any;
-    private processRow;
-    static resolveFunction(functionName: string): any;
-    processCells(cells: PipeItems): unknown[];
-    private isFunction;
-    private isMappable;
-    resolveCellValue(currentCell: PipeItem): unknown;
-    private getNestedProperty;
-    resolveMappableValue(currentCell: string): unknown;
-    resolveFunctionTerm(currentCell: string): string;
-    resolveMapTerm(currentCell: string): string;
-}
-export { Pipe };

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

@@ -1,122 +0,0 @@
-import FUNCTIONS from './functions';
-class Pipe {
-    constructor(rules, jobData) {
-        this.rules = rules;
-        this.jobData = jobData;
-    }
-    isPipeType(currentRow) {
-        return !Array.isArray(currentRow) && '@pipe' in currentRow;
-    }
-    static isPipeObject(obj) {
-        return typeof obj === 'object' && obj !== null && !Array.isArray(obj) && '@pipe' in obj;
-    }
-    static resolve(unresolved, context) {
-        let pipe;
-        if (Pipe.isPipeObject(unresolved)) {
-            pipe = new Pipe(unresolved['@pipe'], context);
-        }
-        else {
-            pipe = new Pipe([[unresolved]], context);
-        }
-        return pipe.process();
-    }
-    /**
-     * loop through each PipeItem row in this Pipe, resolving and transforming line by line
-     * @returns {any} the result of the pipe
-     */
-    process() {
-        let resolved = this.processCells(this.rules[0]);
-        const len = this.rules.length;
-        for (let i = 1; i < len; i++) {
-            resolved = this.processRow(this.rules[i], resolved, []);
-        }
-        return resolved[0];
-    }
-    processRow(currentRow, resolvedPriorRow, subPipeQueue) {
-        if (this.isPipeType(currentRow)) {
-            //currentRow is a recursive subPipe
-            const subPipe = new Pipe(currentRow['@pipe'], this.jobData);
-            subPipeQueue.push(subPipe.process());
-            //return prior row as if nothing happened
-            return resolvedPriorRow;
-        }
-        else {
-            if (subPipeQueue.length > 0) {
-                //if items in subPipeQueue, flush and use as resolvedPriorRow
-                resolvedPriorRow = [...subPipeQueue];
-                subPipeQueue.length = 0;
-            }
-            else if (!resolvedPriorRow) {
-                //if no prior row, use current row as prior row
-                return [].concat(this.processCells([...currentRow]));
-            }
-            else {
-                const [functionName, ...params] = currentRow;
-                //use resolved values from prior row (n - 1) as input params to cell 1 function
-                const resolvedValue = Pipe.resolveFunction(functionName)(...resolvedPriorRow);
-                //resolve remaining cells in row and return concatenated with resolvedValue
-                return [resolvedValue].concat(this.processCells([...params]));
-            }
-        }
-    }
-    static resolveFunction(functionName) {
-        let [prefix, suffix] = functionName.split('.');
-        prefix = prefix.substring(2);
-        suffix = suffix.substring(0, suffix.length - 1);
-        const domain = FUNCTIONS[prefix];
-        if (!domain) {
-            throw new Error(`Unknown domain name [${functionName}]: ${prefix}`);
-        }
-        if (!domain[suffix]) {
-            throw new Error(`Unknown domain function [${functionName}]: ${prefix}.${suffix}`);
-        }
-        return domain[suffix];
-    }
-    processCells(cells) {
-        const resolved = [];
-        for (const currentCell of cells) {
-            resolved.push(this.resolveCellValue(currentCell));
-        }
-        return resolved;
-    }
-    isFunction(currentCell) {
-        return typeof currentCell === 'string' && currentCell.startsWith('{@') && currentCell.endsWith('}');
-    }
-    isMappable(currentCell) {
-        return typeof currentCell === 'string' && currentCell.startsWith('{') && currentCell.endsWith('}');
-    }
-    resolveCellValue(currentCell) {
-        if (this.isFunction(currentCell)) {
-            const fn = Pipe.resolveFunction(currentCell);
-            return fn.call();
-        }
-        else if (this.isMappable(currentCell)) {
-            return this.resolveMappableValue(currentCell);
-        }
-        else {
-            return currentCell;
-        }
-    }
-    getNestedProperty(obj, path) {
-        const pathParts = path.split('.');
-        let current = obj;
-        for (const part of pathParts) {
-            if (current === null || typeof current !== 'object' || !current.hasOwnProperty(part)) {
-                return undefined;
-            }
-            current = current[part];
-        }
-        return current;
-    }
-    resolveMappableValue(currentCell) {
-        const term = this.resolveMapTerm(currentCell);
-        return this.getNestedProperty(this.jobData, term);
-    }
-    resolveFunctionTerm(currentCell) {
-        return currentCell.substring(2, currentCell.length - 1);
-    }
-    resolveMapTerm(currentCell) {
-        return currentCell.substring(1, currentCell.length - 1);
-    }
-}
-export { Pipe };

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

@@ -1,34 +0,0 @@
-import { EngineService } from '../engine';
-import { ILogger } from '../logger';
-import { StoreService } from '../store';
-import { SubService } from '../sub';
-import { CacheMode } from '../../types/cache';
-import { QuorumMessageCallback, SubscriptionCallback, ThrottleMessage } from '../../types/quorum';
-import { HotMeshApps, HotMeshConfig } from '../../types/hotmesh';
-import { RedisClient, RedisMulti } from '../../types/redis';
-declare class QuorumService {
-    namespace: string;
-    apps: HotMeshApps | null;
-    appId: string;
-    guid: string;
-    engine: EngineService;
-    store: StoreService<RedisClient, RedisMulti> | null;
-    subscribe: SubService<RedisClient, RedisMulti> | null;
-    logger: ILogger;
-    cacheMode: CacheMode;
-    untilVersion: string | null;
-    quorum: number | null;
-    callbacks: QuorumMessageCallback[];
-    static init(namespace: string, appId: string, guid: string, config: HotMeshConfig, engine: EngineService, logger: ILogger): Promise<QuorumService>;
-    verifyQuorumFields(config: HotMeshConfig): void;
-    initStoreChannel(store: RedisClient): Promise<void>;
-    initSubChannel(sub: RedisClient): Promise<void>;
-    subscriptionHandler(): SubscriptionCallback;
-    sayPong(appId: string, guid: string, originator: string): Promise<void>;
-    requestQuorum(delay?: number): Promise<number>;
-    pub(quorumMessage: ThrottleMessage): Promise<boolean>;
-    sub(callback: QuorumMessageCallback): Promise<void>;
-    unsub(callback: QuorumMessageCallback): Promise<void>;
-    activate(version: string, delay?: number): Promise<boolean>;
-}
-export { QuorumService };

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

@@ -1,144 +0,0 @@
-import { KeyType } from '../../modules/key';
-import { identifyRedisType, sleepFor } from '../../modules/utils';
-import { CompilerService } from '../compiler';
-import { RedisStoreService as RedisStore } from '../store/clients/redis';
-import { IORedisStoreService as IORedisStore } from '../store/clients/ioredis';
-import { IORedisSubService as IORedisSub } from '../sub/clients/ioredis';
-import { RedisSubService as RedisSub } from '../sub/clients/redis';
-//wait time to see if quorum is reached
-const QUORUM_DELAY = 250;
-class QuorumService {
-    constructor() {
-        this.cacheMode = 'cache';
-        this.untilVersion = null;
-        this.quorum = null;
-        this.callbacks = [];
-    }
-    static async init(namespace, appId, guid, config, engine, logger) {
-        if (config.engine) {
-            const instance = new QuorumService();
-            instance.verifyQuorumFields(config);
-            instance.namespace = namespace;
-            instance.appId = appId;
-            instance.guid = guid;
-            instance.logger = logger;
-            instance.engine = engine;
-            //note: `quorum` shares/re-uses the engine's `store`/`sub` Redis clients
-            await instance.initStoreChannel(config.engine.store);
-            await instance.initSubChannel(config.engine.sub);
-            await instance.subscribe.subscribe(KeyType.QUORUM, instance.subscriptionHandler(), appId); //general quorum subscription
-            await instance.subscribe.subscribe(KeyType.QUORUM, instance.subscriptionHandler(), appId, instance.guid); //app-specific quorum subscription (used for pubsub one-time request/response)
-            instance.engine.processWebHooks();
-            instance.engine.processTimeHooks();
-            return instance;
-        }
-    }
-    verifyQuorumFields(config) {
-        if (!identifyRedisType(config.engine.store) ||
-            !identifyRedisType(config.engine.sub)) {
-            throw new Error('quorum config must include `store` and `sub` fields.');
-        }
-    }
-    async initStoreChannel(store) {
-        if (identifyRedisType(store) === 'redis') {
-            this.store = new RedisStore(store);
-        }
-        else {
-            this.store = new IORedisStore(store);
-        }
-        await this.store.init(this.namespace, this.appId, this.logger);
-    }
-    async initSubChannel(sub) {
-        if (identifyRedisType(sub) === 'redis') {
-            this.subscribe = new RedisSub(sub);
-        }
-        else {
-            this.subscribe = new IORedisSub(sub);
-        }
-        await this.subscribe.init(this.namespace, this.appId, this.guid, this.logger);
-    }
-    subscriptionHandler() {
-        const self = this;
-        return async (topic, message) => {
-            self.logger.debug('quorum-event-received', { topic, type: message.type });
-            if (message.type === 'activate') {
-                self.engine.setCacheMode(message.cache_mode, message.until_version);
-            }
-            else if (message.type === 'ping') {
-                this.sayPong(self.appId, self.guid, message.originator);
-            }
-            else if (message.type === 'pong' && self.guid === message.originator) {
-                self.quorum = self.quorum + 1;
-            }
-            else if (message.type === 'throttle') {
-                self.engine.throttle(message.throttle);
-            }
-            else if (message.type === 'work') {
-                self.engine.processWebHooks();
-            }
-            else if (message.type === 'job') {
-                self.engine.routeToSubscribers(message.topic, message.job);
-            }
-            //if there are any callbacks, call them
-            if (self.callbacks.length > 0) {
-                self.callbacks.forEach(cb => cb(topic, message));
-            }
-        };
-    }
-    async sayPong(appId, guid, originator) {
-        this.store.publish(KeyType.QUORUM, { type: 'pong', guid, originator }, appId);
-    }
-    async requestQuorum(delay = QUORUM_DELAY) {
-        const quorum = this.quorum;
-        this.quorum = 0;
-        await this.store.publish(KeyType.QUORUM, { type: 'ping', originator: this.guid }, this.appId);
-        await sleepFor(delay);
-        return quorum;
-    }
-    // ************* PUB/SUB METHODS *************
-    //publish a message to the quorum
-    async pub(quorumMessage) {
-        return await this.store.publish(KeyType.QUORUM, quorumMessage, this.appId, quorumMessage.topic || quorumMessage.guid);
-    }
-    //subscribe user to quorum messages
-    async sub(callback) {
-        //the quorum is always subscribed to the `quorum` topic; just register the fn
-        this.callbacks.push(callback);
-    }
-    //unsubscribe user from quorum messages
-    async unsub(callback) {
-        //the quorum is always subscribed to the `quorum` topic; just unregister the fn
-        this.callbacks = this.callbacks.filter(cb => cb !== callback);
-    }
-    // ************* COMPILER METHODS *************
-    async activate(version, delay = QUORUM_DELAY) {
-        version = version.toString();
-        const config = await this.engine.getVID();
-        //request a quorum to activate the version
-        await this.requestQuorum(delay);
-        const q1 = await this.requestQuorum(delay);
-        const q2 = await this.requestQuorum(delay);
-        const q3 = await this.requestQuorum(delay);
-        if (q1 && q1 === q2 && q2 === q3) {
-            this.logger.info('quorum-rollcall-succeeded', { q1, q2, q3 });
-            this.store.publish(KeyType.QUORUM, { type: 'activate', cache_mode: 'nocache', until_version: version }, this.appId);
-            await new Promise(resolve => setTimeout(resolve, delay));
-            //confirm we received the activation message
-            if (this.engine.untilVersion === version) {
-                this.logger.info('quorum-activation-succeeded', { version });
-                const { id } = config;
-                const compiler = new CompilerService(this.store, this.logger);
-                return await compiler.activate(id, version);
-            }
-            else {
-                this.logger.error('quorum-activation-error', { version });
-                throw new Error(`UntilVersion Not Received. Version ${version} not activated`);
-            }
-        }
-        else {
-            this.logger.info('quorum-rollcall-error', { q1, q2, q3 });
-            throw new Error(`Quorum not reached. Version ${version} not activated.`);
-        }
-    }
-}
-export { QuorumService };

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

@@ -1,47 +0,0 @@
-import { ILogger } from '../logger';
-import { StoreService } from '../store';
-import { TriggerActivity } from '../../types/activity';
-import { AppVID } from '../../types/app';
-import { JobState } from '../../types/job';
-import { RedisClient, RedisMulti } from '../../types/redis';
-import { GetStatsOptions, StatsResponse, IdsResponse, StatsType, StatType } from '../../types/stats';
-declare class ReporterService {
-    private appVersion;
-    private logger;
-    private store;
-    static DEFAULT_GRANULARITY: string;
-    constructor(appVersion: AppVID, store: StoreService<RedisClient, RedisMulti>, logger: ILogger);
-    getStats(options: GetStatsOptions): Promise<StatsResponse>;
-    private validateOptions;
-    private generateDateTimeSets;
-    private convertRangeToMinutes;
-    private buildRedisKey;
-    private aggregateData;
-    private buildStatsResponse;
-    private handleSegments;
-    private isoTimestampFromKeyTimestamp;
-    getIds(options: GetStatsOptions, facets: string[], idRange?: [number, number]): Promise<IdsResponse>;
-    private buildIdsResponse;
-    private buildTimeSegments;
-    getUniqueFacets(data: StatsResponse): string[];
-    getTargetForKey(key: string): string;
-    getTargetForTime(key: string): string;
-    getWorkItems(options: GetStatsOptions, facets: string[]): Promise<string[]>;
-    private buildWorkerLists;
-    /**
-     * called by `trigger` activity to generate the stats that should
-     * be saved to the database. doesn't actually save the stats, but
-     * just generates the info that should be saved
-     */
-    resolveTriggerStatistics({ stats: statsConfig }: TriggerActivity, context: JobState): StatsType;
-    isGeneralMetric(metric: string): boolean;
-    isMedianMetric(metric: string): boolean;
-    isIndexMetric(metric: string): boolean;
-    resolveMetric({ metric, target }: {
-        metric: any;
-        target: any;
-    }, context: JobState): StatType;
-    isCardinalMetric(metric: string): boolean;
-    resolveTarget(metric: string, target: string, resolvedValue: string): string;
-}
-export { ReporterService };