@hotmeshio/hotmesh 0.0.16 → 0.0.18

package/build/services/durable/client.js

@@ -76,6 +76,40 @@ class ClientService {
             await this.activateWorkflow(await hotMeshClient);
             return hotMeshClient;
         };
+        /**
+         * For those deployments with a redis stack backend (with the FT module),
+         * this method will configure the search index for the workflow.
+         */
+        this.configureSearchIndex = async (hotMeshClient, search) => {
+            if (search) {
+                const store = hotMeshClient.engine.store;
+                const schema = [];
+                for (const [key, value] of Object.entries(search.schema)) {
+                    //prefix with a comma (avoids collisions with hotmesh reserved words)
+                    schema.push(`_${key}`);
+                    schema.push(value.type);
+                    if (value.sortable) {
+                        schema.push('SORTABLE');
+                    }
+                }
+                try {
+                    const keyParams = {
+                        appId: hotMeshClient.appId,
+                        jobId: ''
+                    };
+                    const hotMeshPrefix = key_1.KeyService.mintKey(hotMeshClient.namespace, key_1.KeyType.JOB_STATE, keyParams);
+                    const prefixes = search.prefix.map((prefix) => `${hotMeshPrefix}${prefix}`);
+                    await store.exec('FT.CREATE', `${search.index}`, 'ON', 'HASH', 'PREFIX', prefixes.length, ...prefixes, 'SCHEMA', ...schema);
+                }
+                catch (err) {
+                    hotMeshClient.engine.logger.info('durable-client-search-err', { err });
+                }
+            }
+        };
+        this.search = async (hotMeshClient, index, query) => {
+            const store = hotMeshClient.engine.store;
+            return await store.exec('FT.SEARCH', index, ...query);
+        };
         this.workflow = {
             start: async (options) => {
                 const taskQueueName = options.taskQueue;
@@ -85,8 +119,10 @@ class ClientService {
                 //topic is concat of taskQueue and workflowName
                 const workflowTopic = `${taskQueueName}-${workflowName}`;
                 const hotMeshClient = await this.getHotMeshClient(workflowTopic);
+                this.configureSearchIndex(hotMeshClient, options.search);
                 const payload = {
                     arguments: [...options.args],
+                    parentWorkflowId: options.parentWorkflowId,
                     workflowId: options.workflowId || (0, nanoid_1.nanoid)(),
                     workflowTopic: workflowTopic,
                     backoffCoefficient: options.config?.backoffCoefficient || factory_1.DEFAULT_COEFFICIENT,
@@ -102,6 +138,17 @@ class ClientService {
                 const workflowTopic = `${taskQueue}-${workflowName}`;
                 const hotMeshClient = await this.getHotMeshClient(workflowTopic);
                 return new handle_1.WorkflowHandleService(hotMeshClient, workflowTopic, workflowId);
+            },
+            search: async (taskQueue, workflowName, index, ...query) => {
+                const workflowTopic = `${taskQueue}-${workflowName}`;
+                const hotMeshClient = await this.getHotMeshClient(workflowTopic);
+                try {
+                    return await this.search(hotMeshClient, index, query);
+                }
+                catch (err) {
+                    hotMeshClient.engine.logger.error('durable-client-search-err', { err });
+                    throw err;
+                }
             }
         };
         this.connection = config.connection;

package/build/services/durable/factory.js

@@ -25,6 +25,8 @@ const getWorkflowYAML = (app, version) => {
         schema:
           type: object
           properties:
+            parentWorkflowId:
+              type: string
             workflowId:
               type: string
             arguments:
@@ -47,12 +49,17 @@ const getWorkflowYAML = (app, version) => {
           type: trigger
           stats:
             id: '{$self.input.data.workflowId}'
+            key: '{$self.input.data.parentWorkflowId}'
+            granularity: infinity
+            measures:
+              - measure: index
+                target: '{$self.input.data.parentWorkflowId}'
           job:
             maps:
               done: false
 
         a1:
-          type: activity
+          type: hook
           cycle: true
           output:
             schema:
@@ -66,6 +73,7 @@ const getWorkflowYAML = (app, version) => {
         w1:
           type: worker
           topic: '{t1.output.data.workflowTopic}'
+          emit: '{$job.data.done}'
           retry:
             '599': [2]
           input:
@@ -123,6 +131,19 @@ const getWorkflowYAML = (app, version) => {
               response: '{$self.output.data.response}'
               done: '{$self.output.data.done}'
 
+        a2:
+          type: hook
+          title: Wait for cleanup signal
+          hook:
+            type: object
+            properties:
+              done:
+                type: boolean
+          job:
+            maps:
+              workflowId: '{t1.output.data.workflowId}'
+
+
         a594:
           title: Wait for signals
           type: await
@@ -227,7 +248,7 @@ const getWorkflowYAML = (app, version) => {
 
         a599:
           title: Sleep exponentially longer before retrying
-          type: activity
+          type: hook
           sleep: '{a1.output.data.duration}'
 
         c599:
@@ -280,7 +301,7 @@ const getWorkflowYAML = (app, version) => {
               done: true
 
         s2:
-          title: Awaken sleep flows so they end and self-clean
+          title: Awaken sleeping flows so they end and self-clean
           type: signal
           subtype: all
           key_name: parentWorkflowId
@@ -352,10 +373,55 @@ const getWorkflowYAML = (app, version) => {
                   type: boolean
             maps:
               done: true
+
+        s4:
+          title: Awaken child FLOWS so they end and self-clean
+          type: signal
+          subtype: all
+          key_name: parentWorkflowId
+          key_value:
+            '@pipe':
+              - ['{$job.metadata.jid}', '-f']
+              - ['{@string.concat}']
+          topic: ${app}.childflow.awaken
+          resolver:
+            schema:
+              type: object
+              properties:
+                data:
+                  type: object
+                  properties:
+                    parentWorkflowId:
+                      type: string
+                scrub:
+                  type: boolean
+            maps:
+              data:
+                parentWorkflowId:
+                  '@pipe':
+                    - ['{$job.metadata.jid}', '-f']
+                    - ['{@string.concat}']
+              scrub: true
+          signal:
+            schema:
+              type: object
+              properties:
+                done:
+                  type: boolean
+            maps:
+              done: true
     
       transitions:
         t1:
           - to: a1
+          - to: a2
+            conditions:
+              match:
+                - expected: true
+                  actual:
+                    '@pipe':
+                      - ['{$job.metadata.key}', true, false]
+                      - ['{@conditional.ternary}']
         a1:
           - to: w1
         w1:
@@ -377,11 +443,13 @@ const getWorkflowYAML = (app, version) => {
           - to: s3
             conditions:
               code: [200, 598, 597, 596]
+          - to: s4
+            conditions:
+              code: [200, 598, 597, 596]
         a594:
           - to: c594
             conditions:
               code: 202
-
         a595:
           - to: c595
             conditions:
@@ -389,6 +457,14 @@ const getWorkflowYAML = (app, version) => {
         a599:
           - to: c599
 
+      hooks:
+        ${app}.childflow.awaken:
+          - to: a2
+            conditions:
+              match:
+                - expected: '{t1.output.data.workflowId}'
+                  actual: '{$self.hook.data.id}'
+  
     - subscribes: ${app}.activity.execute
       publishes: ${app}.activity.executed
 
@@ -464,7 +540,7 @@ const getWorkflowYAML = (app, version) => {
               done: true
 
         s1a:
-          type: activity
+          type: hook
           title: Wait for cleanup signal
           hook:
             type: object
@@ -484,6 +560,7 @@ const getWorkflowYAML = (app, version) => {
       hooks:
         ${app}.activity.awaken:
           - to: s1a
+            keep_alive: true
             conditions:
               match:
                 - expected: '{t1a.output.data.workflowId}'
@@ -530,13 +607,13 @@ const getWorkflowYAML = (app, version) => {
                 target: '{$self.input.data.parentWorkflowId}'
 
         a1s:
-          type: activity
+          type: hook
           title: Sleep for a duration
           sleep: '{t1s.output.data.duration}'
           emit: true
 
         a2s:
-          type: activity
+          type: hook
           title: Wait for cleanup signal
           hook:
             type: object
@@ -608,7 +685,7 @@ const getWorkflowYAML = (app, version) => {
 
         a1wc:
           title: Split signal data
-          type: activity
+          type: hook
           cycle: true
           output:
             schema:
@@ -646,7 +723,7 @@ const getWorkflowYAML = (app, version) => {
                   - ['{t1wc.output.data.signals}', 1]
                   - ['{@array.slice}']
         a2wc:
-          type: activity
+          type: hook
           output:
             schema:
               type: object
@@ -773,7 +850,7 @@ const getWorkflowYAML = (app, version) => {
                 target: '{$self.input.data.parentWorkflowId}'
 
         a1ww:
-          type: activity
+          type: hook
           title: Wait for custom signal
           emit: true
           hook:
@@ -788,7 +865,7 @@ const getWorkflowYAML = (app, version) => {
               signalId: '{t1ww.output.data.signalId}'
 
         a2ww:
-          type: activity
+          type: hook
           title: Wait for cleanup signal
           hook:
             type: object

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

@@ -0,0 +1,15 @@
+import { HotMeshService as HotMesh } from '../hotmesh';
+import { RedisClient, RedisMulti } from '../../types/redis';
+import { StoreService } from '../store';
+export declare class Search {
+    jobId: string;
+    hotMeshClient: HotMesh;
+    store: StoreService<RedisClient, RedisMulti> | null;
+    safeKey(key: string): string;
+    constructor(workflowId: string, hotMeshClient: HotMesh);
+    set(key: string, value: string): Promise<void>;
+    get(key: string): Promise<string>;
+    del(key: string): Promise<void>;
+    incr(key: string, val: number): Promise<number>;
+    mult(key: string, val: number): Promise<number>;
+}

package/build/services/durable/search.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Search = void 0;
+const key_1 = require("../../modules/key");
+class Search {
+    safeKey(key) {
+        //note: protect the execution namespace with a prefix,
+        //so its design never conflicts with the hotmesh keyspace
+        return `_${key}`;
+    }
+    constructor(workflowId, hotMeshClient) {
+        const keyParams = {
+            appId: hotMeshClient.appId,
+            jobId: ''
+        };
+        const hotMeshPrefix = key_1.KeyService.mintKey(hotMeshClient.namespace, key_1.KeyType.JOB_STATE, keyParams);
+        this.jobId = `${hotMeshPrefix}${workflowId}`;
+        this.hotMeshClient = hotMeshClient;
+        this.store = hotMeshClient.engine.store;
+    }
+    async set(key, value) {
+        await this.store.exec('HSET', this.jobId, this.safeKey(key), value.toString());
+    }
+    async get(key) {
+        try {
+            return await this.store.exec('HGET', this.jobId, this.safeKey(key));
+        }
+        catch (err) {
+            this.hotMeshClient.logger.error('durable-search-get-error', { err });
+            return '';
+        }
+    }
+    async del(key) {
+        await this.store.exec('HDEL', this.jobId, this.safeKey(key));
+    }
+    async incr(key, val) {
+        return Number(await this.store.exec('HINCRBYFLOAT', this.jobId, this.safeKey(key), val.toString()));
+    }
+    async mult(key, val) {
+        const log = Math.log(val);
+        const logTotal = Number(await this.store.exec('HINCRBYFLOAT', this.jobId, this.safeKey(key), log.toString()));
+        return Math.exp(logTotal);
+    }
+}
+exports.Search = Search;

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

@@ -5,6 +5,7 @@ export declare class WorkflowService {
      */
     static executeChild<T>(options: WorkflowOptions): Promise<T>;
     static proxyActivities<ACT>(options?: ActivityConfig): ProxyType<ACT>;
+    static data(command: 'del' | 'get' | 'set' | 'incr' | 'mult', ...args: string[]): Promise<number | boolean | string>;
     static sleep(duration: string): Promise<number>;
     static waitForSignal(signals: string[], options?: Record<string, string>): Promise<Record<any, any>[]>;
     static wrapActivity<T>(activityName: string, options?: ActivityConfig): T;

package/build/services/durable/workflow.js

@@ -11,6 +11,7 @@ const client_1 = require("./client");
 const connection_1 = require("./connection");
 const factory_1 = require("./factory");
 const errors_1 = require("../../modules/errors");
+const search_1 = require("./search");
 /*
 `proxyActivities` returns a wrapped instance of the
 target activity, so that when the workflow calls a
@@ -54,6 +55,7 @@ class WorkflowService {
         const COUNTER = store.get('counter');
         const execIndex = COUNTER.counter = COUNTER.counter + 1;
         const childJobId = `${workflowId}-$${options.workflowName}-${execIndex}`;
+        const parentWorkflowId = `${workflowId}-f`;
         const client = new client_1.ClientService({
             connection: await connection_1.ConnectionService.connect(worker_1.WorkerService.connection),
         });
@@ -65,6 +67,7 @@ class WorkflowService {
             handle = await client.workflow.start({
                 ...options,
                 workflowId: childJobId,
+                parentWorkflowId,
                 workflowTrace,
                 workflowSpan,
             });
@@ -86,6 +89,39 @@ class WorkflowService {
         }
         return proxy;
     }
+    static async data(command, ...args) {
+        const store = asyncLocalStorage_1.asyncLocalStorage.getStore();
+        if (!store) {
+            throw new Error('durable-store-not-found');
+        }
+        const workflowId = store.get('workflowId');
+        const workflowTopic = store.get('workflowTopic');
+        try {
+            const hotMeshClient = await worker_1.WorkerService.getHotMesh(workflowTopic);
+            const search = new search_1.Search(workflowId, hotMeshClient);
+            if (command === 'get') {
+                return await search.get(args[0]);
+            }
+            else if (command === 'set') {
+                await search.set(args[0], args[1]);
+                return true;
+            }
+            else if (command === 'del') {
+                await search.del(args[0]);
+                return true;
+            }
+            else if (command === 'incr') {
+                return await search.incr(args[0], Number(args[1]));
+            }
+            else if (command === 'mult') {
+                return await search.mult(args[0], Number(args[1]));
+            }
+        }
+        catch (e) {
+            console.error(e);
+            return '';
+        }
+    }
     static async sleep(duration) {
         const seconds = (0, ms_1.default)(duration) / 1000;
         const store = asyncLocalStorage_1.asyncLocalStorage.getStore();

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

@@ -1,4 +1,9 @@
-import { Activity } from '../activities/activity';
+import { Await } from '../activities/await';
+import { Cycle } from '../activities/cycle';
+import { Hook } from '../activities/hook';
+import { Signal } from '../activities/signal';
+import { Worker } from '../activities/worker';
+import { Trigger } from '../activities/trigger';
 import { ILogger } from '../logger';
 import { StoreSignaler } from '../signaler/store';
 import { StreamSignaler } from '../signaler/stream';
@@ -44,7 +49,7 @@ declare class EngineService {
     processWebHooks(): Promise<void>;
     processTimeHooks(): Promise<void>;
     throttle(delayInMillis: number): Promise<void>;
-    initActivity(topic: string, data?: JobData, context?: JobState): Promise<Activity>;
+    initActivity(topic: string, data?: JobData, context?: JobState): Promise<Await | Cycle | Hook | Signal | Trigger | Worker>;
     getSchema(topic: string): Promise<[activityId: string, schema: ActivityType]>;
     getSettings(): Promise<HotMeshSettings>;
     isPrivate(topic: string): boolean;

package/build/services/engine/index.js

@@ -143,7 +143,8 @@ class EngineService {
     // ************* METADATA/MODEL METHODS *************
     async initActivity(topic, data = {}, context) {
         const [activityId, schema] = await this.getSchema(topic);
-        const ActivityHandler = activities_1.default[schema.type];
+        utils_1.polyfill;
+        const ActivityHandler = activities_1.default[utils_1.polyfill.resolveActivityType(schema.type)];
         if (ActivityHandler) {
             const utc = (0, utils_1.formatISODate)(new Date());
             const metadata = {

package/build/services/store/clients/ioredis.d.ts

@@ -14,6 +14,7 @@ declare class IORedisStoreService extends StoreService<RedisClientType, RedisMul
     serializer: Serializer;
     constructor(redisClient: RedisClientType);
     getMulti(): RedisMultiType;
+    exec(...args: any[]): Promise<string | string[] | string[][]>;
     hGetAllResult(result: any): any;
     addTaskQueues(keys: string[]): Promise<void>;
     publish(keyType: KeyType.QUORUM, message: Record<string, any>, appId: string, engineId?: string): Promise<boolean>;

package/build/services/store/clients/ioredis.js

@@ -10,6 +10,18 @@ class IORedisStoreService extends index_1.StoreService {
     getMulti() {
         return this.redisClient.multi();
     }
+    async exec(...args) {
+        const response = await this.redisClient.call.apply(this.redisClient, args);
+        if (typeof response === 'string') {
+            return response;
+        }
+        else if (Array.isArray(response)) {
+            if (Array.isArray(response[0])) {
+                return response;
+            }
+            return response;
+        }
+    }
     hGetAllResult(result) {
         //ioredis response signature is [null, {}] or [null, null]
         return result[1];

package/build/services/store/clients/redis.d.ts

@@ -15,6 +15,7 @@ declare class RedisStoreService extends StoreService<RedisClientType, RedisMulti
     commands: Record<string, string>;
     constructor(redisClient: RedisClientType);
     getMulti(): RedisMultiType;
+    exec(...args: any[]): Promise<string | string[] | string[][]>;
     publish(keyType: KeyType.QUORUM, message: Record<string, any>, appId: string, engineId?: string): Promise<boolean>;
     zAdd(key: string, score: number | string, value: string | number, redisMulti?: RedisMultiType): Promise<any>;
     zRangeByScoreWithScores(key: string, score: number | string, value: string | number): Promise<string | null>;

package/build/services/store/clients/redis.js

@@ -36,6 +36,9 @@ class RedisStoreService extends index_1.StoreService {
         const multi = this.redisClient.MULTI();
         return multi;
     }
+    async exec(...args) {
+        return await this.redisClient.sendCommand(args);
+    }
     async publish(keyType, message, appId, engineId) {
         const topic = this.mintKey(keyType, { appId, engineId });
         const status = await this.redisClient.publish(topic, JSON.stringify(message));

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

@@ -22,6 +22,7 @@ declare abstract class StoreService<T, U extends AbstractRedisClient> {
     logger: ILogger;
     commands: Record<string, string>;
     abstract getMulti(): U;
+    abstract exec(...args: any[]): Promise<string | string[] | string[][]>;
     abstract publish(keyType: KeyType.QUORUM, message: Record<string, any>, appId: string, engineId?: string): Promise<boolean>;
     abstract xgroup(command: 'CREATE', key: string, groupName: string, id: string, mkStream?: 'MKSTREAM'): Promise<boolean>;
     abstract xadd(key: string, id: string, messageId: string, messageValue: string, multi?: U): Promise<string | U>;

package/build/services/telemetry/index.js

@@ -8,6 +8,7 @@ const package_json_1 = __importDefault(require("../../package.json"));
 const mapper_1 = require("../mapper");
 const stream_1 = require("../../types/stream");
 const telemetry_1 = require("../../types/telemetry");
+const utils_1 = require("../../modules/utils");
 class TelemetryService {
     constructor(appId, config, metadata, context) {
         this.leg = 1;
@@ -209,7 +210,7 @@ class TelemetryService {
             state[`${metadata.aid}/output/metadata/l1s`] = context['$self'].output.metadata.l1s;
             state[`${metadata.aid}/output/metadata/l2s`] = context['$self'].output.metadata.l2s;
         }
-        else if (config.type === 'activity' && leg === 1) {
+        else if (utils_1.polyfill.resolveActivityType(config.type) === 'hook' && leg === 1) {
             //activities run non-duplexed and only have a single leg
             state[`${metadata.aid}/output/metadata/l1s`] = context['$self'].output.metadata.l1s;
             state[`${metadata.aid}/output/metadata/l2s`] = context['$self'].output.metadata.l1s;

package/build/types/activity.d.ts

@@ -1,6 +1,6 @@
 import { MetricTypes } from "./stats";
 import { StreamRetryPolicy } from "./stream";
-type ActivityExecutionType = 'trigger' | 'await' | 'worker' | 'activity' | 'emit' | 'iterate' | 'cycle' | 'signal';
+type ActivityExecutionType = 'trigger' | 'await' | 'worker' | 'activity' | 'emit' | 'iterate' | 'cycle' | 'signal' | 'hook';
 type Consumes = Record<string, string[]>;
 interface BaseActivity {
     title?: string;
@@ -59,6 +59,9 @@ interface CycleActivity extends BaseActivity {
     type: 'cycle';
     ancestor: string;
 }
+interface HookActivity extends BaseActivity {
+    type: 'hook';
+}
 interface SignalActivity extends BaseActivity {
     type: 'signal';
     subtype: 'one' | 'all';
@@ -72,7 +75,7 @@ interface SignalActivity extends BaseActivity {
 interface IterateActivity extends BaseActivity {
     type: 'iterate';
 }
-type ActivityType = BaseActivity | TriggerActivity | AwaitActivity | WorkerActivity | IterateActivity;
+type ActivityType = BaseActivity | TriggerActivity | AwaitActivity | WorkerActivity | IterateActivity | HookActivity;
 type ActivityData = Record<string, any>;
 type ActivityMetadata = {
     aid: string;
@@ -98,4 +101,4 @@ type ActivityDataType = {
     hook?: Record<string, unknown>;
 };
 type ActivityLeg = 1 | 2;
-export { ActivityContext, ActivityData, ActivityDataType, ActivityDuplex, ActivityLeg, ActivityMetadata, ActivityType, Consumes, TriggerActivityStats, AwaitActivity, CycleActivity, SignalActivity, BaseActivity, IterateActivity, TriggerActivity, WorkerActivity };
+export { ActivityContext, ActivityData, ActivityDataType, ActivityDuplex, ActivityLeg, ActivityMetadata, ActivityType, Consumes, TriggerActivityStats, AwaitActivity, CycleActivity, HookActivity, SignalActivity, BaseActivity, IterateActivity, TriggerActivity, WorkerActivity };

package/build/types/durable.d.ts

@@ -5,13 +5,23 @@ type WorkflowConfig = {
     maximumInterval?: string;
     initialInterval?: string;
 };
+type WorkflowSearchOptions = {
+    index: string;
+    prefix: string[];
+    schema: Record<string, {
+        type: 'TEXT' | 'NUMERIC' | 'TAG';
+        sortable: boolean;
+    }>;
+};
 type WorkflowOptions = {
     taskQueue: string;
     args: any[];
     workflowId: string;
     workflowName?: string;
+    parentWorkflowId?: string;
     workflowTrace?: string;
     workflowSpan?: string;
+    search?: WorkflowSearchOptions;
     config?: WorkflowConfig;
 };
 type SignalOptions = {
@@ -72,4 +82,4 @@ type ActivityConfig = {
         maximumInterval: string;
     };
 };
-export { ActivityConfig, ActivityWorkflowDataType, ClientConfig, ContextType, ConnectionConfig, Connection, NativeConnection, ProxyType, Registry, SignalOptions, WorkerConfig, WorkflowConfig, WorkerOptions, WorkflowDataType, WorkflowOptions, };
+export { ActivityConfig, ActivityWorkflowDataType, ClientConfig, ContextType, ConnectionConfig, Connection, NativeConnection, ProxyType, Registry, SignalOptions, WorkerConfig, WorkflowConfig, WorkerOptions, WorkflowSearchOptions, WorkflowDataType, WorkflowOptions, };

package/build/types/hook.d.ts

@@ -12,6 +12,7 @@ interface HookConditions {
 }
 interface HookRule {
     to: string;
+    keep_alive?: boolean;
     conditions: HookConditions;
 }
 interface HookRules {

package/build/types/index.d.ts

@@ -1,9 +1,9 @@
-export { ActivityType, ActivityDataType, ActivityContext, ActivityData, ActivityDuplex, ActivityLeg, ActivityMetadata, Consumes, AwaitActivity, BaseActivity, CycleActivity, WorkerActivity, IterateActivity, SignalActivity, TriggerActivity, TriggerActivityStats } from './activity';
+export { ActivityType, ActivityDataType, ActivityContext, ActivityData, ActivityDuplex, ActivityLeg, ActivityMetadata, Consumes, AwaitActivity, BaseActivity, CycleActivity, HookActivity, WorkerActivity, IterateActivity, SignalActivity, TriggerActivity, TriggerActivityStats } from './activity';
 export { App, AppVID, AppTransitions, AppSubscriptions } from './app';
 export { AsyncSignal } from './async';
 export { CacheMode } from './cache';
 export { CollationFaultType, CollationStage } from './collator';
-export { ActivityConfig, ActivityWorkflowDataType, ClientConfig, ContextType, ConnectionConfig, Connection, NativeConnection, ProxyType, Registry, WorkflowConfig, WorkerConfig, WorkerOptions, WorkflowDataType, WorkflowOptions, } from './durable';
+export { ActivityConfig, ActivityWorkflowDataType, ClientConfig, ContextType, ConnectionConfig, Connection, NativeConnection, ProxyType, Registry, WorkflowConfig, WorkerConfig, WorkerOptions, WorkflowSearchOptions, WorkflowDataType, WorkflowOptions, } from './durable';
 export { HookCondition, HookConditions, HookGate, HookInterface, HookRule, HookRules, HookSignal } from './hook';
 export { RedisClientType as IORedisClientType, RedisMultiType as IORedisMultiType } from './ioredisclient';
 export { ILogger } from './logger';

package/modules/utils.ts

@@ -23,6 +23,17 @@ export function identifyRedisType(redisInstance: any): 'redis' | 'ioredis' | nul
   return null;
 }
 
+//todo: the polyfill methods will all be deleted in the `beta` release.
+export const polyfill = {
+  resolveActivityType(activityType: string): string {
+    if (activityType === 'activity') {
+      return 'hook';
+    }
+    return activityType;
+  }
+}
+
+
 export function identifyRedisTypeFromClass(redisClass: any): 'redis' | 'ioredis' | null {
   if (redisClass && redisClass.name === 'Redis' || redisClass.name === 'EventEmitter') {
     return 'ioredis';

package/package.json

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