@hotmeshio/hotmesh 0.4.0 → 0.4.2

package/build/services/memflow/index.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemFlow = void 0;
+const hotmesh_1 = require("../hotmesh");
+const client_1 = require("./client");
+const connection_1 = require("./connection");
+const search_1 = require("./search");
+const context_1 = require("./context");
+const worker_1 = require("./worker");
+const workflow_1 = require("./workflow");
+const handle_1 = require("./handle");
+/**
+ * The MemFlow 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, MemFlow, 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: 'memflow',
+ *   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: 'memflow',
+ * });
+ *
+ * //4) subscribe to the eventual result
+ * console.log('\nRESPONSE', await handle.result(), '\n');
+ * //logs '¡Hola, HotMesh!'
+ *
+ * //5) Shutdown (typically on sigint)
+ * await MemFlow.shutdown();
+ * ```
+ */
+class MemFlowClass {
+    /**
+     * @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 MemFlowClass.Client.shutdown();
+        await MemFlowClass.Worker.shutdown();
+        await hotmesh_1.HotMesh.stop();
+    }
+}
+exports.MemFlow = MemFlowClass;
+/**
+ * The MemFlow `Client` service is functionally
+ * equivalent to the Temporal `Client` service.
+ */
+MemFlowClass.Client = client_1.ClientService;
+/**
+ * The MemFlow `Connection` service is functionally
+ * equivalent to the Temporal `Connection` service.
+ */
+MemFlowClass.Connection = connection_1.ConnectionService;
+/**
+ * @private
+ */
+MemFlowClass.Search = search_1.Search;
+/**
+ * @private
+ */
+MemFlowClass.Context = context_1.Context;
+/**
+ * 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 MemFlow.Client class (workflow.getHandle).
+ */
+MemFlowClass.Handle = handle_1.WorkflowHandleService;
+/**
+ * The MemFlow `Worker` service is functionally
+ * equivalent to the Temporal `Worker` service.
+ */
+MemFlowClass.Worker = worker_1.WorkerService;
+/**
+ * The MemFlow `workflow` service is functionally
+ * equivalent to the Temporal `Workflow` service
+ * with additional methods for managing workflows,
+ * including: `execChild`, `waitFor`, `sleep`, etc
+ */
+MemFlowClass.workflow = workflow_1.WorkflowService;

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

@@ -0,0 +1,29 @@
+/**
+ *********** HOTMESH 'MEMFLOW' 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 = "memflow";
+/**
+ * returns a new memflow workflow schema
+ * @param {string} app - app name (e.g., 'memflow')
+ * @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 };