@hotmeshio/hotmesh 0.1.15 → 0.1.17

package/build/services/durable/client.d.ts

@@ -1,49 +0,0 @@
-import { HotMeshService as HotMesh } from '../hotmesh';
-import { ClientConfig, Connection, HookOptions, WorkflowOptions } from '../../types/durable';
-import { WorkflowHandleService } from './handle';
-export declare class ClientService {
-    connection: Connection;
-    options: WorkflowOptions;
-    static topics: string[];
-    static instances: Map<string, HotMesh | Promise<HotMesh>>;
-    constructor(config: ClientConfig);
-    getHotMeshClient: (workflowTopic: string | null, namespace?: string) => Promise<HotMesh>;
-    /**
-     * Creates a stream (Redis `XGROUP.CREATE`) where events can be published (XADD).
-     * It is possible that the worker that will read from this stream channel
-     * has not yet been initialized, so this call ensures that the channel
-     * exists and is ready to serve as a container for events.
-     */
-    static createStream: (hotMeshClient: HotMesh, workflowTopic: string, namespace?: string) => Promise<void>;
-    /**
-     * It is possible for a client to invoke a workflow without first
-     * creating the stream. This method will verify that the stream
-     * exists and if not, create it.
-     */
-    verifyStream: (hotMeshClient: HotMesh, workflowTopic: string, namespace?: string) => Promise<void>;
-    search: (hotMeshClient: HotMesh, index: string, query: string[]) => Promise<string[]>;
-    workflow: {
-        start: (options: WorkflowOptions) => Promise<WorkflowHandleService>;
-        /**
-         * send a message to a running workflow that is paused and awaiting the signal
-         */
-        signal: (signalId: string, data: Record<any, any>, namespace?: string) => Promise<string>;
-        /**
-         * send a message to spawn an parallel in-process thread of execution
-         * with the same job state as the main thread but bound to a different
-         * handler function. All job state will be journaled to the same hash
-         * as is used by the main thread.
-         */
-        hook: (options: HookOptions) => Promise<string>;
-        getHandle: (taskQueue: string, workflowName: string, workflowId: string, namespace?: string) => Promise<WorkflowHandleService>;
-        search: (taskQueue: string, workflowName: string, namespace: null | string, index: string, ...query: string[]) => Promise<string[]>;
-    };
-    /**
-     * Any point of presence can be used to deploy and activate the HotMesh
-     * distributed executable to the active quorum.
-     */
-    deployAndActivate(namespace?: string, version?: string): Promise<void>;
-    verifyWorkflowActive(hotMesh: HotMesh, appId?: string, count?: number): Promise<boolean>;
-    activateWorkflow(hotMesh: HotMesh, appId?: string, version?: string): Promise<void>;
-    static shutdown(): Promise<void>;
-}

package/build/services/durable/exporter.d.ts

@@ -1,51 +0,0 @@
-import { ILogger } from '../logger';
-import { StoreService } from '../store';
-import { ExportOptions, DurableJobExport, TimelineType, TransitionType, ExportFields } from '../../types/exporter';
-import { RedisClient, RedisMulti } from '../../types/redis';
-import { StringStringType, Symbols } from '../../types/serializer';
-declare class ExporterService {
-    appId: string;
-    logger: ILogger;
-    store: StoreService<RedisClient, RedisMulti>;
-    symbols: Promise<Symbols> | Symbols;
-    private static symbols;
-    constructor(appId: string, store: StoreService<RedisClient, RedisMulti>, logger: ILogger);
-    /**
-     * Convert the job hash from its compiles format into a DurableJobExport object with
-     * facets that describe the workflow in terms relevant to narrative storytelling.
-     */
-    export(jobId: string, options?: ExportOptions): Promise<DurableJobExport>;
-    /**
-     * Inflates the job data from Redis into a DurableJobExport object
-     * @param jobHash - the job data from Redis
-     * @param dependencyList - the list of dependencies for the job
-     * @returns - the inflated job data
-     */
-    inflate(jobHash: StringStringType, options: ExportOptions): DurableJobExport;
-    resolveValue(raw: string, withValues: boolean): Record<string, any> | string | number | null;
-    /**
-     * Inflates the key from Redis, 3-character symbol
-     * into a human-readable JSON path, reflecting the
-     * tree-like structure of the unidimensional Hash
-     * @private
-     */
-    inflateKey(key: string): string;
-    filterFields(fullObject: DurableJobExport, block?: ExportFields[], allow?: ExportFields[]): Partial<DurableJobExport>;
-    inflateTransition(match: RegExpMatchArray, value: string, transitionsObject: Record<string, TransitionType>): void;
-    sortEntriesByCreated(obj: {
-        [key: string]: TransitionType;
-    }): TransitionType[];
-    /**
-     * marker names are overloaded with details like sequence, type, etc
-     */
-    keyToObject(key: string): {
-        index: number;
-        dimension?: string;
-        secondary?: number;
-    };
-    /**
-     * idem list has a complicated sort order based on indexes and dimensions
-     */
-    sortParts(parts: TimelineType[]): TimelineType[];
-}
-export { ExporterService };

package/build/services/durable/handle.d.ts

@@ -1,58 +0,0 @@
-import { HotMeshService as HotMesh } from '../hotmesh';
-import { DurableJobExport, ExportOptions } from '../../types/exporter';
-import { JobInterruptOptions } from '../../types/job';
-import { StreamError } from '../../types/stream';
-import { ExporterService } from './exporter';
-export declare class WorkflowHandleService {
-    exporter: ExporterService;
-    hotMesh: HotMesh;
-    workflowTopic: string;
-    workflowId: string;
-    constructor(hotMesh: HotMesh, workflowTopic: string, workflowId: string);
-    export(options?: ExportOptions): Promise<DurableJobExport>;
-    /**
-     * Sends a signal to the workflow. This is a way to send
-     * a message to a workflow that is paused due to having
-     * executed `Durable.workflow.waitFor`. The workflow
-     * will awaken if no other signals are pending.
-     */
-    signal(signalId: string, data: Record<any, any>): Promise<void>;
-    /**
-     * Returns the job state of the workflow. If the workflow has completed
-     * this is also the job output. If the workflow is still running, this
-     * is the current state of the job, but it may change depending upon
-     * the activities that remain.
-     */
-    state(metadata?: boolean): Promise<Record<string, any>>;
-    /**
-     * Returns the current search state of the workflow. This is
-     * different than the job state or individual activity state.
-     * Search state represents name/value pairs that were added
-     * to the workflow. As the workflow is stored in a Redis hash,
-     * this is a way to store additional data that is indexed
-     * and searchable using the RediSearch module.
-     */
-    queryState(fields: string[]): Promise<Record<string, any>>;
-    /**
-     * Returns the current status of the workflow. This is a semaphore
-     * value that represents the current state of the workflow, where
-     * 0 is complete and a negative value represents that the flow was
-     * interrupted.
-     */
-    status(): Promise<number>;
-    /**
-     * Interrupts a running workflow. Standard Job Completion tasks will
-     * run. Subscribers will be notified and the job hash will be expired.
-     */
-    interrupt(options?: JobInterruptOptions): Promise<string>;
-    /**
-     * Waits for the workflow to complete and returns the result. If
-     * the workflow response includes an error, this method will rethrow
-     * the error, including the stack trace if available.
-     * Wrap calls in a try/catch as necessary to avoid unhandled exceptions.
-     */
-    result<T>(config?: {
-        state?: boolean;
-        throwOnError?: boolean;
-    }): Promise<T | StreamError>;
-}

package/build/services/durable/index.d.ts

@@ -1,19 +0,0 @@
-import { ContextType } from '../../types/durable';
-import { ClientService } from './client';
-import { ConnectionService } from './connection';
-import { Search } from './search';
-import { WorkerService } from './worker';
-import { WorkflowService } from './workflow';
-export declare const Durable: {
-    Client: typeof ClientService;
-    Connection: typeof ConnectionService;
-    Search: typeof Search;
-    Worker: typeof WorkerService;
-    workflow: typeof WorkflowService;
-    /**
-     * Shutdown everything. All connections, workers, and clients will be closed.
-     * Include in your signal handlers to ensure a clean shutdown.
-     */
-    shutdown(): Promise<void>;
-};
-export type { ContextType };

package/build/services/durable/index.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Durable = void 0;
-const hotmesh_1 = require("../hotmesh");
-const client_1 = require("./client");
-const connection_1 = require("./connection");
-const search_1 = require("./search");
-const worker_1 = require("./worker");
-const workflow_1 = require("./workflow");
-exports.Durable = {
-    Client: client_1.ClientService,
-    Connection: connection_1.ConnectionService,
-    Search: search_1.Search,
-    Worker: worker_1.WorkerService,
-    workflow: workflow_1.WorkflowService,
-    /**
-     * Shutdown everything. All connections, workers, and clients will be closed.
-     * Include in your signal handlers to ensure a clean shutdown.
-     */
-    async shutdown() {
-        await client_1.ClientService.shutdown();
-        await worker_1.WorkerService.shutdown();
-        await hotmesh_1.HotMeshService.stop();
-    },
-};

package/build/services/durable/schemas/factory.d.ts

@@ -1,33 +0,0 @@
-/**
- *********** HOTMESH 'DURABLE' MODULE APPLICATION GRAPH **********
- *
- * This HotMesh application spec uses 50 activities and 25 transitions
- * to model and emulate the Temporal Application & Query servers using
- * Redis as the backend.
- *
- * It's particularly useful for organizations with high-speed, high-volume
- * use cases as it uses in-memory Redis Streams for transactional,
- * workflow processing, while adhering to Temporal's developer-friendly syntax.
- *
- * This YAML file can also serve as a useful starting point for building
- * Integration/BPM/Workflow servers in general (MuleSoft, etc) without the need
- * for a physical application server.
- *
- * Possible use cases include:
- * * Orchestration servers
- * * Integration servers
- * * BPMN engines
- * * Reentrant process servers
- * * Service Meshes
- * * Master Data Management systems
- */
-declare const APP_VERSION = "3";
-declare const APP_ID = "durable";
-/**
- * returns a new durable workflow schema
- * @param {string} app - app name (e.g., 'durable')
- * @param {string} version - number as string (e.g., '1')
- * @returns {string} HotMesh App YAML
- */
-declare const getWorkflowYAML: (app: string, version: string) => string;
-export { getWorkflowYAML, APP_VERSION, APP_ID };

package/build/services/durable/search.d.ts

@@ -1,120 +0,0 @@
-import { HotMeshService as HotMesh } from '../hotmesh';
-import { RedisClient, RedisMulti } from '../../types/redis';
-import { StoreService } from '../store';
-import { WorkflowSearchOptions } from '../../types/durable';
-export declare class Search {
-    jobId: string;
-    searchSessionId: string;
-    searchSessionIndex: number;
-    hotMeshClient: HotMesh;
-    store: StoreService<RedisClient, RedisMulti> | null;
-    cachedFields: Record<string, string>;
-    constructor(workflowId: string, hotMeshClient: HotMesh, searchSessionId: string);
-    /**
-     * Prefixes the key with an underscore to keep separate from the
-     * activity and job history (and searchable via HKEYS)
-     * @param {string} key - the key to be sanitized. Wrap in quotes to avoid sanitization.
-     * @returns {string} - the sanitized key
-     * @private
-     */
-    safeKey(key: string): string;
-    /**
-     * For those deployments with a redis stack backend (with the FT module),
-     * this method will configure the search index for the workflow. For all
-     * others, this method will exit/fail gracefully and not index
-     * the fields in the HASH. All values are searchable via HKEYS/HSC/HGET
-     * @param {HotMesh} hotMeshClient - the hotmesh client
-     * @param {WorkflowSearchOptions} search - the search options
-     * @returns {Promise<void>}
-     * @example
-     * const search = {
-     *  index: 'my_search_index',
-     *  prefix: ['my_workflow_prefix'],
-     *  schema: {
-     *   field1: { type: 'TEXT', sortable: true },
-     *   field2: { type: 'NUMERIC', sortable: true }
-     *  }
-     * }
-     * await Search.configureSearchIndex(hotMeshClient, search);
-     */
-    static configureSearchIndex(hotMeshClient: HotMesh, search?: WorkflowSearchOptions): Promise<void>;
-    /**
-     * For those deployments with a redis stack backend (with the FT module),
-     * this method will list all search indexes.
-     *
-     * @param {HotMesh} hotMeshClient - the hotmesh client
-     * @returns {Promise<string[]>} - the list of search indexes
-     * @example
-     * const searchIndexes = await Search.listSearchIndexes(hotMeshClient);
-     */
-    static listSearchIndexes(hotMeshClient: HotMesh): Promise<string[]>;
-    /**
-     * increments the index to return a unique search session guid when
-     * calling any method that produces side effects (changes the value)
-     * @private
-     */
-    getSearchSessionGuid(): string;
-    /**
-     * Sets the fields listed in args. Returns the
-     * count of new fields that were set (does not
-     * count fields that were updated)
-     * @param args
-     * @returns {number}
-     * @example
-     * const search = new Search();
-     * const count = await search.set('field1', 'value1', 'field2', 'value2');
-     */
-    set(...args: string[]): Promise<number>;
-    /**
-     * Returns the value of the field in the HASH stored at key.
-     * @param key
-     * @returns {string}
-     * @example
-     * const search = new Search();
-     * const value = await search.get('field1');
-     */
-    get(key: string): Promise<string>;
-    /**
-     * Returns the values of all specified fields in the HASH stored at key.
-     * @param args
-     * @returns
-     */
-    mget(...args: string[]): Promise<string[]>;
-    /**
-     * Deletes the fields provided as args. Returns the
-     * count of fields that were deleted.
-     *
-     * @param args
-     * @returns {number}
-     * @example
-     * sont search = new Search();
-     * const count = await search.del('field1', 'field2', 'field3');
-     */
-    del(...args: string[]): Promise<number | void>;
-    /**
-     * Increments the value of a float field by the given amount. Returns the
-     * new value of the field after the increment. Pass a negative
-     * number to decrement the value.
-     *
-     * @param key - the key to increment
-     * @param val - the value to increment by
-     * @returns {number} - the new value
-     * @example
-     * const search = new Search();
-     * const count = await search.incr('field1', 1.5);
-     */
-    incr(key: string, val: number): Promise<number>;
-    /**
-     * Multiplies the value of a field by the given amount. Returns the
-     * new value of the field after the multiplication. NOTE:
-     * this is exponential multiplication.
-     *
-     * @param key - the key to multiply
-     * @param val - the value to multiply by
-     * @returns {number} - the new product of the multiplication
-     * @example
-     * const search = new Search();
-     * const product = await search.mult('field1', 1.5);
-     */
-    mult(key: string, val: number): Promise<number>;
-}

package/build/services/durable/workflow.d.ts

@@ -1,143 +0,0 @@
-import { HotMeshService as HotMesh } from '../hotmesh';
-import { ActivityConfig, HookOptions, ProxyType, WorkflowContext, WorkflowOptions } from '../../types/durable';
-import { JobInterruptOptions } from '../../types/job';
-import { DurableChildErrorType, DurableProxyErrorType } from '../../types/error';
-import { Search } from './search';
-export declare class WorkflowService {
-    /**
-     * Returns the synchronous output from the activity (replay)
-     * if available locally, revealing whether or not the activity already
-     * ran during a prior execution cycle
-     * @param {string} prefix - one of: proxy, child, start, wait etc
-     * @returns
-     */
-    static didRun(prefix: string): Promise<[boolean, number, any]>;
-    /**
-     * Those methods that may only be called once must be protected by flagging
-     * their execution with a unique key (the key is stored in the HASH alongside
-     * process state and job state)
-     * @private
-     */
-    static isSideEffectAllowed(hotMeshClient: HotMesh, prefix: string): Promise<boolean>;
-    /**
-     * Returns the current workflow context restored
-     * from Redis
-     */
-    static getContext(): WorkflowContext;
-    /**
-     * Return a handle to the hotmesh client hosting the workflow execution
-     * @returns {Promise<HotMesh>} - a hotmesh client
-     */
-    static getHotMesh(): Promise<HotMesh>;
-    /**
-     * Spawns a child workflow and awaits the return.
-     * @template T - the result type
-     * @param {WorkflowOptions} options - the workflow options
-     * @returns {Promise<T>} - the result of the child workflow
-     * @example
-     * const result = await Durable.workflow.execChild<typeof resultType>({ ...options });
-     */
-    static execChild<T>(options: WorkflowOptions): Promise<T>;
-    /**
-     * constructs the payload necessary to spawn a child job
-     * @private
-     */
-    static getChildInterruptPayload(context: WorkflowContext, options: WorkflowOptions, execIndex: number): DurableChildErrorType;
-    /**
-     * Spawns a child workflow and returns the child Job ID.
-     * This method guarantees the spawned child has reserved the Job ID,
-     * returning a 'DuplicateJobError' error if not. Otherwise,
-     * this is a fire-and-forget method.
-     *
-     * @param {WorkflowOptions} options - the workflow options
-     * @returns {Promise<string>} - the childJobId
-     * @example
-     * const childJobId = await Durable.workflow.startChild({ ...options });
-     */
-    static startChild(options: WorkflowOptions): Promise<string>;
-    /**
-     * Wraps activities in a proxy that durably runs/re-runs them to completion.
-     * TODO: verify that activities do not collide if named same on same server but bound to different workflows
-     *
-     * @param {ActivityConfig} options - the activity configuration
-     * that will be used to wrap the activities.
-     * @returns {ProxyType<ACT>} - a proxy object with the same keys as the
-     * activities object, but with the values replaced by a wrapped function
-     *
-     * @example
-     * // import the activities
-     * import * as activities from './activities';
-     * const proxy = WorkflowService.proxyActivities<typeof activities>({ activities });
-     *
-     * //or destructure the proxy object, as the function names are the keys
-     * const { activity1, activity2 } = WorkflowService.proxyActivities<typeof activities>({ activities });
-     */
-    static proxyActivities<ACT>(options?: ActivityConfig): ProxyType<ACT>;
-    static wrapActivity<T>(activityName: string, options?: ActivityConfig): T;
-    /**
-     * constructs the payload necessary to spawn a proxyActivity job
-     * @private
-     */
-    static getProxyInterruptPayload(context: WorkflowContext, activityName: string, execIndex: number, args: any[], options?: ActivityConfig): DurableProxyErrorType;
-    /**
-     * Returns a search session for use when reading/writing to the workflow HASH.
-     * The search session provides access to methods like `get`, `mget`, `set`, `del`, and `incr`.
-     * @returns {Promise<Search>} - a search session
-     */
-    static search(): Promise<Search>;
-    /**
-     * Returns a random number between 0 and 1. This number is deterministic
-     * and will never vary for a given seed. This is useful for randomizing
-     * pathways in a workflow that can be safely replayed.
-     * @returns {number} - a random number between 0 and 1
-     */
-    static random(): number;
-    /**
-     * Sends signal data into any other paused thread (which is currently
-     * awaiting the signal)
-     * @param {string} signalId - the signal id
-     * @param {Record<any, any>} data - the signal data
-     * @returns {Promise<string>} - the stream id
-     */
-    static signal(signalId: string, data: Record<any, any>): Promise<string>;
-    /**
-     * Spawns a hook from either the main thread or a hook thread with
-     * the provided options; worflowId/TaskQueue/Name are optional and will
-     * default to the current workflowId/WorkflowTopic if not provided
-     * @param {HookOptions} options - the hook options
-     */
-    static hook(options: HookOptions): Promise<string>;
-    /**
-     * Executes a function once and caches the result. If the function is called
-     * again, the cached result is returned. This is useful for wrapping
-     * expensive activity calls that should only be run once, but which might
-     * not require the cost and safety provided by proxyActivities.
-     * @template T - the result type
-     */
-    static once<T>(fn: (...args: any[]) => Promise<T>, ...args: any[]): Promise<T>;
-    /**
-     * Interrupts a running job
-     */
-    static interrupt(jobId: string, options?: JobInterruptOptions): Promise<string | void>;
-    /**
-     * Promise.all (limited to 25 total concurrent workflow)
-     */
-    static all<T>(...promises: Promise<T>[]): Promise<T[]>;
-    /**
-     * Sleeps the workflow for a duration. As the function is reentrant,
-     * upon reentry, the function will traverse prior execution paths up
-     * until the sleep command and then resume execution thereafter.
-     * @param {string} duration - See the `ms` package for syntax examples: '1 minute', '2 hours', '3 days'
-     * @returns {Promise<number>} - resolved duration in seconds
-     */
-    static sleepFor(duration: string): Promise<number>;
-    /**
-     * Pauses the workflow until `signalId` is received.
-     * @template T - the result type
-     * @param {string} signalId - a unique, shareable guid (e.g, 'abc123')
-     * @returns {Promise<T>}
-     * @example
-     * const result = await Durable.workflow.waitFor<typeof resultType>('abc123');
-     */
-    static waitFor<T>(signalId: string): Promise<T>;
-}