@hotmeshio/hotmesh 0.0.55 → 0.0.56

package/build/types/stream.js

@@ -1,14 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StreamRole = exports.StreamDataType = exports.StreamStatus = void 0;
-/** Enumerated status values for stream operations */
 var StreamStatus;
 (function (StreamStatus) {
-    /** Indicates successful completion of the stream operation */
     StreamStatus["SUCCESS"] = "success";
-    /** Indicates an error occurred during the stream operation */
     StreamStatus["ERROR"] = "error";
-    /** Indicates the stream operation is still pending */
     StreamStatus["PENDING"] = "pending";
 })(StreamStatus = exports.StreamStatus || (exports.StreamStatus = {}));
 var StreamDataType;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hotmeshio/hotmesh",
-  "version": "0.0.55",
+  "version": "0.0.56",
   "description": "Unbreakable Workflows",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
@@ -65,11 +65,14 @@
   },
   "keywords": [
     "durable workflow",
-    "hotmesh",
+    "HotMesh",
     "service mesh",
     "workflows",
     "operational data",
-    "redis"
+    "Redis",
+    "OLAP",
+    "OLTP",
+    "HTAP"
   ],
   "author": "luke.birdeau@gmail.com",
   "license": "SEE LICENSE IN LICENSE",
@@ -90,11 +93,15 @@
     "eslint": "^8.36.0",
     "ioredis": "^5.3.2",
     "jest": "^29.5.0",
-    "redis": "^4.6.6",
+    "redis": "^4.6.13",
     "rimraf": "^4.4.1",
     "ts-jest": "^29.0.5",
     "ts-node": "^10.9.1",
     "ts-node-dev": "^2.0.0",
     "typescript": "^5.0.4"
+  },
+  "peerDependencies": {
+    "redis": "^4.0.0",
+    "ioredis": "^4.0.0 || ^5.0.0"
   }
 }

package/types/durable.ts

@@ -110,6 +110,7 @@ type WorkflowContext = {
 }
 
 type WorkflowSearchOptions = {
+
   /** FT index name (myapp:myindex) */
   index?: string;
 
@@ -119,13 +120,110 @@ type WorkflowSearchOptions = {
   /** 
    * Schema mapping each field to a type with an optional sortable flag 
    */
-  schema?: Record<string, { type: 'TEXT' | 'NUMERIC' | 'TAG', sortable?: boolean }>;
+  schema?: Record<string, {
+    /**
+     * The FT.SEARCH field type. One of: TEXT, NUMERIC, TAG. TEXT is
+     * most expensive, but also most expressive.
+     */
+    type: 'TEXT' | 'NUMERIC' | 'TAG';
+
+    /**
+     * FT.SEARCH SORTABLE field. If true, results may be sorted according to this field
+     * @default false
+     */
+    sortable?: boolean;
+
+    /**
+     * FT.SEARCH NOSTEM field. applies to TEXT fields types.
+     * If true, the text field index will not stem words
+     * @default false
+     */
+    nostem?: boolean;
+
+    /**
+     * FT.SEARCH NOINDEX field. If true and if the field is sortable, the field will aid
+     * in sorting results but not be directly indexed as a standalone
+     * @default false
+     */
+    noindex?: boolean;
+
+    /**
+     * if true, the field is indexed and searchable within the FT.SEARCH index
+     * This is different from `noindex` which is FT.SEARCH specific and relates
+     * to sorting and indexing. This is a general flag for the field that will
+     * enable or disable indexing and searching entirely. Use for fields with
+     * absolutely no meaning to query or sorting but which are important
+     * nonetheless as part of the data record that is saved and returned.
+     * @default true
+     */
+    indexed?: boolean;
+
+    /**
+     * An array of possible values for the field
+     */
+    examples?: string[];
+
+    /**
+     * 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.
+     * Set to true only if the field is a TEXT or TAG type and
+     * you wish to save the string `null` as a value to search
+     * on (the tag, {null}, or the string, (null)
+     * @default false
+     */
+    nilable?: boolean;
+
+    /**
+     * possible scalar/primitive types for the field. Use when
+     * serializing and restoring data to ensure the field is
+     * properly typed. If not provided, the field will be
+     * treated as a string.
+     */
+    primitive?: 'string' | 'number' | 'boolean' | 'array' | 'object';
+
+    /**
+     * if true, the field is required to be present in the data record
+     * @default false
+     */
+    required?: boolean;
+
+    /**
+     * an enumerated list of allowed values; if field is nilable, it is implied
+     * and therefore not necessary to include `null` in the list
+     * @default []
+     */
+    enum?: string[];
+
+    /**
+     * a regular expression pattern for the field
+     * @default '.*'
+     * @example '^[a-zA-Z0-9_]*$'
+     */
+    pattern?: string;
+  }>;
 
   /** Additional data as a key-value record */
   data?: StringStringType;
 }
 
 
+type SearchResults = {
+  /**
+   * the total number of results
+   */
+  count: number,
+  /**
+   * the raw FT.SEARCH query string
+   */
+  query: string,
+  /**
+   * the raw FT.SEARCH results as an array of objects
+   */
+  data: StringStringType[]
+};
+
 type WorkflowOptions = {
 
   /**
@@ -280,8 +378,8 @@ type WorkflowDataType = {
 }
 
 type ConnectionConfig = {
-  class: RedisClass;
-  options: RedisOptions;
+  class: Partial<RedisClass>;
+  options: Partial<RedisOptions>;
 }
 type Connection =  ConnectionConfig;
 
@@ -328,6 +426,7 @@ type FindOptions = {
   taskQueue?: string;
   namespace?: string;
   index?: string;
+  search?: WorkflowSearchOptions;
 }
 
 type FindWhereOptions = {
@@ -341,6 +440,23 @@ type FindWhereOptions = {
   }
 }
 
+type FindJobsOptions = {
+  /** The workflow name; include an asterisk for wilcard search; refer to Redis SCAN for the allowed format */
+  match?: string;
+
+  /** application namespace; defaults to 'durable' */
+  namespace?: string;
+
+  /** The suggested response limit. Reduce batch size to reduce the likelihood of large overages. */
+  limit?: number;
+
+  /** How many records to scan at a time */
+  batch?: number;
+
+  /** The start cursor; defaults to 0 */
+  cursor?: string;
+}
+
 type WorkerOptions = {
   /** Log level: debug, info, warn, error */
   logLevel?: LogLevel;
@@ -422,10 +538,12 @@ export {
   ProxyType,
   Registry,
   SignalOptions,
+  FindJobsOptions,
   FindOptions,
   FindWhereOptions,
   FindWhereQuery,
   HookOptions,
+  SearchResults,
   WorkerConfig,
   WorkflowConfig,
   WorkerOptions,

package/types/hotmesh.ts

@@ -50,8 +50,8 @@ type KeyStoreParams = {
 type HotMesh = typeof HotMeshService;
 
 type RedisConfig = {
-  class: RedisClass;
-  options: RedisOptions;
+  class: Partial<RedisClass>;
+  options: Partial<RedisOptions>;
 }
 
 type HotMeshEngine = {
@@ -68,10 +68,7 @@ type HotMeshWorker = {
   store?: RedisClient;  //set by hotmesh using instanced `redis` class
   stream?: RedisClient; //set by hotmesh using instanced `redis` class
   sub?: RedisClient;    //set by hotmesh using instanced `redis` class
-  redis?: {
-    class: RedisClass;
-    options: RedisOptions;
-  };
+  redis?: RedisConfig;
   reclaimDelay?: number; //milliseconds
   reclaimCount?: number; //max number of times to reclaim a stream
   callback: (payload: StreamData) => Promise<StreamDataResponse|void>;

package/types/index.ts

@@ -39,10 +39,12 @@ export {
     ProxyType,
     Registry,
     SignalOptions,
+    FindJobsOptions,
     FindOptions,
     FindWhereOptions,
     FindWhereQuery,
     HookOptions,
+    SearchResults,
     WorkflowConfig,
     WorkerConfig,
     WorkerOptions,
@@ -78,19 +80,18 @@ export {
   HookRules,
   HookSignal
 } from './hook';
-export {
-  RedisClientType as IORedisClientType,
-  RedisMultiType as IORedisMultiType } from './ioredisclient';
 export { ILogger } from './logger';
 export {
+  ExtensionType,
+  JobCompletionOptions,
   JobData,
   JobsData,
+  JobInterruptOptions,
   JobMetadata,
   JobOutput,
   JobState,
   JobStatus,
-  PartialJobState,
-  ExtensionType } from './job';
+  PartialJobState } from './job';
 export { MappingStatements } from './map';
 export {
   Pipe,
@@ -123,18 +124,30 @@ export {
   QuorumMessageCallback,
   QuorumProfile,
   RollCallMessage,
+  RollCallOptions,
   SubscriptionCallback,
+  SubscriptionOptions,
   SystemHealth,
   ThrottleMessage,
   ThrottleOptions,
   WorkMessage } from './quorum';
 export {
-  MultiResponseFlags,
+  RedisClass,
+  RedisRedisClientType,
+  RedisRedisClientOptions,
+  RedisRedisClassType,
+  IORedisClientType,
   RedisClient,
-  RedisMulti } from './redis'; //common redis types
-export {
-  RedisClientType,
-  RedisMultiType } from './redisclient';
+  RedisMulti,
+  RedisRedisMultiType,
+  IORedisClientOptions,
+  IORedisClassType,
+  IORedisMultiType,
+  RedisOptions,
+  MultiResponseFlags,
+  isRedisClient,
+  isIORedisClient,
+} from './redis'; //common redis types
 export {
   JSONSchema,
   StringAnyType,

package/types/job.ts

@@ -201,9 +201,9 @@ type JobCompletionOptions = {
 
 export {
   JobCompletionOptions,
-  JobInterruptOptions,
   JobData,
   JobsData,
+  JobInterruptOptions,
   JobMetadata,
   JobOutput,
   JobState,

package/types/quorum.ts

@@ -32,14 +32,21 @@ export type ThrottleOptions = {
   guid?: string;
   /** target a worker quorum */
   topic?: string;
+  /** entity/noun */
+  entity?: string;
   /** in milliseconds; default is 0 */
   throttle: number;
+  /** namespace
+   * @default 'durable'
+   */
+  namespace?: string;
 };
 
 export interface QuorumProfile {
   namespace: string;
   app_id: string;
   engine_id: string;
+  entity?: string;
   worker_topic?: string;
   stream?: string;
   stream_depth?: number;
@@ -54,6 +61,7 @@ export interface QuorumProfile {
 }
 
 interface QuorumMessageBase {
+  entity?: string;
   guid?: string;
   topic?: string;
   type?: string;
@@ -80,6 +88,7 @@ export interface PongMessage extends QuorumMessageBase {
   type: 'pong';
   guid: string;            //call initiator
   originator: string;      //clone of originator guid passed in ping
+  entity?: string;         //optional entity
   profile?: QuorumProfile; //contains details about the engine/worker
 }
 
@@ -91,6 +100,7 @@ export interface ActivateMessage extends QuorumMessageBase {
 
 export interface JobMessage extends QuorumMessageBase {
   type: 'job';
+  entity?: string;
   topic: string; //this comes from the 'publishes' field in the YAML
   job: JobOutput
 }
@@ -98,6 +108,7 @@ export interface JobMessage extends QuorumMessageBase {
 export interface ThrottleMessage extends QuorumMessageBase {
   type: 'throttle';
   guid?: string; //target engine AND workers with this guid
+  entity?: string;
   topic?: string;  //target worker(s) matching this topic (pass null to only target the engine, pass undefined to target engine and workers)
   throttle: number; //0-n; millis
 }
@@ -105,6 +116,7 @@ export interface ThrottleMessage extends QuorumMessageBase {
 export interface RollCallMessage extends QuorumMessageBase {
   type: 'rollcall';
   guid?: string;    //target the engine quorum
+  entity?: string;
   topic?: string | null;   //target a worker if string; suppress if `null`;
   interval: number; //every 'n' seconds
   max?: number;     //max broadcasts
@@ -123,6 +135,16 @@ export interface QuorumMessageCallback {
   (topic: string, message: QuorumMessage): void;
 }
 
+export type RollCallOptions = {
+  delay?: number;
+  namespace?: string;
+};
+
+export type SubscriptionOptions = {
+  namespace?: string;
+};
+
+
 /**
  * The types in this file are used to define those messages that are sent
  * to hotmesh client instances when a new version is about to be activated.