@hotmeshio/hotmesh 0.0.17 → 0.0.19

package/build/services/durable/client.js

@@ -6,46 +6,7 @@ const factory_1 = require("./factory");
 const handle_1 = require("./handle");
 const hotmesh_1 = require("../hotmesh");
 const key_1 = require("../../modules/key");
-/*
-Here is an example of how the methods in this file are used:
-
-./client.ts
-
-import { Durable } from '@hotmeshio/hotmesh';
-import Redis from 'ioredis';
-import { example } from './workflows';
-import { nanoid } from 'nanoid';
-
-async function run() {
-  const connection = await Durable.Connection.connect({
-    class: Redis,
-    options: {
-      host: 'localhost',
-      port: 6379,
-    },
-  });
-
-  const client = new Durable.Client({
-    connection,
-  });
-
-  const handle = await client.workflow.start({
-    args: ['HotMesh'],
-    taskQueue: 'hello-world',
-    workflowName: 'example',
-    workflowId: 'workflow-' + nanoid(),
-  });
-
-  console.log(`Started workflow ${handle.workflowId}`);
-  console.log(await handle.result());
-}
-
-run().catch((err) => {
-  console.error(err);
-  process.exit(1);
-});
-
-*/
+const search_1 = require("./search");
 class ClientService {
     constructor(config) {
         this.getHotMeshClient = async (worflowTopic) => {
@@ -76,6 +37,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?.schema) {
+                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,6 +80,7 @@ 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,
@@ -94,6 +90,13 @@ class ClientService {
                 };
                 const context = { metadata: { trc, spn }, data: {} };
                 const jobId = await hotMeshClient.pub(factory_1.SUBSCRIBES_TOPIC, payload, context);
+                if (jobId && options.search?.data) {
+                    //job successfully kicked off; there is default job data to persist
+                    const search = new search_1.Search(jobId, hotMeshClient);
+                    for (const [key, value] of Object.entries(options.search.data)) {
+                        search.set(key, value);
+                    }
+                }
                 return new handle_1.WorkflowHandleService(hotMeshClient, workflowTopic, jobId);
             },
             signal: async (signalId, data) => {
@@ -103,6 +106,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

@@ -59,7 +59,7 @@ const getWorkflowYAML = (app, version) => {
               done: false
 
         a1:
-          type: activity
+          type: hook
           cycle: true
           output:
             schema:
@@ -132,7 +132,7 @@ const getWorkflowYAML = (app, version) => {
               done: '{$self.output.data.done}'
 
         a2:
-          type: activity
+          type: hook
           title: Wait for cleanup signal
           hook:
             type: object
@@ -248,7 +248,7 @@ const getWorkflowYAML = (app, version) => {
 
         a599:
           title: Sleep exponentially longer before retrying
-          type: activity
+          type: hook
           sleep: '{a1.output.data.duration}'
 
         c599:
@@ -540,7 +540,7 @@ const getWorkflowYAML = (app, version) => {
               done: true
 
         s1a:
-          type: activity
+          type: hook
           title: Wait for cleanup signal
           hook:
             type: object
@@ -560,6 +560,7 @@ const getWorkflowYAML = (app, version) => {
       hooks:
         ${app}.activity.awaken:
           - to: s1a
+            keep_alive: true
             conditions:
               match:
                 - expected: '{t1a.output.data.workflowId}'
@@ -606,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
@@ -684,7 +685,7 @@ const getWorkflowYAML = (app, version) => {
 
         a1wc:
           title: Split signal data
-          type: activity
+          type: hook
           cycle: true
           output:
             schema:
@@ -722,7 +723,7 @@ const getWorkflowYAML = (app, version) => {
                   - ['{t1wc.output.data.signals}', 1]
                   - ['{@array.slice}']
         a2wc:
-          type: activity
+          type: hook
           output:
             schema:
               type: object
@@ -849,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:
@@ -864,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/worker.d.ts

@@ -1,5 +1,5 @@
 import { HotMeshService as HotMesh } from '../hotmesh';
-import { Connection, Registry, WorkerConfig, WorkerOptions } from "../../types/durable";
+import { Connection, Registry, WorkerConfig, WorkerOptions, WorkflowSearchOptions } from "../../types/durable";
 export declare class WorkerService {
     static activityRegistry: Registry;
     static connection: Connection;
@@ -14,6 +14,11 @@ export declare class WorkerService {
      * allowing proxyActivities to succeed.
      */
     static registerActivities<ACT>(activities: ACT): Registry;
+    /**
+     * For those deployments with a redis stack backend (with the FT module),
+     * this method will configure the search index for the workflow.
+     */
+    static configureSearchIndex(hotMeshClient: HotMesh, search?: WorkflowSearchOptions): Promise<void>;
     static create(config: WorkerConfig): Promise<WorkerService>;
     static resolveWorkflowTarget(workflow: object | Function): [string, Function];
     run(): Promise<void>;

package/build/services/durable/worker.js

@@ -7,36 +7,7 @@ const asyncLocalStorage_1 = require("./asyncLocalStorage");
 const factory_1 = require("./factory");
 const hotmesh_1 = require("../hotmesh");
 const stream_1 = require("../../types/stream");
-/*
-Here is an example of how the methods in this file are used:
-
-./worker.ts
-
-import { Durable } from '@hotmeshio/hotmesh';
-import Redis from 'ioredis'; //OR `import * as Redis from 'redis';`
-
-import * as workflows from './workflows';
-
-async function run() {
-  const worker = await Durable.Worker.create({
-    connection: {
-      class: Redis,
-      options: {
-        host: 'localhost',
-        port: 6379,
-      },
-    },
-    taskQueue: 'hello-world',
-    workflow: workflows.example,
-  });
-  await worker.run();
-}
-
-run().catch((err) => {
-  console.error(err);
-  process.exit(1);
-});
-*/
+const key_1 = require("../../modules/key");
 class WorkerService {
     static async activateWorkflow(hotMesh) {
         const app = await hotMesh.engine.store.getApp(factory_1.APP_ID);
@@ -79,6 +50,38 @@ class WorkerService {
         }
         return WorkerService.activityRegistry;
     }
+    /**
+     * For those deployments with a redis stack backend (with the FT module),
+     * this method will configure the search index for the workflow.
+     */
+    //todo: bind this to the Search service; update constructor to expect hotMeshClient as first param (id is optional
+    //refactor and delete other one as well)
+    static async configureSearchIndex(hotMeshClient, search) {
+        if (search?.schema) {
+            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 });
+            }
+        }
+    }
     static async create(config) {
         //always call `registerActivities` before `import`
         WorkerService.connection = config.connection;
@@ -91,6 +94,7 @@ class WorkerService {
         const worker = new WorkerService();
         worker.activityRunner = await worker.initActivityWorker(config, activityTopic);
         worker.workflowRunner = await worker.initWorkflowWorker(config, workflowTopic, workflowFunction);
+        WorkerService.configureSearchIndex(worker.workflowRunner, config.search);
         await WorkerService.activateWorkflow(worker.workflowRunner);
         return worker;
     }

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

@@ -1,10 +1,12 @@
 import { ActivityConfig, ProxyType, WorkflowOptions } from "../../types/durable";
+import { Search } from './search';
 export declare class WorkflowService {
     /**
      * Spawn a child workflow. await the result.
      */
     static executeChild<T>(options: WorkflowOptions): Promise<T>;
     static proxyActivities<ACT>(options?: ActivityConfig): ProxyType<ACT>;
+    static search(): Promise<Search>;
     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,34 +11,7 @@ const client_1 = require("./client");
 const connection_1 = require("./connection");
 const factory_1 = require("./factory");
 const errors_1 = require("../../modules/errors");
-/*
-`proxyActivities` returns a wrapped instance of the
-target activity, so that when the workflow calls a
-proxied activity, it is actually calling the proxy
-function, which in turn calls the activity function.
-
-Here is an example of how the methods in this file are used:
-
-./workflows.ts
-
-import { Durable } from '@hotmeshio/hotmesh';
-import * as activities from './activities';
-
-const { greet } = Durable.workflow.proxyActivities<typeof activities>({
-  activities: activities,
-  startToCloseTimeout: '1 minute',
-  retryPolicy: {
-    initialInterval: '5 seconds',  // Initial delay between retries
-    maximumAttempts: 3,            // Max number of retry attempts
-    backoffCoefficient: 2.0,       // Backoff factor for delay between retries: delay = initialInterval * (backoffCoefficient ^ retry_attempt)
-    maximumInterval: '30 seconds', // Max delay between retries
-  },
-});
-
-export async function example(name: string): Promise<string> {
-  return await greet(name);
-}
-*/
+const search_1 = require("./search");
 class WorkflowService {
     /**
      * Spawn a child workflow. await the result.
@@ -88,6 +61,16 @@ class WorkflowService {
         }
         return proxy;
     }
+    static async search() {
+        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');
+        const hotMeshClient = await worker_1.WorkerService.getHotMesh(workflowTopic);
+        return new search_1.Search(workflowId, hotMeshClient);
+    }
     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,6 +5,15 @@ type WorkflowConfig = {
     maximumInterval?: string;
     initialInterval?: string;
 };
+type WorkflowSearchOptions = {
+    index?: string;
+    prefix?: string[];
+    schema?: Record<string, {
+        type: 'TEXT' | 'NUMERIC' | 'TAG';
+        sortable: boolean;
+    }>;
+    data?: Record<string, string>;
+};
 type WorkflowOptions = {
     taskQueue: string;
     args: any[];
@@ -13,6 +22,7 @@ type WorkflowOptions = {
     parentWorkflowId?: string;
     workflowTrace?: string;
     workflowSpan?: string;
+    search?: WorkflowSearchOptions;
     config?: WorkflowConfig;
 };
 type SignalOptions = {
@@ -50,6 +60,7 @@ type WorkerConfig = {
     taskQueue: string;
     workflow: Function;
     options?: WorkerOptions;
+    search?: WorkflowSearchOptions;
 };
 type WorkerOptions = {
     maxSystemRetries?: number;
@@ -73,4 +84,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';