@hotmeshio/hotmesh 0.1.16 → 0.2.0

package/README.md

@@ -12,8 +12,8 @@ You have a Redis instance? Good. You're ready to go.
 ## SDK Docs
 [Read the Docs](https://hotmeshio.github.io/sdk-typescript/)
 
-## MeshCall
-The **MeshCall** module connects and exposes your functions as idempotent endpoints.
+## MeshCall | Connect Everything
+The **MeshCall** module connects any function with a connection to Redis. Function responses are cacheable and functions can even run as cyclical cron jobs. Make blazing fast interservice calls that return in milliseconds without the overhead of HTTP.
 
 <details style="padding: .5em">
   <summary style="font-size:1.25em;">Run an idempotent cron job</summary>
@@ -21,7 +21,7 @@ The **MeshCall** module connects and exposes your functions as idempotent endpoi
   ### Run a Cron
   This example demonstrates an *idempotent* cron that runs every day. The `id` makes each cron job unique and ensures that only one instance runs, despite repeated invocations. *The `cron` method fails silently if a workflow is already running with the same `id`.*
   
-  Optionally set `maxCycles` or `maxDuration` to limit the number of cycles.
+  Optionally set a `delay` and/or set `maxCycles` to limit the number of cycles.
 
 1. Define the cron function.
     ```typescript
@@ -39,7 +39,7 @@ The **MeshCall** module connects and exposes your functions as idempotent endpoi
         callback: async () => {
           //your code here...
         },
-        options: { id, interval }
+        options: { id, interval, maxCycles: 24 }
       });
     };
     ```
@@ -78,7 +78,7 @@ The **MeshCall** module connects and exposes your functions as idempotent endpoi
   <summary style="font-size:1.25em;">Call any function in any service</summary>
 
   ### Call a Function
-  Make blazing fast interservice calls that return in milliseconds without the overhead of HTTP.
+  Make blazing fast interservice calls that behave like HTTP but without the setup and performance overhead. This example demonstrates how to connect a function to the mesh and call it from anywhere on the network.
 
 1. Call `MeshCall.connect` and provide a `topic` to uniquely identify the function.
 
@@ -167,7 +167,7 @@ The **MeshCall** module connects and exposes your functions as idempotent endpoi
     ```
 </details>
 
-## MeshFlow
+## MeshFlow | Transactional Workflow
 The **MeshFlow** module is a drop-in replacement for [Temporal.io](https://temporal.io). If you need to orchestrate your functions as durable workflows, MeshFlow combines the popular Temporal SDK with Redis' *in-memory execution speed*.
 
 <details style="padding: .5em">
@@ -502,17 +502,17 @@ This example calls an activity and then sleeps for a week. It runs indefinitely
     ```
 </details>
 
-## MeshData
+## MeshData | Transactional Analytics
 The **MeshData** service extends the **MeshFlow** service, combining data record concepts and transactional workflow principles into a single *Operational Data Layer*. 
 
 Deployments with the Redis `FT.SEARCH` module enabled can use the **MeshData** module to merge [OLTP](https://en.wikipedia.org/wiki/Online_transaction_processing) and [OLAP](https://en.wikipedia.org/wiki/Online_analytical_processing) operations into a hybrid transactional/analytics ([HTAP](https://en.wikipedia.org/wiki/Hybrid_transactional/analytical_processing)) system.
 
->For those Redis deployments without the `FT.SEARCH` module, it's still useful to define a workflow schema. The MeshData class provides convenience methods for reading and writing hash field data to a workflow record (e.g., `get`, `del`, and `incr`).*
+*For those Redis deployments without the `FT.SEARCH` module, it's still useful to define a workflow schema. The MeshData class provides convenience methods for reading and writing hash field data to a workflow record (e.g., `get`, `del`, and `incr`).*
 
 <details style="padding: .5em">
   <summary style="font-size:1.25em;">Create a search index</summary>
 
-### Schemas and Indexes
+### Workflow Data Indexes
 
 This example demonstrates how to define a schema and deploy an index for a 'user' entity type.
 
@@ -552,7 +552,7 @@ This example demonstrates how to define a schema and deploy an index for a 'user
 <details style="padding: .5em">
   <summary style="font-size:1.25em;">Create an indexed, searchable record</summary>
 
-### Searchable Workflow
+### Workflow Record Data
 This example demonstrates how to create a 'user' workflow backed by the searchable schema from the prior example.
 
 1. Call MeshData `connect` to initialize a 'user' entity *worker*. It references a target worker function which will run the workflow. Data fields that are documented in the schema (like `active`) will be automatically indexed when set on the workflow record.
@@ -632,7 +632,7 @@ This example demonstrates how to create a 'user' workflow backed by the searchab
 <details style="padding: .5em">
   <summary style="font-size:1.25em;">Fetch record data</summary>
 
-### Workflow Record Fields
+### Read Record Data
 This example demonstrates how to read data fields directly from a workflow.
 
 1. Read data fields directly from the *jimbo123* 'user' record.
@@ -663,7 +663,7 @@ This example demonstrates how to read data fields directly from a workflow.
 <details style="padding: .5em">
   <summary style="font-size:1.25em;">Search record data</summary>
 
-### Searchable Workflow
+### Query Record Data
 This example demonstrates how to search for those workflows where a given condition exists in the data. This one searches for active users. *NOTE: The native Redis FT.SEARCH syntax is supported. The JSON abstraction shown here is a convenience method for straight-forward, one-dimensional queries.*
 
 1. Search for active users (where the value of the `active` field is `yes`).

package/build/index.d.ts

@@ -1,16 +1,7 @@
 import { MeshCall } from './services/meshcall';
 import { MeshData } from './services/meshdata';
+import { MeshFlow } from './services/meshflow';
 import { HotMesh } from './services/hotmesh';
-import { ClientService } from './services/meshflow/client';
-import { WorkerService } from './services/meshflow/worker';
-import { WorkflowService } from './services/meshflow/workflow';
-import { ConnectionService } from './services/meshflow/connection';
 import { HotMeshConfig } from './types/hotmesh';
-declare const MeshFlow: {
-    Client: typeof ClientService;
-    Worker: typeof WorkerService;
-    workflow: typeof WorkflowService;
-    Connection: typeof ConnectionService;
-};
 export { HotMesh, MeshCall, MeshData, MeshFlow, HotMeshConfig, };
 export * as Types from './types';

package/build/index.js

@@ -28,17 +28,8 @@ const meshcall_1 = require("./services/meshcall");
 Object.defineProperty(exports, "MeshCall", { enumerable: true, get: function () { return meshcall_1.MeshCall; } });
 const meshdata_1 = require("./services/meshdata");
 Object.defineProperty(exports, "MeshData", { enumerable: true, get: function () { return meshdata_1.MeshData; } });
+const meshflow_1 = require("./services/meshflow");
+Object.defineProperty(exports, "MeshFlow", { enumerable: true, get: function () { return meshflow_1.MeshFlow; } });
 const hotmesh_1 = require("./services/hotmesh");
 Object.defineProperty(exports, "HotMesh", { enumerable: true, get: function () { return hotmesh_1.HotMesh; } });
-const client_1 = require("./services/meshflow/client");
-const worker_1 = require("./services/meshflow/worker");
-const workflow_1 = require("./services/meshflow/workflow");
-const connection_1 = require("./services/meshflow/connection");
-const MeshFlow = {
-    Client: client_1.ClientService,
-    Worker: worker_1.WorkerService,
-    workflow: workflow_1.WorkflowService,
-    Connection: connection_1.ConnectionService,
-};
-exports.MeshFlow = MeshFlow;
 exports.Types = __importStar(require("./types"));

package/build/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hotmeshio/hotmesh",
-    "version": "0.1.16",
+    "version": "0.2.0",
     "description": "Unbreakable Workflows",
     "main": "./build/index.js",
     "types": "./build/index.d.ts",

package/build/services/meshcall/index.js

@@ -127,7 +127,7 @@ class MeshCall {
     }
     static async flush(params) {
         const hotMeshInstance = await MeshCall.getInstance(params.namespace, params.redis);
-        await hotMeshInstance.scrub(params.id);
+        await hotMeshInstance.scrub(params.id ?? params?.options?.id);
     }
     static async cron(params) {
         try {
@@ -140,14 +140,17 @@ class MeshCall {
                 namespace: params.namespace,
             });
             const TOPIC = `${params.namespace ?? key_1.HMNS}.cron`;
+            const interval = (0, ms_1.default)(params.options.interval) / 1000;
+            const delay = params.options.delay ? (0, ms_1.default)(params.options.delay) / 1000 : undefined;
+            const maxCycles = params.options.maxCycles ?? 1000000;
             const hotMeshInstance = await MeshCall.getInstance(params.namespace, params.redis);
             await hotMeshInstance.pub(TOPIC, {
                 id: params.options.id,
                 topic: params.topic,
                 args: params.args,
-                interval: params.options.interval,
-                maxCycles: params.options.maxCycles ?? 1000000000,
-                maxDuration: params.options.maxDuration,
+                interval,
+                maxCycles,
+                delay,
             });
             return true;
         }

package/build/services/meshcall/schemas/factory.js

@@ -98,10 +98,6 @@ const getWorkflowYAML = (appId = key_1.HMNS, version = exports.VERSION) => {
             maxCycles:
               type: number
               description: maximum number of cycles to run before stopping
-            maxDuration:
-              type: integer
-              description: timevalue (GMT) ceiling. If the current time exceeds this value, the cron will stop.
-              example: 1630000000000
 
       output:
         schema:

package/build/types/meshcall.d.ts

@@ -11,7 +11,7 @@ interface MeshCallConnectParams {
     namespace?: string;
     topic: string;
     redis: RedisConfig;
-    callback: <T extends any[], U>(...args: T) => Promise<U>;
+    callback: (...args: any[]) => any;
 }
 interface MeshCallExecParams {
     namespace?: string;
@@ -20,17 +20,21 @@ interface MeshCallExecParams {
     redis: RedisConfig;
     options?: MeshCallExecOptions;
 }
+interface MeshCallFlushOptions {
+    id: string;
+}
 interface MeshCallFlushParams {
     namespace?: string;
-    id: string;
+    id?: string;
     topic: string;
     redis: RedisConfig;
+    options?: MeshCallFlushOptions;
 }
 interface MeshCallCronOptions {
     id: string;
     interval: string;
     maxCycles?: number;
-    maxDuration?: string;
+    delay?: string;
 }
 interface MeshCallInterruptOptions {
     id: string;
@@ -42,7 +46,7 @@ interface MeshCallCronParams {
     topic: string;
     redis: RedisConfig;
     args: any[];
-    callback: <T extends any[], U>(...args: T) => Promise<U>;
+    callback: (...args: any[]) => any;
     options: MeshCallCronOptions;
 }
 interface MeshCallInterruptParams {
@@ -51,4 +55,4 @@ interface MeshCallInterruptParams {
     redis: RedisConfig;
     options: MeshCallInterruptOptions;
 }
-export { MeshCallConnectParams, MeshCallExecParams, MeshCallCronParams, MeshCallExecOptions, MeshCallCronOptions, MeshCallInterruptOptions, MeshCallInterruptParams, MeshCallFlushParams, };
+export { MeshCallConnectParams, MeshCallExecParams, MeshCallCronParams, MeshCallExecOptions, MeshCallCronOptions, MeshCallInterruptOptions, MeshCallInterruptParams, MeshCallFlushOptions, MeshCallFlushParams, };

package/index.ts

@@ -1,19 +1,9 @@
 import { MeshCall } from './services/meshcall';
 import { MeshData } from './services/meshdata';
+import { MeshFlow } from './services/meshflow';
 import { HotMesh } from './services/hotmesh';
-import { ClientService } from './services/meshflow/client';
-import { WorkerService } from './services/meshflow/worker';
-import { WorkflowService } from './services/meshflow/workflow';
-import { ConnectionService } from './services/meshflow/connection';
 import { HotMeshConfig } from './types/hotmesh';
 
-const MeshFlow = {
-  Client: ClientService,
-  Worker: WorkerService,
-  workflow: WorkflowService,
-  Connection: ConnectionService,
-};
-
 export {
   HotMesh,
   MeshCall,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hotmeshio/hotmesh",
-  "version": "0.1.16",
+  "version": "0.2.0",
   "description": "Unbreakable Workflows",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",

package/types/meshcall.ts

@@ -16,29 +16,84 @@ interface MeshCallExecOptions {
   flush?: boolean;
 }
 interface MeshCallConnectParams {
+  /**
+   * Log level for the worker
+   */
   logLevel?: LogLevel;
-  guid?: string; // Assign a custom engine id
+  /**
+   * Idempotent GUID for the worker and engine
+   */
+  guid?: string;
+  /**
+   * Namespace for grouping common functions
+   */
   namespace?: string;
+  /**
+   * Unique topic for the worker function
+   */
   topic: string;
+  /**
+   * Redis configuration for the worker
+   */
   redis: RedisConfig;
-  callback: <T extends any[], U>(...args: T) => Promise<U>;
+  /**
+   * The linked worker function that will be called
+   */
+  callback: (...args: any[]) => any;
 }
 
 interface MeshCallExecParams {
+  /**
+   * namespace for grouping common functions
+   */
   namespace?: string;
+  /**
+   * topic assigned to the worker when it was connected
+   */
   topic: string;
+  /**
+   * Arguments to pass to the worker function
+   */
   args: any[];
+  /**
+   * Redis configuration
+   */
   redis: RedisConfig;
+  /**
+   * Execution options like caching ttl
+   */
   options?: MeshCallExecOptions;
 }
 
+interface MeshCallFlushOptions {
+  /**
+   * Cache id when caching/flushing/retrieving function results.
+   */
+  id: string;
+}
+
 interface MeshCallFlushParams {
+  /**
+   * namespace for grouping common functions
+   */
   namespace?: string;
-  id: string;
+  /**
+   * id for cached response to flush
+   */
+  id?: string;
+  /**
+   * topic assigned to the worker when it was connected
+   */
   topic: string;
+  /**
+   * Redis configuration
+   */
   redis: RedisConfig;
+  /**
+   * Options for the flush
+   */
+  options?: MeshCallFlushOptions;
 }
-
 interface MeshCallCronOptions {
   /**
    * Idempotent GUID for the function
@@ -50,14 +105,15 @@ interface MeshCallCronOptions {
    */
   interval: string;
   /**
-   * Maximum number of cycles to run before stopping.
+   * Maximum number of cycles to run before exiting the cron.
    */
   maxCycles?: number;
   /**
-   * Maximum duration to run before stopping the cron.
-   * Refer to the syntax for the `ms` NPM package.
+   * Time in seconds to sleep before invoking the first cycle.
+   * For example, `1 day`, `1 hour`. Fidelity is generally
+   * within 5 seconds. Refer to the syntax for the `ms` NPM package.
    */
-  maxDuration?: string;
+  delay?: string;
 }
 
 interface MeshCallInterruptOptions {
@@ -95,9 +151,9 @@ interface MeshCallCronParams {
    */
   args: any[];
   /**
-   * Callback function to invoke each time the cron job runs; `args` will be passed
+   * linked worker function to run
    */
-  callback: <T extends any[], U>(...args: T) => Promise<U>;
+  callback: (...args: any[]) => any;
   /**
    * Options for the cron job
    */
@@ -105,9 +161,21 @@ interface MeshCallCronParams {
 }
 
 interface MeshCallInterruptParams {
+  /**
+   * namespace for grouping common functions
+   */
   namespace?: string;
+  /**
+   * topic assigned to the cron worker when it was connected
+   */
   topic: string;
+  /**
+   * Redis configuration
+   */
   redis: RedisConfig;
+  /**
+   * Options for interrupting the cron
+   */
   options: MeshCallInterruptOptions;
 }
 
@@ -119,5 +187,6 @@ export {
   MeshCallCronOptions,
   MeshCallInterruptOptions,
   MeshCallInterruptParams,
+  MeshCallFlushOptions,
   MeshCallFlushParams,
 };