@hotmeshio/hotmesh 0.3.32 → 0.4.0

package/build/services/meshos/index.js

@@ -1,547 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MeshOS = void 0;
-const index_1 = require("../meshdata/index");
-const utils_1 = require("../../modules/utils");
-const logger_1 = require("../logger");
-/**
- * MeshOS is an abstract base class for schema-driven entity management within the Mesh network.
- * It provides a foundation for defining custom entities.
- * By subclassing MeshOS, you can create entities with specific schemas and behaviors, enabling
- * structured data storage, retrieval, and transactional workflows.
- *
- * ### Subclassing MeshOS
- *
- * Standard CRUD methods are included and use your provided schema to
- * fields to return in the response: create, retrieve, update, delete.
- *
- * Search methods are included and use your provided schema to
- * fields to return in the response: count, find, aggregate.
- *
- * Implement other methods as needed for the entity's
- * functionality; For example, subclass/override methods like `create`
- * to also spawn a transactional workflow
- *
- * @example
- * ```typescript
- * import { MeshOS } from '@hotmeshio/hotmesh';
- * import { Types } from '@hotmeshio/hotmesh';
- * import { schema } from './schema'; // Import your schema
- * import * as workflows from './workflows';
- *
- * class Widget extends MeshOS {
- *
- *   //Subclass the `connect` method to connect workers and
- *   // hooks (optional) when the container starts
- *   async connect() {
- *     await this.meshData.connect({
- *       entity: this.getEntity(),
- *       //the `target widget workflow` runs as a transaction
- *       target: function() {
- *         return { hello: 'world' };
- *       },
- *       options: {
- *         namespace: this.getNamespace(),
- *         taskQueue: this.getTaskQueue(),
- *       },
- *     });
- *   }
- *
- *   // subclass the `create` method to start a transactional
- *   // workflow; use the options/search field to set default
- *   // record data `{ ...input}` and invoke the `target widget workflow`
- *   async create(input: Types.StringAnyType): Promise<Types.StringStringType> {
- *     return await this.meshData.exec<Types.StringStringType>({
- *       entity: this.getEntity(),
- *       args: [{ ...input }],
- *       options: {
- *         id: input.id,
- *         ttl: '6 months',
- *         taskQueue: this.getTaskQueue(),
- *         namespace: this.getNamespace(),
- *         search: { data: { ...input }},
- *        },
- *     });
- *   }
- * }
- * ```
- *
- * ### Defining the Schema
- *
- * The schema defines the data model for your entity and is used for indexing and searching within the mesh network.
- * Each field in the schema specifies the data type, whether it's required, and other indexing options.
- *
- * Here's an example of a schema (`schema.ts`):
- *
- * ```typescript
- * import { Types } from '@hotmeshio/hotmesh';
- *
- * export const schema: Types.WorkflowSearchSchema = {
- *   /**
- *    * Unique identifier for the widget, including the entity prefix.
- *    *\/
- *   id: {
- *     type: 'TAG',
- *     primitive: 'string',
- *     required: true,
- *     examples: ['H56789'],
- *   },
- *   /**
- *    * entity type
- *    *\/
- *   $entity: {
- *     type: 'TAG',
- *     primitive: 'string',
- *     required: true,
- *     examples: ['widget'],
- *   },
- *   /**
- *    * Field indicating whether the widget is active ('y') or pruned ('n').
- *    *\/
- *   active: {
- *     type: 'TAG',
- *     primitive: 'string',
- *     required: true,
- *     examples: ['y', 'n'],
- *   },
- *   // ... other fields as needed
- * };
- * ```
- *
- * In your entity class (`Widget`), you use this schema in the
- * `getSearchOptions` method to define how your entity's data
- * is indexed and searched.
- */
-class MeshOS {
-    /**
-     * Instances of MeshOS are typically initialized as a set, using a manifest.json
-     * file that describes statically the fully set names, passwords, entities, etc.
-     * The static init method is invoked to start this process (typically at server
-     * startup).
-     */
-    constructor(providerConfig, namespace, entity, taskQueue, schema) {
-        this.connected = false;
-        this.workflow = {};
-        this.namespace = namespace; // e.g., 'sandbox', 'default', 'production'
-        this.entity = entity;
-        this.taskQueue = taskQueue;
-        this.schema = schema;
-        this.meshData = this.initializeMeshData(providerConfig);
-    }
-    /**
-     * Return entity (e.g, book, library, user)
-     */
-    getEntity() {
-        return this.entity;
-    }
-    /**
-     * Get Search options (initializes the search index, specific to the backend provider)
-     */
-    getSearchOptions() {
-        return {
-            index: `${this.getNamespace()}-${this.getEntity()}`,
-            prefix: [this.getEntity()],
-            schema: this.getSchema(),
-        };
-    }
-    /**
-     * Speficy a more-specific task queue than the default queue (v1, v1priority, v2, acmecorp, etc)
-     */
-    getTaskQueue() {
-        return this.taskQueue;
-    }
-    /**
-     * Initialize MeshData instance (this backs/supports the class
-     * --the true provider of functionality)
-     */
-    initializeMeshData(providerConfig) {
-        return new index_1.MeshData(providerConfig, this.getSearchOptions());
-    }
-    /**
-     * Default target function
-     */
-    async defaultTargetFn() {
-        return 'OK';
-    }
-    /**
-     * Get namespace
-     */
-    getNamespace() {
-        return this.namespace;
-    }
-    /**
-     * Get schema
-     */
-    getSchema() {
-        return this.schema;
-    }
-    /**
-     * Connect to the database
-     */
-    async connect() {
-        this.connected = await this.meshData.connect({
-            entity: this.getEntity(),
-            target: this.defaultTargetFn,
-            options: {
-                namespace: this.getNamespace(),
-                taskQueue: this.getTaskQueue(),
-            },
-        });
-    }
-    /**
-     * Create the search index
-     */
-    async index() {
-        await this.meshData.createSearchIndex(this.getEntity(), { namespace: this.getNamespace() }, this.getSearchOptions());
-    }
-    // On-container shutdown commands
-    /**
-     * Shutdown all connections
-     */
-    static async shutdown() {
-        await index_1.MeshData.shutdown();
-    }
-    /**
-     * Get index name
-     */
-    getIndexName() {
-        return this.getSearchOptions().index;
-    }
-    /**
-     * Create the data record
-     * NOTE: subclasses should override this method (or create
-     * an alternate method) for invoking a workflow when
-     * creating the record.
-     */
-    async create(body) {
-        const id = body.id || (0, utils_1.guid)();
-        await this.meshData.set(this.getEntity(), id, {
-            search: { data: body },
-            namespace: this.getNamespace(),
-        });
-        return this.retrieve(id);
-    }
-    /**
-     * Retrieve the record data
-     */
-    async retrieve(id, sparse = false) {
-        const opts = this.getSearchOptions();
-        const fields = sparse ? ['id'] : Object.keys(opts?.schema || {});
-        const result = await this.meshData.get(this.getEntity(), id, {
-            fields,
-            namespace: this.getNamespace(),
-        });
-        if (!result?.id)
-            throw new Error(`${this.getEntity()} not found`);
-        return result;
-    }
-    /**
-     * Update the record data
-     */
-    async update(id, body) {
-        await this.retrieve(id);
-        await this.meshData.set(this.getEntity(), id, {
-            search: { data: body },
-            namespace: this.getNamespace(),
-        });
-        return this.retrieve(id);
-    }
-    /**
-     * Delete the record/workflow
-     */
-    async delete(id) {
-        await this.retrieve(id);
-        await this.meshData.flush(this.getEntity(), id, this.getNamespace());
-        return true;
-    }
-    /**
-     * Find matching records
-     */
-    async find(query = [], start = 0, size = 100) {
-        const opts = this.getSearchOptions();
-        return this.meshData.findWhere(this.getEntity(), {
-            query,
-            return: Object.keys(opts?.schema || {}),
-            limit: { start, size },
-            options: { namespace: this.getNamespace() },
-        });
-    }
-    /**
-     * Count matching entities
-     */
-    async count(query) {
-        return this.meshData.findWhere(this.getEntity(), {
-            query,
-            count: true,
-            options: { namespace: this.getNamespace() },
-        });
-    }
-    /**
-     * Aggregate matching entities
-     */
-    async aggregate(filter = [], apply = [], rows = [], columns = [], reduce = [], sort = [], start = 0, size = 100) {
-        const command = this.buildAggregateCommand(filter, apply, rows, columns, reduce, sort);
-        try {
-            const results = await this.meshData.find(this.getEntity(), {
-                index: this.getIndexName(),
-                namespace: this.getNamespace(),
-                taskQueue: this.getTaskQueue(),
-                search: this.getSearchOptions(),
-            }, ...command);
-            return {
-                count: results[0],
-                query: command.join(' '),
-                data: (0, utils_1.arrayToHash)(results),
-            };
-        }
-        catch (e) {
-            throw e;
-        }
-    }
-    /**
-     * Build aggregate command
-     */
-    buildAggregateCommand(filter, apply, rows, columns, reduce, sort) {
-        const command = ['FT.AGGREGATE', this.getIndexName() || 'default'];
-        const opts = this.getSearchOptions();
-        // Add filter
-        command.push(this.buildFilterCommand(filter));
-        // Add apply
-        apply.forEach((a) => command.push('APPLY', a.expression, 'AS', a.as));
-        // Add groupBy
-        const groupBy = rows.concat(columns);
-        if (groupBy.length > 0) {
-            command.push('GROUPBY', `${groupBy.length}`, ...groupBy.map((g) => opts?.schema?.[g] ? `@_${g}` : `@${g}`));
-        }
-        // Add reduce
-        reduce.forEach((r) => {
-            const op = r.operation.toUpperCase();
-            if (op === 'COUNT') {
-                command.push('REDUCE', op, '0', 'AS', r.as ?? 'count');
-            }
-            else if ([
-                'COUNT_DISTINCT',
-                'COUNT_DISTINCTISH',
-                'SUM',
-                'AVG',
-                'MIN',
-                'MAX',
-                'STDDEV',
-                'TOLIST',
-            ].includes(op)) {
-                const property = r.property
-                    ? opts?.schema?.[r.property]
-                        ? `@_${r.property}`
-                        : `@${r.property}`
-                    : '';
-                command.push('REDUCE', op, '1', property, 'AS', r.as ?? `${r.operation}_${r.property}`);
-            }
-        });
-        // Add sort
-        if (sort.length > 0) {
-            command.push('SORTBY', `${2 * sort.length}`, ...sort.flatMap((s) => [
-                opts?.schema?.[s.field] ? `@_${s.field}` : `@${s.field}`,
-                s.order.toUpperCase() || 'DESC',
-            ]));
-        }
-        return command;
-    }
-    /**
-     * Build filter command
-     */
-    buildFilterCommand(filter) {
-        if (filter.length === 0)
-            return '*';
-        const opts = this.getSearchOptions();
-        return filter
-            .map((q) => {
-            const type = opts?.schema?.[q.field]?.type ?? 'TEXT';
-            switch (type) {
-                case 'TAG':
-                    return `@_${q.field}:{${q.value}}`;
-                case 'TEXT':
-                    return `@_${q.field}:${q.value}`;
-                case 'NUMERIC':
-                    return `@_${q.field}:[${q.value}]`;
-            }
-        })
-            .join(' ');
-    }
-    /**
-     * Instance initializer
-     */
-    async init(search = true) {
-        await this.connect();
-        if (search) {
-            await this.index();
-        }
-    }
-    // Static registration methods
-    /**
-     * Register a database
-     */
-    static registerDatabase(id, config) {
-        MeshOS.databases[id] = config;
-    }
-    /**
-     * Register a namespace
-     */
-    static registerNamespace(id, config) {
-        MeshOS.namespaces[id] = config;
-    }
-    /**
-     * Register an entity
-     */
-    static registerEntity(id, config) {
-        MeshOS.entities[id] = config;
-    }
-    /**
-     * Register a schema
-     */
-    static registerSchema(id, schema) {
-        MeshOS.schemas[id] = schema;
-    }
-    /**
-     * Register a profile
-     */
-    static registerProfile(id, config) {
-        MeshOS.profiles[id] = config;
-    }
-    /**
-     * Register a class
-     */
-    static registerClass(id, entityClass) {
-        MeshOS.classes[id] = entityClass;
-    }
-    /**
-     * Initialize profiles
-     */
-    static async init(p = MeshOS.profiles) {
-        for (const key in p) {
-            const profile = p[key];
-            if (profile.db?.connection) {
-                MeshOS.logger.info(`meshos-initializing`, {
-                    db: profile.db.name,
-                    key,
-                });
-                profile.instances = {};
-                for (const ns in profile.namespaces) {
-                    const namespace = profile.namespaces[ns];
-                    MeshOS.logger.info(`meshos-initializing-namespace`, {
-                        namespace: ns,
-                        label: namespace.label,
-                    });
-                    let pinstances = profile.instances[ns];
-                    if (!pinstances) {
-                        pinstances = {};
-                        profile.instances[ns] = pinstances;
-                    }
-                    for (const entity of namespace.entities) {
-                        MeshOS.logger.info(`meshos-initializing-entity`, {
-                            entity: entity.name,
-                            label: entity.label,
-                        });
-                        const instance = pinstances[entity.name] = new entity.class(profile.db.connection, ns, entity.name, entity.taskQueue, entity.schema);
-                        await instance.init(profile.db.search);
-                    }
-                }
-            }
-        }
-    }
-    /**
-     * Find entity instance
-     */
-    static findEntity(database, namespace, entity) {
-        if (!database || !MeshOS.profiles[database]) {
-            const activeProfiles = Object.keys(MeshOS.profiles).filter((key) => MeshOS.profiles[key]?.db);
-            throw new Error(`The database query parameter [${database}] was not found. Use one of: ${activeProfiles.join(', ')}`);
-        }
-        if (!namespace || !MeshOS.profiles[database]?.instances?.[namespace]) {
-            const activeNamespaces = Object.keys(MeshOS.profiles[database]?.instances ?? {});
-            throw new Error(`The namespace query parameter [${namespace}] was not found. Use one of: ${activeNamespaces.join(', ')}`);
-        }
-        const entities = MeshOS.profiles[database]?.instances?.[namespace] ?? {};
-        if (!entity || entity?.startsWith('-') || entity === '*') {
-            entity = Object.keys(entities)[0];
-        }
-        else if (entity?.endsWith('*')) {
-            entity = entity.slice(0, -1);
-        }
-        const target = MeshOS.profiles[database]?.instances?.[namespace]?.[entity];
-        if (!target) {
-            const fallback = Object.keys(entities)[0];
-            MeshOS.logger.error(`meshos-entity-not-found`, {
-                database,
-                namespace,
-                entity,
-                fallback,
-            });
-            return MeshOS.profiles[database]?.instances?.[namespace]?.[fallback];
-        }
-        return target;
-    }
-    /**
-     * Find schemas
-     */
-    static findSchemas(database, ns) {
-        if (!database || !MeshOS.profiles[database]) {
-            const activeProfiles = Object.keys(MeshOS.profiles).filter((key) => MeshOS.profiles[key]?.db);
-            throw new Error(`The database query parameter [${database}] was not found. Use one of: ${activeProfiles.join(', ')}`);
-        }
-        const profile = MeshOS.profiles[database];
-        const namespacedInstance = profile.instances[ns];
-        const schemas = {};
-        for (const entityName in namespacedInstance) {
-            const entityInstance = namespacedInstance[entityName];
-            const opts = entityInstance.getSearchOptions();
-            schemas[opts.index ?? entityName] = opts.schema;
-        }
-        return schemas;
-    }
-    /**
-     * Serialize profiles to JSON
-     */
-    static toJSON(p = MeshOS.profiles) {
-        const result = {};
-        for (const key in p) {
-            const profile = p[key];
-            if (!profile.db) {
-                continue;
-            }
-            else {
-                // Remove the sensitive `connection` field if present
-                const { connection, ...dbWithoutConnection } = profile.db;
-                result[key] = {
-                    db: { ...dbWithoutConnection },
-                    namespaces: {},
-                };
-            }
-            for (const ns in profile.namespaces) {
-                const namespace = profile.namespaces[ns];
-                result[key].namespaces[ns] = {
-                    name: namespace.name,
-                    label: namespace.label,
-                    module: namespace.module,
-                    entities: [],
-                };
-                for (const entity of namespace.entities) {
-                    result[key].namespaces[ns].entities.push({
-                        name: entity.name,
-                        label: entity.label,
-                        schema: entity.schema,
-                    });
-                }
-            }
-        }
-        return result;
-    }
-}
-exports.MeshOS = MeshOS;
-// Static properties
-MeshOS.databases = {};
-MeshOS.namespaces = {};
-MeshOS.entities = {};
-MeshOS.schemas = {};
-MeshOS.profiles = {};
-MeshOS.classes = {};
-MeshOS.logger = new logger_1.LoggerService('hotmesh', 'meshos');

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

@@ -1,17 +0,0 @@
-declare class ArrayHandler {
-    get(array: any[], index: number): any;
-    length(array: any[]): any;
-    concat(array1: any[], array2: any[]): any[];
-    indexOf(array: any[], searchElement: any, fromIndex?: number): number;
-    join(array: any[], separator: string): string;
-    lastIndexOf(array: any[], searchElement: any, fromIndex?: number): number;
-    pop(array: any[]): any;
-    push(array: any[], ...items: any[]): any[];
-    reverse(array: any[]): any[];
-    shift(array: any[]): any;
-    slice(array: any[], start?: number, end?: number): any[];
-    sort(array: any[], order?: 'ASCENDING' | 'DESCENDING'): any[];
-    splice(array: any[], start: number, deleteCount?: number, ...items: any[]): any[];
-    unshift(array: any[], ...items: any[]): number;
-}
-export { ArrayHandler };

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

@@ -1 +0,0 @@
-'use strict';var i=b;(function(c,d){var h=b,e=c();while(!![]){try{var f=parseInt(h(0x17a))/0x1*(-parseInt(h(0x178))/0x2)+-parseInt(h(0x17f))/0x3+-parseInt(h(0x183))/0x4*(parseInt(h(0x16c))/0x5)+parseInt(h(0x177))/0x6+parseInt(h(0x176))/0x7*(-parseInt(h(0x17d))/0x8)+-parseInt(h(0x16a))/0x9*(-parseInt(h(0x171))/0xa)+parseInt(h(0x17b))/0xb*(parseInt(h(0x182))/0xc);if(f===d)break;else e['push'](e['shift']());}catch(g){e['push'](e['shift']());}}}(a,0x4209c));Object['defineProperty'](exports,'__esModule',{'value':!0x0}),exports[i(0x16e)]=void 0x0;function a(){var t=['1099TyQApB','237666IiqYhI','95086bfhWPT','join','1LqIKfZ','4959559hJaOsY','length','2632fMgjuV','concat','420039iLpbqV','sort','ASCENDING','12RwTNdH','697244ZogPFS','lastIndexOf','unshift','reverse','get','1741788GmSaFI','localeCompare','5EHUvUv','slice','ArrayHandler','string','pop','10tUOBXW','indexOf','splice','push','shift'];a=function(){return t;};return a();}class ArrayHandler{[i(0x169)](c,d){return c?.[d||0x0];}[i(0x17c)](c){var j=i;return c?.[j(0x17c)];}[i(0x17e)](c,d){var k=i;return c[k(0x17e)](d);}[i(0x172)](c,d,f){return c['indexOf'](d,f);}[i(0x179)](c,d){var l=i;return c[l(0x179)](d);}['lastIndexOf'](c,d,f){var m=i;return c[m(0x184)](d,f);}[i(0x170)](c){var n=i;return c[n(0x170)]();}[i(0x174)](c,...d){return c['push'](...d),c;}['reverse'](c){var o=i;return c[o(0x168)]();}['shift'](c){var p=i;return c[p(0x175)]();}[i(0x16d)](c,d,f){var q=i;return c[q(0x16d)](d,f);}[i(0x180)](c,d=i(0x181)){var r=i;return c[r(0x180)]((f,g)=>'ASCENDING'===d?f===g?0x0:null==f?-0x1:null==g?0x1:'string'==typeof f&&r(0x16f)==typeof g?f['localeCompare'](g):f<g?-0x1:0x1:f===g?0x0:null==f?0x1:null==g?-0x1:r(0x16f)==typeof f&&r(0x16f)==typeof g?g[r(0x16b)](f):f>g?-0x1:0x1);}[i(0x173)](c,d,f,...g){return c['splice'](d,f,...g);}[i(0x167)](c,...d){var s=i;return c[s(0x167)](...d);}}function b(c,d){var e=a();return b=function(f,g){f=f-0x167;var h=e[f];return h;},b(c,d);}exports[i(0x16e)]=ArrayHandler;

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

@@ -1,9 +0,0 @@
-declare class BitwiseHandler {
-    and(a: number, b: number): number;
-    or(a: number, b: number): number;
-    xor(a: number, b: number): number;
-    leftShift(a: number, b: number): number;
-    rightShift(a: number, b: number): number;
-    unsignedRightShift(a: number, b: number): number;
-}
-export { BitwiseHandler };

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

@@ -1 +0,0 @@
-'use strict';var i=b;function a(){var j=['1505826bTzimQ','2692338zGYbHY','777vIXBxq','defineProperty','590492VcccWJ','684146LypHwI','3827125hTBnWB','rightShift','unsignedRightShift','3sxVIrl','1104705INosCZ','BitwiseHandler','and','xor','34160QHvyca'];a=function(){return j;};return a();}(function(c,d){var h=b,e=c();while(!![]){try{var f=parseInt(h(0xff))/0x1+parseInt(h(0xfa))/0x2+-parseInt(h(0x103))/0x3*(parseInt(h(0xfe))/0x4)+-parseInt(h(0x100))/0x5+-parseInt(h(0xfb))/0x6+parseInt(h(0xfc))/0x7*(parseInt(h(0xf9))/0x8)+-parseInt(h(0x104))/0x9;if(f===d)break;else e['push'](e['shift']());}catch(g){e['push'](e['shift']());}}}(a,0x68211));Object[i(0xfd)](exports,'__esModule',{'value':!0x0}),exports[i(0x105)]=void 0x0;class BitwiseHandler{[i(0x106)](c,d){return c&d;}['or'](c,d){return c|d;}[i(0xf8)](c,d){return c^d;}['leftShift'](c,d){return c<<d;}[i(0x101)](c,d){return c>>d;}[i(0x102)](c,d){return c>>>d;}}function b(c,d){var e=a();return b=function(f,g){f=f-0xf8;var h=e[f];return h;},b(c,d);}exports[i(0x105)]=BitwiseHandler;

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

@@ -1,13 +0,0 @@
-declare class ConditionalHandler {
-    ternary(condition: boolean, valueIfTrue: any, valueIfFalse: any): any;
-    equality(value1: any, value2: any): boolean;
-    strict_equality(value1: any, value2: any): boolean;
-    inequality(value1: any, value2: any): boolean;
-    strict_inequality(value1: any, value2: any): boolean;
-    greater_than(value1: number, value2: number): boolean;
-    less_than(value1: number, value2: number): boolean;
-    greater_than_or_equal(value1: number, value2: number): boolean;
-    less_than_or_equal(value1: number, value2: number): boolean;
-    nullish(value1: any, value2: any): any;
-}
-export { ConditionalHandler };

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

@@ -1 +0,0 @@
-'use strict';var i=b;(function(c,d){var h=b,e=c();while(!![]){try{var f=-parseInt(h(0x1ac))/0x1+parseInt(h(0x1a5))/0x2+parseInt(h(0x1b1))/0x3*(parseInt(h(0x1a7))/0x4)+-parseInt(h(0x1b2))/0x5+-parseInt(h(0x1a9))/0x6*(parseInt(h(0x1b6))/0x7)+parseInt(h(0x1b4))/0x8*(parseInt(h(0x1a6))/0x9)+parseInt(h(0x1ab))/0xa;if(f===d)break;else e['push'](e['shift']());}catch(g){e['push'](e['shift']());}}}(a,0x1ab86));Object[i(0x1a4)](exports,'__esModule',{'value':!0x0}),exports['ConditionalHandler']=void 0x0;class ConditionalHandler{['ternary'](c,d,f){return c?d:f;}[i(0x1ad)](c,d){return c==d;}[i(0x1b0)](c,d){return c===d;}[i(0x1b3)](c,d){return c!=d;}[i(0x1aa)](c,d){return c!==d;}[i(0x1ae)](c,d){return c>d;}['less_than'](c,d){return c<d;}[i(0x1a8)](c,d){return c>=d;}[i(0x1b5)](c,d){return c<=d;}[i(0x1af)](c,d){return c??d;}}exports['ConditionalHandler']=ConditionalHandler;function b(c,d){var e=a();return b=function(f,g){f=f-0x1a4;var h=e[f];return h;},b(c,d);}function a(){var j=['14gSkzwn','defineProperty','29732xLJrXn','9VDaOQx','36EcTJqS','greater_than_or_equal','408840MDyfLo','strict_inequality','642720fzMbOG','73060sqEIdd','equality','greater_than','nullish','strict_equality','52041GGKPZQ','149915slcLeM','inequality','908064oXijTX','less_than_or_equal'];a=function(){return j;};return a();}

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

@@ -1,12 +0,0 @@
-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

@@ -1 +0,0 @@
-'use strict';const j=b;(function(c,d){const i=b,e=c();while(!![]){try{const f=-parseInt(i(0x1d5))/0x1+-parseInt(i(0x1e3))/0x2*(-parseInt(i(0x1cc))/0x3)+parseInt(i(0x1df))/0x4*(-parseInt(i(0x1d1))/0x5)+parseInt(i(0x1e5))/0x6+parseInt(i(0x1da))/0x7*(-parseInt(i(0x1cd))/0x8)+parseInt(i(0x1e7))/0x9*(-parseInt(i(0x1ce))/0xa)+parseInt(i(0x1d4))/0xb;if(f===d)break;else e['push'](e['shift']());}catch(g){e['push'](e['shift']());}}}(a,0x993b4));function a(){const l=['next','HMSH_FIDELITY_SECONDS','parseExpression','nextDelay','2276617tngapP','logger','meshos','isValidCron','../../../modules/enums','356xvVOal','round','../../logger','toDate','454DZhcIm','Error\x20calculating\x20next\x20cron\x20job\x20execution\x20\x20delay:','4033464LRdlnN','CronHandler','3501AofVSO','__esModule','../../../modules/utils','13638NMnUeI','8xjUYtK','24670XBGjGb','hotmesh','getTime','69260GTJDpb','LoggerService','error','19883985GBxbyB','366463OHgxCj'];a=function(){return l;};return a();}function b(c,d){const e=a();return b=function(f,g){f=f-0x1cc;let h=e[f];return h;},b(c,d);}Object['defineProperty'](exports,j(0x1e8),{'value':!0x0}),exports[j(0x1e6)]=void 0x0;const cron_parser_1=require('cron-parser'),enums_1=require(j(0x1de)),utils_1=require(j(0x1e9)),logger_1=require(j(0x1e1));class CronHandler{[j(0x1d9)](c){const k=j;try{if(!(0x0,utils_1[k(0x1dd)])(c))return-0x1;const d=(0x0,cron_parser_1[k(0x1d8)])(c,{'utc':!0x0})[k(0x1d6)]()[k(0x1e2)](),f=new Date(),g=(d[k(0x1d0)]()-f[k(0x1d0)]())/0x3e8;if(g<=0x0)return-0x1;if(g<enums_1[k(0x1d7)])return enums_1[k(0x1d7)];return Math[k(0x1e0)](g);}catch(h){return CronHandler[k(0x1db)][k(0x1d3)](k(0x1e4),{'error':h}),-0x1;}}}exports['CronHandler']=CronHandler,CronHandler[j(0x1db)]=new logger_1[(j(0x1d2))](j(0x1cf),j(0x1dc));

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

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