@hotmeshio/hotmesh 0.0.55 → 0.0.56

package/modules/key.ts

@@ -1,101 +0,0 @@
-import { KeyStoreParams, KeyType } from '../types/hotmesh';
-
-/**
- * Keys
- * 
- * hmsh ->                                            {hash}    hotmesh config {version: "0.0.1", namespace: "hmsh"}
- * hmsh:a:<appid> ->                                  {hash}    app profile { "id": "appid", "version": "2", "versions/1": "GMT", "versions/2": "GMT"}
- * hmsh:<appid>:e:<engineId> ->                       {string}  setnx to ensure only one engine of given id
- * hmsh:<appid>:w: ->                                 {zset}    work items/tasks an engine must do like garbage collect or hook a set of matching records (hookAll)
- * hmsh:<appid>:t: ->                                 {zset}    an ordered set of list (work lists) ids
- * hmsh:<appid>:t:<timeValue?> ->                     {list}    a worklist of `jobId+activityId` items that should be awakened
- * hmsh:<appid>:q: ->                                 {hash}    quorum-wide messages
- * hmsh:<appid>:q:<ngnid> ->                          {hash}    engine-targeted messages (targeted quorum-oriented message)
- * hmsh:<appid>:j:<jobid> ->                          {hash}    job data
- * hmsh:<appid>:j:<jobid>:<activityid>  ->            {hash}    job activity data (a1)
- * hmsh:<appid>:s:<jobkey>:<dateTime> ->              {hash}    job stats (general)
- * hmsh:<appid>:s:<jobkey>:<dateTime>:mdn:<field/path>:<fieldvalue> ->      {zset}    job stats (median)
- * hmsh:<appid>:s:<jobkey>:<dateTime>:index:<field/path>:<fieldvalue> ->    {list}    job stats (index of jobid[])
- * hmsh:<appid>:v:<version>:activities ->             {hash}    schemas [cache]
- * hmsh:<appid>:v:<version>:transitions ->            {hash}    transitions [cache]
- * hmsh:<appid>:v:<version>:subscriptions ->          {hash}    subscriptions [cache]
- * hmsh:<appid>:x: ->                                 {xstream} when an engine is sent or reads a buffered task (engines read from their custom topic)
- * hmsh:<appid>:x:<topic> ->                          {xstream} when a worker is sent or reads a buffered task (workers read from their custom topic)
- * hmsh:<appid>:hooks ->                              {hash}    hook patterns/rules; set at compile time
- * hmsh:<appid>:signals ->                            {hash}    dynamic hook signals (hget/hdel) when resolving (always self-clean); added/removed at runtime
- * hmsh:<appid>:sym:keys: ->                          {hash}    list of symbol ranges and :cursor assigned at version deploy time for job keys
- * hmsh:<appid>:sym:keys:<activityid|$subscribes> ->  {hash}    list of symbols based upon schema enums (initially) and adaptively optimized (later) during runtime; if '$subscribes' is used as the activityid, it is a top-level `job` symbol set (for job keys)
- * hmsh:<appid>:sym:vals: ->                          {hash}    list of symbols for job values across all app versions
- */
-
-const HMNS = "hmsh";
-
-const KEYSEP = ':';  //default delimiter for keys 
-const VALSEP = '::'; //default delimiter for vals
-const WEBSEP = '::'; //default delimiter for webhook vals
-const TYPSEP = '::'; //delimiter for ZSET task typing (how should a list be used?)
-
-class KeyService {
-
-  /**
-   * returns a key that can be used to access a value in the key/value store
-   * appropriate for the given key type; the keys have an implicit hierarchy
-   * and are used to organize data in the store in a tree-like structure
-   * via the use of colons as separators. The top-level entity is the hmsh manifest.
-   * This file will reveal the full scope of what is on the server (apps, versions, etc)
-   * @param namespace 
-   * @param keyType 
-   * @param params 
-   * @returns {string}
-   */
-  static mintKey(namespace: string, keyType: KeyType, params: KeyStoreParams): string {
-    switch (keyType) {
-      case KeyType.HOTMESH:
-        return namespace;
-      case KeyType.ENGINE_ID:
-        return `${namespace}:${params.appId}:e:${params.engineId}`;
-      case KeyType.WORK_ITEMS:
-        return `${namespace}:${params.appId}:w:${params.scoutType || ''}`;
-      case KeyType.TIME_RANGE:
-        return `${namespace}:${params.appId}:t:${params.timeValue || ''}`;
-      case KeyType.APP:
-        return `${namespace}:a:${params.appId || ''}`;
-      case KeyType.QUORUM:
-        return `${namespace}:${params.appId}:q:${params.engineId || ''}`;
-      case KeyType.JOB_STATE:
-          return `${namespace}:${params.appId}:j:${params.jobId}`;
-      case KeyType.JOB_DEPENDENTS:
-        return `${namespace}:${params.appId}:d:${params.jobId}`;
-      case KeyType.JOB_STATS_GENERAL:
-        return `${namespace}:${params.appId}:s:${params.jobKey}:${params.dateTime}`;
-      case KeyType.JOB_STATS_MEDIAN:
-        return `${namespace}:${params.appId}:s:${params.jobKey}:${params.dateTime}:${params.facet}`;
-      case KeyType.JOB_STATS_INDEX:
-        return `${namespace}:${params.appId}:s:${params.jobKey}:${params.dateTime}:${params.facet}`;
-      case KeyType.SCHEMAS:
-        return `${namespace}:${params.appId}:v:${params.appVersion}:schemas`;
-      case KeyType.SUBSCRIPTIONS:
-        return `${namespace}:${params.appId}:v:${params.appVersion}:subscriptions`;
-      case KeyType.SUBSCRIPTION_PATTERNS:
-        return `${namespace}:${params.appId}:v:${params.appVersion}:transitions`;
-      case KeyType.HOOKS:
-        //`hooks` provide the pattern to resolve a value
-        return `${namespace}:${params.appId}:hooks`;
-      case KeyType.SIGNALS:
-        //`signals` provide the registry of resolved values that link back to paused jobs
-        return `${namespace}:${params.appId}:signals`;
-      case KeyType.SYMKEYS:
-        //`symbol keys` provide the registry of replacement values for job keys
-        return `${namespace}:${params.appId}:sym:keys:${params.activityId || ''}`;
-      case KeyType.SYMVALS:
-        //`symbol vals` provide the registry of replacement values for job vals
-        return `${namespace}:${params.appId}:sym:vals:`;
-      case KeyType.STREAMS:
-        return `${namespace}:${params.appId || ''}:x:${params.topic || ''}`;
-      default:
-        throw new Error("Invalid key type.");
-    }
-  }
-}
-
-export { KeyService, KeyType, KeyStoreParams, HMNS, KEYSEP, TYPSEP, WEBSEP, VALSEP };

package/modules/storage.ts

@@ -1,3 +0,0 @@
-import { AsyncLocalStorage } from 'async_hooks';
-
-export const asyncLocalStorage = new AsyncLocalStorage<Map<string, any>>();

package/modules/utils.ts

@@ -1,242 +0,0 @@
-import os from 'os';
-import si from 'systeminformation';
-import { nanoid } from "nanoid";
-import { StoreService } from "../services/store";
-import { AppSubscriptions, AppTransitions, AppVID } from "../types/app";
-import { RedisClient, RedisMulti } from "../types/redis";
-import { StringAnyType } from "../types/serializer";
-import { StreamCode, StreamStatus } from "../types/stream";
-import { SystemHealth } from '../types/quorum';
-
-async function safeExecute<T>(operation: Promise<T>, defaultValue: T): Promise<T> {
-  try {
-    return await operation;
-  } catch (error) {
-    console.error(`Operation Error: ${error}`);
-    return defaultValue;
-  }
-}
-
-export async function getSystemHealth(): Promise<SystemHealth> {
-  const totalMemory = os.totalmem();
-  const freeMemory = os.freemem();
-  const usedMemory = totalMemory - freeMemory;
-  const cpus = os.cpus();
-
-  // CPU load calculation remains unchanged
-  const cpuLoad = cpus.map((cpu, i) => {
-    const total = Object.values(cpu.times).reduce((acc, tv) => acc + tv, 0);
-    const idle = cpu.times.idle;
-    const usage = ((total - idle) / total) * 100;
-    return { [`CPU ${i} Usage`]: `${usage.toFixed(2)}%` };
-  });
-
-  // Wrap each systeminformation call with safeExecute
-  const networkStats = await safeExecute(si.networkStats(), []);
-
-  // Construct the system health object with error handling in mind
-  const systemHealth = {
-    TotalMemoryGB: `${(totalMemory / 1024 / 1024 / 1024).toFixed(2)} GB`,
-    FreeMemoryGB: `${(freeMemory / 1024 / 1024 / 1024).toFixed(2)} GB`,
-    UsedMemoryGB: `${(usedMemory / 1024 / 1024 / 1024).toFixed(2)} GB`,
-    CPULoad: cpuLoad,
-    NetworkStats: networkStats,
-  };
-
-  return systemHealth as SystemHealth;
-}
-
-export async function sleepFor(ms: number) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-export function guid(): string {
-  return nanoid().replace(/[_-]/g, '0');
-}
-
-export function deterministicRandom(seed: number): number {
-  let x = Math.sin(seed) * 10000;
-  return x - Math.floor(x);
-}
-
-export function identifyRedisType(redisInstance: any): 'redis' | 'ioredis' | null {
-  const prototype = Object.getPrototypeOf(redisInstance);
-  if ('defineCommand' in prototype || Object.keys(prototype).includes('multi')) {
-    return 'ioredis';
-  } else if (Object.keys(prototype).includes('Multi')) {
-    return 'redis';
-  }
-  if (redisInstance.constructor) {
-    if (redisInstance.constructor.name === 'Redis' || redisInstance.constructor.name === 'EventEmitter') {
-      if ('hset' in redisInstance) {
-        return 'ioredis';
-      }
-    } else if (redisInstance.constructor.name === 'RedisClient' || redisInstance.constructor.name === 'Commander') {
-      if ('HSET' in redisInstance) {
-        return 'redis';
-      }
-    }
-  }
-  return null;
-}
-
-//todo: the polyfill methods will all be deleted in the `beta` release.
-export const polyfill = {
-  resolveActivityType(activityType: string): string {
-    if (activityType === 'activity') {
-      return 'hook';
-    }
-    return activityType;
-  }
-}
-
-
-export function identifyRedisTypeFromClass(redisClass: any): 'redis' | 'ioredis' | null {
-  if (redisClass && redisClass.name === 'Redis' || redisClass.name === 'EventEmitter') {
-    return 'ioredis';
-  } else if (redisClass && 'createClient' in redisClass) {
-    return 'redis';
-  }
-  return null;
-}
-
-export function matchesStatusCode(code: StreamCode, pattern: string | RegExp): boolean {
-  if (typeof pattern === 'string') {
-    // Convert '*' wildcard to its regex equivalent (\d)
-    const regexPattern = `^${pattern.replace(/\*/g, "\\d")}$`;
-    return new RegExp(regexPattern).test(code.toString());
-  }
-  return pattern.test(code.toString());
-}
-
-export function matchesStatus(status: StreamStatus, targetStatus: StreamStatus): boolean {
-  return status === targetStatus;
-}
-
-export function XSleepFor(ms: number): { promise: Promise<unknown>, timerId: NodeJS.Timeout } {
-  //can be interrupted with `clearTimeout`
-  let timerId: NodeJS.Timeout;
-  let promise = new Promise((resolve) => {
-    timerId = setTimeout(resolve, ms);
-  });
-  return { promise, timerId };
-}
-
-export function findTopKey(obj: AppTransitions, input: string): string | null {
-  for (const [key, value] of Object.entries(obj)) {
-    if (value.hasOwnProperty(input)) {
-      const parentKey = findTopKey(obj, key.replace(/^\./, ''));
-      return (parentKey || key).replace(/^\./, '');
-    }
-  }
-  return null;
-}
-
-export function findSubscriptionForTrigger(obj: AppSubscriptions, value: string): string | null {
-  for (const [key, itemValue] of Object.entries(obj)) {
-    if (itemValue === value) {
-      return key;
-    }
-  }
-  return null;
-}
-
-/**
- * Get the subscription topic for the flow to which @activityId belongs.
- * TODO: resolve this value in the compiler...do not call this at runtime
- */
-export async function getSubscriptionTopic(activityId: string, store: StoreService<RedisClient, RedisMulti>, appVID: AppVID): Promise<string | undefined> {
-  const appTransitions = await store.getTransitions(appVID);
-  const appSubscriptions = await store.getSubscriptions(appVID);
-  const triggerId = findTopKey(appTransitions, activityId);
-  const topic = findSubscriptionForTrigger(appSubscriptions, triggerId);
-  return topic;
-}
-
-/**
- * returns the 12-digit format of the iso timestamp (e.g, 202101010000); returns
- * an empty string if overridden by the user to not segment by time (infinity).
- */
-export function getTimeSeries(granularity: string): string {
-  if (granularity.toString() === 'infinity') {
-    return '0';
-  }
-  const now = new Date();
-  const granularityUnit = granularity.slice(-1);
-  const granularityValue = parseInt(granularity.slice(0, -1), 10);
-  if (granularityUnit === 'm') {
-    const minute = Math.floor(now.getMinutes() / granularityValue) * granularityValue;
-    now.setUTCMinutes(minute, 0, 0);
-  } else if (granularityUnit === 'h') {
-    now.setUTCMinutes(0, 0, 0);
-  }
-  return now.toISOString().replace(/:\d\d\..+|-|T/g, '').replace(':','');
-}
-
-export function formatISODate(input: Date | string): string {
-  const date = input instanceof Date ? input : new Date(input);
-  return date.toISOString().replace(/[:TZ-]/g, '');
-}
-
-export function getSymKey(number: number): string {
-  const alphabet = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
-  const base = alphabet.length;
-  if (number < 0 || number >= Math.pow(base, 3)) {
-    throw new Error('Number out of range');
-  }
-  let [q1, r1] = divmod(number, base);
-  let [q2, r2] = divmod(q1, base);
-  return alphabet[q2] + alphabet[r1] + alphabet[r2];
-}
-
-export function getSymVal(number: number): string {
-  const alphabet = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
-  const base = alphabet.length;
-  if (number < 0 || number >= Math.pow(base, 2)) {
-    throw new Error('Number out of range');
-  }
-  let [q, r] = divmod(number, base);
-  return alphabet[q] + alphabet[r];
-}
-
-function divmod(m: number, n: number): number[] {
-  return [Math.floor(m / n), m % n];
-}
-
-export function getIndexedHash<T>(hash: T, target: string): [number, T] {
-  const index = hash[target] as number || 0;
-  const newHash = { ...hash };
-  delete newHash[target];
-  return [index, newHash as T];
-}
-
-export function getValueByPath(obj: { [key: string]: any }, path: string): any {
-  const pathParts = path.split('/');
-  let currentValue = obj;
-  for (const part of pathParts) {
-    if (currentValue[part] !== undefined) {
-      currentValue = currentValue[part];
-    } else {
-      return undefined;
-    }
-  }
-  return currentValue;
-}
-
-export function restoreHierarchy(obj: StringAnyType): StringAnyType {
-  const result: StringAnyType = {};
-  for (const key in obj) {
-    if (obj[key] === undefined) continue;
-    const keys = key.split('/');
-    let current = result;
-    for (let i = 0; i < keys.length; i++) {
-      if (i === keys.length - 1) {
-        current[keys[i]] = obj[key];
-      } else {
-        current[keys[i]] = current[keys[i]] || {};
-        current = current[keys[i]];
-      }
-    }
-  }
-  return result;
-}