@hotmeshio/hotmesh 0.4.0 → 0.4.1

package/build/modules/key.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VALSEP = exports.WEBSEP = exports.TYPSEP = exports.KEYSEP = exports.HMNS = exports.KeyType = exports.KeyService = void 0;
+const hotmesh_1 = require("../types/hotmesh");
+Object.defineProperty(exports, "KeyType", { enumerable: true, get: function () { return hotmesh_1.KeyType; } });
+/**
+ * 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>:r: ->                                 {hash}    throttle rates {':': '23', 'topic.thing': '555'} => {':i': 'all', 'topic.thing': '555seconds'}
+ * 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>: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 ->                            {string}  dynamic hook signals (hget/hdel); expirable
+ * 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';
+exports.HMNS = HMNS;
+const KEYSEP = ':'; // default delimiter for keys
+exports.KEYSEP = KEYSEP;
+const VALSEP = '::'; // default delimiter for vals
+exports.VALSEP = VALSEP;
+const WEBSEP = '::'; // default delimiter for webhook vals
+exports.WEBSEP = WEBSEP;
+const TYPSEP = '::'; // delimiter for ZSET task typing (how should a list be used?)
+exports.TYPSEP = TYPSEP;
+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.
+     * @param namespace
+     * @param keyType
+     * @param params
+     * @returns {string}
+     */
+    static mintKey(namespace, keyType, params) {
+        switch (keyType) {
+            case hotmesh_1.KeyType.HOTMESH:
+                return namespace;
+            case hotmesh_1.KeyType.THROTTLE_RATE:
+                return `${namespace}:${params.appId}:r:`;
+            case hotmesh_1.KeyType.WORK_ITEMS:
+                return `${namespace}:${params.appId}:w:${params.scoutType || ''}`;
+            case hotmesh_1.KeyType.TIME_RANGE:
+                return `${namespace}:${params.appId}:t:${params.timeValue || ''}`;
+            case hotmesh_1.KeyType.APP:
+                return `${namespace}:a:${params.appId || ''}`;
+            case hotmesh_1.KeyType.QUORUM:
+                return `${namespace}:${params.appId}:q:${params.engineId || ''}`;
+            case hotmesh_1.KeyType.JOB_STATE:
+                return `${namespace}:${params.appId}:j:${params.jobId}`;
+            case hotmesh_1.KeyType.JOB_DEPENDENTS:
+                return `${namespace}:${params.appId}:d:${params.jobId}`;
+            case hotmesh_1.KeyType.JOB_STATS_GENERAL:
+                return `${namespace}:${params.appId}:s:${params.jobKey}:${params.dateTime}`;
+            case hotmesh_1.KeyType.JOB_STATS_MEDIAN:
+                return `${namespace}:${params.appId}:s:${params.jobKey}:${params.dateTime}:${params.facet}`;
+            case hotmesh_1.KeyType.JOB_STATS_INDEX:
+                return `${namespace}:${params.appId}:s:${params.jobKey}:${params.dateTime}:${params.facet}`;
+            case hotmesh_1.KeyType.SCHEMAS:
+                return `${namespace}:${params.appId}:v:${params.appVersion}:schemas`;
+            case hotmesh_1.KeyType.SUBSCRIPTIONS:
+                return `${namespace}:${params.appId}:v:${params.appVersion}:subscriptions`;
+            case hotmesh_1.KeyType.SUBSCRIPTION_PATTERNS:
+                return `${namespace}:${params.appId}:v:${params.appVersion}:transitions`;
+            case hotmesh_1.KeyType.HOOKS:
+                return `${namespace}:${params.appId}:hooks`;
+            case hotmesh_1.KeyType.SIGNALS:
+                return `${namespace}:${params.appId}:signals`;
+            case hotmesh_1.KeyType.SYMKEYS:
+                return `${namespace}:${params.appId}:sym:keys:${params.activityId || ''}`;
+            case hotmesh_1.KeyType.SYMVALS:
+                return `${namespace}:${params.appId}:sym:vals:`;
+            case hotmesh_1.KeyType.STREAMS:
+                return `${namespace}:${params.appId || ''}:x:${params.topic || ''}`;
+            default:
+                throw new Error('Invalid key type.');
+        }
+    }
+    /**
+     * Extracts the parts of a given key string, safely handling cases where
+     * the 'id' portion may contain additional colons.
+     * @param key - The key to parse.
+     * @returns An object with the parsed key parts.
+     */
+    static parseKey(key) {
+        const [namespace, appId, entity, ...rest] = key.split(KEYSEP);
+        const id = rest.join(KEYSEP) || ''; // Join remaining parts to reconstruct the id
+        return {
+            namespace,
+            app: entity === 'a' ? appId : undefined,
+            entity,
+            id,
+        };
+    }
+    /**
+     * Reconstructs a key string from its parts.
+     * @param parts - An object with the key parts.
+     * @returns The reconstructed key string.
+     */
+    static reconstituteKey(parts) {
+        const { namespace, app, entity, id } = parts;
+        return `${namespace}${KEYSEP}${app}${KEYSEP}${entity}${KEYSEP}${id || ''}`;
+    }
+    /**
+     * Resolves an entity type abbreviation to a table-friendly name.
+     * @param abbreviation - The abbreviated entity type.
+     * @returns The long-form entity name.
+     */
+    static resolveEntityType(abbreviation, id = '') {
+        switch (abbreviation) {
+            case 'a':
+                return 'applications';
+            case 'r':
+                return 'throttles';
+            case 'w':
+                return id === '' ? 'task_priorities' : 'roles';
+            case 't':
+                return id === '' ? 'task_schedules' : 'task_lists';
+            case 'q':
+                return 'events';
+            case 'j':
+                return 'jobs';
+            case 's':
+                return 'stats';
+            case 'v':
+                return 'versions';
+            case 'x':
+                return id === '' ? 'streams' : 'stream_topics';
+            case 'hooks':
+                return 'signal_patterns';
+            case 'signals':
+                return 'signal_registry';
+            case 'sym':
+                return 'symbols';
+            default:
+                return 'unknown_entity';
+        }
+    }
+    static resolveAbbreviation(entity) {
+        switch (entity) {
+            case 'applications':
+                return 'a';
+            case 'throttles':
+                return 'r';
+            case 'roles':
+                return 'w';
+            case 'task_schedules':
+                return 't';
+            case 'task_lists':
+                return 't';
+            case 'events':
+                return 'q';
+            case 'jobs':
+                return 'j';
+            case 'stats':
+                return 's';
+            case 'versions':
+                return 'v';
+            case 'streams':
+                return 'x';
+            case 'signal_patterns':
+                return 'hooks';
+            case 'signal_registry':
+                return 'signals';
+            case 'symbols':
+                return 'sym';
+            default:
+                return 'unknown_entity';
+        }
+    }
+}
+exports.KeyService = KeyService;

package/build/modules/storage.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+import { AsyncLocalStorage } from 'async_hooks';
+export declare const asyncLocalStorage: AsyncLocalStorage<Map<string, any>>;

package/build/modules/storage.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asyncLocalStorage = void 0;
+const async_hooks_1 = require("async_hooks");
+exports.asyncLocalStorage = new async_hooks_1.AsyncLocalStorage();

package/build/modules/utils.d.ts

@@ -0,0 +1,119 @@
+/// <reference types="node" />
+import { StoreService } from '../services/store';
+import { AppSubscriptions, AppTransitions, AppVID } from '../types/app';
+import { ProviderClient, ProviderConfig, ProviderTransaction, Providers, ProvidersConfig } from '../types/provider';
+import { StringAnyType } from '../types/serializer';
+import { StreamCode, StreamData, StreamStatus } from '../types/stream';
+import { SystemHealth } from '../types/quorum';
+/**
+ * @private
+ */
+export declare const hashOptions: (options: any) => string;
+export declare function getSystemHealth(): Promise<SystemHealth>;
+export declare function deepCopy<T>(obj: T): T;
+export declare function deterministicRandom(seed: number): number;
+export declare function guid(size?: number): string;
+export declare function sleepFor(ms: number): Promise<void>;
+export declare function sleepImmediate(): Promise<void>;
+export declare function XSleepFor(ms: number): {
+    promise: Promise<unknown>;
+    timerId: NodeJS.Timeout;
+};
+/**
+ * Identies the provider type based on the provider object. Customers may
+ * explicitly set the provider type in the configuration. But this is a
+ * convenience method to automatically identify the provider type.
+ * @private
+ */
+export declare function identifyProvider(provider: any): Providers | null;
+/**
+ * @private
+ */
+export declare const polyfill: {
+    /**
+     * `redis` is deprecated; `connection` is the generic replacement
+     */
+    providerConfig(obj: any): any;
+    /**
+     * NOTE: `redisClass and redisOptions` input parameters are deprecated; use `connection` for all configuration inputs
+     */
+    meshDataConfig(obj: {
+        connection?: Partial<ProviderConfig | ProvidersConfig>;
+        redisClass?: any;
+        redisOptions?: StringAnyType;
+    }): Partial<ProviderConfig> | Partial<ProvidersConfig>;
+};
+/**
+ * @private
+ */
+export declare function matchesStatusCode(code: StreamCode, pattern: string | RegExp): boolean;
+/**
+ * @private
+ */
+export declare function matchesStatus(status: StreamStatus, targetStatus: StreamStatus): boolean;
+/**
+ * @private
+ */
+export declare function findTopKey(obj: AppTransitions, input: string): string | null;
+/**
+ * @private
+ */
+export declare function findSubscriptionForTrigger(obj: AppSubscriptions, value: string): string | null;
+/**
+ * Get the subscription topic for the flow to which activityId belongs.
+ * @private
+ */
+export declare function getSubscriptionTopic(activityId: string, store: StoreService<ProviderClient, ProviderTransaction>, appVID: AppVID): Promise<string | undefined>;
+/**
+ * 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).
+ * @private
+ */
+export declare function getTimeSeries(granularity: string): string;
+/**
+ * @private
+ */
+export declare function formatISODate(input: Date | string): string;
+/**
+ * @private
+ */
+export declare function getSymKey(number: number): string;
+/**
+ * @private
+ */
+export declare function getSymVal(number: number): string;
+/**
+ * @private
+ */
+export declare function getIndexedHash<T>(hash: T, target: string): [number, T];
+/**
+ * @private
+ */
+export declare function getValueByPath(obj: {
+    [key: string]: any;
+}, path: string): any;
+/**
+ * @private
+ */
+export declare function restoreHierarchy(obj: StringAnyType): StringAnyType;
+/**
+ * @private
+ */
+export declare function isValidCron(cronExpression: string): boolean;
+/**
+ * Returns the number of seconds for a string using the milliseconds format
+ * used by the `ms` npm package as the input.
+ */
+export declare const s: (input: string) => number;
+/**
+ * @private
+ */
+export declare const parseStreamMessage: (message: string) => StreamData;
+/**
+ * @private
+ */
+export declare const isStreamMessage: (result: any) => boolean;
+/**
+ * Transforms  an array of arrays to an array of objects.
+ */
+export declare const arrayToHash: (response: [number, ...Array<string | string[]>]) => Record<string, string>[];

package/build/modules/utils.js

@@ -0,0 +1,374 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayToHash = exports.isStreamMessage = exports.parseStreamMessage = exports.s = exports.isValidCron = exports.restoreHierarchy = exports.getValueByPath = exports.getIndexedHash = exports.getSymVal = exports.getSymKey = exports.formatISODate = exports.getTimeSeries = exports.getSubscriptionTopic = exports.findSubscriptionForTrigger = exports.findTopKey = exports.matchesStatus = exports.matchesStatusCode = exports.polyfill = exports.identifyProvider = exports.XSleepFor = exports.sleepImmediate = exports.sleepFor = exports.guid = exports.deterministicRandom = exports.deepCopy = exports.getSystemHealth = exports.hashOptions = void 0;
+const os_1 = __importDefault(require("os"));
+const crypto_1 = require("crypto");
+const nanoid_1 = require("nanoid");
+const ms_1 = __importDefault(require("ms"));
+const logger_1 = require("../services/logger");
+const enums_1 = require("./enums");
+const logger = new logger_1.LoggerService('hotmesh', 'utils');
+/**
+ * @private
+ */
+const hashOptions = (options) => {
+    const str = JSON.stringify(options);
+    return (0, crypto_1.createHash)('sha256').update(str).digest('hex');
+};
+exports.hashOptions = hashOptions;
+async function getSystemHealth() {
+    const totalMemory = os_1.default.totalmem();
+    const freeMemory = os_1.default.freemem();
+    const usedMemory = totalMemory - freeMemory;
+    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: [],
+        NetworkStats: [],
+    };
+    return systemHealth;
+}
+exports.getSystemHealth = getSystemHealth;
+function deepCopy(obj) {
+    return JSON.parse(JSON.stringify(obj));
+}
+exports.deepCopy = deepCopy;
+function deterministicRandom(seed) {
+    const x = Math.sin(seed) * 10000;
+    return x - Math.floor(x);
+}
+exports.deterministicRandom = deterministicRandom;
+function guid(size = enums_1.HMSH_GUID_SIZE) {
+    return `H` + (0, nanoid_1.nanoid)(size);
+}
+exports.guid = guid;
+async function sleepFor(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+exports.sleepFor = sleepFor;
+function sleepImmediate() {
+    return new Promise((resolve) => setImmediate(resolve));
+}
+exports.sleepImmediate = sleepImmediate;
+function XSleepFor(ms) {
+    //can be interrupted with `clearTimeout`
+    let timerId;
+    const promise = new Promise((resolve) => {
+        timerId = setTimeout(resolve, ms);
+    });
+    return { promise, timerId };
+}
+exports.XSleepFor = XSleepFor;
+/**
+ * Identies the provider type based on the provider object. Customers may
+ * explicitly set the provider type in the configuration. But this is a
+ * convenience method to automatically identify the provider type.
+ * @private
+ */
+function identifyProvider(provider) {
+    const prototype = Object.getPrototypeOf(provider);
+    if (provider.Query?.prototype ||
+        Object.keys(provider).includes('database') ||
+        prototype.name === 'Pool') {
+        return 'postgres';
+    }
+    else if (provider.toString().toLowerCase().includes('nats')) {
+        return 'nats';
+    }
+    else if ('defineCommand' in prototype ||
+        Object.keys(prototype).includes('multi')) {
+        return 'ioredis';
+    }
+    else if (Object.keys(prototype).includes('Multi')) {
+        return 'redis';
+    }
+    if (provider.constructor) {
+        if (provider.constructor.name === 'Redis' ||
+            provider.constructor.name === 'EventEmitter') {
+            if ('hset' in provider) {
+                return 'ioredis';
+            }
+        }
+        else if (provider.constructor.name === 'ProviderClient' ||
+            provider.constructor.name === 'Commander') {
+            if ('HSET' in provider) {
+                return 'redis';
+            }
+        }
+    }
+    let type = null;
+    if (Object.keys(provider).includes('connection') ||
+        !isNaN(provider.totalCount) && !isNaN(provider.idleCount)) {
+        type = 'postgres';
+    }
+    else if (Object.keys(provider).includes('Pipeline')) {
+        type = 'ioredis';
+    }
+    else if (Object.keys(provider).includes('createClient')) {
+        type = 'redis';
+    }
+    else if (prototype.constructor.toString().includes('NatsConnectionImpl')) {
+        type = 'nats';
+    }
+    return type;
+}
+exports.identifyProvider = identifyProvider;
+/**
+ * @private
+ */
+exports.polyfill = {
+    /**
+     * `redis` is deprecated; `connection` is the generic replacement
+     */
+    providerConfig(obj) {
+        return obj?.connection ?? obj?.redis ?? obj?.connections;
+    },
+    /**
+     * NOTE: `redisClass and redisOptions` input parameters are deprecated; use `connection` for all configuration inputs
+     */
+    meshDataConfig(obj) {
+        return { ...obj.connection };
+    },
+};
+/**
+ * @private
+ */
+function matchesStatusCode(code, pattern) {
+    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());
+}
+exports.matchesStatusCode = matchesStatusCode;
+/**
+ * @private
+ */
+function matchesStatus(status, targetStatus) {
+    return status === targetStatus;
+}
+exports.matchesStatus = matchesStatus;
+/**
+ * @private
+ */
+function findTopKey(obj, input) {
+    for (const [key, value] of Object.entries(obj)) {
+        if (value.hasOwnProperty(input)) {
+            const parentKey = findTopKey(obj, key.replace(/^\./, ''));
+            return (parentKey || key).replace(/^\./, '');
+        }
+    }
+    return null;
+}
+exports.findTopKey = findTopKey;
+/**
+ * @private
+ */
+function findSubscriptionForTrigger(obj, value) {
+    for (const [key, itemValue] of Object.entries(obj)) {
+        if (itemValue === value) {
+            return key;
+        }
+    }
+    return null;
+}
+exports.findSubscriptionForTrigger = findSubscriptionForTrigger;
+/**
+ * Get the subscription topic for the flow to which activityId belongs.
+ * @private
+ */
+async function getSubscriptionTopic(activityId, store, appVID) {
+    const appTransitions = await store.getTransitions(appVID);
+    const appSubscriptions = await store.getSubscriptions(appVID);
+    const triggerId = findTopKey(appTransitions, activityId);
+    const topic = findSubscriptionForTrigger(appSubscriptions, triggerId);
+    return topic;
+}
+exports.getSubscriptionTopic = getSubscriptionTopic;
+/**
+ * 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).
+ * @private
+ */
+function getTimeSeries(granularity) {
+    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(':', '');
+}
+exports.getTimeSeries = getTimeSeries;
+/**
+ * @private
+ */
+function formatISODate(input) {
+    const date = input instanceof Date ? input : new Date(input);
+    return date.toISOString().replace(/[:TZ-]/g, '');
+}
+exports.formatISODate = formatISODate;
+/**
+ * @private
+ */
+function getSymKey(number) {
+    const alphabet = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
+    const base = alphabet.length;
+    if (number < 0 || number >= Math.pow(base, 3)) {
+        throw new Error('Number out of range');
+    }
+    const [q1, r1] = divmod(number, base);
+    const [q2, r2] = divmod(q1, base);
+    return alphabet[q2] + alphabet[r1] + alphabet[r2];
+}
+exports.getSymKey = getSymKey;
+/**
+ * @private
+ */
+function getSymVal(number) {
+    const alphabet = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
+    const base = alphabet.length;
+    if (number < 0 || number >= Math.pow(base, 2)) {
+        throw new Error('Number out of range');
+    }
+    const [q, r] = divmod(number, base);
+    return alphabet[q] + alphabet[r];
+}
+exports.getSymVal = getSymVal;
+/**
+ * @private
+ */
+function divmod(m, n) {
+    return [Math.floor(m / n), m % n];
+}
+/**
+ * @private
+ */
+function getIndexedHash(hash, target) {
+    const index = hash[target] || 0;
+    const newHash = { ...hash };
+    delete newHash[target];
+    return [index, newHash];
+}
+exports.getIndexedHash = getIndexedHash;
+/**
+ * @private
+ */
+function getValueByPath(obj, path) {
+    const pathParts = path.split('/');
+    let currentValue = obj;
+    for (const part of pathParts) {
+        if (currentValue[part] !== undefined) {
+            currentValue = currentValue[part];
+        }
+        else {
+            return undefined;
+        }
+    }
+    return currentValue;
+}
+exports.getValueByPath = getValueByPath;
+/**
+ * @private
+ */
+function restoreHierarchy(obj) {
+    const result = {};
+    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;
+}
+exports.restoreHierarchy = restoreHierarchy;
+/**
+ * @private
+ */
+function isValidCron(cronExpression) {
+    const cronRegex = /^(\*|([0-5]?\d)) (\*|([01]?\d|2[0-3])) (\*|([12]?\d|3[01])) (\*|([1-9]|1[0-2])) (\*|([0-6](?:-[0-6])?(?:,[0-6])?))$/;
+    return cronRegex.test(cronExpression);
+}
+exports.isValidCron = isValidCron;
+/**
+ * Returns the number of seconds for a string using the milliseconds format
+ * used by the `ms` npm package as the input.
+ */
+const s = (input) => {
+    return (0, ms_1.default)(input) / 1000;
+};
+exports.s = s;
+/**
+ * @private
+ */
+const parseStreamMessage = (message) => {
+    try {
+        return JSON.parse(message);
+    }
+    catch (error) {
+        logger.error('Error parsing Stream message', { error });
+        throw error;
+    }
+};
+exports.parseStreamMessage = parseStreamMessage;
+/**
+ * @private
+ */
+const isStreamMessage = (result) => {
+    return Array.isArray(result) && Array.isArray(result[0]);
+};
+exports.isStreamMessage = isStreamMessage;
+/**
+ * Transforms  an array of arrays to an array of objects.
+ */
+const arrayToHash = (response) => {
+    const results = [];
+    let key;
+    for (let i = 1; i < response.length; i++) {
+        // ignore count
+        const row = response[i];
+        const result = {};
+        if (Array.isArray(row)) {
+            // Check if row is an array
+            for (let j = 0; j < row.length; j += 2) {
+                const key = row[j];
+                const value = row[j + 1];
+                result[key] = value;
+            }
+            if (key) {
+                result.$ = key;
+            }
+            results.push(result);
+            key = undefined;
+        }
+        else {
+            key = row;
+        }
+    }
+    return results;
+};
+exports.arrayToHash = arrayToHash;