@hotmeshio/hotmesh 0.2.0 → 0.2.1

package/README.md

@@ -13,13 +13,13 @@ You have a Redis instance? Good. You're ready to go.
 [Read the Docs](https://hotmeshio.github.io/sdk-typescript/)
 
 ## MeshCall | Connect Everything
-The **MeshCall** module connects any function with a connection to Redis. Function responses are cacheable and functions can even run as cyclical cron jobs. Make blazing fast interservice calls that return in milliseconds without the overhead of HTTP.
+[MeshCall](https://hotmeshio.github.io/sdk-typescript/classes/services_meshcall.MeshCall.html) connects your functions to the Redis-backed mesh, exposing them as idempotent endpoints. Function responses are cacheable and functions can even run as idempotent cron jobs. Make blazing fast interservice calls that return in milliseconds without the overhead of HTTP.
 
 <details style="padding: .5em">
   <summary style="font-size:1.25em;">Run an idempotent cron job</summary>
 
   ### Run a Cron
-  This example demonstrates an *idempotent* cron that runs every day. The `id` makes each cron job unique and ensures that only one instance runs, despite repeated invocations. *The `cron` method fails silently if a workflow is already running with the same `id`.*
+  This example demonstrates an *idempotent* cron that runs every day. The `id` makes each cron job unique and ensures that only one instance runs, despite repeated invocations. *The `cron` method returns `false` if a workflow is already running with the same `id`.*
   
   Optionally set a `delay` and/or set `maxCycles` to limit the number of cycles.
 
@@ -29,8 +29,8 @@ The **MeshCall** module connects any function with a connection to Redis. Functi
     import { MeshCall } from '@hotmeshio/hotmesh';
     import * as Redis from 'redis';
 
-    export const runMyCron = (id: string, interval = '1 day') => {
-      MeshCall.cron({
+    export const runMyCron = async (id: string, interval = '1 day'): Promise<boolean> => {
+      return await MeshCall.cron({
         topic: 'my.cron.function',
         redis: {
           class: Redis,
@@ -87,8 +87,8 @@ The **MeshCall** module connects any function with a connection to Redis. Functi
     import { MeshCall, Types } from '@hotmeshio/hotmesh';
     import * as Redis from 'redis';
 
-    export const connectMyFunction = () => {
-      MeshCall.connect({
+    export const connectMyFunction = async () => {
+      return await MeshCall.connect({
         topic: 'my.demo.function',
         redis: {
           class: Redis,
@@ -168,7 +168,7 @@ The **MeshCall** module connects any function with a connection to Redis. Functi
 </details>
 
 ## MeshFlow | Transactional Workflow
-The **MeshFlow** module is a drop-in replacement for [Temporal.io](https://temporal.io). If you need to orchestrate your functions as durable workflows, MeshFlow combines the popular Temporal SDK with Redis' *in-memory execution speed*.
+[MeshFlow](https://hotmeshio.github.io/sdk-typescript/classes/services_meshflow.MeshFlow.html) is a drop-in replacement for [Temporal.io](https://temporal.io). If you need to orchestrate your functions as durable workflows, MeshFlow combines the popular Temporal SDK with Redis' *in-memory execution speed*.
 
 <details style="padding: .5em">
   <summary style="font-size:1.25em;">Orchestrate unpredictable activities</summary>
@@ -503,7 +503,7 @@ This example calls an activity and then sleeps for a week. It runs indefinitely
 </details>
 
 ## MeshData | Transactional Analytics
-The **MeshData** service extends the **MeshFlow** service, combining data record concepts and transactional workflow principles into a single *Operational Data Layer*. 
+[MeshData](https://hotmeshio.github.io/sdk-typescript/classes/services_meshdata.MeshData.html) extends the **MeshFlow** service, combining data record concepts and transactional workflow principles into a single *Operational Data Layer*. 
 
 Deployments with the Redis `FT.SEARCH` module enabled can use the **MeshData** module to merge [OLTP](https://en.wikipedia.org/wiki/Online_transaction_processing) and [OLAP](https://en.wikipedia.org/wiki/Online_analytical_processing) operations into a hybrid transactional/analytics ([HTAP](https://en.wikipedia.org/wiki/Hybrid_transactional/analytical_processing)) system.
 

package/build/index.d.ts

@@ -3,5 +3,5 @@ import { MeshData } from './services/meshdata';
 import { MeshFlow } from './services/meshflow';
 import { HotMesh } from './services/hotmesh';
 import { HotMeshConfig } from './types/hotmesh';
-export { HotMesh, MeshCall, MeshData, MeshFlow, HotMeshConfig, };
+export { HotMesh, MeshCall, MeshData, MeshFlow, HotMeshConfig };
 export * as Types from './types';

package/build/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hotmeshio/hotmesh",
-    "version": "0.2.0",
+    "version": "0.2.1",
     "description": "Unbreakable Workflows",
     "main": "./build/index.js",
     "types": "./build/index.d.ts",

package/build/services/engine/index.js

@@ -108,7 +108,10 @@ class EngineService {
                 return await this.fetchAndVerifyVID(vid, count + 1);
             }
             else {
-                this.logger.error('engine-vid-resolution-error', { id: vid.id, guid: this.guid });
+                this.logger.error('engine-vid-resolution-error', {
+                    id: vid.id,
+                    guid: this.guid,
+                });
             }
         }
         return vid;
@@ -132,7 +135,7 @@ class EngineService {
         else {
             return await this.fetchAndVerifyVID({
                 id: this.appId,
-                version: this.apps?.[this.appId].version
+                version: this.apps?.[this.appId].version,
             });
         }
     }

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

@@ -1,12 +1,12 @@
-import { HotMesh } from "../hotmesh";
-import { MeshCallConnectParams, MeshCallCronParams, MeshCallExecParams, MeshCallFlushParams, MeshCallInterruptParams } from "../../types/meshcall";
-import { RedisConfig } from "../../types";
+import { HotMesh } from '../hotmesh';
+import { MeshCallConnectParams, MeshCallCronParams, MeshCallExecParams, MeshCallFlushParams, MeshCallInterruptParams } from '../../types/meshcall';
+import { RedisConfig } from '../../types';
 declare class MeshCall {
     static workers: Map<string, HotMesh | Promise<HotMesh>>;
     static engines: Map<string, HotMesh | Promise<HotMesh>>;
     static connections: Map<string, any>;
     constructor();
-    static findFirstMatching(workers: Map<string, (HotMesh | Promise<HotMesh>)>, namespace: string, config: RedisConfig): Promise<HotMesh | void>;
+    static findFirstMatching(workers: Map<string, HotMesh | Promise<HotMesh>>, namespace: string, config: RedisConfig): Promise<HotMesh | void>;
     static getHotMeshClient: (namespace: string, connection: RedisConfig) => Promise<HotMesh>;
     static verifyWorkflowActive(hotMesh: HotMesh, appId?: string, count?: number): Promise<boolean>;
     static activateWorkflow(hotMesh: HotMesh, appId?: string, version?: string): Promise<void>;

package/build/services/meshcall/index.js

@@ -64,7 +64,7 @@ class MeshCall {
         if (!hotMeshInstance) {
             hotMeshInstance = await MeshCall.findFirstMatching(MeshCall.engines, namespace, redis);
             if (!hotMeshInstance) {
-                hotMeshInstance = await MeshCall.getHotMeshClient(namespace, redis);
+                hotMeshInstance = (await MeshCall.getHotMeshClient(namespace, redis));
             }
         }
         return hotMeshInstance;
@@ -89,7 +89,7 @@ class MeshCall {
                             data: { response },
                         };
                     },
-                }
+                },
             ],
         });
         MeshCall.workers.set(targetTopic, hotMeshWorker);
@@ -141,7 +141,9 @@ class MeshCall {
             });
             const TOPIC = `${params.namespace ?? key_1.HMNS}.cron`;
             const interval = (0, ms_1.default)(params.options.interval) / 1000;
-            const delay = params.options.delay ? (0, ms_1.default)(params.options.delay) / 1000 : undefined;
+            const delay = params.options.delay
+                ? (0, ms_1.default)(params.options.delay) / 1000
+                : undefined;
             const maxCycles = params.options.maxCycles ?? 1000000;
             const hotMeshInstance = await MeshCall.getInstance(params.namespace, params.redis);
             await hotMeshInstance.pub(TOPIC, {
@@ -163,7 +165,7 @@ class MeshCall {
     }
     static async interrupt(params) {
         const hotMeshInstance = await MeshCall.getInstance(params.namespace, params.redis);
-        await hotMeshInstance.interrupt(`${params.namespace ?? key_1.HMNS}.cron`, params.options.id, { 'throw': false, expire: 60 });
+        await hotMeshInstance.interrupt(`${params.namespace ?? key_1.HMNS}.cron`, params.options.id, { throw: false, expire: 60 });
     }
     static async shutdown() {
         for (const [_, hotMeshInstance] of MeshCall.workers) {

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

@@ -10,7 +10,7 @@ declare class MeshData {
     connectionSignatures: StringStringType;
     redisOptions: RedisOptions;
     redisClass: RedisClass;
-    instances: Map<string, (Promise<HotMesh> | HotMesh)>;
+    instances: Map<string, Promise<HotMesh> | HotMesh>;
     search: WorkflowSearchOptions;
     static workflow: {
         sleep: typeof import("../meshflow/workflow").WorkflowService.sleepFor;
@@ -44,7 +44,7 @@ declare class MeshData {
         pub: (message: QuorumMessage, options?: SubscriptionOptions) => Promise<void>;
         unsub: (callback: QuorumMessageCallback, options?: SubscriptionOptions) => Promise<void>;
     };
-    connect<T>({ entity, target, options }: ConnectionInput<T>): Promise<boolean>;
+    connect<T>({ entity, target, options, }: ConnectionInput<T>): Promise<boolean>;
     bindCallOptions(args: any[], options: ConnectOptions, callOptions?: CallOptions): StringAnyType;
     pauseForTTL<T>(result: T, options: CallOptions): Promise<void>;
     publishDone<T>(result: T, hotMesh: HotMesh, options: CallOptions): Promise<void>;
@@ -53,7 +53,7 @@ declare class MeshData {
     signal(guid: string, payload: StringAnyType, namespace?: string): Promise<string>;
     rollCall(options?: RollCallOptions): Promise<QuorumProfile[]>;
     throttle(options: ThrottleOptions): Promise<boolean>;
-    hook({ entity, id, hookEntity, hookArgs, options }: HookInput): Promise<string>;
+    hook({ entity, id, hookEntity, hookArgs, options, }: HookInput): Promise<string>;
     exec<T>({ entity, args, options }: ExecInput): Promise<T>;
     info(entity: string, id: string, options?: CallOptions): Promise<JobOutput>;
     export(entity: string, id: string, options?: ExportOptions, namespace?: string): Promise<MeshFlowJobExport>;

package/build/services/meshdata/index.js

@@ -41,7 +41,7 @@ class MeshData {
             unsub: async (callback, options = {}) => {
                 const hotMesh = await this.getHotMesh(options.namespace || 'durable');
                 await hotMesh.quorum?.unsub(callback);
-            }
+            },
         };
         this.redisClass = redisClass;
         this.redisOptions = redisOptions;
@@ -50,9 +50,7 @@ class MeshData {
         }
     }
     validate(entity) {
-        if (entity.includes(':') ||
-            entity.includes('$') ||
-            entity.includes(' ')) {
+        if (entity.includes(':') || entity.includes('$') || entity.includes(' ')) {
             throw "Invalid string [':','$',' ' not allowed]";
         }
     }
@@ -67,25 +65,30 @@ class MeshData {
             connection: {
                 class: this.redisClass,
                 options: this.redisOptions,
-            }
+            },
         });
     }
     safeKey(key) {
         return `_${key}`;
     }
     arrayToHash(input) {
-        const [_count, ...rest] = input;
-        const max = rest.length / 2;
+        const max = input.length;
         const hashes = [];
-        for (let i = 0; i < max * 2; i += 2) {
-            const fields = rest[i + 1];
-            const hash = { '$': rest[i] };
-            for (let j = 0; j < fields.length; j += 2) {
-                const fieldKey = fields[j].replace(/^_/, '');
-                const fieldValue = fields[j + 1];
-                hash[fieldKey] = fieldValue;
+        for (let i = 1; i < max; i++) {
+            const fields = input[i];
+            if (Array.isArray(fields)) {
+                const hash = {};
+                const hashId = input[i - 1];
+                for (let j = 0; j < fields.length; j += 2) {
+                    const fieldKey = fields[j].replace(/^_/, '');
+                    const fieldValue = fields[j + 1];
+                    hash[fieldKey] = fieldValue;
+                }
+                if (typeof hashId === 'string') {
+                    hash['$'] = hashId;
+                }
+                hashes.push(hash);
             }
-            hashes.push(hash);
         }
         return hashes;
     }
@@ -114,7 +117,7 @@ class MeshData {
     }
     static mintGuid(entity, id) {
         if (!id && !entity) {
-            throw "Invalid arguments [entity and id are both null]";
+            throw 'Invalid arguments [entity and id are both null]';
         }
         else if (!id) {
             id = hotmesh_1.HotMesh.guid();
@@ -136,8 +139,8 @@ class MeshData {
                     redis: {
                         class: this.redisClass,
                         options: this.redisOptions,
-                    }
-                }
+                    },
+                },
             });
             this.instances.set(namespace, hotMesh);
             hotMesh = await hotMesh;
@@ -148,17 +151,22 @@ class MeshData {
     async mintKey(entity, workflowId, namespace) {
         const handle = await this.getClient().workflow.getHandle(entity, entity, workflowId, namespace);
         const store = handle.hotMesh.engine?.store;
-        return store?.mintKey(hotmesh_2.KeyType.JOB_STATE, { jobId: workflowId, appId: handle.hotMesh.engine?.appId });
+        return store?.mintKey(hotmesh_2.KeyType.JOB_STATE, {
+            jobId: workflowId,
+            appId: handle.hotMesh.engine?.appId,
+        });
     }
-    async connect({ entity, target, options = {} }) {
+    async connect({ entity, target, options = {}, }) {
         this.validate(entity);
         this.connectionSignatures[entity] = target.toString();
-        const targetFunction = { [entity]: async (...args) => {
+        const targetFunction = {
+            [entity]: async (...args) => {
                 const { callOptions } = this.bindCallOptions(args, options);
-                const result = await target.apply(target, args);
+                const result = (await target.apply(target, args));
                 await this.pauseForTTL(result, callOptions);
                 return result;
-            } };
+            },
+        };
         await meshflow_1.MeshFlow.Worker.create({
             namespace: options.namespace,
             options: options.options,
@@ -197,11 +205,14 @@ class MeshData {
             if (`-${prefix}${workflowDimension}-${counter + 1}-` in replay) {
                 return;
             }
-            await new Promise(resolve => setImmediate(resolve));
+            await new Promise((resolve) => setImmediate(resolve));
             options.$guid = options.$guid ?? workflowId;
             const hotMesh = await MeshData.workflow.getHotMesh();
             const store = hotMesh.engine?.store;
-            const jobKey = store?.mintKey(hotmesh_2.KeyType.JOB_STATE, { jobId: options.$guid, appId: hotMesh.engine?.appId });
+            const jobKey = store?.mintKey(hotmesh_2.KeyType.JOB_STATE, {
+                jobId: options.$guid,
+                appId: hotMesh.engine?.appId,
+            });
             const jobResponse = ['aAa', '/t', 'aBa', this.toString(result)];
             await store?.exec('HSET', jobKey, ...jobResponse);
             await this.publishDone(result, hotMesh, options);
@@ -225,24 +236,24 @@ class MeshData {
                     jid: options.$guid,
                     aid: 't1',
                     ts: '0',
-                    js: 0
+                    js: 0,
                 },
                 data: {
                     done: true,
                     response: result,
-                    workflowId: options.$guid
-                }
-            }
+                    workflowId: options.$guid,
+                },
+            },
         }, hotMesh.engine.appId, `${hotMesh.engine.appId}.executed.${options.$guid}`);
     }
     async flush(entity, id, namespace) {
         const workflowId = MeshData.mintGuid(entity, id);
         await this.getClient().workflow.signal(`flush-${workflowId}`, {}, namespace);
-        await new Promise(resolve => setTimeout(resolve, 1000));
+        await new Promise((resolve) => setTimeout(resolve, 1000));
         await this.interrupt(entity, id, {
             descend: true,
             suppress: true,
-            expire: 1
+            expire: 1,
         }, namespace);
     }
     async interrupt(entity, id, options = {}, namespace) {
@@ -264,7 +275,7 @@ class MeshData {
     async throttle(options) {
         return (await this.getHotMesh(options.namespace || 'durable')).throttle(options);
     }
-    async hook({ entity, id, hookEntity, hookArgs, options = {} }) {
+    async hook({ entity, id, hookEntity, hookArgs, options = {}, }) {
         const workflowId = MeshData.mintGuid(entity, id);
         this.validate(workflowId);
         return await this.getClient().workflow.hook({
@@ -286,7 +297,7 @@ class MeshData {
             if (state?.data?.done) {
                 return state.data.response;
             }
-            return await handle.result();
+            return (await handle.result());
         }
         catch (e) {
             const optionsClone = { ...options };
@@ -311,7 +322,7 @@ class MeshData {
             if (options.await === false) {
                 return handle.workflowId;
             }
-            return await handle.result();
+            return (await handle.result());
         }
     }
     async info(entity, id, options = {}) {
@@ -330,7 +341,7 @@ class MeshData {
         this.validate(workflowId);
         let prefixedFields = [];
         if (Array.isArray(options.fields)) {
-            prefixedFields = options.fields.map(field => `_${field}`);
+            prefixedFields = options.fields.map((field) => `_${field}`);
         }
         else if (this.search?.schema) {
             prefixedFields = Object.entries(this.search.schema).map(([key, value]) => {
@@ -353,7 +364,7 @@ class MeshData {
     async all(entity, id, options = {}) {
         const rawResponse = await this.raw(entity, id, options);
         const responseObj = {};
-        for (let key in rawResponse) {
+        for (const key in rawResponse) {
             if (key.startsWith('_')) {
                 responseObj[key.substring(1)] = rawResponse[key];
             }
@@ -366,7 +377,7 @@ class MeshData {
         const handle = await this.getClient().workflow.getHandle(entity, entity, workflowId, options.namespace);
         const store = handle.hotMesh.engine?.store;
         const jobKey = await this.mintKey(entity, workflowId, options.namespace);
-        const rawResponse = await store?.exec('HGETALL', jobKey);
+        const rawResponse = (await store?.exec('HGETALL', jobKey));
         const responseObj = {};
         for (let i = 0; i < rawResponse.length; i += 2) {
             responseObj[rawResponse[i]] = rawResponse[i + 1];
@@ -380,10 +391,10 @@ class MeshData {
         const store = handle.hotMesh.engine?.store;
         const jobId = await this.mintKey(entity, workflowId, options.namespace);
         const safeArgs = [];
-        for (let key in options.search?.data) {
+        for (const key in options.search?.data) {
             safeArgs.push(this.safeKey(key), options.search?.data[key].toString());
         }
-        return await store?.exec('HSET', jobId, ...safeArgs);
+        return (await store?.exec('HSET', jobId, ...safeArgs));
     }
     async incr(entity, id, field, amount, options = {}) {
         const workflowId = MeshData.mintGuid(options.prefix ?? entity, id);
@@ -398,9 +409,9 @@ class MeshData {
         const workflowId = MeshData.mintGuid(options.prefix ?? entity, id);
         this.validate(workflowId);
         if (!Array.isArray(options.fields)) {
-            throw "Invalid arguments [options.fields is not an array]";
+            throw 'Invalid arguments [options.fields is not an array]';
         }
-        const prefixedFields = options.fields.map(field => `_${field}`);
+        const prefixedFields = options.fields.map((field) => `_${field}`);
         const handle = await this.getClient().workflow.getHandle(entity, entity, workflowId, options.namespace);
         const store = handle.hotMesh.engine?.store;
         const jobKey = await this.mintKey(entity, workflowId, options.namespace);
@@ -409,14 +420,16 @@ class MeshData {
     }
     async findJobs(options = {}) {
         const hotMesh = await this.getHotMesh(options.namespace);
-        return await hotMesh.engine?.store?.findJobs(options.match, options.limit, options.batch, options.cursor);
+        return (await hotMesh.engine?.store?.findJobs(options.match, options.limit, options.batch, options.cursor));
     }
     async find(entity, options, ...args) {
         return await this.getClient().workflow.search(options.taskQueue ?? entity, options.workflowName ?? entity, options.namespace || 'durable', options.index ?? options.search?.index ?? this.search.index ?? '', ...args);
     }
     async findWhere(entity, options) {
         const targetSearch = options.options?.search ?? this.search;
-        const args = [this.generateSearchQuery(options.query, targetSearch)];
+        const args = [
+            this.generateSearchQuery(options.query, targetSearch),
+        ];
         if (options.count) {
             args.push('LIMIT', '0', '0');
         }
@@ -424,7 +437,7 @@ class MeshData {
             args.push('RETURN');
             args.push(((options.return?.length ?? 0) + 1).toString());
             args.push('$');
-            options.return?.forEach(returnField => {
+            options.return?.forEach((returnField) => {
                 if (returnField.startsWith('"')) {
                     args.push(returnField.slice(1, -1));
                 }
@@ -450,9 +463,10 @@ class MeshData {
     }
     generateSearchQuery(query, search) {
         if (!Array.isArray(query) || query.length === 0) {
-            return typeof (query) === 'string' ? query : '*';
+            return typeof query === 'string' ? query : '*';
         }
-        let queryString = query.map(q => {
+        const queryString = query
+            .map((q) => {
             const { field, is, value, type } = q;
             let prefixedFieldName;
             if (search?.schema && field in search.schema) {
@@ -490,7 +504,8 @@ class MeshData {
                 default:
                     return '';
             }
-        }).join(' ');
+        })
+            .join(' ');
         return queryString;
     }
     async createSearchIndex(entity, options = {}, searchOptions) {
@@ -525,17 +540,25 @@ MeshData.workflow = {
         await meshflow_1.MeshFlow.workflow.interrupt(jobId, options);
     },
     execChild: async (options = {}) => {
-        const pluckOptions = { ...options, args: [...options.args, { $type: 'exec' }] };
+        const pluckOptions = {
+            ...options,
+            args: [...options.args, { $type: 'exec' }],
+        };
         return meshflow_1.MeshFlow.workflow.execChild(pluckOptions);
     },
     executeChild: async (options = {}) => {
-        const pluckOptions = { ...options, args: [...options.args, { $type: 'exec' }] };
+        const pluckOptions = {
+            ...options,
+            args: [...options.args, { $type: 'exec' }],
+        };
         return meshflow_1.MeshFlow.workflow.execChild(pluckOptions);
     },
     startChild: async (options = {}) => {
-        const pluckOptions = { ...options, args: [...options.args, { $type: 'exec' }] };
+        const pluckOptions = {
+            ...options,
+            args: [...options.args, { $type: 'exec' }],
+        };
         return meshflow_1.MeshFlow.workflow.startChild(pluckOptions);
     },
 };
 MeshData.proxyActivities = meshflow_1.MeshFlow.workflow.proxyActivities;
-;

package/build/services/meshflow/workflow.js

@@ -84,7 +84,10 @@ class WorkflowService {
         const workflowTopic = store.get('workflowTopic');
         const connection = store.get('connection');
         const namespace = store.get('namespace');
-        return await worker_1.WorkerService.getHotMesh(workflowTopic, { connection, namespace });
+        return await worker_1.WorkerService.getHotMesh(workflowTopic, {
+            connection,
+            namespace,
+        });
     }
     static async execChild(options) {
         const isStartChild = options.await === false;
@@ -324,7 +327,7 @@ class WorkflowService {
         return response;
     }
     static async interrupt(jobId, options = {}) {
-        const { workflowTopic, connection, namespace, } = WorkflowService.getContext();
+        const { workflowTopic, connection, namespace } = WorkflowService.getContext();
         const hotMeshClient = await worker_1.WorkerService.getHotMesh(workflowTopic, {
             connection,
             namespace,

package/build/types/index.d.ts

@@ -7,7 +7,7 @@ export { ActivityConfig, ActivityWorkflowDataType, ChildResponseType, ClientConf
 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 { 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';

package/build/types/meshcall.d.ts

@@ -1,5 +1,5 @@
-import { RedisConfig } from "./hotmesh";
-import { LogLevel } from "./logger";
+import { RedisConfig } from './hotmesh';
+import { LogLevel } from './logger';
 interface MeshCallExecOptions {
     id: string;
     ttl?: string;

package/build/types/meshdata.d.ts

@@ -1,5 +1,5 @@
-import { HookOptions, WorkflowConfig, WorkflowSearchOptions } from "./meshflow";
-import { StringStringType } from "./serializer";
+import { HookOptions, WorkflowConfig, WorkflowSearchOptions } from './meshflow';
+import { StringStringType } from './serializer';
 export type CallOptions = {
     id?: string;
     ttl?: string;

package/index.ts

@@ -4,12 +4,6 @@ import { MeshFlow } from './services/meshflow';
 import { HotMesh } from './services/hotmesh';
 import { HotMeshConfig } from './types/hotmesh';
 
-export {
-  HotMesh,
-  MeshCall,
-  MeshData,
-  MeshFlow,
-  HotMeshConfig,
-};
+export { HotMesh, MeshCall, MeshData, MeshFlow, HotMeshConfig };
 
 export * as Types from './types';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hotmeshio/hotmesh",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Unbreakable Workflows",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",

package/types/index.ts

@@ -78,10 +78,7 @@ export {
   HookRules,
   HookSignal,
 } from './hook';
-export {
-  ILogger,
-  LogLevel,
-} from './logger';
+export { ILogger, LogLevel } from './logger';
 export {
   ExtensionType,
   JobCompletionOptions,

package/types/job.ts

@@ -115,7 +115,7 @@ type ExtensionType = {
    * 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
@@ -126,7 +126,7 @@ type ExtensionType = {
   /**
    * Workflows that apply a status threshold will be initialized
    * with a status value of 1m - statusThreshold.
-   * 
+   *
    * The value provided should be the count of descendant activities
    * (those that descend from the trigger) that should be allowed to
    * remain open once 'done' event is emitted.

package/types/meshcall.ts

@@ -1,5 +1,5 @@
-import { RedisConfig } from "./hotmesh";
-import { LogLevel } from "./logger";
+import { RedisConfig } from './hotmesh';
+import { LogLevel } from './logger';
 
 interface MeshCallExecOptions {
   /**
@@ -9,7 +9,7 @@ interface MeshCallExecOptions {
   /**
    * Time to live for the cache key. For example, `1 day`, `1 hour`. Refer to the syntax for the `ms` NPM package.
    */
-  ttl?: string; 
+  ttl?: string;
   /**
    * If true, the cache will first be flushed and the function will be executed.
    */
@@ -99,7 +99,7 @@ interface MeshCallCronOptions {
    * Idempotent GUID for the function
    * */
   id: string;
-  /** 
+  /**
    * For example, `1 day`, `1 hour`. Fidelity is generally
    * within 5 seconds. Refer to the syntax for the `ms` NPM package.
    */

package/types/meshdata.ts

@@ -1,5 +1,5 @@
-import { HookOptions, WorkflowConfig, WorkflowSearchOptions } from "./meshflow";
-import { StringStringType } from "./serializer";
+import { HookOptions, WorkflowConfig, WorkflowSearchOptions } from './meshflow';
+import { StringStringType } from './serializer';
 
 export type CallOptions = {
   /**
@@ -74,7 +74,7 @@ export type ConnectOptions = {
   /**
    * prefix for the workflowId (defaults to entity value if not provided)
    */
-  prefix?: string; 
+  prefix?: string;
   /**
    * optional namespace for the the worker; how it appears in Redis (defaults to 'durable')
    */
@@ -96,14 +96,14 @@ export type ConnectOptions = {
 export type ConnectionInput<T> = {
   /**
    * The connected function's entity identifier
-   * 
+   *
    * @example
    * user
    */
   entity: string;
   /**
    * The target function reference
-   * 
+   *
    * @example
    * function() { return "hello world" }
    */
@@ -122,7 +122,7 @@ export type ConnectionInput<T> = {
  * removed by calling `flush`. During this time, the function will remain active and can
  * its state can be augmented by calling `set`, `incr`, `del`, etc OR by calling a
  * transactional 'hook' function.
- * 
+ *
  * @template T The expected return type of the remote function.
  */
 export type ExecInput = {
@@ -177,7 +177,6 @@ export type HookInput = {
   options?: Partial<HookOptions>;
 };
 
-
 export type MeshDataWorkflowOptions = {
   /**
    * The app deployment namespace; how it appears in redis (e.g., 'durable')

package/types/meshflow.ts

@@ -1,4 +1,5 @@
 import { WorkflowHandleService } from '../services/meshflow/handle';
+
 import { LogLevel } from './logger';
 import { RedisClass, RedisOptions } from './redis';
 import { StringAnyType, StringStringType } from './serializer';
@@ -582,10 +583,25 @@ type ChildResponseType<T> = {
 
 interface ClientWorkflow {
   start(options: WorkflowOptions): Promise<WorkflowHandleService>;
-  signal(signalId: string, data: StringAnyType, namespace?: string): Promise<string>;
+  signal(
+    signalId: string,
+    data: StringAnyType,
+    namespace?: string,
+  ): Promise<string>;
   hook(options: HookOptions): Promise<string>;
-  getHandle(taskQueue: string, workflowName: string, workflowId: string, namespace?: string): Promise<WorkflowHandleService>;
-  search(taskQueue: string, workflowName: string, namespace: string | null, index: string, ...query: string[]): Promise<string[]>;
+  getHandle(
+    taskQueue: string,
+    workflowName: string,
+    workflowId: string,
+    namespace?: string,
+  ): Promise<WorkflowHandleService>;
+  search(
+    taskQueue: string,
+    workflowName: string,
+    namespace: string | null,
+    index: string,
+    ...query: string[]
+  ): Promise<string[]>;
 }
 
 export {