@hotmeshio/hotmesh 0.3.29 → 0.3.31

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

@@ -1,19 +1,108 @@
 import { HotMesh } from '../hotmesh';
 import { ClientConfig, ClientWorkflow, Connection, WorkflowOptions } from '../../types/meshflow';
+/**
+ * The MeshFlow `Client` service is functionally
+ * equivalent to the Temporal `Client` service.
+ * Start a new workflow execution by calling
+ * `workflow.start`. Note the direct connection to
+ * Postgres.
+ *
+ * NATS can be used as the message broker if advanced
+ * messaging is required (i.e, patterned subscriptions).
+ * @example
+
+ * ```typescript
+ * //client.ts
+ * import { Client, HotMesh } from '@hotmeshio/hotmesh';
+ * import { Client as Postgres } from 'pg';
+
+ * async function run(): Promise<string> {
+ *   const client = new Client({
+ *     connection: {
+ *       class: Postgres,
+ *       options: { connectionString: 'postgresql://usr:pwd@localhost:5432/db' }
+ *     }
+ *   });
+
+ *   const handle = await client.workflow.start({
+ *     args: ['HotMesh'],
+ *     taskQueue: 'default',
+ *     workflowName: 'example',
+ *     workflowId: HotMesh.guid()
+ *   });
+
+ *   return await handle.result();
+ *   //returns ['Hello HotMesh', '¡Hola, HotMesh!']
+ * }
+ * ```
+ */
 export declare class ClientService {
+    /**
+     * @private
+     */
     connection: Connection;
+    /**
+     * @private
+     */
     options: WorkflowOptions;
+    /**
+     * @private
+     */
     static topics: string[];
+    /**
+     * @private
+     */
     static instances: Map<string, HotMesh | Promise<HotMesh>>;
+    /**
+     * @private
+     */
     constructor(config: ClientConfig);
+    /**
+     * @private
+     */
     getHotMeshClient: (workflowTopic: string | null, namespace?: string) => Promise<HotMesh>;
+    /**
+     * Creates a stream where messages can be published to ensure there is a
+     * channel in place when the message arrives (a race condition for those
+     * platforms without implicit topic setup).
+     * @private
+     */
     static createStream: (hotMeshClient: HotMesh, workflowTopic: string, namespace?: string) => Promise<void>;
     hashOptions(): string;
+    /**
+     * 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.
+     * @private
+     */
     verifyStream: (hotMeshClient: HotMesh, workflowTopic: string, namespace?: string) => Promise<void>;
+    /**
+     * @private
+     */
     search: (hotMeshClient: HotMesh, index: string, query: string[]) => Promise<string[]>;
+    /**
+     * The MeshFlow `Client` service is functionally
+     * equivalent to the Temporal `Client` service.
+     * Starting a workflow is the primary use case and
+     * is accessed by calling workflow.start().
+     */
     workflow: ClientWorkflow;
+    /**
+     * Any router can be used to deploy and activate the HotMesh
+     * distributed executable to the active quorum EXCEPT for
+     * those routers in `readonly` mode.
+     */
     deployAndActivate(namespace?: string, version?: string): Promise<void>;
+    /**
+     * @private
+     */
     verifyWorkflowActive(hotMesh: HotMesh, appId?: string, count?: number): Promise<boolean>;
+    /**
+     * @private
+     */
     activateWorkflow(hotMesh: HotMesh, appId?: string, version?: string): Promise<void>;
+    /**
+     * @private
+     */
     static shutdown(): Promise<void>;
 }

package/build/services/meshflow/client.js

@@ -10,9 +10,55 @@ const types_1 = require("../../types");
 const search_1 = require("./search");
 const handle_1 = require("./handle");
 const factory_1 = require("./schemas/factory");
+/**
+ * The MeshFlow `Client` service is functionally
+ * equivalent to the Temporal `Client` service.
+ * Start a new workflow execution by calling
+ * `workflow.start`. Note the direct connection to
+ * Postgres.
+ *
+ * NATS can be used as the message broker if advanced
+ * messaging is required (i.e, patterned subscriptions).
+ * @example
+
+ * ```typescript
+ * //client.ts
+ * import { Client, HotMesh } from '@hotmeshio/hotmesh';
+ * import { Client as Postgres } from 'pg';
+
+ * async function run(): Promise<string> {
+ *   const client = new Client({
+ *     connection: {
+ *       class: Postgres,
+ *       options: { connectionString: 'postgresql://usr:pwd@localhost:5432/db' }
+ *     }
+ *   });
+
+ *   const handle = await client.workflow.start({
+ *     args: ['HotMesh'],
+ *     taskQueue: 'default',
+ *     workflowName: 'example',
+ *     workflowId: HotMesh.guid()
+ *   });
+
+ *   return await handle.result();
+ *   //returns ['Hello HotMesh', '¡Hola, HotMesh!']
+ * }
+ * ```
+ */
 class ClientService {
+    /**
+     * @private
+     */
     constructor(config) {
+        /**
+         * @private
+         */
         this.getHotMeshClient = async (workflowTopic, namespace) => {
+            //namespace isolation requires the connection options to be hashed
+            //as multiple intersecting databases can be used by the same service
+            //hashing options allows for reuse of the same connection without risk of
+            //overwriting data in another namespace.
             const optionsHash = this.hashOptions();
             const targetNS = namespace ?? factory_1.APP_ID;
             const connectionNS = `${optionsHash}.${targetNS}`;
@@ -21,18 +67,35 @@ class ClientService {
                 await this.verifyWorkflowActive(hotMeshClient, targetNS);
                 return hotMeshClient;
             }
-            const hotMeshClient = hotmesh_1.HotMesh.init({
+            //init, but don't await
+            const readonly = this.connection.readonly ?? undefined;
+            let hotMeshClient = hotmesh_1.HotMesh.init({
                 appId: targetNS,
                 logLevel: enums_1.HMSH_LOGLEVEL,
                 engine: {
-                    readonly: this.connection.readonly ?? undefined,
+                    readonly,
                     connection: this.connection,
                 },
             });
+            //synchronously cache the promise (before awaiting)
             ClientService.instances.set(connectionNS, hotMeshClient);
-            await this.activateWorkflow(await hotMeshClient, targetNS);
-            return hotMeshClient;
+            //resolve, activate, and return the client
+            const resolvedClient = await hotMeshClient;
+            if (!readonly) {
+                resolvedClient.engine.logger.info('meshflow-readonly-client', {
+                    guid: resolvedClient.engine.guid,
+                    appId: targetNS,
+                });
+                await this.activateWorkflow(resolvedClient, targetNS);
+            }
+            return resolvedClient;
         };
+        /**
+         * 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.
+         * @private
+         */
         this.verifyStream = async (hotMeshClient, workflowTopic, namespace) => {
             const optionsHash = this.hashOptions();
             const targetNS = namespace ?? factory_1.APP_ID;
@@ -42,18 +105,33 @@ class ClientService {
                 await ClientService.createStream(hotMeshClient, workflowTopic, namespace);
             }
         };
+        /**
+         * @private
+         */
         this.search = async (hotMeshClient, index, query) => {
             const searchClient = hotMeshClient.engine.search;
             return await searchClient.sendIndexedQuery(index, query);
         };
+        /**
+         * The MeshFlow `Client` service is functionally
+         * equivalent to the Temporal `Client` service.
+         * Starting a workflow is the primary use case and
+         * is accessed by calling workflow.start().
+         */
         this.workflow = {
+            /**
+             * Starts a workflow, verifies the idempotent id, and
+             * adds searchable data to the record.
+             */
             start: async (options) => {
                 const taskQueueName = options.taskQueue ?? options.entity;
                 const workflowName = options.entity ?? options.workflowName;
                 const trc = options.workflowTrace;
                 const spn = options.workflowSpan;
+                //hotmesh `topic` is equivalent to `queue+workflowname` pattern in other systems
                 const workflowTopic = `${taskQueueName}-${workflowName}`;
                 const hotMeshClient = await this.getHotMeshClient(workflowTopic, options.namespace);
+                //verify that the stream channel exists before enqueueing
                 await this.verifyStream(hotMeshClient, workflowTopic, options.namespace);
                 const payload = {
                     arguments: [...options.args],
@@ -76,10 +154,32 @@ class ClientService {
                 });
                 return new handle_1.WorkflowHandleService(hotMeshClient, workflowTopic, jobId);
             },
+            /**
+             * Sends a message payload to a running workflow that is paused and awaiting the signal
+             */
             signal: async (signalId, data, namespace) => {
                 const topic = `${namespace ?? factory_1.APP_ID}.wfs.signal`;
                 return await (await this.getHotMeshClient(topic, namespace)).hook(topic, { id: signalId, data });
             },
+            /**
+             * Spawns an a new, isolated execution cycle within the same job.
+             * Similar to `worker` functions, `hook` functions have a linked
+             * function. But hooks do not start a new job and instead read/write
+             * their isolated activity data to an existing Job record (HASH).
+             *
+             * This example spawns a hook that will update workflow `guid123`.
+             *
+             * @example
+             * ```typescript
+             * await client.workflow.hook({
+             *   namespace: 'demo',
+             *   taskQueue: 'default',
+             *   workflowName: 'myDemoFunction',
+             *   workflowId: 'guid123',
+             *   args: ['Hello'],
+             * });
+             * ```
+             */
             hook: async (options) => {
                 const workflowTopic = `${options.taskQueue ?? options.entity}-${options.entity ?? options.workflowName}`;
                 const payload = {
@@ -90,8 +190,10 @@ class ClientService {
                     maximumAttempts: options.config?.maximumAttempts || enums_1.HMSH_MESHFLOW_MAX_ATTEMPTS,
                     maximumInterval: (0, utils_1.s)(options.config?.maximumInterval || enums_1.HMSH_MESHFLOW_MAX_INTERVAL),
                 };
+                //seed search data before entering
                 const hotMeshClient = await this.getHotMeshClient(workflowTopic, options.namespace);
                 const msgId = await hotMeshClient.hook(`${hotMeshClient.appId}.flow.signal`, payload, types_1.StreamStatus.PENDING, 202);
+                //todo: commit search data BEFORE enqueuing hook
                 if (options.search?.data) {
                     const searchSessionId = `-search-${hotmesh_1.HotMesh.guid()}-0`;
                     const search = new search_1.Search(options.workflowId, hotMeshClient, searchSessionId);
@@ -100,11 +202,49 @@ class ClientService {
                 }
                 return msgId;
             },
+            /**
+             * Returns a reference to a running workflow,
+             * allowing callers to check the status of the workflow,
+             * interrupt it, and even await its eventual response
+             * if still in a pending state.
+             *
+             * @example
+             * ```typescript
+             * const handle = await client.workflow.getHandle(
+             *  'default',
+             *  'myFunction',
+             *  'someGuid123',
+             *  'demo',
+             * );
+             * ```
+             */
             getHandle: async (taskQueue, workflowName, workflowId, namespace) => {
                 const workflowTopic = `${taskQueue}-${workflowName}`;
                 const hotMeshClient = await this.getHotMeshClient(workflowTopic, namespace);
                 return new handle_1.WorkflowHandleService(hotMeshClient, workflowTopic, workflowId);
             },
+            /**
+             * Provides direct access to the SEARCH backend when making
+             * queries. Taskqueues and workflow names are
+             * used to identify the point of presence to use. `...args` is
+             * the tokenized query. When querying Redis/FTSEARCH, the trailing
+             * ...args might be `'@_custom1:meshflow'`. For postgres,
+             * the trailing ...args would be: `'_custom', 'meshflow'`. In each case,
+             * the query looks for all job data where the field `_custom` is
+             * equal to `meshflow`.
+             *
+             * @example
+             * ```typescript
+             * await client.workflow.search(
+             *   'someTaskQueue'
+             *   'someWorkflowName',
+             *   'meshflow',
+             *   'user',
+             *   ...args,
+             * );
+             * //returns [count, [id, fields[]], [id, fields[]], [id, fields[]], ...]]
+             * ```
+             */
             search: async (taskQueue, workflowName, namespace, index, ...query) => {
                 const workflowTopic = `${taskQueue}-${workflowName}`;
                 const hotMeshClient = await this.getHotMeshClient(workflowTopic, namespace);
@@ -123,9 +263,11 @@ class ClientService {
     }
     hashOptions() {
         if ('options' in this.connection) {
+            //shorthand format
             return (0, utils_1.hashOptions)(this.connection.options);
         }
         else {
+            //longhand format (sub, store, stream, pub, search)
             const response = [];
             for (const p in this.connection) {
                 if (this.connection[p].options) {
@@ -135,6 +277,11 @@ class ClientService {
             return response.join('');
         }
     }
+    /**
+     * Any router can be used to deploy and activate the HotMesh
+     * distributed executable to the active quorum EXCEPT for
+     * those routers in `readonly` mode.
+     */
     async deployAndActivate(namespace = factory_1.APP_ID, version = factory_1.APP_VERSION) {
         if (isNaN(Number(version))) {
             throw new Error('Invalid version number');
@@ -142,6 +289,9 @@ class ClientService {
         const hotMesh = await this.getHotMeshClient('', namespace);
         await this.activateWorkflow(hotMesh, namespace, version);
     }
+    /**
+     * @private
+     */
     async verifyWorkflowActive(hotMesh, appId = factory_1.APP_ID, count = 0) {
         const app = await hotMesh.engine.store.getApp(appId);
         const appVersion = app?.version;
@@ -154,6 +304,9 @@ class ClientService {
         }
         return true;
     }
+    /**
+     * @private
+     */
     async activateWorkflow(hotMesh, appId = factory_1.APP_ID, version = factory_1.APP_VERSION) {
         const app = await hotMesh.engine.store.getApp(appId);
         const appVersion = app?.version;
@@ -181,6 +334,9 @@ class ClientService {
             }
         }
     }
+    /**
+     * @private
+     */
     static async shutdown() {
         for (const [_, hotMeshInstance] of ClientService.instances) {
             (await hotMeshInstance).stop();
@@ -188,8 +344,20 @@ class ClientService {
     }
 }
 _a = ClientService;
+/**
+ * @private
+ */
 ClientService.topics = [];
+/**
+ * @private
+ */
 ClientService.instances = new Map();
+/**
+ * Creates a stream where messages can be published to ensure there is a
+ * channel in place when the message arrives (a race condition for those
+ * platforms without implicit topic setup).
+ * @private
+ */
 ClientService.createStream = async (hotMeshClient, workflowTopic, namespace) => {
     const params = { appId: namespace ?? factory_1.APP_ID, topic: workflowTopic };
     const streamKey = hotMeshClient.engine.store.mintKey(key_1.KeyType.STREAMS, params);
@@ -197,6 +365,7 @@ ClientService.createStream = async (hotMeshClient, workflowTopic, namespace) =>
         await hotMeshClient.engine.stream.createConsumerGroup(streamKey, 'WORKER');
     }
     catch (err) {
+        //ignore if already exists
     }
 };
 exports.ClientService = ClientService;

package/build/services/meshflow/connection.d.ts

@@ -1,6 +1,23 @@
 import { Connection } from '../../types/meshflow';
 import { ProviderConfig, ProvidersConfig } from '../../types/provider';
+/**
+ * The Connection service is used to declare the class
+ * and connection options but does not connect quite yet. Connection
+ * happens at a later lifecycle stage when a workflow
+ * is started by the MeshFlow Client module (`(new MeshFlow.Client())).start()`).
+ *
+ * The config options optionall support a multi-connection setup
+ * where the `store` connection explicitly defined along with `stream`, `sub`, etc.
+ * For example, Postgres can be used for stream and store while
+ * Redis is used for sub.
+ */
 export declare class ConnectionService {
+    /**
+     * @private
+     */
     constructor();
+    /**
+     * Instance initializer
+     */
     static connect(config: ProviderConfig | ProvidersConfig): Promise<Connection>;
 }

package/build/services/meshflow/connection.js

@@ -1,8 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConnectionService = void 0;
+/**
+ * The Connection service is used to declare the class
+ * and connection options but does not connect quite yet. Connection
+ * happens at a later lifecycle stage when a workflow
+ * is started by the MeshFlow Client module (`(new MeshFlow.Client())).start()`).
+ *
+ * The config options optionall support a multi-connection setup
+ * where the `store` connection explicitly defined along with `stream`, `sub`, etc.
+ * For example, Postgres can be used for stream and store while
+ * Redis is used for sub.
+ */
 class ConnectionService {
+    /**
+     * @private
+     */
     constructor() { }
+    /**
+     * Instance initializer
+     */
     static async connect(config) {
         return 'store' in config
             ? config

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

@@ -10,20 +10,42 @@ declare class ExporterService {
     symbols: Promise<Symbols> | Symbols;
     private static symbols;
     constructor(appId: string, store: StoreService<ProviderClient, ProviderTransaction>, logger: ILogger);
+    /**
+     * Convert the job hash from its compiles format into a MeshFlowJobExport object with
+     * facets that describe the workflow in terms relevant to narrative storytelling.
+     */
     export(jobId: string, options?: ExportOptions): Promise<MeshFlowJobExport>;
+    /**
+     * Inflates the job data from Redis into a MeshFlowJobExport 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): MeshFlowJobExport;
     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: MeshFlowJobExport, block?: ExportFields[], allow?: ExportFields[]): Partial<MeshFlowJobExport>;
     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/meshflow/exporter.js

@@ -1 +1 @@
-'use strict';const q=b;(function(c,d){const p=b,e=c();while(!![]){try{const f=-parseInt(p(0x1d2))/0x1*(parseInt(p(0x1cc))/0x2)+-parseInt(p(0x1d1))/0x3*(-parseInt(p(0x1e6))/0x4)+parseInt(p(0x1d6))/0x5+parseInt(p(0x1d7))/0x6+-parseInt(p(0x1cd))/0x7+-parseInt(p(0x1ff))/0x8*(-parseInt(p(0x1e9))/0x9)+-parseInt(p(0x1d5))/0xa;if(f===d)break;else e['push'](e['shift']());}catch(g){e['push'](e['shift']());}}}(a,0xe9d7a));function a(){const D=['6222696jYiilY','data','split','$error','__esModule','sortEntriesByCreated','symbols','inflate','resolveValue','entries','updated','/output/metadata/ac','endsWith','get','allow','16gRXjjk','join','object','135ocUtZl','keyToObject','inflateKey','values','SerializerService','block','../serializer','getRaw','sort','length','defineProperty','appId','forEach','inflateTransition','filterFields','push','created','shift','sortParts','/output/metadata/au','export','restoreHierarchy','859864nNEeXX','../../modules/utils','set','10XnRBQv','6522250raRppZ','ExporterService','startsWith','localeCompare','951348VqfGas','347239lKJDnM','store','match','11681250eUeIaQ','4380315IOOTJD'];a=function(){return D;};return a();}function b(c,d){const e=a();return b=function(f,g){f=f-0x1cc;let h=e[f];return h;},b(c,d);}Object[q(0x1f3)](exports,q(0x1db),{'value':!![]}),exports[q(0x1ce)]=void 0x0;const utils_1=require(q(0x200)),serializer_1=require(q(0x1ef));class ExporterService{constructor(c,d,e){const r=q;this[r(0x1f4)]=c,this['logger']=e,this[r(0x1d3)]=d;}async[q(0x1fd)](c,d={}){const s=q;if(!ExporterService['symbols']['has'](this[s(0x1f4)])){const g=this[s(0x1d3)]['getAllSymbols']();ExporterService['symbols'][s(0x201)](this[s(0x1f4)],await g);}const e=await this[s(0x1d3)][s(0x1f0)](c),f=this[s(0x1de)](e,d);return f;}['inflate'](c,d){const t=q,e=[],f={},g={},h={},i=/^([a-zA-Z]{3}),(\d+(?:,\d+)*)/;return Object[t(0x1e0)](c)['forEach'](([j,k])=>{const u=t,l=j[u(0x1d4)](i);if(l)this[u(0x1f6)](l,k,h);else{if(j[u(0x1cf)]('_'))g[j['substring'](0x1)]=k;else{if(j[u(0x1cf)]('-')){const m=this[u(0x1ea)](j);e[u(0x1f8)]({...m,'key':j,'value':this[u(0x1df)](k,d[u(0x1ec)])});}else j['length']===0x3&&(f[this[u(0x1eb)](j)]=serializer_1[u(0x1ed)]['fromString'](k));}}}),this[t(0x1f7)]({'data':(0x0,utils_1[t(0x1fe)])(g),'state':Object[t(0x1e0)]((0x0,utils_1[t(0x1fe)])(f))[0x0][0x1],'status':parseInt(c[':'],0xa),'timeline':this[t(0x1fb)](e),'transitions':this['sortEntriesByCreated'](h)},d[t(0x1ee)],d[t(0x1e5)]);}[q(0x1df)](c,d){const v=q,e=serializer_1['SerializerService']['fromString'](c);if(d!==![])return e;return e&&typeof e===v(0x1e8)&&('data'in e&&(e[v(0x1d8)]={}),v(0x1da)in e&&(e[v(0x1da)]={})),e;}[q(0x1eb)](c){const w=q,d=ExporterService[w(0x1dd)][w(0x1e4)](this[w(0x1f4)]);if(c in d){const e=d[c],f=e[w(0x1d9)]('/');return f['join']('/');}return c;}['filterFields'](c,d=[],e=[]){const x=q;let f={};return e&&e[x(0x1f2)]>0x0?e['forEach'](g=>{g in c&&(f[g]=c[g]);}):f={...c},d&&d[x(0x1f2)]>0x0&&d[x(0x1f5)](g=>{g in f&&delete f[g];}),f;}['inflateTransition'](c,d,e){const y=q,[f,g,h]=c,i=this[y(0x1eb)](g),j=i['split']('/'),k=j[0x0],l=i['endsWith'](y(0x1e2)),m=i[y(0x1e3)](y(0x1fc));if(l||m){const n=k+','+h,o=e[n];!o?e[n]={'activity':k,'dimensions':h,'created':l?d:null,'updated':m?d:null}:o[l?y(0x1f9):'updated']=d;}}[q(0x1dc)](c){const z=q,d=Object['values'](c);return d[z(0x1f1)]((e,f)=>{const A=z;return(e[A(0x1f9)]||e[A(0x1e1)])[A(0x1d0)](f[A(0x1f9)]||f[A(0x1e1)]);}),d;}['keyToObject'](c){const C=q;function d(f){const B=b,g=f[B(0x1d9)](',');if(g['length']>0x1)return g[B(0x1fa)](),g[B(0x1e7)](',');}const e=c[C(0x1d9)]('-');return e[C(0x1f2)]===0x4?{'index':parseInt(e[0x2],0xa),'dimension':d(e[0x1])}:{'index':parseInt(e[0x2],0xa),'secondary':parseInt(e[0x3],0xa),'dimension':d(e[0x1])};}[q(0x1fb)](c){return c['sort']((d,e)=>{const {dimension:f,index:g,secondary:h}=d,{dimension:i,index:j,secondary:k}=e;if(f===undefined&&i!==undefined)return-0x1;if(f!==undefined&&i===undefined)return 0x1;if(f!==undefined&&i!==undefined){if(f<i)return-0x1;if(f>i)return 0x1;}if(g<j)return-0x1;if(g>j)return 0x1;if(h===undefined&&k!==undefined)return-0x1;if(h!==undefined&&k===undefined)return 0x1;if(h!==undefined&&k!==undefined){if(h<k)return-0x1;if(h>k)return 0x1;}return 0x0;});}}exports['ExporterService']=ExporterService,ExporterService['symbols']=new Map();
+'use strict';const y=b;(function(c,d){const x=b,e=c();while(!![]){try{const f=parseInt(x(0x168))/0x1*(-parseInt(x(0x16c))/0x2)+-parseInt(x(0x167))/0x3+-parseInt(x(0x151))/0x4*(-parseInt(x(0x16b))/0x5)+parseInt(x(0x174))/0x6*(-parseInt(x(0x16a))/0x7)+parseInt(x(0x146))/0x8*(parseInt(x(0x16e))/0x9)+parseInt(x(0x14b))/0xa+parseInt(x(0x15d))/0xb;if(f===d)break;else e['push'](e['shift']());}catch(g){e['push'](e['shift']());}}}(a,0x9fcc0));Object[y(0x17c)](exports,'__esModule',{'value':!0x0}),exports['ExporterService']=void 0x0;function b(c,d){const e=a();return b=function(f,g){f=f-0x145;let h=e[f];return h;},b(c,d);}const utils_1=require('../../modules/utils'),serializer_1=require(y(0x145));function a(){const L=['endsWith','3528489FyPZCf','3608msDCbM','substring','128030lXyhbD','43535OOFWQo','522vopEjC','/output/metadata/au','36594OfdJQc','getRaw','keyToObject','appId','get','split','54PVjLwy','entries','sortParts','SerializerService','sort','join','localeCompare','allow','defineProperty','../serializer','488GhczTX','ExporterService','inflateTransition','forEach','filterFields','5490300uibDlf','set','symbols','inflateKey','resolveValue','match','260guGtWx','inflate','length','created','$error','fromString','logger','/output/metadata/ac','data','restoreHierarchy','startsWith','has','17313758BYcTDU','block','store','sortEntriesByCreated','export','shift','values','updated','getAllSymbols'];a=function(){return L;};return a();}class ExporterService{constructor(c,d,f){const z=y;this['appId']=c,this[z(0x157)]=f,this[z(0x15f)]=d;}async[y(0x161)](c,d={}){const A=y;if(!ExporterService[A(0x14d)][A(0x15c)](this[A(0x171)])){const g=this['store'][A(0x165)]();ExporterService[A(0x14d)][A(0x14c)](this[A(0x171)],await g);}const f=await this[A(0x15f)][A(0x16f)](c);return this[A(0x152)](f,d);}[y(0x152)](c,d){const C=y,f=[],g={},h={},j={},k=/^([a-zA-Z]{3}),(\d+(?:,\d+)*)/;return Object['entries'](c)['forEach'](([m,p])=>{const B=b,q=m[B(0x150)](k);if(q)this[B(0x148)](q,p,j);else{if(m[B(0x15b)]('_'))h[m[B(0x169)](0x1)]=p;else{if(m[B(0x15b)]('-')){const u=this[B(0x170)](m);f['push']({...u,'key':m,'value':this[B(0x14f)](p,d[B(0x163)])});}else 0x3===m[B(0x153)]&&(g[this[B(0x14e)](m)]=serializer_1[B(0x177)]['fromString'](p));}}}),this['filterFields']({'data':(0x0,utils_1[C(0x15a)])(h),'state':Object[C(0x175)]((0x0,utils_1[C(0x15a)])(g))[0x0][0x1],'status':parseInt(c[':'],0xa),'timeline':this[C(0x176)](f),'transitions':this[C(0x160)](j)},d[C(0x15e)],d[C(0x17b)]);}[y(0x14f)](c,d){const D=y,f=serializer_1[D(0x177)][D(0x156)](c);return!0x1!==d||f&&'object'==typeof f&&('data'in f&&(f[D(0x159)]={}),D(0x155)in f&&(f['$error']={})),f;}['inflateKey'](c){const E=y,d=ExporterService[E(0x14d)][E(0x172)](this[E(0x171)]);if(c in d)return d[c][E(0x173)]('/')[E(0x179)]('/');return c;}[y(0x14a)](c,d=[],f=[]){const F=y;let g={};return f&&f[F(0x153)]>0x0?f[F(0x149)](h=>{h in c&&(g[h]=c[h]);}):g={...c},d&&d[F(0x153)]>0x0&&d[F(0x149)](h=>{h in g&&delete g[h];}),g;}[y(0x148)](c,f,g){const G=y,[h,j,k]=c,m=this['inflateKey'](j),p=m[G(0x173)]('/')[0x0],q=m['endsWith'](G(0x158)),u=m[G(0x166)](G(0x16d));if(q||u){const v=p+','+k,w=g[v];w?w[q?'created':G(0x164)]=f:g[v]={'activity':p,'dimensions':k,'created':q?f:null,'updated':u?f:null};}}[y(0x160)](c){const H=y,d=Object[H(0x163)](c);return d[H(0x178)]((f,g)=>(f['created']||f[H(0x164)])[H(0x17a)](g[H(0x154)]||g[H(0x164)])),d;}[y(0x170)](c){const J=y;function d(g){const I=b,h=g[I(0x173)](',');if(h[I(0x153)]>0x1)return h[I(0x162)](),h['join'](',');}const f=c[J(0x173)]('-');return 0x4===f['length']?{'index':parseInt(f[0x2],0xa),'dimension':d(f[0x1])}:{'index':parseInt(f[0x2],0xa),'secondary':parseInt(f[0x3],0xa),'dimension':d(f[0x1])};}[y(0x176)](c){const K=y;return c[K(0x178)]((d,f)=>{const {dimension:g,index:h,secondary:j}=d,{dimension:k,index:l,secondary:m}=f;if(void 0x0===g&&void 0x0!==k)return-0x1;if(void 0x0!==g&&void 0x0===k)return 0x1;if(void 0x0!==g&&void 0x0!==k){if(g<k)return-0x1;if(g>k)return 0x1;}if(h<l)return-0x1;if(h>l)return 0x1;if(void 0x0===j&&void 0x0!==m)return-0x1;if(void 0x0!==j&&void 0x0===m)return 0x1;if(void 0x0!==j&&void 0x0!==m){if(j<m)return-0x1;if(j>m)return 0x1;}return 0x0;});}}exports[y(0x147)]=ExporterService,ExporterService['symbols']=new Map();

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

@@ -3,18 +3,86 @@ import { MeshFlowJobExport, ExportOptions } from '../../types/exporter';
 import { JobInterruptOptions } from '../../types/job';
 import { StreamError } from '../../types/stream';
 import { ExporterService } from './exporter';
+/**
+ * The WorkflowHandleService provides methods to interact with a running
+ * workflow. This includes exporting the workflow, sending signals, and
+ * querying the state of the workflow. It is instanced/accessed via the
+ * MeshFlow.Client class.
+ *
+ * @example
+ * ```typescript
+ * import { Client } from '@hotmeshio/hotmesh';
+ * import { Client as Postgres } from 'pg';
+ *
+ * const client = new Client({ connection: {
+ *   class: Postgres,
+ *   options: { connectionString: 'postgres://user:pass@localhost:5432/db' }
+ * }});
+ *
+ * const handle = await client.workflow.start({
+ *  args: ['HotMesh'],
+ *  taskQueue: 'hello-world',
+ * });
+ *
+ * //perform actions like send a signal
+ * await handle.signal('my-signal', { data: 'Hello' });
+ * ```
+ */
 export declare class WorkflowHandleService {
+    /**
+     * @private
+     */
     exporter: ExporterService;
     hotMesh: HotMesh;
     workflowTopic: string;
     workflowId: string;
+    /**
+     * @private
+     */
     constructor(hotMesh: HotMesh, workflowTopic: string, workflowId: string);
+    /**
+     * Exports the workflow state to a JSON object.
+     */
     export(options?: ExportOptions): Promise<MeshFlowJobExport>;
+    /**
+     * Sends a signal to the workflow. This is a way to send
+     * a message to a workflow that is paused due to having
+     * executed `MeshFlow.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.
+     */
     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;