@hotmeshio/hotmesh 0.4.0 → 0.4.2

package/build/services/pipe/functions/conditional.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConditionalHandler = void 0;
+class ConditionalHandler {
+    ternary(condition, valueIfTrue, valueIfFalse) {
+        return condition ? valueIfTrue : valueIfFalse;
+    }
+    equality(value1, value2) {
+        return value1 == value2;
+    }
+    strict_equality(value1, value2) {
+        return value1 === value2;
+    }
+    inequality(value1, value2) {
+        return value1 != value2;
+    }
+    strict_inequality(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;
+    }
+    nullish(value1, value2) {
+        return value1 ?? value2;
+    }
+}
+exports.ConditionalHandler = ConditionalHandler;

package/build/services/pipe/functions/cron.d.ts

@@ -0,0 +1,12 @@
+import { ILogger } from '../../../types/logger';
+/**
+ * Safely calculates the delay in seconds until the next execution of a cron job.
+ * Fails silently and returns -1 if the cron expression is invalid.
+ * @param cronExpression The cron expression to parse (e.g. '0 0 * * *').
+ * @returns The delay in seconds until the next cron job execution (minimum 5 seconds).
+ */
+declare class CronHandler {
+    static logger: ILogger;
+    nextDelay(cronExpression: string): number;
+}
+export { CronHandler };

package/build/services/pipe/functions/cron.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CronHandler = void 0;
+const cron_parser_1 = require("cron-parser");
+const enums_1 = require("../../../modules/enums");
+const utils_1 = require("../../../modules/utils");
+const logger_1 = require("../../logger");
+/**
+ * Safely calculates the delay in seconds until the next execution of a cron job.
+ * Fails silently and returns -1 if the cron expression is invalid.
+ * @param cronExpression The cron expression to parse (e.g. '0 0 * * *').
+ * @returns The delay in seconds until the next cron job execution (minimum 5 seconds).
+ */
+class CronHandler {
+    nextDelay(cronExpression) {
+        try {
+            if (!(0, utils_1.isValidCron)(cronExpression)) {
+                return -1;
+            }
+            const interval = (0, cron_parser_1.parseExpression)(cronExpression, { utc: true });
+            const nextDate = interval.next().toDate();
+            const now = new Date();
+            const delay = (nextDate.getTime() - now.getTime()) / 1000;
+            if (delay <= 0) {
+                return -1;
+            }
+            if (delay < enums_1.HMSH_FIDELITY_SECONDS) {
+                return enums_1.HMSH_FIDELITY_SECONDS;
+            }
+            const iDelay = Math.round(delay);
+            return iDelay;
+        }
+        catch (error) {
+            CronHandler.logger.error('Error calculating next cron job execution  delay:', { error });
+            return -1;
+        }
+    }
+}
+exports.CronHandler = CronHandler;
+CronHandler.logger = new logger_1.LoggerService('hotmesh', 'meshos');

package/build/services/pipe/functions/date.d.ts

@@ -0,0 +1,58 @@
+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;
+    toISOXString(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 };

package/build/services/pipe/functions/date.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DateHandler = void 0;
+const utils_1 = require("../../../modules/utils");
+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) {
+        const ISO_REGEX = /^\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z)?$/;
+        if (typeof input === 'string') {
+            if (ISO_REGEX.test(input)) {
+                return new Date(input);
+            }
+            const milliseconds = parseInt(input, 10);
+            if (!isNaN(milliseconds)) {
+                return new Date(milliseconds);
+            }
+        }
+        else if (input instanceof Date) {
+            return input;
+        }
+        else if (typeof input === 'number') {
+            return new Date(input);
+        }
+        throw new Error('Invalid date format');
+    }
+    fromISOString(isoString) {
+        return new Date(isoString);
+    }
+    now() {
+        return Date.now();
+    }
+    parse(dateString) {
+        return Date.parse(dateString);
+    }
+    getDate(date) {
+        return DateHandler.getDateInstance(date).getDate();
+    }
+    getDay(date) {
+        return DateHandler.getDateInstance(date).getDay();
+    }
+    getFullYear(date) {
+        return DateHandler.getDateInstance(date).getFullYear();
+    }
+    getHours(date) {
+        return DateHandler.getDateInstance(date).getHours();
+    }
+    getMilliseconds(date) {
+        return DateHandler.getDateInstance(date).getMilliseconds();
+    }
+    getMinutes(date) {
+        return DateHandler.getDateInstance(date).getMinutes();
+    }
+    getMonth(date) {
+        return DateHandler.getDateInstance(date).getMonth();
+    }
+    getSeconds(date) {
+        return DateHandler.getDateInstance(date).getSeconds();
+    }
+    getTime(date) {
+        return DateHandler.getDateInstance(date).getTime();
+    }
+    getTimezoneOffset(date) {
+        return DateHandler.getDateInstance(date).getTimezoneOffset();
+    }
+    getUTCDate(date) {
+        return DateHandler.getDateInstance(date).getUTCDate();
+    }
+    getUTCDay(date) {
+        return DateHandler.getDateInstance(date).getUTCDay();
+    }
+    getUTCFullYear(date) {
+        return DateHandler.getDateInstance(date).getUTCFullYear();
+    }
+    getUTCHours(date) {
+        return DateHandler.getDateInstance(date).getUTCHours();
+    }
+    getUTCMilliseconds(date) {
+        return DateHandler.getDateInstance(date).getUTCMilliseconds();
+    }
+    getUTCMinutes(date) {
+        return DateHandler.getDateInstance(date).getUTCMinutes();
+    }
+    getUTCMonth(date) {
+        return DateHandler.getDateInstance(date).getUTCMonth();
+    }
+    getUTCSeconds(date) {
+        return DateHandler.getDateInstance(date).getUTCSeconds();
+    }
+    setMilliseconds(date, ms) {
+        return DateHandler.getDateInstance(date).setMilliseconds(ms);
+    }
+    setMinutes(date, minutes, seconds, ms) {
+        return DateHandler.getDateInstance(date).setMinutes(minutes, seconds, ms);
+    }
+    setMonth(date, month, day) {
+        return DateHandler.getDateInstance(date).setMonth(month, day);
+    }
+    setSeconds(date, seconds, ms) {
+        return DateHandler.getDateInstance(date).setSeconds(seconds, ms);
+    }
+    setTime(date, time) {
+        return DateHandler.getDateInstance(date).setTime(time);
+    }
+    setUTCDate(date, day) {
+        return DateHandler.getDateInstance(date).setUTCDate(day);
+    }
+    setUTCFullYear(date, year, month, day) {
+        return DateHandler.getDateInstance(date).setUTCFullYear(year, month, day);
+    }
+    setUTCHours(date, hours, minutes, seconds, ms) {
+        return DateHandler.getDateInstance(date).setUTCHours(hours, minutes, seconds, ms);
+    }
+    setUTCMilliseconds(date, ms) {
+        return DateHandler.getDateInstance(date).setUTCMilliseconds(ms);
+    }
+    setUTCMinutes(date, minutes, seconds, ms) {
+        return DateHandler.getDateInstance(date).setUTCMinutes(minutes, seconds, ms);
+    }
+    setUTCMonth(date, month, day) {
+        return DateHandler.getDateInstance(date).setUTCMonth(month, day);
+    }
+    setUTCSeconds(date, seconds, ms) {
+        return DateHandler.getDateInstance(date).setUTCSeconds(seconds, ms);
+    }
+    setDate(date, day) {
+        return DateHandler.getDateInstance(date).setDate(day);
+    }
+    setFullYear(date, year, month, day) {
+        return DateHandler.getDateInstance(date).setFullYear(year, month, day);
+    }
+    setHours(date, hours, minutes, seconds, ms) {
+        return DateHandler.getDateInstance(date).setHours(hours, minutes, seconds, ms);
+    }
+    toDateString(date) {
+        return DateHandler.getDateInstance(date).toDateString();
+    }
+    toISOString(date) {
+        return DateHandler.getDateInstance(date).toISOString();
+    }
+    toISOXString(date) {
+        return (0, utils_1.formatISODate)(date ? DateHandler.getDateInstance(date) : new Date());
+    }
+    toJSON(date) {
+        return DateHandler.getDateInstance(date).toJSON();
+    }
+    toLocaleDateString(date, locales, options) {
+        return DateHandler.getDateInstance(date).toLocaleDateString(locales, options);
+    }
+    toLocaleString(date, locales, options) {
+        return DateHandler.getDateInstance(date).toLocaleString(locales, options);
+    }
+    toLocaleTimeString(date, locales, options) {
+        return DateHandler.getDateInstance(date).toLocaleTimeString(locales, options);
+    }
+    toString(date) {
+        return DateHandler.getDateInstance(date).toString();
+    }
+    UTC(year, month, date, hours, minutes, seconds, ms) {
+        return Date.UTC(year, month, date, hours, minutes, seconds, ms);
+    }
+    valueOf(date) {
+        return DateHandler.getDateInstance(date).valueOf();
+    }
+}
+exports.DateHandler = DateHandler;

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

@@ -0,0 +1,29 @@
+import { ArrayHandler } from './array';
+import { BitwiseHandler } from './bitwise';
+import { ConditionalHandler } from './conditional';
+import { CronHandler } from './cron';
+import { DateHandler } from './date';
+import { JsonHandler } from './json';
+import { LogicalHandler } from './logical';
+import { MathHandler } from './math';
+import { NumberHandler } from './number';
+import { ObjectHandler } from './object';
+import { StringHandler } from './string';
+import { SymbolHandler } from './symbol';
+import { UnaryHandler } from './unary';
+declare const _default: {
+    array: ArrayHandler;
+    bitwise: BitwiseHandler;
+    conditional: ConditionalHandler;
+    cron: CronHandler;
+    date: DateHandler;
+    json: JsonHandler;
+    logical: LogicalHandler;
+    math: MathHandler;
+    number: NumberHandler;
+    object: ObjectHandler;
+    string: StringHandler;
+    symbol: SymbolHandler;
+    unary: UnaryHandler;
+};
+export default _default;

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const array_1 = require("./array");
+const bitwise_1 = require("./bitwise");
+const conditional_1 = require("./conditional");
+const cron_1 = require("./cron");
+const date_1 = require("./date");
+const json_1 = require("./json");
+const logical_1 = require("./logical");
+const math_1 = require("./math");
+const number_1 = require("./number");
+const object_1 = require("./object");
+const string_1 = require("./string");
+const symbol_1 = require("./symbol");
+const unary_1 = require("./unary");
+exports.default = {
+    array: new array_1.ArrayHandler(),
+    bitwise: new bitwise_1.BitwiseHandler(),
+    conditional: new conditional_1.ConditionalHandler(),
+    cron: new cron_1.CronHandler(),
+    date: new date_1.DateHandler(),
+    json: new json_1.JsonHandler(),
+    logical: new logical_1.LogicalHandler(),
+    math: new math_1.MathHandler(),
+    number: new number_1.NumberHandler(),
+    object: new object_1.ObjectHandler(),
+    string: new string_1.StringHandler(),
+    symbol: new symbol_1.SymbolHandler(),
+    unary: new unary_1.UnaryHandler(),
+};

package/build/services/pipe/functions/json.d.ts

@@ -0,0 +1,5 @@
+declare class JsonHandler {
+    stringify(value: any, replacer?: (this: any, key: string, value: any) => any | (number | string)[] | null, space?: string | number): string;
+    parse(text: string, reviver?: (this: any, key: string, value: any) => any): any;
+}
+export { JsonHandler };

package/build/services/pipe/functions/json.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonHandler = void 0;
+class JsonHandler {
+    stringify(value, replacer, space) {
+        return JSON.stringify(value, replacer, space);
+    }
+    parse(text, reviver) {
+        return JSON.parse(text, reviver);
+    }
+}
+exports.JsonHandler = JsonHandler;

package/build/services/pipe/functions/logical.d.ts

@@ -0,0 +1,5 @@
+declare class LogicalHandler {
+    and(firstValue: boolean, secondValue: boolean): boolean;
+    or(firstValue: boolean, secondValue: boolean): boolean;
+}
+export { LogicalHandler };

package/build/services/pipe/functions/logical.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogicalHandler = void 0;
+class LogicalHandler {
+    and(firstValue, secondValue) {
+        return firstValue && secondValue;
+    }
+    or(firstValue, secondValue) {
+        return firstValue || secondValue;
+    }
+}
+exports.LogicalHandler = LogicalHandler;

package/build/services/pipe/functions/math.d.ts

@@ -0,0 +1,42 @@
+declare class MathHandler {
+    add(...operands: (number | number[])[]): number;
+    subtract(...operands: (number | number[])[]): number;
+    multiply(...operands: (number | number[])[]): number;
+    divide(...operands: (number | number[])[]): number;
+    abs(x: number): number;
+    acos(x: number): number;
+    acosh(x: number): number;
+    asin(x: number): number;
+    asinh(x: number): number;
+    atan(x: number): number;
+    atan2(y: number, x: number): number;
+    atanh(x: number): number;
+    cbrt(x: number): number;
+    ceil(x: number): number;
+    clz32(x: number): number;
+    cos(x: number): number;
+    cosh(x: number): number;
+    exp(x: number): number;
+    expm1(x: number): number;
+    floor(x: number): number;
+    fround(x: number): number;
+    hypot(...values: number[]): number;
+    imul(x: number, y: number): number;
+    log(x: number): number;
+    log10(x: number): number;
+    log1p(x: number): number;
+    log2(x: number): number;
+    max(...values: number[]): number;
+    min(...values: number[]): number;
+    pow(x: number, y: number): number;
+    random(): number;
+    round(x: number): number;
+    sign(x: number): number;
+    sin(x: number): number;
+    sinh(x: number): number;
+    sqrt(x: number): number;
+    tan(x: number): number;
+    tanh(x: number): number;
+    trunc(x: number): number;
+}
+export { MathHandler };

package/build/services/pipe/functions/math.js

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MathHandler = void 0;
+class MathHandler {
+    add(...operands) {
+        // @ts-ignore
+        return operands.reduce((a, b) => {
+            if (Array.isArray(b)) {
+                return a + this.add(...b);
+            }
+            else {
+                return a + b;
+            }
+        }, 0);
+    }
+    subtract(...operands) {
+        if (operands.length === 0) {
+            throw new Error('At least one operand is required.');
+        }
+        let flatOperands = [];
+        operands.forEach((op) => {
+            if (Array.isArray(op)) {
+                flatOperands = [...flatOperands, ...op];
+            }
+            else {
+                flatOperands.push(op);
+            }
+        });
+        if (flatOperands.length === 0) {
+            throw new Error('At least one operand is required after flattening.');
+        }
+        const result = flatOperands.reduce((a, b, i) => {
+            return i === 0 ? a : a - b;
+        });
+        return result;
+    }
+    multiply(...operands) {
+        if (operands.length === 0) {
+            throw new Error('At least one operand is required.');
+        }
+        // @ts-ignore
+        return operands.reduce((a, b) => {
+            if (Array.isArray(b)) {
+                return a * this.multiply(...b);
+            }
+            else {
+                return a * b;
+            }
+        }, 1);
+    }
+    divide(...operands) {
+        if (operands.length === 0) {
+            throw new Error('At least one operand is required.');
+        }
+        let flatOperands = [];
+        operands.forEach((op) => {
+            if (Array.isArray(op)) {
+                flatOperands = [...flatOperands, ...op];
+            }
+            else {
+                flatOperands.push(op);
+            }
+        });
+        if (flatOperands.length === 0) {
+            throw new Error('At least one operand is required after flattening.');
+        }
+        const result = flatOperands.reduce((a, b, i) => {
+            if (b === 0) {
+                return NaN;
+            }
+            return i === 0 ? a : a / b;
+        });
+        if (isNaN(result)) {
+            return NaN;
+        }
+        return result;
+    }
+    abs(x) {
+        return Math.abs(x);
+    }
+    acos(x) {
+        return Math.acos(x);
+    }
+    acosh(x) {
+        return Math.acosh(x);
+    }
+    asin(x) {
+        return Math.asin(x);
+    }
+    asinh(x) {
+        return Math.asinh(x);
+    }
+    atan(x) {
+        return Math.atan(x);
+    }
+    atan2(y, x) {
+        return Math.atan2(y, x);
+    }
+    atanh(x) {
+        return Math.atanh(x);
+    }
+    cbrt(x) {
+        return Math.cbrt(x);
+    }
+    ceil(x) {
+        return Math.ceil(x);
+    }
+    clz32(x) {
+        return Math.clz32(x);
+    }
+    cos(x) {
+        return Math.cos(x);
+    }
+    cosh(x) {
+        return Math.cosh(x);
+    }
+    exp(x) {
+        return Math.exp(x);
+    }
+    expm1(x) {
+        return Math.expm1(x);
+    }
+    floor(x) {
+        return Math.floor(x);
+    }
+    fround(x) {
+        return Math.fround(x);
+    }
+    hypot(...values) {
+        return Math.hypot(...values);
+    }
+    imul(x, y) {
+        return Math.imul(x, y);
+    }
+    log(x) {
+        return Math.log(x);
+    }
+    log10(x) {
+        return Math.log10(x);
+    }
+    log1p(x) {
+        return Math.log1p(x);
+    }
+    log2(x) {
+        return Math.log2(x);
+    }
+    max(...values) {
+        return Math.max(...values);
+    }
+    min(...values) {
+        return Math.min(...values);
+    }
+    pow(x, y) {
+        return Math.pow(x, y);
+    }
+    random() {
+        return Math.random();
+    }
+    round(x) {
+        return Math.round(x);
+    }
+    sign(x) {
+        return Math.sign(x);
+    }
+    sin(x) {
+        return Math.sin(x);
+    }
+    sinh(x) {
+        return Math.sinh(x);
+    }
+    sqrt(x) {
+        return Math.sqrt(x);
+    }
+    tan(x) {
+        return Math.tan(x);
+    }
+    tanh(x) {
+        return Math.tanh(x);
+    }
+    trunc(x) {
+        return Math.trunc(x);
+    }
+}
+exports.MathHandler = MathHandler;

package/build/services/pipe/functions/number.d.ts

@@ -0,0 +1,21 @@
+declare class NumberHandler {
+    isFinite(input: number): boolean;
+    isEven(input: number): boolean;
+    isOdd(input: number): boolean;
+    isInteger(input: number): boolean;
+    isNaN(input: number): boolean;
+    parseFloat(input: string): number;
+    parseInt(input: string, radix?: number): number;
+    toFixed(input: number, digits?: number): string;
+    toExponential(input: number, fractionalDigits?: number): string;
+    toPrecision(input: number, precision?: number): string;
+    gte(input: number, compareValue: number): boolean;
+    lte(input: number, compareValue: number): boolean;
+    gt(input: number, compareValue: number): boolean;
+    lt(input: number, compareValue: number): boolean;
+    max(...values: number[]): number;
+    min(...values: number[]): number;
+    pow(base: number, exponent: number): number;
+    round(input: number): number;
+}
+export { NumberHandler };