@hotmeshio/hotmesh 0.0.51 → 0.0.53

package/build/services/durable/meshos.d.ts

@@ -1,127 +0,0 @@
-import { WorkflowHandleService } from './handle';
-import { WorkflowService } from './workflow';
-import { FindOptions, FindWhereOptions, FindWhereQuery, MeshOSActivityOptions, MeshOSConfig, MeshOSOptions, MeshOSWorkerOptions, WorkflowSearchOptions } from '../../types/durable';
-import { RedisOptions, RedisClass } from '../../types/redis';
-import { StringAnyType } from '../../types/serializer';
-/**
- * The base class for running MeshOS workflows.
- * Extend this class, add your Redis config, and add functions to
- * execute as durable `hooks`, `workflows`, and `activities`.
- */
-export declare class MeshOSService {
-    /**
-     * The top-level Redis isolation. All workflow data is
-     * isolated within this namespace. Values should be
-     * lower-case with no spaces (e.g, 'staging', 'prod', 'test',
-     * 'routing-stagig', 'reporting-prod', etc.).
-     *  1) only url-safe values are allowed;
-     *  2) the 'a' symbol is reserved by HotMesh for indexing apps
-     */
-    namespace: string;
-    /**
-     * Data is routed to workers that specify this task queue.
-     * Setting the task queue when the worker is created will
-     * ensure that the worker only receives messages destined
-     * for the queue. Callers can specify the taskQue to when
-     * starting a job to call those workers.
-     */
-    taskQueue: string;
-    /**
-     * These methods run as durable workflows
-     */
-    workflowFunctions: Array<MeshOSOptions | string>;
-    /**
-     * These methods run as hooks (hook into a running workflow)
-     */
-    hookFunctions: Array<MeshOSOptions | string>;
-    /**
-     * These methods run as proxied activities (and are safely memoized)
-     */
-    proxyFunctions: Array<MeshOSActivityOptions | string>;
-    /**
-     * The workflow GUID. Workflows will be persisted to
-     * Redis using the pattern hmsh:<namespace>:j:<id>.
-     */
-    id: string;
-    /**
-     * The Redis connection options. NOTE: Redis and IORedis
-     * use different formats for their connection config.
-     */
-    redisOptions: RedisOptions;
-    /**
-     * The Redis connection class.
-     *
-     * @example
-     * import Redis from 'ioredis';
-     * import * as Redis from 'redis';
-     */
-    redisClass: RedisClass;
-    /**
-     * Optional model declaration (custom workflow state)
-     */
-    model: StringAnyType;
-    /**
-     * Optional configuration for Redis FT search
-     */
-    search: WorkflowSearchOptions;
-    static MeshOS: typeof WorkflowService;
-    static getHotMeshClient(redisClass: RedisClass, redisOptions: RedisOptions, namespace: string, taskQueue: string): Promise<import("../hotmesh").HotMeshService>;
-    /**
-     * mints a workflow ID, using the search prefix.
-     * NOTE: The prefix is necesary when indexing
-     *       HASHes when FT search is enabled.
-     * @returns {string}
-     */
-    static mintGuid(): string;
-    /**
-     * Creates an FT search index
-     */
-    static createIndex(): Promise<void>;
-    /**
-     * Lists FT search indexes
-     */
-    static listIndexes(): Promise<string[]>;
-    /**
-     * stop the workers
-     * @returns {Promise<void>}
-     */
-    static stopWorkers(): Promise<void>;
-    /**
-     * Initializes the worker(s). This is a static
-     * method that allows for optional task Queue targeting.
-     * An `allowList` may be optionally provided to start
-     * specific `worker` and `hook` methods.
-     * @param {MeshOSWorkerOptions} [options]
-     */
-    static startWorkers(options?: MeshOSWorkerOptions): Promise<void>;
-    /**
-     * executes the redis FT search query; optionally specify other commands
-     * @example '@_quantity:[89 89]'
-     * @example '@_quantity:[89 89] @_name:"John"'
-     * @example 'FT.search my-index @_quantity:[89 89]'
-     * @param {FindOptions} options
-     * @param {any[]} args
-     * @returns {Promise<string[] | [number] | Array<number, string | number | string[]>>}
-     */
-    static find(options: FindOptions, ...args: string[]): Promise<string[] | [number] | Array<string | number | string[]>>;
-    /**
-     * Provides a JSON abstraction for the Redis FT.search command
-     * (e.g, `count`, `query`, `return`, `limit`)
-     * @param {FindWhereOptions} options
-     * @returns {Promise<string[] | [number] | Array<string | number | string[]>>}
-     */
-    static findWhere(options: FindWhereOptions): Promise<string[] | [number] | Array<string | number | string[]>>;
-    static generateSearchQuery(query: FindWhereQuery[]): string;
-    /**
-     * returns the workflow handle. The handle can then be
-     * used to query for status, state, custom state, etc.
-     * @param {string} id
-     * @returns {Promise<WorkflowHandleService>}
-     */
-    static get(id: string): Promise<WorkflowHandleService>;
-    /**
-     * Optionally include a target taskQueue to exec the
-     * workflow's call on a specific worker queue.
-     */
-    constructor(id?: string | MeshOSConfig, options?: MeshOSConfig);
-}

package/build/services/durable/meshos.js

@@ -1,380 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MeshOSService = void 0;
-const _1 = require(".");
-const storage_1 = require("../../modules/storage");
-const client_1 = require("./client");
-const search_1 = require("./search");
-const worker_1 = require("./worker");
-const workflow_1 = require("./workflow");
-const utils_1 = require("../../modules/utils");
-/**
- * The base class for running MeshOS workflows.
- * Extend this class, add your Redis config, and add functions to
- * execute as durable `hooks`, `workflows`, and `activities`.
- */
-class MeshOSService {
-    static async getHotMeshClient(redisClass, redisOptions, namespace, taskQueue) {
-        const client = new client_1.ClientService({
-            connection: {
-                class: redisClass,
-                options: redisOptions,
-            }
-        });
-        return await client.getHotMeshClient(taskQueue, namespace);
-    }
-    /**
-     * mints a workflow ID, using the search prefix.
-     * NOTE: The prefix is necesary when indexing
-     *       HASHes when FT search is enabled.
-     * @returns {string}
-     */
-    static mintGuid() {
-        const my = new this();
-        return `${my.search?.prefix?.[0]}${(0, utils_1.guid)()}`;
-    }
-    /**
-     * Creates an FT search index
-     */
-    static async createIndex() {
-        const my = new this();
-        const hmClient = await MeshOSService.getHotMeshClient(my.redisClass, my.redisOptions, my.namespace, my.taskQueue);
-        await search_1.Search.configureSearchIndex(hmClient, my.search);
-    }
-    /**
-     * Lists FT search indexes
-     */
-    static async listIndexes() {
-        const my = new this();
-        const hmClient = await MeshOSService.getHotMeshClient(my.redisClass, my.redisOptions, my.namespace, my.taskQueue);
-        return await search_1.Search.listSearchIndexes(hmClient);
-    }
-    /**
-     * stop the workers
-     * @returns {Promise<void>}
-     */
-    static async stopWorkers() {
-        await _1.Durable.shutdown();
-    }
-    /**
-     * Initializes the worker(s). This is a static
-     * method that allows for optional task Queue targeting.
-     * An `allowList` may be optionally provided to start
-     * specific `worker` and `hook` methods.
-     * @param {MeshOSWorkerOptions} [options]
-     */
-    static async startWorkers(options) {
-        const taskQueue = options && options.taskQueue;
-        const allowList = options && options.allowList || [];
-        const my = new this();
-        //helper functions
-        const resolveFunctionNames = (arr) => arr.map(item => typeof item === 'string' ? item : item.name);
-        const belongsTo = (name, target) => {
-            const isWorkflow = target.find((item) => {
-                return typeof item === 'string' ? item === name : item.name === name;
-            });
-            return isWorkflow !== undefined;
-        };
-        // proxy registered activities
-        const proxyFunctionNames = resolveFunctionNames([...my.proxyFunctions]);
-        if (proxyFunctionNames.length) {
-            const proxyActivities = proxyFunctionNames.reduce((acc, funcName) => {
-                let originalMethod = my[funcName];
-                if (typeof originalMethod === 'function') {
-                    acc[funcName] = async (...args) => {
-                        return await originalMethod.apply(my, args);
-                    };
-                }
-                return acc;
-            }, {});
-            const proxiedActivities = _1.Durable.workflow.proxyActivities({
-                activities: proxyActivities
-            });
-            Object.assign(my, proxiedActivities);
-        }
-        const functionsToIterate = allowList.length ? resolveFunctionNames(allowList) : resolveFunctionNames([...my.workflowFunctions, ...my.hookFunctions]);
-        // Iterating through the functions sequentially
-        for (const funcName of functionsToIterate) {
-            const originalMethod = my[funcName];
-            if (typeof originalMethod === 'function') {
-                //wrap the function to return
-                const wrappedFunction = {
-                    [funcName]: async (...args) => {
-                        const store = storage_1.asyncLocalStorage.getStore();
-                        const workflowId = store.get('workflowId');
-                        //use a Proxy to wrap hook methods
-                        const context = new Proxy(my, {
-                            get: (target, prop, receiver) => {
-                                if (prop === 'id') {
-                                    return workflowId;
-                                }
-                                else if (typeof target[prop] === 'function') {
-                                    return (...args) => {
-                                        return new Promise(async (resolve, reject) => {
-                                            if (belongsTo(prop, my.hookFunctions)) {
-                                                return workflow_1.WorkflowService.hook({
-                                                    namespace: my.namespace,
-                                                    taskQueue: my.taskQueue,
-                                                    workflowName: prop,
-                                                    workflowId,
-                                                    args,
-                                                }).then(resolve).catch(reject);
-                                            }
-                                            //otherwise, call the method as a standard instance method.
-                                            target[prop].apply(this, args).then(resolve).catch(reject);
-                                        });
-                                    };
-                                }
-                                return Reflect.get(target, prop, receiver);
-                            },
-                        });
-                        return await originalMethod.apply(context, args);
-                    }
-                };
-                //start the worker
-                await worker_1.WorkerService.create({
-                    namespace: my.namespace,
-                    connection: {
-                        class: my.redisClass,
-                        options: my.redisOptions,
-                    },
-                    taskQueue: taskQueue ?? my.taskQueue,
-                    workflow: wrappedFunction,
-                });
-            }
-        }
-    }
-    /**
-     * executes the redis FT search query; optionally specify other commands
-     * @example '@_quantity:[89 89]'
-     * @example '@_quantity:[89 89] @_name:"John"'
-     * @example 'FT.search my-index @_quantity:[89 89]'
-     * @param {FindOptions} options
-     * @param {any[]} args
-     * @returns {Promise<string[] | [number] | Array<number, string | number | string[]>>}
-     */
-    static async find(options, ...args) {
-        const my = new this();
-        const client = new client_1.ClientService({ connection: {
-                class: my.redisClass,
-                options: my.redisOptions
-            } });
-        let workflowName;
-        if (options.workflowName) {
-            workflowName = options?.workflowName;
-        }
-        else if (my.workflowFunctions?.length) {
-            let target = my.workflowFunctions[0];
-            if (typeof target === 'string') {
-                workflowName = target;
-            }
-            else {
-                workflowName = target.name;
-            }
-        }
-        return await client.workflow.search(options.taskQueue ?? my.taskQueue, workflowName, options.namespace ?? my.namespace, options.index ?? my.search.index, ...args); //[count, [id, fields[]], [id, fields[]], [id, fields[]], ...]]
-    }
-    /**
-     * Provides a JSON abstraction for the Redis FT.search command
-     * (e.g, `count`, `query`, `return`, `limit`)
-     * @param {FindWhereOptions} options
-     * @returns {Promise<string[] | [number] | Array<string | number | string[]>>}
-     */
-    static async findWhere(options) {
-        const args = [this.generateSearchQuery(options.query)];
-        if (options.count) {
-            args.push('LIMIT', '0', '0');
-        }
-        else {
-            //limit which hash fields to return
-            args.push('RETURN');
-            args.push(((options.return?.length ?? 0) + 1).toString());
-            args.push('$');
-            options.return?.forEach(returnField => {
-                if (returnField.startsWith('"')) {
-                    //allow literal values to be requested
-                    args.push(returnField.slice(1, -1));
-                }
-                else {
-                    args.push(`_${returnField}`);
-                }
-            });
-            //paginate
-            if (options.limit) {
-                args.push('LIMIT', options.limit.start.toString(), options.limit.size.toString());
-            }
-        }
-        return await this.find(options.options ?? {}, ...args);
-    }
-    static generateSearchQuery(query) {
-        if (!Array.isArray(query) || query.length === 0) {
-            return '*';
-        }
-        const my = new this();
-        let queryString = query.map(q => {
-            const { field, is, value, type } = q;
-            const prefixedFieldName = my.search?.schema && field in my.search.schema ? `@_${field}` : `@${field}`;
-            const fieldType = my.search?.schema[field]?.type ?? type ?? 'TEXT';
-            switch (fieldType) {
-                case 'TAG':
-                    return `${prefixedFieldName}:{${value}}`;
-                case 'TEXT':
-                    return `${prefixedFieldName}:"${value}"`;
-                case 'NUMERIC':
-                    let range = '';
-                    if (is.startsWith('=')) { //equal
-                        range = `[${value} ${value}]`;
-                    }
-                    else if (is.startsWith('<')) { //less than or equal
-                        range = `[-inf ${value}]`;
-                    }
-                    else if (is.startsWith('>')) { //greater than or equal
-                        range = `[${value} +inf]`;
-                    }
-                    else if (is === '[]') { //between
-                        range = `[${value[0]} ${value[1]}]`;
-                    }
-                    return `${prefixedFieldName}:${range}`;
-                default:
-                    return '';
-            }
-        }).join(' ');
-        return queryString;
-    }
-    /**
-     * returns the workflow handle. The handle can then be
-     * used to query for status, state, custom state, etc.
-     * @param {string} id
-     * @returns {Promise<WorkflowHandleService>}
-     */
-    static async get(id) {
-        const my = new this();
-        const client = new client_1.ClientService({ connection: {
-                class: my.redisClass,
-                options: my.redisOptions
-            } });
-        let workflowName;
-        let target = my.workflowFunctions[0];
-        if (typeof target === 'string') {
-            workflowName = target;
-        }
-        else {
-            workflowName = target.name;
-        }
-        return await client.workflow.getHandle(my.taskQueue, workflowName, id, my.namespace);
-    }
-    /**
-     * Optionally include a target taskQueue to exec the
-     * workflow's call on a specific worker queue.
-     */
-    constructor(id, options) {
-        /**
-         * The top-level Redis isolation. All workflow data is
-         * isolated within this namespace. Values should be
-         * lower-case with no spaces (e.g, 'staging', 'prod', 'test',
-         * 'routing-stagig', 'reporting-prod', etc.).
-         *  1) only url-safe values are allowed;
-         *  2) the 'a' symbol is reserved by HotMesh for indexing apps
-         */
-        this.namespace = 'durable';
-        /**
-         * Data is routed to workers that specify this task queue.
-         * Setting the task queue when the worker is created will
-         * ensure that the worker only receives messages destined
-         * for the queue. Callers can specify the taskQue to when
-         * starting a job to call those workers.
-         */
-        this.taskQueue = 'default';
-        /**
-         * These methods run as durable workflows
-         */
-        this.workflowFunctions = [];
-        /**
-         * These methods run as hooks (hook into a running workflow)
-         */
-        this.hookFunctions = [];
-        /**
-         * These methods run as proxied activities (and are safely memoized)
-         */
-        this.proxyFunctions = [];
-        /**
-         * The Redis connection options. NOTE: Redis and IORedis
-         * use different formats for their connection config.
-         */
-        this.redisOptions = {
-            host: 'localhost',
-            port: 6379,
-            password: '',
-            db: 0,
-        };
-        if (typeof (id) === 'string') {
-            this.id = id;
-        }
-        else if (id?.id) {
-            this.id = id.id;
-            options = id;
-            id = undefined;
-        }
-        ;
-        if (options?.taskQueue) {
-            this.taskQueue = options.taskQueue;
-        }
-        else if (!id && !options?.taskQueue) {
-            return this;
-        }
-        function belongsTo(name, target) {
-            const isWorkflow = target.find((item) => {
-                return typeof item === 'string' ? item === name : item.name === name;
-            });
-            return isWorkflow !== undefined;
-        }
-        return new Proxy(this, {
-            get: (target, prop, receiver) => {
-                if (typeof target[prop] === 'function') {
-                    return (...args) => {
-                        return new Promise(async (resolve, reject) => {
-                            const client = new client_1.ClientService({ connection: {
-                                    class: this.redisClass,
-                                    options: this.redisOptions
-                                } });
-                            if (belongsTo(prop, this.workflowFunctions)) {
-                                //start a new workflow
-                                const handle = await client.workflow.start({
-                                    namespace: this.namespace,
-                                    args,
-                                    taskQueue: this.taskQueue,
-                                    workflowName: prop,
-                                    workflowId: this.id,
-                                });
-                                if (options?.await) {
-                                    //wait for the workflow to complete
-                                    const result = await handle.result();
-                                    return resolve(result);
-                                }
-                                else {
-                                    //return the workflow handle
-                                    return resolve(handle);
-                                }
-                            }
-                            else if (belongsTo(prop, this.hookFunctions)) {
-                                //hook into a running workflow
-                                return client.workflow.hook({
-                                    namespace: this.namespace,
-                                    taskQueue: this.taskQueue,
-                                    workflowName: prop,
-                                    workflowId: this.id,
-                                    args,
-                                }).then(resolve).catch(reject);
-                            }
-                            //otherwise, call the method as a standard instance method.
-                            target[prop].apply(this, args).then(resolve).catch(reject);
-                        });
-                    };
-                }
-                return Reflect.get(target, prop, receiver);
-            },
-        });
-    }
-}
-MeshOSService.MeshOS = workflow_1.WorkflowService;
-exports.MeshOSService = MeshOSService;