@hotmeshio/hotmesh 0.1.16 → 0.1.17

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/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.1.17",
   "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,
 };