@hotmeshio/hotmesh 0.0.16 → 0.0.18

package/build/modules/utils.d.ts

@@ -6,6 +6,9 @@ import { StringAnyType } from "../types/serializer";
 import { StreamCode, StreamStatus } from "../types/stream";
 export declare function sleepFor(ms: number): Promise<unknown>;
 export declare function identifyRedisType(redisInstance: any): 'redis' | 'ioredis' | null;
+export declare const polyfill: {
+    resolveActivityType(activityType: string): string;
+};
 export declare function identifyRedisTypeFromClass(redisClass: any): 'redis' | 'ioredis' | null;
 export declare function matchesStatusCode(code: StreamCode, pattern: string | RegExp): boolean;
 export declare function matchesStatus(status: StreamStatus, targetStatus: StreamStatus): boolean;

package/build/modules/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.restoreHierarchy = exports.getValueByPath = exports.getIndexedHash = exports.getSymVal = exports.getSymKey = exports.formatISODate = exports.getTimeSeries = exports.getSubscriptionTopic = exports.findSubscriptionForTrigger = exports.findTopKey = exports.XSleepFor = exports.matchesStatus = exports.matchesStatusCode = exports.identifyRedisTypeFromClass = exports.identifyRedisType = exports.sleepFor = void 0;
+exports.restoreHierarchy = exports.getValueByPath = exports.getIndexedHash = exports.getSymVal = exports.getSymKey = exports.formatISODate = exports.getTimeSeries = exports.getSubscriptionTopic = exports.findSubscriptionForTrigger = exports.findTopKey = exports.XSleepFor = exports.matchesStatus = exports.matchesStatusCode = exports.identifyRedisTypeFromClass = exports.polyfill = exports.identifyRedisType = exports.sleepFor = void 0;
 async function sleepFor(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -21,6 +21,15 @@ function identifyRedisType(redisInstance) {
     return null;
 }
 exports.identifyRedisType = identifyRedisType;
+//todo: the polyfill methods will all be deleted in the `beta` release.
+exports.polyfill = {
+    resolveActivityType(activityType) {
+        if (activityType === 'activity') {
+            return 'hook';
+        }
+        return activityType;
+    }
+};
 function identifyRedisTypeFromClass(redisClass) {
     if (redisClass && redisClass.name === 'Redis' || redisClass.name === 'EventEmitter') {
         return 'ioredis';

package/build/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",

package/build/services/activities/activity.d.ts

@@ -7,7 +7,6 @@ import { JobState, JobStatus } from '../../types/job';
 import { MultiResponseFlags, RedisClient, RedisMulti } from '../../types/redis';
 import { StringAnyType } from '../../types/serializer';
 import { StreamCode, StreamData, StreamStatus } from '../../types/stream';
-import { HookRule } from '../../types/hook';
 /**
  * The base class for all activities
  */
@@ -26,18 +25,11 @@ declare class Activity {
     adjacencyList: StreamData[];
     adjacentIndex: number;
     constructor(config: ActivityType, data: ActivityData, metadata: ActivityMetadata, hook: ActivityData | null, engine: EngineService, context?: JobState);
-    process(): Promise<string>;
     setLeg(leg: ActivityLeg): void;
-    doesHook(): boolean;
-    getHookRule(topic: string): Promise<HookRule | undefined>;
-    registerHook(multi?: RedisMulti): Promise<string | void>;
-    processWebHookEvent(): Promise<JobStatus | void>;
-    processTimeHookEvent(jobId: string): Promise<JobStatus | void>;
-    processHookEvent(jobId: string): Promise<JobStatus | void>;
-    processEvent(status?: StreamStatus, code?: StreamCode): Promise<void>;
-    processPending(telemetry: TelemetryService): Promise<MultiResponseFlags>;
-    processSuccess(telemetry: TelemetryService): Promise<MultiResponseFlags>;
-    processError(telemetry: TelemetryService): Promise<MultiResponseFlags>;
+    processEvent(status?: StreamStatus, code?: StreamCode, type?: 'hook' | 'output', jobId?: string): Promise<void>;
+    processPending(telemetry: TelemetryService, type: 'hook' | 'output'): Promise<MultiResponseFlags>;
+    processSuccess(telemetry: TelemetryService, type: 'hook' | 'output'): Promise<MultiResponseFlags>;
+    processError(telemetry: TelemetryService, type: string): Promise<MultiResponseFlags>;
     transitionAdjacent(multiResponse: MultiResponseFlags, telemetry: TelemetryService): Promise<void>;
     resolveStatus(multiResponse: MultiResponseFlags): number;
     mapJobData(): void;

package/build/services/activities/activity.js

@@ -7,7 +7,6 @@ const collator_1 = require("../collator");
 const mapper_1 = require("../mapper");
 const pipe_1 = require("../pipe");
 const serializer_1 = require("../serializer");
-const store_1 = require("../signaler/store");
 const telemetry_1 = require("../telemetry");
 const stream_1 = require("../../types/stream");
 /**
@@ -17,7 +16,7 @@ class Activity {
     constructor(config, data, metadata, hook, engine, context) {
         this.status = stream_1.StreamStatus.SUCCESS;
         this.code = 200;
-        this.adjacentIndex = 0; //can be updated by leg2 using 'as' metadata hincrby output
+        this.adjacentIndex = 0;
         this.config = config;
         this.data = data;
         this.metadata = metadata;
@@ -27,161 +26,20 @@ class Activity {
         this.logger = engine.logger;
         this.store = engine.store;
     }
-    //********  INITIAL ENTRY POINT (A)  ********//
-    async process() {
-        this.logger.debug('activity-process', { jid: this.context.metadata.jid, aid: this.metadata.aid });
-        let telemetry;
-        try {
-            this.setLeg(1);
-            await collator_1.CollatorService.notarizeEntry(this);
-            await this.getState();
-            telemetry = new telemetry_1.TelemetryService(this.engine.appId, this.config, this.metadata, this.context);
-            telemetry.startActivitySpan(this.leg);
-            let multiResponse;
-            const multi = this.store.getMulti();
-            if (this.doesHook()) {
-                //sleep and wait to awaken upon a signal
-                await this.registerHook(multi);
-                this.mapOutputData();
-                this.mapJobData();
-                await this.setState(multi);
-                await collator_1.CollatorService.authorizeReentry(this, multi);
-                await this.setStatus(0, multi);
-                await multi.exec();
-                telemetry.mapActivityAttributes();
-            }
-            else {
-                //end the activity and transition to its children
-                this.adjacencyList = await this.filterAdjacent();
-                this.mapOutputData();
-                this.mapJobData();
-                await this.setState(multi);
-                await collator_1.CollatorService.notarizeEarlyCompletion(this, multi);
-                await this.setStatus(this.adjacencyList.length - 1, multi);
-                multiResponse = await multi.exec();
-                telemetry.mapActivityAttributes();
-                const jobStatus = this.resolveStatus(multiResponse);
-                const attrs = { 'app.job.jss': jobStatus };
-                const messageIds = await this.transition(this.adjacencyList, jobStatus);
-                if (messageIds.length) {
-                    attrs['app.activity.mids'] = messageIds.join(',');
-                }
-                telemetry.setActivityAttributes(attrs);
-            }
-            return this.context.metadata.aid;
-        }
-        catch (error) {
-            if (error instanceof errors_1.GetStateError) {
-                this.logger.error('activity-get-state-error', { error });
-            }
-            else {
-                this.logger.error('activity-process-error', { error });
-            }
-            telemetry.setActivityError(error.message);
-            throw error;
-        }
-        finally {
-            telemetry.endActivitySpan();
-            this.logger.debug('activity-process-end', { jid: this.context.metadata.jid, aid: this.metadata.aid });
-        }
-    }
     setLeg(leg) {
         this.leg = leg;
     }
-    //********  SIGNAL RE-ENTRY POINT  ********//
-    doesHook() {
-        return !!(this.config.hook?.topic || this.config.sleep);
-    }
-    async getHookRule(topic) {
-        const rules = await this.store.getHookRules();
-        return rules?.[topic]?.[0];
-    }
-    async registerHook(multi) {
-        if (this.config.hook?.topic) {
-            const signaler = new store_1.StoreSignaler(this.store, this.logger);
-            return await signaler.registerWebHook(this.config.hook.topic, this.context, multi);
-        }
-        else if (this.config.sleep) {
-            const durationInSeconds = pipe_1.Pipe.resolve(this.config.sleep, this.context);
-            const jobId = this.context.metadata.jid;
-            const activityId = this.metadata.aid;
-            const dId = this.metadata.dad;
-            await this.engine.task.registerTimeHook(jobId, `${activityId}${dId || ''}`, 'sleep', durationInSeconds);
-            return jobId;
-        }
-    }
-    async processWebHookEvent() {
-        this.logger.debug('engine-process-web-hook-event', {
-            topic: this.config.hook.topic,
-            aid: this.metadata.aid
-        });
-        const signaler = new store_1.StoreSignaler(this.store, this.logger);
-        const data = { ...this.data };
-        const jobId = await signaler.processWebHookSignal(this.config.hook.topic, data);
-        if (jobId) {
-            await this.processHookEvent(jobId);
-            await signaler.deleteWebHookSignal(this.config.hook.topic, data);
-        } //else => already resolved
-    }
-    async processTimeHookEvent(jobId) {
-        this.logger.debug('engine-process-time-hook-event', {
-            jid: jobId,
-            aid: this.metadata.aid
-        });
-        return await this.processHookEvent(jobId);
-    }
-    async processHookEvent(jobId) {
-        this.logger.debug('activity-process-hook-event', { jobId });
-        let telemetry;
-        try {
-            this.setLeg(2);
-            await this.getState(jobId);
-            telemetry = new telemetry_1.TelemetryService(this.engine.appId, this.config, this.metadata, this.context);
-            telemetry.startActivitySpan(this.leg);
-            const aState = await collator_1.CollatorService.notarizeReentry(this);
-            this.adjacentIndex = collator_1.CollatorService.getDimensionalIndex(aState);
-            this.bindActivityData('hook');
-            this.mapJobData();
-            this.adjacencyList = await this.filterAdjacent();
-            const multi = this.engine.store.getMulti();
-            await this.setState(multi);
-            await collator_1.CollatorService.notarizeCompletion(this, multi);
-            await this.setStatus(this.adjacencyList.length - 1, multi);
-            const multiResponse = await multi.exec();
-            telemetry.mapActivityAttributes();
-            const jobStatus = this.resolveStatus(multiResponse);
-            const attrs = { 'app.job.jss': jobStatus };
-            const messageIds = await this.transition(this.adjacencyList, jobStatus);
-            if (messageIds.length) {
-                attrs['app.activity.mids'] = messageIds.join(',');
-            }
-            telemetry.setActivityAttributes(attrs);
-            return jobStatus;
-        }
-        catch (error) {
-            if (error instanceof errors_1.CollationError && error.fault === 'inactive') {
-                this.logger.info('process-hook-event-inactive-error', { error });
-                return;
-            }
-            this.logger.error('engine-process-hook-event-error', { error });
-            telemetry.setActivityError(error.message);
-            throw error;
-        }
-        finally {
-            telemetry.endActivitySpan();
-        }
-    }
     //********  DUPLEX RE-ENTRY POINT  ********//
-    async processEvent(status = stream_1.StreamStatus.SUCCESS, code = 200) {
+    async processEvent(status = stream_1.StreamStatus.SUCCESS, code = 200, type = 'output', jobId) {
         this.setLeg(2);
-        const jid = this.context.metadata.jid;
+        const jid = this.context.metadata.jid || jobId;
         const aid = this.metadata.aid;
         this.status = status;
         this.code = code;
         this.logger.debug('activity-process-event', { topic: this.config.subtype, jid, aid, status, code });
         let telemetry;
         try {
-            await this.getState();
+            await this.getState(jobId);
             const aState = await collator_1.CollatorService.notarizeReentry(this);
             this.adjacentIndex = collator_1.CollatorService.getDimensionalIndex(aState);
             telemetry = new telemetry_1.TelemetryService(this.engine.appId, this.config, this.metadata, this.context);
@@ -194,21 +52,22 @@ class Activity {
             telemetry.startActivitySpan(this.leg);
             let multiResponse;
             if (status === stream_1.StreamStatus.PENDING) {
-                multiResponse = await this.processPending(telemetry);
+                multiResponse = await this.processPending(telemetry, type);
             }
             else if (status === stream_1.StreamStatus.SUCCESS) {
-                multiResponse = await this.processSuccess(telemetry);
+                multiResponse = await this.processSuccess(telemetry, type);
             }
             else {
-                multiResponse = await this.processError(telemetry);
+                multiResponse = await this.processError(telemetry, type);
             }
             this.transitionAdjacent(multiResponse, telemetry);
         }
         catch (error) {
-            if (error instanceof errors_1.CollationError && error.fault === 'inactive') {
+            if (error instanceof errors_1.CollationError) {
                 this.logger.info('process-event-inactive-error', { error });
                 return;
             }
+            console.error(error);
             this.logger.error('activity-process-event-error', { error });
             telemetry && telemetry.setActivityError(error.message);
             throw error;
@@ -218,8 +77,8 @@ class Activity {
             this.logger.debug('activity-process-event-end', { jid, aid });
         }
     }
-    async processPending(telemetry) {
-        this.bindActivityData('output');
+    async processPending(telemetry, type) {
+        this.bindActivityData(type);
         this.adjacencyList = await this.filterAdjacent();
         this.mapJobData();
         const multi = this.store.getMulti();
@@ -228,8 +87,8 @@ class Activity {
         await this.setStatus(this.adjacencyList.length, multi);
         return await multi.exec();
     }
-    async processSuccess(telemetry) {
-        this.bindActivityData('output');
+    async processSuccess(telemetry, type) {
+        this.bindActivityData(type);
         this.adjacencyList = await this.filterAdjacent();
         this.mapJobData();
         const multi = this.store.getMulti();
@@ -238,7 +97,7 @@ class Activity {
         await this.setStatus(this.adjacencyList.length - 1, multi);
         return await multi.exec();
     }
-    async processError(telemetry) {
+    async processError(telemetry, type) {
         this.bindActivityError(this.data);
         this.adjacencyList = await this.filterAdjacent();
         const multi = this.store.getMulti();
@@ -496,7 +355,11 @@ class Activity {
     }
     async transition(adjacencyList, jobStatus) {
         let mIds = [];
-        if (jobStatus <= 0 || this.config.emit) {
+        let emit = false;
+        if (this.config.emit) {
+            emit = pipe_1.Pipe.resolve(this.config.emit, this.context);
+        }
+        if (jobStatus <= 0 || emit) {
             //activity should not send 'emit' if the job is truly over
             const isTrueEmit = jobStatus > 0;
             await this.engine.runJobCompletionTasks(this.context, isTrueEmit);

package/build/services/activities/hook.d.ts

@@ -0,0 +1,20 @@
+import { EngineService } from '../engine';
+import { ActivityData, ActivityMetadata, ActivityType, HookActivity } from '../../types/activity';
+import { JobState, JobStatus } from '../../types/job';
+import { RedisMulti } from '../../types/redis';
+import { HookRule } from '../../types/hook';
+import { Activity } from './activity';
+/**
+ * Listens for `webhook`, `timehook`, and `cycle` (repeat) signals
+ */
+declare class Hook extends Activity {
+    config: HookActivity;
+    constructor(config: ActivityType, data: ActivityData, metadata: ActivityMetadata, hook: ActivityData | null, engine: EngineService, context?: JobState);
+    process(): Promise<string>;
+    doesHook(): boolean;
+    getHookRule(topic: string): Promise<HookRule | undefined>;
+    registerHook(multi?: RedisMulti): Promise<string | void>;
+    processWebHookEvent(): Promise<JobStatus | void>;
+    processTimeHookEvent(jobId: string): Promise<JobStatus | void>;
+}
+export { Hook };

package/build/services/activities/hook.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Hook = void 0;
+const errors_1 = require("../../modules/errors");
+const collator_1 = require("../collator");
+const pipe_1 = require("../pipe");
+const store_1 = require("../signaler/store");
+const telemetry_1 = require("../telemetry");
+const activity_1 = require("./activity");
+const types_1 = require("../../types");
+/**
+ * Listens for `webhook`, `timehook`, and `cycle` (repeat) signals
+ */
+class Hook extends activity_1.Activity {
+    constructor(config, data, metadata, hook, engine, context) {
+        super(config, data, metadata, hook, engine, context);
+    }
+    //********  INITIAL ENTRY POINT (A)  ********//
+    async process() {
+        this.logger.debug('hook-process', { jid: this.context.metadata.jid, aid: this.metadata.aid });
+        let telemetry;
+        try {
+            this.setLeg(1);
+            await collator_1.CollatorService.notarizeEntry(this);
+            await this.getState();
+            telemetry = new telemetry_1.TelemetryService(this.engine.appId, this.config, this.metadata, this.context);
+            telemetry.startActivitySpan(this.leg);
+            let multiResponse;
+            const multi = this.store.getMulti();
+            if (this.doesHook()) {
+                //sleep and wait to awaken upon a signal
+                await this.registerHook(multi);
+                this.mapOutputData();
+                this.mapJobData();
+                await this.setState(multi);
+                await collator_1.CollatorService.authorizeReentry(this, multi);
+                await this.setStatus(0, multi);
+                await multi.exec();
+                telemetry.mapActivityAttributes();
+            }
+            else {
+                //end the activity and transition to its children
+                this.adjacencyList = await this.filterAdjacent();
+                this.mapOutputData();
+                this.mapJobData();
+                await this.setState(multi);
+                await collator_1.CollatorService.notarizeEarlyCompletion(this, multi);
+                await this.setStatus(this.adjacencyList.length - 1, multi);
+                multiResponse = await multi.exec();
+                telemetry.mapActivityAttributes();
+                const jobStatus = this.resolveStatus(multiResponse);
+                const attrs = { 'app.job.jss': jobStatus };
+                const messageIds = await this.transition(this.adjacencyList, jobStatus);
+                if (messageIds.length) {
+                    attrs['app.activity.mids'] = messageIds.join(',');
+                }
+                telemetry.setActivityAttributes(attrs);
+            }
+            return this.context.metadata.aid;
+        }
+        catch (error) {
+            if (error instanceof errors_1.GetStateError) {
+                this.logger.error('hook-get-state-error', { error });
+            }
+            else {
+                this.logger.error('hook-process-error', { error });
+            }
+            telemetry.setActivityError(error.message);
+            throw error;
+        }
+        finally {
+            telemetry.endActivitySpan();
+            this.logger.debug('hook-process-end', { jid: this.context.metadata.jid, aid: this.metadata.aid });
+        }
+    }
+    //********  SIGNAL RE-ENTRY POINT  ********//
+    doesHook() {
+        //does this activity use a time-hook or web-hook
+        return !!(this.config.hook?.topic || this.config.sleep);
+    }
+    async getHookRule(topic) {
+        const rules = await this.store.getHookRules();
+        return rules?.[topic]?.[0];
+    }
+    async registerHook(multi) {
+        if (this.config.hook?.topic) {
+            const signaler = new store_1.StoreSignaler(this.store, this.logger);
+            return await signaler.registerWebHook(this.config.hook.topic, this.context, multi);
+        }
+        else if (this.config.sleep) {
+            const durationInSeconds = pipe_1.Pipe.resolve(this.config.sleep, this.context);
+            const jobId = this.context.metadata.jid;
+            const activityId = this.metadata.aid;
+            const dId = this.metadata.dad;
+            await this.engine.task.registerTimeHook(jobId, `${activityId}${dId || ''}`, 'sleep', durationInSeconds);
+            return jobId;
+        }
+    }
+    async processWebHookEvent() {
+        this.logger.debug('hook-process-web-hook-event', {
+            topic: this.config.hook.topic,
+            aid: this.metadata.aid
+        });
+        const signaler = new store_1.StoreSignaler(this.store, this.logger);
+        const data = { ...this.data };
+        const jobId = await signaler.processWebHookSignal(this.config.hook.topic, data);
+        if (jobId) {
+            //if a webhook signal is sent that includes 'keep_alive' the hook will remain open
+            const code = data.keep_alive ? 202 : 200;
+            await this.processEvent(types_1.StreamStatus.SUCCESS, code, 'hook', jobId);
+            if (code === 200) {
+                await signaler.deleteWebHookSignal(this.config.hook.topic, data);
+            }
+        } //else => already resolved
+    }
+    async processTimeHookEvent(jobId) {
+        this.logger.debug('hook-process-time-hook-event', {
+            jid: jobId,
+            aid: this.metadata.aid
+        });
+        await this.processEvent(types_1.StreamStatus.SUCCESS, 200, 'hook');
+    }
+}
+exports.Hook = Hook;

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

@@ -1,6 +1,7 @@
 import { Activity } from './activity';
 import { Await } from './await';
 import { Cycle } from './cycle';
+import { Hook } from './hook';
 import { Iterate } from './iterate';
 import { Signal } from './signal';
 import { Trigger } from './trigger';
@@ -9,6 +10,7 @@ declare const _default: {
     activity: typeof Activity;
     await: typeof Await;
     cycle: typeof Cycle;
+    hook: typeof Hook;
     iterate: typeof Iterate;
     signal: typeof Signal;
     trigger: typeof Trigger;

package/build/services/activities/index.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const activity_1 = require("./activity");
 const await_1 = require("./await");
 const cycle_1 = require("./cycle");
+const hook_1 = require("./hook");
 const iterate_1 = require("./iterate");
 const signal_1 = require("./signal");
 const trigger_1 = require("./trigger");
@@ -11,6 +12,7 @@ exports.default = {
     activity: activity_1.Activity,
     await: await_1.Await,
     cycle: cycle_1.Cycle,
+    hook: hook_1.Hook,
     iterate: iterate_1.Iterate,
     signal: signal_1.Signal,
     trigger: trigger_1.Trigger,

package/build/services/activities/trigger.js

@@ -151,7 +151,7 @@ class Trigger extends activity_1.Activity {
     }
     async setStats(multi) {
         const md = this.context.metadata;
-        if (this.config.stats?.measures) {
+        if (md.key && this.config.stats?.measures) {
             const config = await this.engine.getVID();
             const reporter = new reporter_1.ReporterService(config, this.store, this.logger);
             await this.store.setStats(md.key, md.jid, md.ts, reporter.resolveTriggerStatistics(this.config, this.context), config, multi);

package/build/services/collator/index.js

@@ -45,7 +45,6 @@ class CollatorService {
         //set second digit to 8, allowing for re-entry
         //decrement by -10_000_000_000_000
         const amount = await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, -10000000000000, this.getDimensionalAddress(activity), multi);
-        //this.verifyInteger(amount, 1, 'exit');
         return amount;
     }
     static async notarizeEarlyExit(activity, multi) {

package/build/services/compiler/deployer.d.ts

@@ -16,7 +16,9 @@ declare class Deployer {
     bindSymbols(startIndex: number, maxIndex: number, existingSymbols: Symbols, prefix: string, produces: string[]): Symbols;
     copyJobSchemas(): void;
     bindBackRefs(): void;
+    bindCycleTarget(): void;
     convertTopicsToTypes(): void;
+    convertActivitiesToHooks(): void;
     bindParents(): Promise<void>;
     collectValues(schema: Record<string, any>, values: Set<string>): void;
     traverse(obj: any, values: Set<string>): void;

package/build/services/compiler/deployer.js

@@ -17,10 +17,12 @@ class Deployer {
     async deploy(store) {
         this.store = store;
         collator_1.CollatorService.compile(this.manifest.app.graphs);
+        this.convertActivitiesToHooks();
         this.convertTopicsToTypes();
         this.copyJobSchemas();
         this.bindBackRefs();
         this.bindParents();
+        this.bindCycleTarget();
         this.resolveMappingDependencies();
         this.resolveJobMapsPaths();
         await this.generateSymKeys();
@@ -136,8 +138,21 @@ class Deployer {
             }
         }
     }
-    //more intuitive for SDK users to use 'topic',
-    //but the compiler is desiged to be generic and uses 'subtypes'
+    //the cycle/goto activity includes and ancestor target;
+    //update with the cycle flag, so it can be rerun
+    bindCycleTarget() {
+        for (const graph of this.manifest.app.graphs) {
+            const activities = graph.activities;
+            for (const activityKey in activities) {
+                const activity = activities[activityKey];
+                if (activity.type === 'cycle') {
+                    activities[activity.ancestor].cycle = true;
+                }
+            }
+        }
+    }
+    //it's more intuitive for SDK users to use 'topic',
+    //but the compiler is desiged to be generic and uses the attribute, 'subtypes'
     convertTopicsToTypes() {
         for (const graph of this.manifest.app.graphs) {
             const activities = graph.activities;
@@ -149,6 +164,18 @@ class Deployer {
             }
         }
     }
+    //legacy; remove at beta (assume no legacy refs to 'activity' at that point)
+    convertActivitiesToHooks() {
+        for (const graph of this.manifest.app.graphs) {
+            const activities = graph.activities;
+            for (const activityKey in activities) {
+                const activity = activities[activityKey];
+                if (['activity'].includes(activity.type)) {
+                    activity.type = 'hook';
+                }
+            }
+        }
+    }
     async bindParents() {
         const graphs = this.manifest.app.graphs;
         for (const graph of graphs) {

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

@@ -1,16 +1,23 @@
 import { WorkflowHandleService } from './handle';
 import { HotMeshService as HotMesh } from '../hotmesh';
-import { ClientConfig, Connection, WorkflowOptions } from '../../types/durable';
+import { ClientConfig, Connection, WorkflowOptions, WorkflowSearchOptions } from '../../types/durable';
 export declare class ClientService {
     connection: Connection;
     options: WorkflowOptions;
     static instances: Map<string, HotMesh | Promise<HotMesh>>;
     constructor(config: ClientConfig);
     getHotMeshClient: (worflowTopic: string) => Promise<HotMesh>;
+    /**
+     * For those deployments with a redis stack backend (with the FT module),
+     * this method will configure the search index for the workflow.
+     */
+    configureSearchIndex: (hotMeshClient: HotMesh, search?: WorkflowSearchOptions) => Promise<void>;
+    search: (hotMeshClient: HotMesh, index: string, query: string[]) => Promise<string[]>;
     workflow: {
         start: (options: WorkflowOptions) => Promise<WorkflowHandleService>;
         signal: (signalId: string, data: Record<any, any>) => Promise<string>;
         getHandle: (taskQueue: string, workflowName: string, workflowId: string) => Promise<WorkflowHandleService>;
+        search: (taskQueue: string, workflowName: string, index: string, ...query: string[]) => Promise<string[]>;
     };
     activateWorkflow(hotMesh: HotMesh, appId?: string, version?: string): Promise<void>;
     static shutdown(): Promise<void>;