@hotmeshio/hotmesh 0.3.31 → 0.4.0

package/build/services/meshflow/handle.d.ts

@@ -1,90 +0,0 @@
-import { HotMesh } from '../hotmesh';
-import { MeshFlowJobExport, ExportOptions } from '../../types/exporter';
-import { JobInterruptOptions } from '../../types/job';
-import { StreamError } from '../../types/stream';
-import { ExporterService } from './exporter';
-/**
- * The WorkflowHandleService provides methods to interact with a running
- * workflow. This includes exporting the workflow, sending signals, and
- * querying the state of the workflow. It is instanced/accessed via the
- * MeshFlow.Client class.
- *
- * @example
- * ```typescript
- * import { Client } from '@hotmeshio/hotmesh';
- * import { Client as Postgres } from 'pg';
- *
- * const client = new Client({ connection: {
- *   class: Postgres,
- *   options: { connectionString: 'postgres://user:pass@localhost:5432/db' }
- * }});
- *
- * const handle = await client.workflow.start({
- *  args: ['HotMesh'],
- *  taskQueue: 'hello-world',
- * });
- *
- * //perform actions like send a signal
- * await handle.signal('my-signal', { data: 'Hello' });
- * ```
- */
-export declare class WorkflowHandleService {
-    /**
-     * @private
-     */
-    exporter: ExporterService;
-    hotMesh: HotMesh;
-    workflowTopic: string;
-    workflowId: string;
-    /**
-     * @private
-     */
-    constructor(hotMesh: HotMesh, workflowTopic: string, workflowId: string);
-    /**
-     * Exports the workflow state to a JSON object.
-     */
-    export(options?: ExportOptions): Promise<MeshFlowJobExport>;
-    /**
-     * Sends a signal to the workflow. This is a way to send
-     * a message to a workflow that is paused due to having
-     * executed `MeshFlow.workflow.waitFor`. The workflow
-     * will awaken if no other signals are pending.
-     */
-    signal(signalId: string, data: Record<any, any>): Promise<void>;
-    /**
-     * Returns the job state of the workflow. If the workflow has completed
-     * this is also the job output. If the workflow is still running, this
-     * is the current state of the job, but it may change depending upon
-     * the activities that remain.
-     */
-    state(metadata?: boolean): Promise<Record<string, any>>;
-    /**
-     * Returns the current search state of the workflow. This is
-     * different than the job state or individual activity state.
-     * Search state represents name/value pairs that were added
-     * to the workflow.
-     */
-    queryState(fields: string[]): Promise<Record<string, any>>;
-    /**
-     * Returns the current status of the workflow. This is a semaphore
-     * value that represents the current state of the workflow, where
-     * 0 is complete and a negative value represents that the flow was
-     * interrupted.
-     */
-    status(): Promise<number>;
-    /**
-     * Interrupts a running workflow. Standard Job Completion tasks will
-     * run. Subscribers will be notified and the job hash will be expired.
-     */
-    interrupt(options?: JobInterruptOptions): Promise<string>;
-    /**
-     * Waits for the workflow to complete and returns the result. If
-     * the workflow response includes an error, this method will rethrow
-     * the error, including the stack trace if available.
-     * Wrap calls in a try/catch as necessary to avoid unhandled exceptions.
-     */
-    result<T>(config?: {
-        state?: boolean;
-        throwOnError?: boolean;
-    }): Promise<T | StreamError>;
-}

package/build/services/meshflow/handle.js

@@ -1,176 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WorkflowHandleService = void 0;
-const exporter_1 = require("./exporter");
-/**
- * The WorkflowHandleService provides methods to interact with a running
- * workflow. This includes exporting the workflow, sending signals, and
- * querying the state of the workflow. It is instanced/accessed via the
- * MeshFlow.Client class.
- *
- * @example
- * ```typescript
- * import { Client } from '@hotmeshio/hotmesh';
- * import { Client as Postgres } from 'pg';
- *
- * const client = new Client({ connection: {
- *   class: Postgres,
- *   options: { connectionString: 'postgres://user:pass@localhost:5432/db' }
- * }});
- *
- * const handle = await client.workflow.start({
- *  args: ['HotMesh'],
- *  taskQueue: 'hello-world',
- * });
- *
- * //perform actions like send a signal
- * await handle.signal('my-signal', { data: 'Hello' });
- * ```
- */
-class WorkflowHandleService {
-    /**
-     * @private
-     */
-    constructor(hotMesh, workflowTopic, workflowId) {
-        this.workflowTopic = workflowTopic;
-        this.workflowId = workflowId;
-        this.hotMesh = hotMesh;
-        this.exporter = new exporter_1.ExporterService(this.hotMesh.appId, this.hotMesh.engine.store, this.hotMesh.engine.logger);
-    }
-    /**
-     * Exports the workflow state to a JSON object.
-     */
-    async export(options) {
-        return this.exporter.export(this.workflowId, options);
-    }
-    /**
-     * Sends a signal to the workflow. This is a way to send
-     * a message to a workflow that is paused due to having
-     * executed `MeshFlow.workflow.waitFor`. The workflow
-     * will awaken if no other signals are pending.
-     */
-    async signal(signalId, data) {
-        await this.hotMesh.hook(`${this.hotMesh.appId}.wfs.signal`, {
-            id: signalId,
-            data,
-        });
-    }
-    /**
-     * Returns the job state of the workflow. If the workflow has completed
-     * this is also the job output. If the workflow is still running, this
-     * is the current state of the job, but it may change depending upon
-     * the activities that remain.
-     */
-    async state(metadata = false) {
-        const state = await this.hotMesh.getState(`${this.hotMesh.appId}.execute`, this.workflowId);
-        if (!state.data && state.metadata.err) {
-            throw new Error(JSON.parse(state.metadata.err));
-        }
-        return metadata ? state : state.data;
-    }
-    /**
-     * Returns the current search state of the workflow. This is
-     * different than the job state or individual activity state.
-     * Search state represents name/value pairs that were added
-     * to the workflow.
-     */
-    async queryState(fields) {
-        return await this.hotMesh.getQueryState(this.workflowId, fields);
-    }
-    /**
-     * Returns the current status of the workflow. This is a semaphore
-     * value that represents the current state of the workflow, where
-     * 0 is complete and a negative value represents that the flow was
-     * interrupted.
-     */
-    async status() {
-        return await this.hotMesh.getStatus(this.workflowId);
-    }
-    /**
-     * Interrupts a running workflow. Standard Job Completion tasks will
-     * run. Subscribers will be notified and the job hash will be expired.
-     */
-    async interrupt(options) {
-        return await this.hotMesh.interrupt(`${this.hotMesh.appId}.execute`, this.workflowId, options);
-    }
-    /**
-     * Waits for the workflow to complete and returns the result. If
-     * the workflow response includes an error, this method will rethrow
-     * the error, including the stack trace if available.
-     * Wrap calls in a try/catch as necessary to avoid unhandled exceptions.
-     */
-    async result(config) {
-        const topic = `${this.hotMesh.appId}.executed.${this.workflowId}`;
-        let isResolved = false;
-        return new Promise(async (resolve, reject) => {
-            /**
-             * rejects/resolves the promise based on the `throwOnError`
-             * default behavior is to throw if error
-             */
-            const safeReject = (err) => {
-                if (config?.throwOnError === false) {
-                    return resolve(err);
-                }
-                reject(err);
-            };
-            /**
-             * Common completion function that unsubscribes from the topic/returns
-             */
-            const complete = async (response, err) => {
-                if (isResolved)
-                    return;
-                isResolved = true;
-                if (err) {
-                    return safeReject(err);
-                }
-                else if (!response) {
-                    const state = await this.hotMesh.getState(`${this.hotMesh.appId}.execute`, this.workflowId);
-                    if (state.data?.done && !state.data?.$error) {
-                        return resolve(state.data.response);
-                    }
-                    else if (state.data?.$error) {
-                        return safeReject(state.data.$error);
-                    }
-                    else if (state.metadata.err) {
-                        return safeReject(JSON.parse(state.metadata.err));
-                    }
-                    response = state.data?.response;
-                }
-                resolve(response);
-            };
-            //more expensive; fetches the entire job, not just the `status`
-            if (config?.state) {
-                const state = await this.hotMesh.getState(`${this.hotMesh.appId}.execute`, this.workflowId);
-                if (state?.data?.done && !state.data?.$error) {
-                    return complete(state.data.response);
-                }
-                else if (state.data?.$error) {
-                    return complete(null, state.data.$error);
-                }
-                else if (state.metadata.err) {
-                    return complete(null, JSON.parse(state.metadata.err));
-                }
-            }
-            //subscribe to 'done' topic
-            this.hotMesh.sub(topic, async (_topic, state) => {
-                this.hotMesh.unsub(topic);
-                if (state.data.done && !state.data?.$error) {
-                    await complete(state.data?.response);
-                }
-                else if (state.data?.$error) {
-                    return complete(null, state.data.$error);
-                }
-                else if (state.metadata.err) {
-                    const error = JSON.parse(state.metadata.err);
-                    return await complete(null, error);
-                }
-            });
-            //check state in case completed during wiring
-            const status = await this.hotMesh.getStatus(this.workflowId);
-            if (status <= 0) {
-                await complete();
-            }
-        });
-    }
-}
-exports.WorkflowHandleService = WorkflowHandleService;

package/build/services/meshflow/index.d.ts

@@ -1,111 +0,0 @@
-import { ContextType } from '../../types/meshflow';
-import { ClientService } from './client';
-import { ConnectionService } from './connection';
-import { Search } from './search';
-import { WorkerService } from './worker';
-import { WorkflowService } from './workflow';
-import { WorkflowHandleService } from './handle';
-/**
- * The MeshFlow service is a collection of services that
- * emulate Temporal's capabilities, but instead are
- * backed by Postgres or Redis/ValKey. The following lifecycle example
- * demonstrates how to start a new workflow, subscribe
- * to the result, and shutdown the system.
- *
- * @example
- * ```typescript
- * import { Client, Worker, MeshFlow, HotMesh } from '@hotmeshio/hotmesh';
- * import { Client as Postgres} from 'pg';
- * import * as workflows from './workflows';
- *
- * //1) Initialize the worker
- * await Worker.create({
- *   connection: {
- *     class: Postgres,
- *     options: {
- *       connectionString: 'postgresql://usr:pwd@localhost:5432/db',
- *     }
- *   }
- *   taskQueue: 'default',
- *   namespace: 'meshflow',
- *   workflow: workflows.example,
- *   options: {
- *     backoffCoefficient: 2,
- *     maximumAttempts: 1_000,
- *     maximumInterval: '5 seconds'
- *   }
- * });
- *
- * //2) initialize the client
- * const client = new Client({
- *   connection: {
- *     class: Postgres,
- *     options: {
- *       connectionString: 'postgresql://usr:pwd@localhost:5432/db',
- *     }
- *   }
- * });
- *
- * //3) start a new workflow
- * const handle = await client.workflow.start({
- *   args: ['HotMesh', 'es'],
- *   taskQueue: 'default',
- *   workflowName: 'example',
- *   workflowId: HotMesh.guid(),
- *   namespace: 'meshflow',
- * });
- *
- * //4) subscribe to the eventual result
- * console.log('\nRESPONSE', await handle.result(), '\n');
- * //logs '¡Hola, HotMesh!'
- *
- * //5) Shutdown (typically on sigint)
- * await MeshFlow.shutdown();
- * ```
- */
-declare class MeshFlowClass {
-    /**
-     * @private
-     */
-    constructor();
-    /**
-     * The MeshFlow `Client` service is functionally
-     * equivalent to the Temporal `Client` service.
-     */
-    static Client: typeof ClientService;
-    /**
-     * The MeshFlow `Connection` service is functionally
-     * equivalent to the Temporal `Connection` service.
-     */
-    static Connection: typeof ConnectionService;
-    /**
-     * @private
-     */
-    static Search: typeof Search;
-    /**
-     * The Handle provides methods to interact with a running
-     * workflow. This includes exporting the workflow, sending signals, and
-     * querying the state of the workflow. An instance of the Handle service
-     * is typically accessed via the MeshFlow.Client class (workflow.getHandle).
-     */
-    static Handle: typeof WorkflowHandleService;
-    /**
-     * The MeshFlow `Worker` service is functionally
-     * equivalent to the Temporal `Worker` service.
-     */
-    static Worker: typeof WorkerService;
-    /**
-     * The MeshFlow `workflow` service is functionally
-     * equivalent to the Temporal `Workflow` service
-     * with additional methods for managing workflows,
-     * including: `execChild`, `waitFor`, `sleep`, etc
-     */
-    static workflow: typeof WorkflowService;
-    /**
-     * Shutdown everything. All connections, workers, and clients will be closed.
-     * Include in your signal handlers to ensure a clean shutdown.
-     */
-    static shutdown(): Promise<void>;
-}
-export { MeshFlowClass as MeshFlow };
-export type { ContextType };

package/build/services/meshflow/index.js

@@ -1,117 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MeshFlow = void 0;
-const hotmesh_1 = require("../hotmesh");
-const client_1 = require("./client");
-const connection_1 = require("./connection");
-const search_1 = require("./search");
-const worker_1 = require("./worker");
-const workflow_1 = require("./workflow");
-const handle_1 = require("./handle");
-/**
- * The MeshFlow service is a collection of services that
- * emulate Temporal's capabilities, but instead are
- * backed by Postgres or Redis/ValKey. The following lifecycle example
- * demonstrates how to start a new workflow, subscribe
- * to the result, and shutdown the system.
- *
- * @example
- * ```typescript
- * import { Client, Worker, MeshFlow, HotMesh } from '@hotmeshio/hotmesh';
- * import { Client as Postgres} from 'pg';
- * import * as workflows from './workflows';
- *
- * //1) Initialize the worker
- * await Worker.create({
- *   connection: {
- *     class: Postgres,
- *     options: {
- *       connectionString: 'postgresql://usr:pwd@localhost:5432/db',
- *     }
- *   }
- *   taskQueue: 'default',
- *   namespace: 'meshflow',
- *   workflow: workflows.example,
- *   options: {
- *     backoffCoefficient: 2,
- *     maximumAttempts: 1_000,
- *     maximumInterval: '5 seconds'
- *   }
- * });
- *
- * //2) initialize the client
- * const client = new Client({
- *   connection: {
- *     class: Postgres,
- *     options: {
- *       connectionString: 'postgresql://usr:pwd@localhost:5432/db',
- *     }
- *   }
- * });
- *
- * //3) start a new workflow
- * const handle = await client.workflow.start({
- *   args: ['HotMesh', 'es'],
- *   taskQueue: 'default',
- *   workflowName: 'example',
- *   workflowId: HotMesh.guid(),
- *   namespace: 'meshflow',
- * });
- *
- * //4) subscribe to the eventual result
- * console.log('\nRESPONSE', await handle.result(), '\n');
- * //logs '¡Hola, HotMesh!'
- *
- * //5) Shutdown (typically on sigint)
- * await MeshFlow.shutdown();
- * ```
- */
-class MeshFlowClass {
-    /**
-     * @private
-     */
-    constructor() { }
-    /**
-     * Shutdown everything. All connections, workers, and clients will be closed.
-     * Include in your signal handlers to ensure a clean shutdown.
-     */
-    static async shutdown() {
-        await MeshFlowClass.Client.shutdown();
-        await MeshFlowClass.Worker.shutdown();
-        await hotmesh_1.HotMesh.stop();
-    }
-}
-exports.MeshFlow = MeshFlowClass;
-/**
- * The MeshFlow `Client` service is functionally
- * equivalent to the Temporal `Client` service.
- */
-MeshFlowClass.Client = client_1.ClientService;
-/**
- * The MeshFlow `Connection` service is functionally
- * equivalent to the Temporal `Connection` service.
- */
-MeshFlowClass.Connection = connection_1.ConnectionService;
-/**
- * @private
- */
-MeshFlowClass.Search = search_1.Search;
-/**
- * The Handle provides methods to interact with a running
- * workflow. This includes exporting the workflow, sending signals, and
- * querying the state of the workflow. An instance of the Handle service
- * is typically accessed via the MeshFlow.Client class (workflow.getHandle).
- */
-MeshFlowClass.Handle = handle_1.WorkflowHandleService;
-/**
- * The MeshFlow `Worker` service is functionally
- * equivalent to the Temporal `Worker` service.
- */
-MeshFlowClass.Worker = worker_1.WorkerService;
-/**
- * The MeshFlow `workflow` service is functionally
- * equivalent to the Temporal `Workflow` service
- * with additional methods for managing workflows,
- * including: `execChild`, `waitFor`, `sleep`, etc
- */
-MeshFlowClass.workflow = workflow_1.WorkflowService;

package/build/services/meshflow/schemas/factory.d.ts

@@ -1,29 +0,0 @@
-/**
- *********** HOTMESH 'MESHFLOW' MODULE APPLICATION GRAPH **********
- *
- * This HotMesh application spec uses 50 activities and 25 transitions
- * to model and emulate the Temporal Application & Query servers using
- * a pluggable backend.
- *
- * This YAML file can also serve as a useful starting point for building
- * Integration/BPM/Workflow servers in general (MuleSoft, etc) without the need
- * for a physical application server.
- *
- * Possible use cases include:
- * * Orchestration servers
- * * Integration servers
- * * BPMN engines
- * * Reentrant process servers
- * * Service Meshes
- * * Master Data Management systems
- */
-declare const APP_VERSION = "4";
-declare const APP_ID = "meshflow";
-/**
- * returns a new meshflow workflow schema
- * @param {string} app - app name (e.g., 'meshflow')
- * @param {string} version - number as string (e.g., '1')
- * @returns {string} HotMesh App YAML
- */
-declare const getWorkflowYAML: (app: string, version: string) => string;
-export { getWorkflowYAML, APP_VERSION, APP_ID };