@hotmeshio/hotmesh 0.1.15 → 0.1.17

package/build/services/worker/index.js

@@ -103,7 +103,6 @@ class WorkerService {
             self.logger.debug('worker-event-received', { topic, type: message.type });
             if (message.type === 'throttle') {
                 if (message.topic !== null) {
-                    //undefined allows passthrough
                     self.throttle(message.throttle);
                 }
             }
@@ -112,16 +111,11 @@ class WorkerService {
             }
             else if (message.type === 'rollcall') {
                 if (message.topic !== null) {
-                    //undefined allows passthrough
                     self.doRollCall(message);
                 }
             }
         };
     }
-    /**
-     * A quorum-wide command to broadcaset system details.
-     *
-     */
     async doRollCall(message) {
         let iteration = 0;
         const max = !isNaN(message.max) ? message.max : enums_1.HMSH_QUORUM_ROLLCALL_CYCLES;

package/build/types/activity.d.ts

@@ -34,18 +34,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;
@@ -53,19 +42,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 {
@@ -104,84 +81,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/error.d.ts

@@ -1,4 +1,4 @@
-export type DurableChildErrorType = {
+export type MeshFlowChildErrorType = {
     arguments: string[];
     await?: boolean;
     backoffCoefficient?: number;
@@ -13,7 +13,7 @@ export type DurableChildErrorType = {
     workflowId: string;
     workflowTopic: string;
 };
-export type DurableWaitForAllErrorType = {
+export type MeshFlowWaitForAllErrorType = {
     items: string[];
     workflowId: string;
     workflowTopic: string;
@@ -23,7 +23,7 @@ export type DurableWaitForAllErrorType = {
     index: number;
     workflowDimension: string;
 };
-export type DurableProxyErrorType = {
+export type MeshFlowProxyErrorType = {
     arguments: string[];
     activityName: string;
     backoffCoefficient?: number;
@@ -37,13 +37,13 @@ export type DurableProxyErrorType = {
     workflowId: string;
     workflowTopic: string;
 };
-export type DurableWaitForErrorType = {
+export type MeshFlowWaitForErrorType = {
     signalId: string;
     index: number;
     workflowDimension: string;
     workflowId: string;
 };
-export type DurableSleepErrorType = {
+export type MeshFlowSleepErrorType = {
     duration: number;
     index: number;
     workflowDimension: string;

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 = {
@@ -67,7 +54,7 @@ export interface TransitionType {
     created: string;
     updated: string;
 }
-export interface DurableJobExport {
+export interface MeshFlowJobExport {
     data?: StringAnyType;
     state?: StringAnyType;
     status?: number;

package/build/types/hotmesh.d.ts

@@ -1,12 +1,9 @@
 import { ILogger } from '../services/logger';
-import { HotMeshService } from '../services/hotmesh';
+import { HotMesh as HotMeshService } from '../services/hotmesh';
 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",
     THROTTLE_RATE = "THROTTLE_RATE",
@@ -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;
@@ -65,12 +59,13 @@ type HotMeshWorker = {
     redis?: RedisConfig;
     reclaimDelay?: number;
     reclaimCount?: number;
-    callback: (payload: StreamData) => Promise<StreamDataResponse | void>;
+    callback: (payload: StreamData) => Promise<StreamDataResponse>;
 };
 type HotMeshConfig = {
     appId: string;
     namespace?: string;
     name?: string;
+    guid?: string;
     logger?: ILogger;
     logLevel?: LogLevel;
     engine?: HotMeshEngine;
@@ -114,7 +109,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,15 +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, FindJobsOptions, FindOptions, FindWhereOptions, FindWhereQuery, HookOptions, SearchResults, WorkflowConfig, WorkerConfig, WorkerOptions, WorkflowContext, WorkflowSearchOptions, WorkflowSearchSchema, 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 { ActivityConfig, ActivityWorkflowDataType, ChildResponseType, ClientConfig, ClientWorkflow, ContextType, ConnectionConfig, Connection, ProxyResponseType, ProxyType, Registry, SignalOptions, FindJobsOptions, FindOptions, FindWhereOptions, FindWhereQuery, HookOptions, SearchResults, WorkflowConfig, WorkerConfig, WorkerOptions, WorkflowContext, WorkflowSearchOptions, WorkflowSearchSchema, WorkflowDataType, WorkflowOptions, } from './meshflow';
+export { MeshFlowChildErrorType, MeshFlowProxyErrorType, MeshFlowSleepErrorType, MeshFlowWaitForAllErrorType, MeshFlowWaitForErrorType, } from './error';
+export { ActivityAction, DependencyExport, MeshFlowJobExport, ExportCycles, ExportItem, ExportOptions, ExportTransitions, JobAction, JobExport, JobActionExport, JobTimeline, } from './exporter';
 export { HookCondition, HookConditions, HookGate, HookInterface, HookRule, HookRules, HookSignal, } from './hook';
 export { ILogger, LogLevel, } from './logger';
 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 { MeshCallConnectParams, MeshCallExecParams, MeshCallCronParams, MeshCallExecOptions, MeshCallCronOptions, MeshCallInterruptOptions, MeshCallInterruptParams, MeshCallFlushParams, } from './meshcall';
+export { CallOptions, MeshDataWorkflowOptions, ConnectOptions, ConnectionInput, ExecInput, } from './meshdata';
 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';

package/build/types/index.js

@@ -7,7 +7,7 @@ var hook_1 = require("./hook");
 Object.defineProperty(exports, "HookGate", { enumerable: true, get: function () { return hook_1.HookGate; } });
 var hotmesh_1 = require("./hotmesh");
 Object.defineProperty(exports, "KeyType", { enumerable: true, get: function () { return hotmesh_1.KeyType; } });
-var redis_1 = require("./redis"); //common redis types
+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");

package/build/types/job.d.ts

@@ -6,92 +6,38 @@ type ActivityData = {
     metadata?: Record<string, unknown>;
 };
 type JobMetadata = {
-    /** job_key */
     key?: string;
-    /** system assigned guid that corresponds to the transition message guid that spawned reentry */
     guid?: string;
-    /** system assigned guid; ensured created/deleted/created jobs are unique */
     gid: string;
-    /** job_id (jid+dad+aid) is composite key for activity */
     jid: string;
-    /** dimensional address for the activity (,0,0,1) */
     dad: string;
-    /** activity_id as in the YAML file */
     aid: string;
-    /** parent_job_id (pj+pd+pa) is composite key for parent activity */
     pj?: string;
-    /** parent_generational_id (system assigned at trigger inception); pg is the parent job's gid (just in case user created/deleted/created a job with same jid) */
     pg?: string;
-    /** parent_dimensional_address */
     pd?: string;
-    /** parent_activity_id */
     pa?: string;
-    /** sever the dependency chain if true (startChild/vs/execChild) */
     px?: boolean;
-    /** engine guid (one time subscriptions) */
     ngn?: string;
-    /** app_id */
     app: string;
-    /** app version */
     vrs: string;
-    /** subscription topic */
     tpc: string;
-    /** 201203120005 (slice of time) //time series */
     ts: string;
-    /** GMT created //job_created */
     jc: string;
-    /** GMT updated //job_updated */
     ju: string;
     js: JobStatus;
-    /** activity_type */
     atp: string;
-    /** activity_subtype */
     stp: string;
-    /** open telemetry span context */
     spn: string;
-    /** open telemetry trace context */
     trc: string;
-    /** stringified job error json: {message: string, code: number, error?} */
     err?: string;
-    /** process data expire policy */
     expire?: number;
 };
-/**
- * User-defined (extended) types for job data. Users may interleave
- * data into the job hash safely by using the `ExtensionType` interface.
- * The data will be prefixed as necessary using an underscore or
- * dash to ensure it is not confused with system process data.
- */
 type ExtensionType = {
-    /**
-     * Custom search data field (name/value pairs) to seed the Hash.
-     * Every field will be prefixed with an underscore before being
-     * stored with the initial Hash data set along side system
-     * process data.
-     */
     search?: StringStringType;
-    /**
-     * Custom marker data field used for adding a searchable marker to the job.
-     * markers always begin with a dash (-). Any field that does not
-     * begin with a dash will be removed and will not be inserted with
-     * the initial data set.
-     */
     marker?: StringStringType;
-    /**
-     * If provided, the job will initialize in a pending state, reserving
-     * only the job ID (HSETNX) and persisting search and marker (if provided).
-     * If a `resume` signal is sent before the specified number of seconds,
-     * the job will resume as normal, transitioning to the adjacent children
-     * of the trigger. If the job is not resumed within the number
-     * of seconds specified, the job will be scrubbed. No dependencies
-     * are added for a job in a pending state; however, dependencies
-     * will be added after the job is resumed if relevant.
-     */
     pending?: number;
+    statusThreshold?: number;
 };
-/**
- * job_status semaphore
- */
 type JobStatus = number;
 type JobState = {
     metadata: JobMetadata;
@@ -105,65 +51,25 @@ type JobState = {
     };
 };
 type JobInterruptOptions = {
-    /**
-     * 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;
-    /**
-     * if true, errors related to inactivation (like overage...already inactive) are suppressed/ignored
-     * @default false
-     */
     suppress?: boolean;
-    /**
-     * how long to wait in seconds before fully expiring/removing the hash from Redis;
-     * the job is inactive, but can remain in the cache indefinitely;
-     * @default 1 second.
-     */
     expire?: number;
-    /**
-     * Optional Error Code; will be used as the error `code` when thrown
-     * @default 410
-     */
     code?: number;
-    /**
-     * Optional stack trace
-     */
     stack?: string;
 };
-/**
- * format when publishing job meta/data on the wire when it completes
- */
 type JobOutput = {
     metadata: JobMetadata;
     data: JobData;
 };
-/**
- * jid+dad+aid is a composite guid; signal in and restore the full job context
- */
 type PartialJobState = {
     metadata: JobMetadata | Pick<JobMetadata, 'jid' | 'dad' | 'aid'>;
     data: JobData;
 };
 type JobCompletionOptions = {
-    /** default false */
     emit?: boolean;
-    /** default undefined */
     interrupt?: boolean;
-    /**
-     * in seconds to wait before deleting/expiring job hash
-     * @default 1 second
-     */
     expire?: number;
 };
 export { JobCompletionOptions, JobData, JobsData, JobInterruptOptions, JobMetadata, JobOutput, JobState, JobStatus, PartialJobState, ExtensionType, };

package/build/types/meshcall.d.ts

@@ -0,0 +1,54 @@
+import { RedisConfig } from "./hotmesh";
+import { LogLevel } from "./logger";
+interface MeshCallExecOptions {
+    id: string;
+    ttl?: string;
+    flush?: boolean;
+}
+interface MeshCallConnectParams {
+    logLevel?: LogLevel;
+    guid?: string;
+    namespace?: string;
+    topic: string;
+    redis: RedisConfig;
+    callback: <T extends any[], U>(...args: T) => Promise<U>;
+}
+interface MeshCallExecParams {
+    namespace?: string;
+    topic: string;
+    args: any[];
+    redis: RedisConfig;
+    options?: MeshCallExecOptions;
+}
+interface MeshCallFlushParams {
+    namespace?: string;
+    id: string;
+    topic: string;
+    redis: RedisConfig;
+}
+interface MeshCallCronOptions {
+    id: string;
+    interval: string;
+    maxCycles?: number;
+    maxDuration?: string;
+}
+interface MeshCallInterruptOptions {
+    id: string;
+}
+interface MeshCallCronParams {
+    logLevel?: LogLevel;
+    guid?: string;
+    namespace?: string;
+    topic: string;
+    redis: RedisConfig;
+    args: any[];
+    callback: <T extends any[], U>(...args: T) => Promise<U>;
+    options: MeshCallCronOptions;
+}
+interface MeshCallInterruptParams {
+    namespace?: string;
+    topic: string;
+    redis: RedisConfig;
+    options: MeshCallInterruptOptions;
+}
+export { MeshCallConnectParams, MeshCallExecParams, MeshCallCronParams, MeshCallExecOptions, MeshCallCronOptions, MeshCallInterruptOptions, MeshCallInterruptParams, MeshCallFlushParams, };

package/build/types/meshdata.d.ts

@@ -0,0 +1,59 @@
+import { HookOptions, WorkflowConfig, WorkflowSearchOptions } from "./meshflow";
+import { StringStringType } from "./serializer";
+export type CallOptions = {
+    id?: string;
+    ttl?: string;
+    $guid?: string;
+    $type?: string;
+    await?: boolean;
+    taskQueue?: string;
+    prefix?: string;
+    search?: WorkflowSearchOptions;
+    fields?: string[];
+    namespace?: string;
+    marker?: StringStringType;
+    pending?: number;
+};
+export type ConnectOptions = {
+    ttl?: string;
+    taskQueue?: string;
+    prefix?: string;
+    namespace?: string;
+    options?: WorkerOptions;
+    search?: WorkflowSearchOptions;
+};
+export type ConnectionInput<T> = {
+    entity: string;
+    target: (...args: any[]) => T;
+    options?: ConnectOptions;
+};
+export type ExecInput = {
+    entity: string;
+    args: any[];
+    options?: Partial<MeshDataWorkflowOptions>;
+};
+export type HookInput = {
+    entity: string;
+    id: string;
+    hookEntity: string;
+    hookArgs: any[];
+    options?: Partial<HookOptions>;
+};
+export type MeshDataWorkflowOptions = {
+    namespace?: string;
+    taskQueue?: string;
+    prefix?: string;
+    id?: string;
+    workflowId?: string;
+    workflowName?: string;
+    workflowTrace?: string;
+    workflowSpan?: string;
+    search?: WorkflowSearchOptions;
+    config?: WorkflowConfig;
+    ttl?: string;
+    await?: boolean;
+    marker?: StringStringType;
+    pending?: number;
+    expire?: number;
+    signalIn?: boolean;
+};

package/build/types/meshdata.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });