@hotmeshio/hotmesh 0.0.60 → 0.1.1

package/types/activity.ts

@@ -1,7 +1,16 @@
-import { MetricTypes } from "./stats";
-import { StreamRetryPolicy } from "./stream";
-
-type ActivityExecutionType = 'trigger' | 'await' | 'worker' | 'activity' | 'emit' | 'interrupt' | 'cycle' | 'signal' | 'hook';
+import { MetricTypes } from './stats';
+import { StreamRetryPolicy } from './stream';
+
+type ActivityExecutionType =
+  | 'trigger'
+  | 'await'
+  | 'worker'
+  | 'activity'
+  | 'emit'
+  | 'interrupt'
+  | 'cycle'
+  | 'signal'
+  | 'hook';
 
 type Consumes = Record<string, string[]>;
 
@@ -15,20 +24,20 @@ interface BaseActivity {
   job?: Record<string, any>;
   hook?: Record<string, any>;
   telemetry?: Record<string, any>;
-  emit?: boolean;                      //if true, the activity will emit a message to the `publishes` topic immediately before transitioning to adjacent activities
-  sleep?: number;                      //@pipe /in seconds
-  expire?: number;                     //-1 forever; 0 persists the flow until the parent flow that expired it is dismissed; 15 seconds is the default
-  retry?: StreamRetryPolicy
-  cycle?: boolean;                     //if true, the `notary` will leave leg 2 open, so it can be re/cycled
-  collationInt?: number;               //compiler
-  consumes?: Consumes;                 //compiler
-  PRODUCES?: string[];                 //compiler
-  produces?: string[];                 //compiler
-  publishes?: string;                  //compiler 
-  subscribes?: string;                 //compiler
-  trigger?: string;                    //compiler
-  parent?: string;                     //compiler
-  ancestors?: string[];                //compiler
+  emit?: boolean; //if true, the activity will emit a message to the `publishes` topic immediately before transitioning to adjacent activities
+  sleep?: number; //@pipe /in seconds
+  expire?: number; //-1 forever; 0 persists the flow until the parent flow that expired it is dismissed; 15 seconds is the default
+  retry?: StreamRetryPolicy;
+  cycle?: boolean; //if true, the `notary` will leave leg 2 open, so it can be re/cycled
+  collationInt?: number; //compiler
+  consumes?: Consumes; //compiler
+  PRODUCES?: string[]; //compiler
+  produces?: string[]; //compiler
+  publishes?: string; //compiler
+  subscribes?: string; //compiler
+  trigger?: string; //compiler
+  parent?: string; //compiler
+  ancestors?: string[]; //compiler
 }
 
 interface Measure {
@@ -38,9 +47,9 @@ interface Measure {
 
 interface TriggerActivityStats {
   /**
-   * dependent parent job id; including this allows the parent's 
-   * expiration/interruption events to cascade; set 
-   * `expire` in the YAML for the dependent graph 
+   * dependent parent job id; including this allows the parent's
+   * expiration/interruption events to cascade; set
+   * `expire` in the YAML for the dependent graph
    * to 0 and provide the parent for dependent,
    * cascading interruption and cleanup
    */
@@ -96,50 +105,50 @@ interface HookActivity extends BaseActivity {
 }
 
 interface SignalActivity extends BaseActivity {
-  type: 'signal';                 //signal activities call hook/hookAll
-  subtype: 'one' | 'all';         //trigger: hook(One) or hookAll
-  topic: string;                  //e.g., 'hook.resume'
-  key_name?: string;              //e.g., 'parent_job_id'
-  key_value?: string;             //e.g., '1234567890'
-  scrub?: boolean;                //if true, the index will be deleted after use
-  signal?: Record<string, any>;   //used to define/map the signal input data (what to send/singnal into the job(s))
+  type: 'signal'; //signal activities call hook/hookAll
+  subtype: 'one' | 'all'; //trigger: hook(One) or hookAll
+  topic: string; //e.g., 'hook.resume'
+  key_name?: string; //e.g., 'parent_job_id'
+  key_value?: string; //e.g., '1234567890'
+  scrub?: boolean; //if true, the index will be deleted after use
+  signal?: Record<string, any>; //used to define/map the signal input data (what to send/singnal into the job(s))
   resolver?: Record<string, any>; //used to define/map the signal key resolver (the key used to lookup the job(s that are assigned to the key)
-  status?: string;                //pending, success (default), error
-  code?: number;                  //202, 200 (default)
+  status?: string; //pending, success (default), error
+  code?: number; //202, 200 (default)
 }
 
 interface InterruptActivity extends BaseActivity {
   type: 'interrupt';
 
-  /** 
+  /**
    * Optional Reason; will be used as the error `message` when thrown
    * @default 'Job Interrupted'
    */
   reason?: string;
 
-  /** 
+  /**
    * throw JobInterrupted error upon interrupting
    * @default true
    */
   throw?: boolean;
 
-  /** 
+  /**
    * Interrupt child/descendant jobs
    * @default false
    */
   descend?: boolean;
 
-  /** 
+  /**
    * Target job id (if not present the current job will be targeted)
    */
   target?: string;
 
-  /** 
+  /**
    * Optional topic to publish the interrupt message (if not present the current job topic will be used
    */
   topic?: string;
 
-  /** 
+  /**
    * Optional Error Code; will be used as the error `code` when thrown
    * @default 410
    */
@@ -151,7 +160,15 @@ interface InterruptActivity extends BaseActivity {
   stack?: string;
 }
 
-type ActivityType = BaseActivity | TriggerActivity | AwaitActivity | WorkerActivity | InterruptActivity | HookActivity | SignalActivity | CycleActivity;
+type ActivityType =
+  | BaseActivity
+  | TriggerActivity
+  | AwaitActivity
+  | WorkerActivity
+  | InterruptActivity
+  | HookActivity
+  | SignalActivity
+  | CycleActivity;
 
 type ActivityData = Record<string, any>;
 
@@ -213,7 +230,7 @@ type ActivityMetadata = {
 type ActivityContext = {
   data?: ActivityData | null;
   metadata: ActivityMetadata;
-  hook?: ActivityData
+  hook?: ActivityData;
 };
 
 type ActivityDuplex = 1 | 2;
@@ -243,5 +260,5 @@ export {
   BaseActivity,
   InterruptActivity,
   TriggerActivity,
-  WorkerActivity
+  WorkerActivity,
 };

package/types/async.ts

@@ -1,7 +1,6 @@
-
 type AsyncSignal = {
-  topic: string,
-  jobId: string
+  topic: string;
+  jobId: string;
 };
 
 export { AsyncSignal };

package/types/collator.ts

@@ -1,9 +1,9 @@
 export type CollationStage = 'enter' | 'exit' | 'confirm';
 
 export enum CollationFaultType {
-  MISSING = 'missing',      //`as` uninitialized; leg1 entry not allowed
-  DUPLICATE = 'duplicate',  //1st digit < 8
-  INACTIVE = 'inactive',    //3rd digit is 8
-  INVALID = 'invalid',      //unknown value (corrupt for unknown reasons)
-  FORBIDDEN = 'forbidden',  //leg 1 not completed; reentry (leg 2) not allowed
+  MISSING = 'missing', //`as` uninitialized; leg1 entry not allowed
+  DUPLICATE = 'duplicate', //1st digit < 8
+  INACTIVE = 'inactive', //3rd digit is 8
+  INVALID = 'invalid', //unknown value (corrupt for unknown reasons)
+  FORBIDDEN = 'forbidden', //leg 1 not completed; reentry (leg 2) not allowed
 }

package/types/durable.ts

@@ -7,19 +7,19 @@ import { StreamData, StreamError } from './stream';
  * Type definition for workflow configuration.
  */
 type WorkflowConfig = {
-  /** 
+  /**
    * Backoff coefficient for retry mechanism.
    * @default 10 (HMSH_DURABLE_EXP_BACKOFF)
    */
   backoffCoefficient?: number;
 
-  /** 
+  /**
    * Maximum number of attempts for retries.
    * @default 5 (HMSH_DURABLE_MAX_ATTEMPTS)
    */
   maximumAttempts?: number;
 
-  /** 
+  /**
    * Maximum interval between retries.
    * @default 120s (HMSH_DURABLE_MAX_INTERVAL)
    */
@@ -32,10 +32,9 @@ type WorkflowConfig = {
    * @default true
    */
   throwOnError?: boolean;
-}
+};
 
 type WorkflowContext = {
-
   /**
    * can the workflow be retried if an error occurs
    */
@@ -46,7 +45,7 @@ type WorkflowContext = {
      * the reentrant semaphore parent counter object for object reference during increment
      */
     counter: number;
-  }
+  };
 
   /**
    * the reentrant semaphore, incremented in real-time as idempotent statements are re-traversed upon reentry. Indicates the current semaphore count.
@@ -83,7 +82,7 @@ type WorkflowContext = {
    */
   workflowId: string;
 
-  /** 
+  /**
    * the dimensional isolation for the reentrant hook, expressed in the format `0,0`, `0,1`, etc
    */
   workflowDimension: string;
@@ -107,24 +106,14 @@ type WorkflowContext = {
    * the native HotMesh message that encapsulates the arguments, metadata, and raw data for the workflow
    */
   raw: StreamData;
-}
-
-type WorkflowSearchOptions = {
-
-  /** FT index name (myapp:myindex) */
-  index?: string;
-
-  /** FT prefixes (['myapp:myindex:prefix1', 'myapp:myindex:prefix2']) */
-  prefix?: string[];
+};
 
-  /** 
-   * Schema mapping each field. Each field is a key-value pair where the key is the field name
-   * and the value is a record of field options. If the fieldName is provided,
-   * it will be used as the indexed field name. If not provided
-   * key will be used as the indexed field name with an underscore prefix.
-   * 
-   */
-  schema?: Record<string, {
+/**
+ * The schema for the full-text-search (RediSearch) index.
+ */
+export type WorkflowSearchSchema = Record<
+  string,
+  {
     /**
      * The FT.SEARCH field type. One of: TEXT, NUMERIC, TAG. TEXT is
      * most expensive, but also most expressive.
@@ -168,7 +157,7 @@ type WorkflowSearchOptions = {
     examples?: string[];
 
     /**
-     * The 'nilable' setting may NOT be set to `true` for 
+     * The 'nilable' setting may NOT be set to `true` for
      * NUMBER types as it causes an indexing error;
      * consider a custom (e.g., negative number) value to represent
      * `null` if desired for a NUMERIC field.
@@ -213,28 +202,42 @@ type WorkflowSearchOptions = {
     fieldName?: string;
   }>;
 
+type WorkflowSearchOptions = {
+  /** FT index name (myapp:myindex) */
+  index?: string;
+
+  /** FT prefixes (['myapp:myindex:prefix1', 'myapp:myindex:prefix2']) */
+  prefix?: string[];
+
+  /**
+   * Schema mapping each field. Each field is a key-value pair where the key is the field name
+   * and the value is a record of field options. If the fieldName is provided,
+   * it will be used as the indexed field name. If not provided
+   * key will be used as the indexed field name with an underscore prefix.
+   *
+   */
+  schema?: WorkflowSearchSchema;
+
   /** Additional data as a key-value record */
   data?: StringStringType;
-}
-
+};
 
 type SearchResults = {
   /**
    * the total number of results
    */
-  count: number,
+  count: number;
   /**
    * the raw FT.SEARCH query string
    */
-  query: string,
+  query: string;
   /**
    * the raw FT.SEARCH results as an array of objects
    */
-  data: StringStringType[]
+  data: StringStringType[];
 };
 
 type WorkflowOptions = {
-
   /**
    * the namespace for the workflow; `durable` is the default namespace if not provided
    */
@@ -288,12 +291,12 @@ type WorkflowOptions = {
   /**
    * the full-text-search (RediSearch) options for the workflow
    */
-  search?: WorkflowSearchOptions
+  search?: WorkflowSearchOptions;
 
   /**
    * marker data (begins with a -)
    */
-  marker?: StringStringType
+  marker?: StringStringType;
 
   /**
    * the workflow configuration object
@@ -309,9 +312,9 @@ type WorkflowOptions = {
    * default is true; if false, will not await the execution
    */
   await?: boolean;
-}
+};
 
-/** 
+/**
  * Options for setting up a hook.
  * 'durable' is the default namespace if not provided; similar to setting `appid` in the YAML
  */
@@ -324,80 +327,80 @@ type HookOptions = {
 
   /** Input arguments to pass into the hook */
   args: any[];
-     
+
   /**
    * Optional entity name. If provided, applies as the workflowName,
    * taskQueue, and prefix. This scopes the FT.SEARCH index appropriately.
    * This is a convenience method but limits options.
    */
   entity?: string;
-  
+
   /** Execution ID, also known as the job ID to hook into */
   workflowId?: string;
-  
+
   /** The name of the user's hook function */
   workflowName?: string;
-  
+
   /** Bind additional search terms immediately before hook reentry */
-  search?: WorkflowSearchOptions
-  
+  search?: WorkflowSearchOptions;
+
   /** Hook function constraints (backoffCoefficient, maximumAttempts, maximumInterval) */
-  config?: WorkflowConfig; 
-}
+  config?: WorkflowConfig;
+};
 
-/** 
+/**
  * Options for sending signals in a workflow.
  */
 type SignalOptions = {
-  /** 
-   * Task queue associated with the workflow 
+  /**
+   * Task queue associated with the workflow
    */
   taskQueue: string;
 
-  /** 
-   * Input data for the signal (any serializable object) 
+  /**
+   * Input data for the signal (any serializable object)
    */
-  data: StringAnyType; 
+  data: StringAnyType;
 
-  /** 
-   * Execution ID, also known as the job ID 
+  /**
+   * Execution ID, also known as the job ID
    */
   workflowId: string;
 
-  /** 
-   * Optional name of the user's workflow function 
+  /**
+   * Optional name of the user's workflow function
    */
   workflowName?: string;
-}
+};
 
 type ActivityWorkflowDataType = {
   activityName: string;
   arguments: any[];
   workflowId: string;
   workflowTopic: string;
-}
+};
 
 type WorkflowDataType = {
   arguments: any[];
   workflowId: string;
   workflowTopic: string;
   workflowDimension?: string; //is present if hook (not main workflow)
-  originJobId?: string;       //is present if there is an originating ancestor job (should rename to originJobId)
+  originJobId?: string; //is present if there is an originating ancestor job (should rename to originJobId)
   canRetry?: boolean;
-}
+};
 
 type ConnectionConfig = {
   class: Partial<RedisClass>;
   options: Partial<RedisOptions>;
-}
-type Connection =  ConnectionConfig;
+};
+type Connection = ConnectionConfig;
 
 type ClientConfig = {
   connection: Connection;
-}
+};
 
-type Registry  = {
-  [key: string]: Function
+type Registry = {
+  [key: string]: Function;
 };
 type WorkerConfig = {
   /** Connection configuration for the worker */
@@ -420,15 +423,14 @@ type WorkerConfig = {
 
   /** Search options for workflow execution details */
   search?: WorkflowSearchOptions;
-}
-
+};
 
 type FindWhereQuery = {
   field: string;
   is: '=' | '==' | '>=' | '<=' | '[]';
   value: string | boolean | number | [number, number];
   type?: string; //default is TEXT
-}
+};
 
 type FindOptions = {
   workflowName?: string; //also the function name
@@ -436,7 +438,7 @@ type FindOptions = {
   namespace?: string;
   index?: string;
   search?: WorkflowSearchOptions;
-}
+};
 
 type FindWhereOptions = {
   options?: FindOptions;
@@ -444,10 +446,10 @@ type FindWhereOptions = {
   query: FindWhereQuery[];
   return?: string[];
   limit?: {
-    start: number,
-    size: number
-  }
-}
+    start: number;
+    size: number;
+  };
+};
 
 type FindJobsOptions = {
   /** The workflow name; include an asterisk for wilcard search; refer to Redis SCAN for the allowed format */
@@ -464,7 +466,7 @@ type FindJobsOptions = {
 
   /** The start cursor; defaults to 0 */
   cursor?: string;
-}
+};
 
 type WorkerOptions = {
   /** Log level: debug, info, warn, error */
@@ -478,14 +480,16 @@ type WorkerOptions = {
 
   /** Maximum interval between retries, default 120s (HMSH_DURABLE_MAX_INTERVAL) */
   maximumInterval?: string;
-}
+};
 
 type ContextType = {
-  workflowId: string
-  workflowTopic: string
+  workflowId: string;
+  workflowTopic: string;
 };
 
-type FunctionSignature<T> = T extends (...args: infer A) => infer R ? (...args: A) => R : never;
+type FunctionSignature<T> = T extends (...args: infer A) => infer R
+  ? (...args: A) => R
+  : never;
 type ProxyType<ACT> = {
   [K in keyof ACT]: FunctionSignature<ACT[K]>;
 };
@@ -517,22 +521,22 @@ type ActivityConfig = {
  * The proxy response object returned from the activity proxy flow
  */
 type ProxyResponseType<T> = {
-  data?: T,             //expected data
-  $error?: StreamError,
-  done?: boolean,       //non-existent if error was thrown in transition (not during execution)
-  jc: string,
-  ju: string
+  data?: T; //expected data
+  $error?: StreamError;
+  done?: boolean; //non-existent if error was thrown in transition (not during execution)
+  jc: string;
+  ju: string;
 };
 
 /**
  * The child flow response object returned from the  main flow during recursion
  */
 type ChildResponseType<T> = {
-  data?: T,             //expected data
-  $error?: StreamError,
-  done?: boolean,       //non-existent if error was thrown in transition (not during execution)
-  jc: string,
-  ju: string
+  data?: T; //expected data
+  $error?: StreamError;
+  done?: boolean; //non-existent if error was thrown in transition (not during execution)
+  jc: string;
+  ju: string;
 };
 
 export {
@@ -543,7 +547,7 @@ export {
   ContextType,
   ConnectionConfig,
   Connection,
-  ProxyResponseType,  
+  ProxyResponseType,
   ProxyType,
   Registry,
   SignalOptions,

package/types/error.ts

@@ -1,52 +1,52 @@
 export type DurableChildErrorType = {
-  arguments: string[],
-  await?: boolean,
-  backoffCoefficient?: number,
-  index: number,
-  maximumAttempts?: number,
-  maximumInterval?: number,
-  originJobId: string | null,
-  parentWorkflowId: string,
-  workflowDimension: string,
-  workflowId: string,
-  workflowTopic: string,
+  arguments: string[];
+  await?: boolean;
+  backoffCoefficient?: number;
+  index: number;
+  maximumAttempts?: number;
+  maximumInterval?: number;
+  originJobId: string | null;
+  parentWorkflowId: string;
+  workflowDimension: string;
+  workflowId: string;
+  workflowTopic: string;
 };
 
 export type DurableWaitForAllErrorType = {
-  items: string[],
-  workflowId: string,
-  workflowTopic: string,
-  parentWorkflowId: string,
-  originJobId: string | null,
-  size: number,
-  index: number,
-  workflowDimension: string
+  items: string[];
+  workflowId: string;
+  workflowTopic: string;
+  parentWorkflowId: string;
+  originJobId: string | null;
+  size: number;
+  index: number;
+  workflowDimension: string;
 };
 
 export type DurableProxyErrorType = {
-  arguments: string[],
-  activityName: string,
-  backoffCoefficient?: number,
-  index: number,
-  maximumAttempts?: number,
-  maximumInterval?: number,
-  originJobId: string | null,
-  parentWorkflowId: string,
-  workflowDimension: string,
-  workflowId: string,
-  workflowTopic: string,
+  arguments: string[];
+  activityName: string;
+  backoffCoefficient?: number;
+  index: number;
+  maximumAttempts?: number;
+  maximumInterval?: number;
+  originJobId: string | null;
+  parentWorkflowId: string;
+  workflowDimension: string;
+  workflowId: string;
+  workflowTopic: string;
 };
 
 export type DurableWaitForErrorType = {
-  signalId: string,
-  index: number,
-  workflowDimension: string
+  signalId: string;
+  index: number;
+  workflowDimension: string;
   workflowId: string;
 };
 
 export type DurableSleepErrorType = {
-  duration: number,
-  index: number,
-  workflowDimension: string,
-  workflowId: string,
+  duration: number;
+  index: number;
+  workflowDimension: string;
+  workflowId: string;
 };