@hotmeshio/hotmesh 0.0.55 → 0.0.56

package/services/exporter/index.ts

@@ -1,146 +0,0 @@
-import { VALSEP } from '../../modules/key';
-import { ILogger } from '../logger';
-import { restoreHierarchy } from '../../modules/utils';
-import { SerializerService } from '../serializer';
-import { StoreService } from '../store';
-import {
-  DependencyExport,
-  ExportOptions,
-  JobActionExport,
-  JobExport } from '../../types/exporter';
-import { RedisClient, RedisMulti } from '../../types/redis';
-import {
-  StringAnyType,
-  StringStringType,
-  Symbols } from "../../types/serializer";
-
-/**
- * Downloads job data from Redis (hscan, hmget, hgetall)
- * Expands process data and includes dependency list
- */
-class ExporterService {
-  appId: string;
-  logger: ILogger;
-  store: StoreService<RedisClient, RedisMulti>;
-  symbols: Promise<Symbols> | Symbols;
-
-  constructor(appId: string, store: StoreService<RedisClient, RedisMulti>, logger: ILogger) {
-    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: string, options: ExportOptions = {}): Promise<JobExport> {
-    if (!this.symbols) {
-      this.symbols = this.store.getAllSymbols();
-      this.symbols = await this.symbols;
-    }
-    const depData = await this.store.getDependencies(jobId);
-    const jobData = await this.store.getRaw(jobId);
-    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: string): string {
-    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: StringStringType, dependencyList: string[]): JobExport {
-    //the list of actions taken in the workflow and hook functions
-    const actions: JobActionExport = {
-      hooks: {},
-      main: {
-        cursor: -1,
-        items: []
-      }
-    };
-    const process: StringAnyType = {};
-    const dependencies = this.inflateDependencyData(dependencyList, actions);
-    const regex = /^([a-zA-Z]{3}),(\d+(?:,\d+)*)/;
-
-    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, '/')}`;
-        const resolved = SerializerService.fromString(value);
-        process[`${dimensions}/${path}`] = resolved;
-      } else if (key.length === 3) {
-        //job state
-        process[this.inflateKey(key)] = SerializerService.fromString(value);
-      }
-    });
-    
-    return {
-      dependencies,
-      process: restoreHierarchy(process),
-      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: string[], actions: JobActionExport): DependencyExport[] {
-    const hookReg = /([0-9,]+)-(\d+)$/;
-    const flowReg = /-(\d+)$/;
-    return data.map((dependency, index: number): DependencyExport => {
-      const [action, topic, gid, _pd, ...jid] = dependency.split(VALSEP);
-      const jobId = jid.join(VALSEP);
-      const match = jobId.match(hookReg);
-      let prefix: string;
-      let type: 'hook' | 'flow' | 'other';
-      let dimensionKey: string = '';
-
-      if (match) {
-        //hook-originating dependency
-        const [_, dimension, counter] = match;
-        dimensionKey = dimension.split(',').join('/');
-        prefix = `${dimensionKey}[${counter}]`;
-        type = 'hook';
-      } 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';
-        }
-      }
-      return {
-        type: action,
-        topic,
-        gid,
-        jid: jobId,
-      } as unknown as DependencyExport;
-    });
-  }
-}
-
-export { ExporterService };

package/services/hotmesh/index.ts

@@ -1,237 +0,0 @@
-import { HMNS } from '../../modules/key';
-import { guid } from '../../modules/utils';
-import { RedisConnection } from '../connector/clients/redis';
-import { RedisConnection as IORedisConnection } from '../connector/clients/ioredis';
-import { EngineService } from '../engine';
-import { LoggerService, ILogger } from '../logger';
-import { QuorumService } from '../quorum';
-import { Router } from '../router';
-import { WorkerService } from '../worker';
-import {
-  JobState,
-  JobData,
-  JobOutput, 
-  JobStatus, 
-  JobInterruptOptions,
-  ExtensionType} from '../../types/job';
-import {
-  HotMeshConfig,
-  HotMeshManifest } from '../../types/hotmesh';
-import { JobMessageCallback, QuorumProfile, ThrottleMessage, ThrottleOptions } from '../../types/quorum';
-import {
-  JobStatsInput,
-  GetStatsOptions,
-  IdsResponse,
-  StatsResponse } from '../../types/stats';
-import { ConnectorService } from '../connector';
-import { StreamCode, StreamData, StreamDataResponse, StreamStatus } from '../../types/stream';
-import { StringAnyType, StringStringType } from '../../types/serializer';
-import { JobExport } from '../../types/exporter';
-
-class HotMeshService {
-  namespace: string;
-  appId: string;
-  guid: string;
-  engine: EngineService | null = null;
-  quorum: QuorumService | null = null;
-  workers: WorkerService[] = [];
-  logger: ILogger;
-
-  static disconnecting = false;
-
-  verifyAndSetNamespace(namespace?: string) {
-    if (!namespace) {
-      this.namespace = HMNS;
-    } else if (!namespace.match(/^[A-Za-z0-9-]+$/)) {
-      throw new Error(`config.namespace [${namespace}] is invalid`);
-    } else {
-      this.namespace = namespace;
-    }
-  }
-
-  verifyAndSetAppId(appId: string) {
-    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: HotMeshConfig) {
-    const instance = new HotMeshService();
-    instance.guid = guid();
-    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.doWork(config, instance.logger);
-    return instance;
-  }
-
-  static guid(): string {
-    return guid();
-  }
-
-  async initEngine(config: HotMeshConfig, logger: ILogger): Promise<void> {
-    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: HotMeshConfig, engine: EngineService, logger: ILogger): Promise<void> {
-    if (engine) {
-      this.quorum = await QuorumService.init(
-        this.namespace,
-        this.appId,
-        this.guid,
-        config,
-        engine,
-        logger
-      );
-    }
-  }
-
-  async doWork(config: HotMeshConfig, logger: ILogger) {
-    this.workers = await WorkerService.init(
-      this.namespace,
-      this.appId,
-      this.guid,
-      config,
-      logger
-    );
-  }
-
-  // ************* PUB/SUB METHODS *************
-  async pub(topic: string, data: JobData = {}, context?: JobState, extended?: ExtensionType): Promise<string> {
-    return await this.engine?.pub(topic, data, context, extended);
-  }
-  async sub(topic: string, callback: JobMessageCallback): Promise<void> {
-    return await this.engine?.sub(topic, callback);
-  }
-  async unsub(topic: string): Promise<void> {
-    return await this.engine?.unsub(topic);
-  }
-  async psub(wild: string, callback: JobMessageCallback): Promise<void> {
-    return await this.engine?.psub(wild, callback);
-  }
-  async punsub(wild: string): Promise<void> {
-    return await this.engine?.punsub(wild);
-  }
-  async pubsub(topic: string, data: JobData = {}, context?: JobState | null, timeout?: number): Promise<JobOutput> {
-    return await this.engine?.pubsub(topic, data, context, timeout);
-  }
-  async add(streamData: StreamData|StreamDataResponse): Promise<string> {
-    return await this.engine.add(streamData) as string;
-  }
-
-
-  // ************* QUORUM METHODS *************
-  async rollCall(delay?: number): Promise<QuorumProfile[]> {
-    return await this.quorum?.rollCall(delay);
-  }
-  async throttle(options: ThrottleOptions): Promise<boolean> {
-    const throttleMessage: ThrottleMessage = {
-      type: 'throttle',
-      throttle: options.throttle,
-    };
-    if (options.guid) {
-      throttleMessage.guid = options.guid;
-    } else if (options.topic) {
-      throttleMessage.topic = options.topic;
-    }
-    return await this.quorum?.pub(throttleMessage);
-  }
-
-  // ************* COMPILER METHODS *************
-  async plan(path: string): Promise<HotMeshManifest> {
-    return await this.engine?.plan(path);
-  }
-  async deploy(pathOrYAML: string): Promise<HotMeshManifest> {
-    return await this.engine?.deploy(pathOrYAML);
-  }
-  async activate(version: string, delay?: number): Promise<boolean> {
-    //activation is a quorum operation
-    return await this.quorum?.activate(version, delay);
-  }
-
-  // ************* REPORTER METHODS *************
-  async export(jobId: string): Promise<JobExport> {
-    return await this.engine?.export(jobId);
-  }
-  async getRaw(jobId: string): Promise<StringStringType> {
-    return await this.engine?.getRaw(jobId);
-  }
-  async getStats(topic: string, query: JobStatsInput): Promise<StatsResponse> {
-    return await this.engine?.getStats(topic, query);
-  }
-  async getStatus(jobId: string): Promise<JobStatus> {
-    return this.engine?.getStatus(jobId);
-  }
-  async getState(topic: string, jobId: string): Promise<JobOutput> {
-    return this.engine?.getState(topic, jobId);
-  }
-  async getQueryState(jobId: string, fields: string[]): Promise<StringAnyType> {
-    return await this.engine?.getQueryState(jobId, fields);
-  }
-  async getIds(topic: string, query: JobStatsInput, queryFacets = []): Promise<IdsResponse> {
-    return await this.engine?.getIds(topic, query, queryFacets);
-  }
-  async resolveQuery(topic: string, query: JobStatsInput): Promise<GetStatsOptions> {
-    return await this.engine?.resolveQuery(topic, query);
-  }
-
-  // ****************** `INTERRUPT` ACTIVE JOBS *****************
-  async interrupt(topic: string, jobId: string, options: JobInterruptOptions = {}): Promise<string> {
-    return await this.engine?.interrupt(topic, jobId, options);
-  }
-
-  // ****************** `SCRUB` CLEAN COMPLETED JOBS *****************
-  async scrub(jobId: string) {
-    await this.engine?.scrub(jobId);
-  }
-
-  // ****** `HOOK` ACTIVITY RE-ENTRY POINT ******
-  async hook(topic: string, data: JobData, status?: StreamStatus, code?: StreamCode): Promise<string> {
-    return await this.engine?.hook(topic, data, status, code);
-  }
-  async hookAll(hookTopic: string, data: JobData, query: JobStatsInput, queryFacets: string[] = []): Promise<string[]> {
-    return await this.engine?.hookAll(hookTopic, data, query, queryFacets);
-  }
-
-  static async stop() {
-    if (!this.disconnecting) {
-      this.disconnecting = true;
-      await Router.stopConsuming();
-      await RedisConnection.disconnectAll();
-      await IORedisConnection.disconnectAll();
-    }
-  }
-
-  stop() {
-    this.engine?.taskService.cancelCleanup();
-    this.quorum?.stop();
-    this.workers?.forEach((worker: WorkerService) => {
-      worker.stop();
-    });
-  }
-
-  async compress(terms: string[]): Promise<boolean> {
-    return await this.engine?.compress(terms);
-  }
-}
-
-export { HotMeshService };

package/services/logger/index.ts

@@ -1,79 +0,0 @@
-import { Logger, createLogger, transports, format } from 'winston';
-import { ILogger } from '../../types/logger';
-
-class LoggerService implements ILogger {
-  private logger: Logger;
-
-  constructor(private appId: string = 'appId', private instanceId: string = 'instanceId', private name: string = 'name', private logLevel: string = 'info', customLogger?: Logger) {
-    this.logger = customLogger || this.createDefaultLogger();
-  }
-
-  private createDefaultLogger(): Logger {
-    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: string, ...meta: any[]): void {
-    this.logger.info(message, ...meta);
-  }
-
-  error(message: string, ...meta: any[]): void {
-    this.logger.error(message, ...meta);
-  }
-
-  warn(message: string, ...meta: any[]): void {
-    this.logger.warn(message, ...meta);
-  }
-
-  debug(message: string, ...meta: any[]): void {
-    this.logger.debug(message, ...meta);
-  }
-
-  tagify(obj: Record<string, unknown>): string {
-    if (!obj) {
-      return '';
-    }
-    const tags: string[] = [];
-    try {
-      Object.entries(obj).forEach(([key, val]) => {
-        let value: any = 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, ILogger };

package/services/mapper/index.ts

@@ -1,89 +0,0 @@
-import { Pipe } from '../pipe';
-import { JobState } from '../../types/job';
-import { Pipe as PipeType } from '../../types/pipe';
-import { TransitionMatch, TransitionRule } from '../../types/transition';
-import { StreamCode } from '../../types';
-
-type RuleType = null | undefined | boolean | string | number | Date | Record<string, any>;
-
-class MapperService {
-  private rules: Record<string, unknown>;
-  private data: JobState;
-
-  constructor(rules: Record<string, unknown>, data: JobState) {
-    this.rules = rules;
-    this.data = data;
-  }
-
-  public mapRules(): Record<string, unknown> {
-    return this.traverseRules(this.rules);
-  }
-
-  private traverseRules(rules: RuleType): Record<string, unknown> {
-    if (typeof rules === 'object' && '@pipe' in rules) {
-      return this.pipe(rules['@pipe'] as PipeType);
-    } if (typeof rules === 'object' && rules !== null) {
-      const mappedRules: Record<string, any> = {};
-      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);
-    }
-  }
-
-  /**
-   * resolves a pipe expression of the form: { @pipe: [["{data.foo.bar}", 2, false, "hello world"]] }
-   * @param value 
-   * @returns 
-   */
-  private pipe(value: PipeType): any {
-    const pipe = new 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 
-   */
-  private resolve(value: any): any {
-    const pipe = new 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: TransitionRule | boolean, context: JobState, code: StreamCode): boolean {
-    if (typeof transitionRule === 'boolean') {
-      return transitionRule;
-    }
-    if ((Array.isArray(transitionRule.code) && transitionRule.code.includes(code || 200)) || 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 }: TransitionMatch) => {
-        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/services/pipe/functions/array.ts

@@ -1,78 +0,0 @@
-class ArrayHandler {
-  get(array: any[], index: number): any {
-    return array?.[index || 0];
-  }
-
-  length(array: any[]): any {
-    return array?.length;
-  }
-
-  concat(array1: any[], array2: any[]): any[] {
-    return array1.concat(array2);
-  }
-
-  indexOf(array: any[], searchElement: any, fromIndex?: number): number {
-    return array.indexOf(searchElement, fromIndex);
-  }
-
-  join(array: any[], separator: string): string {
-    return array.join(separator);
-  }
-
-  lastIndexOf(array: any[], searchElement: any, fromIndex?: number): number {
-    return array.lastIndexOf(searchElement, fromIndex);
-  }
-
-  pop(array: any[]): any {
-    return array.pop();
-  }
-
-  push(array: any[], ...items: any[]): any[] {
-    array.push(...items);
-    return array;
-  }
-
-  reverse(array: any[]): any[] {
-    return array.reverse();
-  }
-
-  shift(array: any[]): any {
-    return array.shift();
-  }
-
-  slice(array: any[], start?: number, end?: number): any[] {
-    return array.slice(start, end);
-  }
-
-  sort(array: any[], order: 'ASCENDING' | 'DESCENDING' = 'ASCENDING'): any[] {
-    return array.sort((a, b) => {
-      if (order === 'ASCENDING') {
-        if (a === b) return 0;
-        if (a === null || a === undefined) return -1;
-        if (b === null || b === undefined) return 1;
-        if (typeof a === 'string' && typeof b === 'string') {
-          return a.localeCompare(b);
-        }
-        return a < b ? -1 : 1;
-      } else {
-        if (a === b) return 0;
-        if (a === null || a === undefined) return 1;
-        if (b === null || b === undefined) return -1;
-        if (typeof a === 'string' && typeof b === 'string') {
-          return b.localeCompare(a);
-        }
-        return a > b ? -1 : 1;
-      }
-    });
-  }
-
-  splice(array: any[], start: number, deleteCount?: number, ...items: any[]): any[] {
-    return array.splice(start, deleteCount, ...items);
-  }
-
-  unshift(array: any[], ...items: any[]): number {
-    return array.unshift(...items);
-  }
-}
-
-export { ArrayHandler };

package/services/pipe/functions/bitwise.ts

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

package/services/pipe/functions/conditional.ts

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