@hotmeshio/hotmesh 0.0.55 → 0.0.57

package/build/types/activity.d.ts

@@ -32,18 +32,7 @@ interface Measure {
     target: string;
 }
 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
-     * to 0 and provide the parent for dependent,
-     * cascading interruption and cleanup
-     */
     parent?: string;
-    /**
-     * adjacent parent job id; this is the actual adjacent
-     * parent in the graph, but it is not used for cascading expiration
-     */
     adjacent?: string;
     id?: {
         [key: string]: unknown;
@@ -51,19 +40,7 @@ interface TriggerActivityStats {
     key?: {
         [key: string]: unknown;
     } | string;
-    /**
-     * @deprecated
-     * return 'infinity' to disable; default behavior
-     * is to always segment keys by time to ensure
-     * indexes (Redis LIST) never grow unbounded
-     * as a default behavior; for now, 5m is default
-     * and infinity can be set to override
-     */
     granularity?: string;
-    /**
-     * @deprecated
-     * what to capture
-     */
     measures?: Measure[];
 }
 interface TriggerActivity extends BaseActivity {
@@ -102,84 +79,26 @@ interface SignalActivity extends BaseActivity {
 }
 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
-     */
     code?: number;
-    /**
-     * Optional stack trace
-     */
     stack?: string;
 }
 type ActivityType = BaseActivity | TriggerActivity | AwaitActivity | WorkerActivity | InterruptActivity | HookActivity | SignalActivity | CycleActivity;
 type ActivityData = Record<string, any>;
-/**
- * Type definition for activity metadata.
- */
 type ActivityMetadata = {
-    /**
-     * Unique identifier for the activity.
-     */
     aid: string;
-    /**
-     * Type of the activity.
-     */
     atp: string;
-    /**
-     * Subtype of the activity.
-     */
     stp: string;
-    /**
-     * Timestamp when the activity was created, in GMT.
-     */
     ac: string;
-    /**
-     * Timestamp when the activity was last updated, in GMT.
-     */
     au: string;
-    /**
-     * Optional stringified JSON containing error details such as message, code, and an optional error object.
-     */
     err?: string;
-    /**
-     * OpenTelemetry span context for the first leg of the activity.
-     */
     l1s?: string;
-    /**
-     * OpenTelemetry span context for the second leg of the activity.
-     */
     l2s?: string;
-    /**
-     * Dimensional address, used for additional metadata.
-     */
     dad?: string;
-    /**
-     * Status of the activity, could be codes representing different states.
-     */
     as?: string;
 };
 type ActivityContext = {

package/build/types/durable.d.ts

@@ -2,215 +2,85 @@ import { LogLevel } from './logger';
 import { RedisClass, RedisOptions } from './redis';
 import { StringAnyType, StringStringType } from './serializer';
 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)
-     */
     maximumInterval?: string;
-    /**
-     * Whether to throw an error on final failure after retries are exhausted
-     * or return the error object as a standard response containing error-related
-     * fields like `stack`, `code`, `message`.
-     * @default true
-     */
     throwOnError?: boolean;
 };
 type WorkflowContext = {
-    /**
-     * can the workflow be retried if an error occurs
-     */
     canRetry: boolean;
     COUNTER: {
-        /**
-         * 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.
-     */
     counter: number;
-    /**
-     * number as string for the replay cursor
-     */
     cursor: string;
-    /**
-     * the replay hash of name/value pairs representing prior executions
-     */
     replay: StringStringType;
-    /**
-     * the HotMesh App namespace. `durable` is the default.
-     */
     namespace: string;
-    /**
-     * holds list of interruption payloads; if list is longer than 1 when the error is thrown, a `collator` subflow will be used
-     */
     interruptionRegistry: any[];
-    /**
-     * entry point ancestor flow; might be the parent; will never be self
-     */
     originJobId: string;
-    /**
-     * the workflow/job ID
-     */
     workflowId: string;
-    /**
-     * the dimensional isolation for the reentrant hook, expressed in the format `0,0`, `0,1`, etc
-     */
     workflowDimension: string;
-    /**
-     * a concatenation of the task queue and workflow name (e.g., `${taskQueueName}-${workflowName}`)
-     */
     workflowTopic: string;
-    /**
-     * the open telemetry trace context for the workflow, used for logging and tracing. If a sink is enabled, this will be sent to the sink.
-     */
     workflowTrace: string;
-    /**
-     * the open telemetry span context for the workflow, used for logging and tracing. If a sink is enabled, this will be sent to the sink.
-     */
     workflowSpan: string;
-    /**
-     * 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 to a type with an optional sortable flag
-     */
     schema?: Record<string, {
         type: 'TEXT' | 'NUMERIC' | 'TAG';
         sortable?: boolean;
+        nostem?: boolean;
+        noindex?: boolean;
+        indexed?: boolean;
+        examples?: string[];
+        nilable?: boolean;
+        primitive?: 'string' | 'number' | 'boolean' | 'array' | 'object';
+        required?: boolean;
+        enum?: string[];
+        pattern?: string;
+        fieldName?: string;
     }>;
-    /** Additional data as a key-value record */
     data?: StringStringType;
 };
+type SearchResults = {
+    count: number;
+    query: string;
+    data: StringStringType[];
+};
 type WorkflowOptions = {
-    /**
-     * the namespace for the workflow; `durable` is the default namespace if not provided
-     */
     namespace?: string;
-    /**
-     * the task queue for the workflow; optional if entity is provided
-     */
     taskQueue?: string;
-    /**
-     * input arguments to pass in
-     */
     args: any[];
-    /**
-     * the job id
-     */
     workflowId?: string;
-    /**
-     * if invoking a workflow, passing 'entity' will apply the value as the workflowName, taskQueue, and prefix, ensuring the FT.SEARCH index is properly scoped. This is a convenience method but limits options.
-     */
     entity?: string;
-    /**
-     * the name of the user's workflow function; optional if 'entity' is provided
-     */
     workflowName?: string;
-    /**
-     * the parent workflow id; adjacent ancestor ID
-     */
     parentWorkflowId?: string;
-    /**
-     * the entry point workflow id
-     */
     originJobId?: string;
-    /**
-     * OpenTelemetry trace context for the workflow
-     */
     workflowTrace?: string;
-    /**
-     * OpenTelemetry span context for the workflow
-     */
     workflowSpan?: string;
-    /**
-     * the full-text-search (RediSearch) options for the workflow
-     */
     search?: WorkflowSearchOptions;
-    /**
-     * marker data (begins with a -)
-     */
     marker?: StringStringType;
-    /**
-     * the workflow configuration object
-     */
     config?: WorkflowConfig;
-    /**
-     * sets the number of seconds a workflow may exist after completion. As the process engine is an in-memory cache, the default policy is to expire and scrub the job hash as soon as it completes.
-     */
     expire?: number;
-    /**
-     * 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
- */
 type HookOptions = {
-    /** Optional namespace under which the hook function will be grouped */
     namespace?: string;
-    /** Optional task queue, needed unless 'entity' is provided */
     taskQueue?: string;
-    /** 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;
-    /** Hook function constraints (backoffCoefficient, maximumAttempts, maximumInterval) */
     config?: WorkflowConfig;
 };
-/**
- * Options for sending signals in a workflow.
- */
 type SignalOptions = {
-    /**
-     * Task queue associated with the workflow
-     */
     taskQueue: string;
-    /**
-     * Input data for the signal (any serializable object)
-     */
     data: StringAnyType;
-    /**
-     * Execution ID, also known as the job ID
-     */
     workflowId: string;
-    /**
-     * Optional name of the user's workflow function
-     */
     workflowName?: string;
 };
 type ActivityWorkflowDataType = {
@@ -228,8 +98,8 @@ type WorkflowDataType = {
     canRetry?: boolean;
 };
 type ConnectionConfig = {
-    class: RedisClass;
-    options: RedisOptions;
+    class: Partial<RedisClass>;
+    options: Partial<RedisOptions>;
 };
 type Connection = ConnectionConfig;
 type ClientConfig = {
@@ -239,20 +109,11 @@ type Registry = {
     [key: string]: Function;
 };
 type WorkerConfig = {
-    /** Connection configuration for the worker */
     connection: Connection;
-    /**
-     * Namespace used in the app configuration, denoted as `appid` in the YAML (e.g., 'durable')
-     * @default durable
-     */
     namespace?: string;
-    /** Task queue name, denoted as `subscribes` in the YAML (e.g., 'hello-world') */
     taskQueue: string;
-    /** Target function or a record type with a name (string) and reference function */
     workflow: Function | Record<string | symbol, Function>;
-    /** Additional options for configuring the worker */
     options?: WorkerOptions;
-    /** Search options for workflow execution details */
     search?: WorkflowSearchOptions;
 };
 type FindWhereQuery = {
@@ -266,6 +127,7 @@ type FindOptions = {
     taskQueue?: string;
     namespace?: string;
     index?: string;
+    search?: WorkflowSearchOptions;
 };
 type FindWhereOptions = {
     options?: FindOptions;
@@ -277,14 +139,17 @@ type FindWhereOptions = {
         size: number;
     };
 };
+type FindJobsOptions = {
+    match?: string;
+    namespace?: string;
+    limit?: number;
+    batch?: number;
+    cursor?: string;
+};
 type WorkerOptions = {
-    /** Log level: debug, info, warn, error */
     logLevel?: LogLevel;
-    /** Maximum number of attempts, default 5 (HMSH_DURABLE_MAX_ATTEMPTS) */
     maximumAttempts?: number;
-    /** Backoff coefficient for retry logic, default 10 (HMSH_DURABLE_EXP_BACKOFF) */
     backoffCoefficient?: number;
-    /** Maximum interval between retries, default 120s (HMSH_DURABLE_MAX_INTERVAL) */
     maximumInterval?: string;
 };
 type ContextType = {
@@ -295,29 +160,16 @@ type FunctionSignature<T> = T extends (...args: infer A) => infer R ? (...args:
 type ProxyType<ACT> = {
     [K in keyof ACT]: FunctionSignature<ACT[K]>;
 };
-/**
- * Configuration settings for activities within a workflow.
- */
 type ActivityConfig = {
-    /** Start to close timeout for the activity; not yet implemented */
     startToCloseTimeout?: string;
-    /** Configuration for specific activities, type not yet specified */
     activities?: any;
-    /** Retry policy configuration for activities */
     retryPolicy?: {
-        /** Maximum number of retry attempts, default is 5 (HMSH_DURABLE_MAX_ATTEMPTS) */
         maximumAttempts?: number;
-        /** Factor by which the retry timeout increases, default is 10 (HMSH_DURABLE_MAX_INTERVAL) */
         backoffCoefficient?: number;
-        /** Maximum interval between retries, default is '120s' (HMSH_DURABLE_EXP_BACKOFF) */
         maximumInterval?: string;
-        /** Whether to throw an error on failure, default is true */
         throwOnError?: boolean;
     };
 };
-/**
- * The proxy response object returned from the activity proxy flow
- */
 type ProxyResponseType<T> = {
     data?: T;
     $error?: StreamError;
@@ -325,9 +177,6 @@ type ProxyResponseType<T> = {
     jc: string;
     ju: string;
 };
-/**
- * The child flow response object returned from the  main flow during recursion
- */
 type ChildResponseType<T> = {
     data?: T;
     $error?: StreamError;
@@ -335,4 +184,4 @@ type ChildResponseType<T> = {
     jc: string;
     ju: string;
 };
-export { ActivityConfig, ActivityWorkflowDataType, ChildResponseType, ClientConfig, ContextType, ConnectionConfig, Connection, ProxyResponseType, ProxyType, Registry, SignalOptions, FindOptions, FindWhereOptions, FindWhereQuery, HookOptions, WorkerConfig, WorkflowConfig, WorkerOptions, WorkflowSearchOptions, WorkflowDataType, WorkflowOptions, WorkflowContext, };
+export { ActivityConfig, ActivityWorkflowDataType, ChildResponseType, ClientConfig, ContextType, ConnectionConfig, Connection, ProxyResponseType, ProxyType, Registry, SignalOptions, FindJobsOptions, FindOptions, FindWhereOptions, FindWhereQuery, HookOptions, SearchResults, WorkerConfig, WorkflowConfig, WorkerOptions, WorkflowSearchOptions, WorkflowDataType, WorkflowOptions, WorkflowContext, };

package/build/types/exporter.d.ts

@@ -1,22 +1,9 @@
 import { StringAnyType } from "./serializer";
 export type ExportItem = [(string | null), string, any];
-/**
- * job export data can be large, particularly transitions the timeline
- */
 export type ExportFields = 'data' | 'state' | 'status' | 'timeline' | 'transitions';
 export interface ExportOptions {
-    /**
-     * limit the export byte size by specifying an allowlist
-     */
     allow?: Array<ExportFields>;
-    /**
-     * limit the export byte size by specifying a block list
-     */
     block?: Array<ExportFields>;
-    /**
-     * If false, do not return timeline values (like child job response, proxy activity response, etc)
-     * @default true
-     */
     values?: boolean;
 }
 export type JobAction = {

package/build/types/hotmesh.d.ts

@@ -4,9 +4,6 @@ import { HookRules } from './hook';
 import { RedisClass, RedisClient, RedisOptions } from './redis';
 import { StreamData, StreamDataResponse } from './stream';
 import { LogLevel } from './logger';
-/**
- * the full set of entity types that are stored in the key/value store
- */
 declare enum KeyType {
     APP = "APP",
     ENGINE_ID = "ENGINE",
@@ -28,9 +25,6 @@ declare enum KeyType {
     TIME_RANGE = "TIME_RANGE",
     WORK_ITEMS = "WORK_ITEMS"
 }
-/**
- * minting keys, requires one or more of the following parameters
- */
 type KeyStoreParams = {
     appId?: string;
     engineId?: string;
@@ -46,8 +40,8 @@ type KeyStoreParams = {
 };
 type HotMesh = typeof HotMeshService;
 type RedisConfig = {
-    class: RedisClass;
-    options: RedisOptions;
+    class: Partial<RedisClass>;
+    options: Partial<RedisOptions>;
 };
 type HotMeshEngine = {
     store?: RedisClient;
@@ -62,10 +56,7 @@ type HotMeshWorker = {
     store?: RedisClient;
     stream?: RedisClient;
     sub?: RedisClient;
-    redis?: {
-        class: RedisClass;
-        options: RedisOptions;
-    };
+    redis?: RedisConfig;
     reclaimDelay?: number;
     reclaimCount?: number;
     callback: (payload: StreamData) => Promise<StreamDataResponse | void>;
@@ -117,7 +108,4 @@ type HotMeshApp = VersionedFields & {
 type HotMeshApps = {
     [appId: string]: HotMeshApp;
 };
-export { HotMesh, HotMeshEngine, RedisConfig, HotMeshWorker, HotMeshSettings, HotMeshApp, //a single app in the db
-HotMeshApps, //object array of all apps in the db
-HotMeshConfig, //customer config
-HotMeshManifest, HotMeshGraph, KeyType, KeyStoreParams, };
+export { HotMesh, HotMeshEngine, RedisConfig, HotMeshWorker, HotMeshSettings, HotMeshApp, HotMeshApps, HotMeshConfig, HotMeshManifest, HotMeshGraph, KeyType, KeyStoreParams, };

package/build/types/hotmesh.js

@@ -1,9 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.KeyType = void 0;
-/**
- * the full set of entity types that are stored in the key/value store
- */
 var KeyType;
 (function (KeyType) {
     KeyType["APP"] = "APP";

package/build/types/index.d.ts

@@ -3,19 +3,17 @@ export { App, AppVID, AppTransitions, AppSubscriptions } from './app';
 export { AsyncSignal } from './async';
 export { CacheMode } from './cache';
 export { CollationFaultType, CollationStage } from './collator';
-export { ActivityConfig, ActivityWorkflowDataType, ChildResponseType, ClientConfig, ContextType, ConnectionConfig, Connection, ProxyResponseType, ProxyType, Registry, SignalOptions, FindOptions, FindWhereOptions, FindWhereQuery, HookOptions, WorkflowConfig, WorkerConfig, WorkerOptions, WorkflowContext, WorkflowSearchOptions, WorkflowDataType, WorkflowOptions, } from './durable';
+export { ActivityConfig, ActivityWorkflowDataType, ChildResponseType, ClientConfig, ContextType, ConnectionConfig, Connection, ProxyResponseType, ProxyType, Registry, SignalOptions, FindJobsOptions, FindOptions, FindWhereOptions, FindWhereQuery, HookOptions, SearchResults, WorkflowConfig, WorkerConfig, WorkerOptions, WorkflowContext, WorkflowSearchOptions, WorkflowDataType, WorkflowOptions, } from './durable';
 export { DurableChildErrorType, DurableProxyErrorType, DurableSleepErrorType, DurableWaitForAllErrorType, DurableWaitForErrorType } from "./error";
 export { ActivityAction, DependencyExport, DurableJobExport, ExportCycles, ExportItem, ExportOptions, ExportTransitions, JobAction, JobExport, JobActionExport, JobTimeline } from './exporter';
 export { HookCondition, HookConditions, HookGate, HookInterface, HookRule, HookRules, HookSignal } from './hook';
-export { RedisClientType as IORedisClientType, RedisMultiType as IORedisMultiType } from './ioredisclient';
 export { ILogger } from './logger';
-export { JobData, JobsData, JobMetadata, JobOutput, JobState, JobStatus, PartialJobState, ExtensionType } from './job';
+export { ExtensionType, JobCompletionOptions, JobData, JobsData, JobInterruptOptions, JobMetadata, JobOutput, JobState, JobStatus, PartialJobState } from './job';
 export { MappingStatements } from './map';
 export { Pipe, PipeContext, PipeItem, PipeItems, PipeObject, ReduceObject } from './pipe';
 export { HotMesh, HotMeshApp, HotMeshApps, HotMeshConfig, HotMeshEngine, RedisConfig, HotMeshGraph, HotMeshManifest, HotMeshSettings, HotMeshWorker, KeyStoreParams, KeyType } from './hotmesh';
-export { ActivateMessage, CronMessage, JobMessage, JobMessageCallback, PingMessage, PongMessage, QuorumMessage, QuorumMessageCallback, QuorumProfile, RollCallMessage, SubscriptionCallback, SystemHealth, ThrottleMessage, ThrottleOptions, WorkMessage } from './quorum';
-export { MultiResponseFlags, RedisClient, RedisMulti } from './redis';
-export { RedisClientType, RedisMultiType } from './redisclient';
+export { ActivateMessage, CronMessage, JobMessage, JobMessageCallback, PingMessage, PongMessage, QuorumMessage, QuorumMessageCallback, QuorumProfile, RollCallMessage, RollCallOptions, SubscriptionCallback, SubscriptionOptions, SystemHealth, ThrottleMessage, ThrottleOptions, WorkMessage } from './quorum';
+export { RedisClass, RedisRedisClientType, RedisRedisClientOptions, RedisRedisClassType, IORedisClientType, RedisClient, RedisMulti, RedisRedisMultiType, IORedisClientOptions, IORedisClassType, IORedisMultiType, RedisOptions, MultiResponseFlags, isRedisClient, isIORedisClient, } from './redis';
 export { JSONSchema, StringAnyType, StringScalarType, StringStringType, SymbolMap, SymbolMaps, SymbolRanges, Symbols, SymbolSets } from './serializer';
 export { AggregatedData, CountByFacet, GetStatsOptions, IdsData, Measure, MeasureIds, MetricTypes, StatType, StatsType, IdsResponse, JobStats, JobStatsInput, JobStatsRange, StatsResponse, Segment, TimeSegment } from './stats';
 export { ReclaimedMessageType, StreamCode, StreamConfig, StreamData, StreamDataType, StreamError, StreamDataResponse, StreamRetryPolicy, StreamRole, StreamStatus } from './stream';

package/build/types/index.js

@@ -1,14 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValueType = exports.trace = exports.SpanKind = exports.SpanStatusCode = exports.propagation = exports.metrics = exports.context = exports.StreamStatus = exports.StreamRole = exports.StreamDataType = exports.KeyType = exports.IORedisClientType = exports.HookGate = exports.CollationFaultType = void 0;
+exports.ValueType = exports.trace = exports.SpanKind = exports.SpanStatusCode = exports.propagation = exports.metrics = exports.context = exports.StreamStatus = exports.StreamRole = exports.StreamDataType = exports.isIORedisClient = exports.isRedisClient = exports.KeyType = exports.HookGate = exports.CollationFaultType = void 0;
 var collator_1 = require("./collator");
 Object.defineProperty(exports, "CollationFaultType", { enumerable: true, get: function () { return collator_1.CollationFaultType; } });
 var hook_1 = require("./hook");
 Object.defineProperty(exports, "HookGate", { enumerable: true, get: function () { return hook_1.HookGate; } });
-var ioredisclient_1 = require("./ioredisclient");
-Object.defineProperty(exports, "IORedisClientType", { enumerable: true, get: function () { return ioredisclient_1.RedisClientType; } });
 var hotmesh_1 = require("./hotmesh");
 Object.defineProperty(exports, "KeyType", { enumerable: true, get: function () { return hotmesh_1.KeyType; } });
+var redis_1 = require("./redis");
+Object.defineProperty(exports, "isRedisClient", { enumerable: true, get: function () { return redis_1.isRedisClient; } });
+Object.defineProperty(exports, "isIORedisClient", { enumerable: true, get: function () { return redis_1.isIORedisClient; } });
 var stream_1 = require("./stream");
 Object.defineProperty(exports, "StreamDataType", { enumerable: true, get: function () { return stream_1.StreamDataType; } });
 Object.defineProperty(exports, "StreamRole", { enumerable: true, get: function () { return stream_1.StreamRole; } });