@hotmeshio/hotmesh 0.0.18 → 0.0.20

package/build/services/signaler/store.js

@@ -11,7 +11,7 @@ class StoreSignaler {
         const rules = await this.store.getHookRules();
         return rules?.[topic]?.[0];
     }
-    async registerWebHook(topic, context, multi) {
+    async registerWebHook(topic, context, dad, multi) {
         const hookRule = await this.getHookRule(topic);
         if (hookRule) {
             const mapExpression = hookRule.conditions.match[0].expected;
@@ -20,7 +20,8 @@ class StoreSignaler {
             const hook = {
                 topic,
                 resolved,
-                jobId,
+                //hookSignalId is composed of `<dad>::<jid>`
+                jobId: `${dad}::${jobId}`,
             };
             await this.store.setHookSignal(hook, multi);
             return jobId;
@@ -36,18 +37,27 @@ class StoreSignaler {
             const context = { $self: { hook: { data } }, $hook: { data } };
             const mapExpression = hookRule.conditions.match[0].actual;
             const resolved = pipe_1.Pipe.resolve(mapExpression, context);
-            const jobId = await this.store.getHookSignal(topic, resolved);
-            return jobId;
+            const hookSignalId = await this.store.getHookSignal(topic, resolved);
+            if (!hookSignalId) {
+                //messages can be double-processed; not an issue; return undefined
+                //users can also provide a bogus topic; not an issue; return undefined
+                return undefined;
+            }
+            const [dad, jid] = hookSignalId.split('::');
+            //return [jid, aid, dad]
+            return [jid, hookRule.to, dad];
         }
         else {
-            throw new Error('signaler.process:error: hook rule not found');
+            throw new Error('signal-not-found');
         }
     }
     async deleteWebHookSignal(topic, data) {
         const hookRule = await this.getHookRule(topic);
         if (hookRule) {
-            //todo: use the rule to generate `resolved`
-            const resolved = data.id;
+            //NOTE: both formats are supported: $self.hook.data OR $hook.data
+            const context = { $self: { hook: { data } }, $hook: { data } };
+            const mapExpression = hookRule.conditions.match[0].actual;
+            const resolved = pipe_1.Pipe.resolve(mapExpression, context);
             return await this.store.deleteHookSignal(topic, resolved);
         }
         else {

package/build/services/signaler/stream.js

@@ -121,6 +121,7 @@ class StreamSignaler {
             output = await callback(input);
         }
         catch (error) {
+            console.error(error);
             this.logger.error(`stream-call-function-error`, { error });
             output = this.structureUnhandledError(input, error);
         }

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

@@ -68,7 +68,7 @@ class RedisStoreService extends index_1.StoreService {
         }
         catch (error) {
             const streamType = mkStream === 'MKSTREAM' ? 'with MKSTREAM' : 'without MKSTREAM';
-            this.logger.warn(`x-group-error ${streamType} for key: ${key} and group: ${groupName}`, { error });
+            this.logger.info(`x-group-error ${streamType} for key: ${key} and group: ${groupName}`, { error });
             throw error;
         }
     }

package/build/services/store/index.js

@@ -422,6 +422,9 @@ class StoreService {
             }
             return [state, status];
         }
+        else {
+            throw new Error(`Job ${jobId} not found`);
+        }
     }
     async collate(jobId, activityId, amount, dIds, multi) {
         const jobKey = this.mintKey(key_1.KeyType.JOB_STATE, { appId: this.appId, jobId });

package/build/services/telemetry/index.js

@@ -207,11 +207,17 @@ class TelemetryService {
     }
     static bindActivityTelemetryToState(state, config, metadata, context, leg) {
         if (config.type === 'trigger') {
+            //trigger activities run non-duplexed and only have a single leg (2)
             state[`${metadata.aid}/output/metadata/l1s`] = context['$self'].output.metadata.l1s;
             state[`${metadata.aid}/output/metadata/l2s`] = context['$self'].output.metadata.l2s;
         }
         else if (utils_1.polyfill.resolveActivityType(config.type) === 'hook' && leg === 1) {
-            //activities run non-duplexed and only have a single leg
+            //hook activities run non-duplexed and only have a single leg (1)
+            state[`${metadata.aid}/output/metadata/l1s`] = context['$self'].output.metadata.l1s;
+            state[`${metadata.aid}/output/metadata/l2s`] = context['$self'].output.metadata.l1s;
+        }
+        else if (config.type === 'signal' && leg === 1) {
+            //signal activities run non-duplexed and only have a single leg (1)
             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

@@ -66,11 +66,13 @@ interface SignalActivity extends BaseActivity {
     type: 'signal';
     subtype: 'one' | 'all';
     topic: string;
-    key_name: string;
-    key_value: string;
-    scrub: boolean;
+    key_name?: string;
+    key_value?: string;
+    scrub?: boolean;
     signal?: Record<string, any>;
     resolver?: Record<string, any>;
+    status?: string;
+    code?: number;
 }
 interface IterateActivity extends BaseActivity {
     type: 'iterate';

package/build/types/durable.d.ts

@@ -6,14 +6,16 @@ type WorkflowConfig = {
     initialInterval?: string;
 };
 type WorkflowSearchOptions = {
-    index: string;
-    prefix: string[];
-    schema: Record<string, {
+    index?: string;
+    prefix?: string[];
+    schema?: Record<string, {
         type: 'TEXT' | 'NUMERIC' | 'TAG';
         sortable: boolean;
     }>;
+    data?: Record<string, string>;
 };
 type WorkflowOptions = {
+    namespace?: string;
     taskQueue: string;
     args: any[];
     workflowId: string;
@@ -24,6 +26,15 @@ type WorkflowOptions = {
     search?: WorkflowSearchOptions;
     config?: WorkflowConfig;
 };
+type HookOptions = {
+    namespace?: string;
+    taskQueue: string;
+    args: any[];
+    workflowId: string;
+    workflowName?: string;
+    search?: WorkflowSearchOptions;
+    config?: WorkflowConfig;
+};
 type SignalOptions = {
     taskQueue: string;
     data: Record<string, any>;
@@ -59,8 +70,10 @@ type WorkerConfig = {
     taskQueue: string;
     workflow: Function;
     options?: WorkerOptions;
+    search?: WorkflowSearchOptions;
 };
 type WorkerOptions = {
+    logLevel?: string;
     maxSystemRetries?: number;
     backoffCoefficient?: number;
 };
@@ -82,4 +95,4 @@ type ActivityConfig = {
         maximumInterval: string;
     };
 };
-export { ActivityConfig, ActivityWorkflowDataType, ClientConfig, ContextType, ConnectionConfig, Connection, NativeConnection, ProxyType, Registry, SignalOptions, WorkerConfig, WorkflowConfig, WorkerOptions, WorkflowSearchOptions, WorkflowDataType, WorkflowOptions, };
+export { ActivityConfig, ActivityWorkflowDataType, ClientConfig, ContextType, ConnectionConfig, Connection, NativeConnection, ProxyType, Registry, SignalOptions, HookOptions, WorkerConfig, WorkflowConfig, WorkerOptions, WorkflowSearchOptions, WorkflowDataType, WorkflowOptions, };

package/build/types/hook.d.ts

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

package/build/types/index.d.ts

@@ -3,7 +3,7 @@ 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, WorkflowSearchOptions, WorkflowDataType, WorkflowOptions, } from './durable';
+export { ActivityConfig, ActivityWorkflowDataType, ClientConfig, ContextType, ConnectionConfig, Connection, NativeConnection, ProxyType, Registry, HookOptions, 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/errors.ts

@@ -36,11 +36,13 @@ class DurableWaitForSignalError extends Error {
 class DurableSleepError extends Error {
   code: number;
   duration: number; //seconds
-  index: number;    //execution order in the workflow 
-  constructor(message: string, duration: number, index: number) {
+  index: number;    //execution order in the workflow
+  dimension: string; //hook dimension (e.g., ',0,1,0') (uses empty string for `null`)
+  constructor(message: string, duration: number, index: number, dimension: string) {
     super(message);
     this.duration = duration;
     this.index = index;
+    this.dimension = dimension;
     this.code = 595;
   }
 }

package/modules/utils.ts

@@ -9,6 +9,12 @@ export async function sleepFor(ms: number) {
 }
 
 export function identifyRedisType(redisInstance: any): 'redis' | 'ioredis' | null {
+  const prototype = Object.getPrototypeOf(redisInstance);
+  if ('defineCommand' in prototype || Object.keys(prototype).includes('multi')) {
+    return 'ioredis';
+  } else if (Object.keys(prototype).includes('Multi')) {
+    return 'redis';
+  }
   if (redisInstance.constructor) {
     if (redisInstance.constructor.name === 'Redis' || redisInstance.constructor.name === 'EventEmitter') {
       if ('hset' in redisInstance) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hotmeshio/hotmesh",
-  "version": "0.0.18",
+  "version": "0.0.20",
   "description": "Unbreakable Workflows",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -45,6 +45,7 @@
     "test:durable": "NODE_ENV=test jest ./tests/durable/*/index.test.ts --detectOpenHandles --forceExit --verbose",
     "test:durable:hello": "NODE_ENV=test jest ./tests/durable/helloworld/index.test.ts --detectOpenHandles --forceExit --verbose",
     "test:durable:goodbye": "NODE_ENV=test jest ./tests/durable/goodbye/index.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:durable:hook": "NODE_ENV=test jest ./tests/durable/hook/index.test.ts --detectOpenHandles --forceExit --verbose",
     "test:durable:retry": "NODE_ENV=test jest ./tests/durable/retry/index.test.ts --detectOpenHandles --forceExit --verbose",
     "test:durable:fatal": "NODE_ENV=test jest ./tests/durable/fatal/index.test.ts --detectOpenHandles --forceExit --verbose",
     "test:durable:sleep": "NODE_ENV=test jest ./tests/durable/sleep/index.test.ts --detectOpenHandles --forceExit --verbose",

package/services/activities/activity.ts

@@ -70,16 +70,20 @@ class Activity {
   }
 
   //********  DUPLEX RE-ENTRY POINT  ********//
-  async processEvent(status: StreamStatus = StreamStatus.SUCCESS, code: StreamCode = 200, type: 'hook' | 'output' = 'output', jobId?: string): Promise<void> {
+  async processEvent(status: StreamStatus = StreamStatus.SUCCESS, code: StreamCode = 200, type: 'hook' | 'output' = 'output'): Promise<void> {
     this.setLeg(2);
-    const jid = this.context.metadata.jid || jobId;
+    const jid = this.context.metadata.jid;
+    if (!jid) {
+      this.logger.error('activity-process-event-error', { message: 'job id is undefined' });
+      return;
+    }
     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: TelemetryService;
     try {
-      await this.getState(jobId);
+      await this.getState();
       const aState = await CollatorService.notarizeReentry(this);
       this.adjacentIndex = CollatorService.getDimensionalIndex(aState);
 
@@ -107,7 +111,6 @@ class Activity {
         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;
@@ -323,7 +326,7 @@ class Activity {
     return MDATA_SYMBOLS[keys_to_save].KEYS.map((key) => `output/metadata/${key}`);
   }
 
-  async getState(jobId?: string) {
+  async getState() {
     //assemble list of paths necessary to create 'job state' from the 'symbol hash'
     const jobSymbolHashName = `$${this.config.subscribes}`;
     const consumes: Consumes = {
@@ -348,10 +351,9 @@ class Activity {
     }
     TelemetryService.addTargetTelemetryPaths(consumes, this.config, this.metadata, this.leg);
     let { dad, jid } = this.context.metadata;
-    jobId = jobId || jid;
-    const dIds = CollatorService.getDimensionsById([...this.config.ancestors, this.metadata.aid], dad);
+    const dIds = CollatorService.getDimensionsById([...this.config.ancestors, this.metadata.aid], dad || '');
     //`state` is a flat hash; context is a tree
-    const [state, status] = await this.store.getState(jobId, consumes, dIds);
+    const [state, status] = await this.store.getState(jid, consumes, dIds);
     this.context = restoreHierarchy(state) as JobState;
     this.initDimensionalAddress(dad);
     this.initSelf(this.context);

package/services/activities/hook.ts

@@ -1,4 +1,5 @@
-import { CollationError, GetStateError } from '../../modules/errors';
+import { GetStateError } from '../../modules/errors';
+import { Activity } from './activity';
 import { CollatorService } from '../collator';
 import { EngineService } from '../engine';
 import { Pipe } from '../pipe';
@@ -8,15 +9,14 @@ import {
   ActivityData,
   ActivityMetadata,
   ActivityType,
-  HookActivity} from '../../types/activity';
+  HookActivity } from '../../types/activity';
+import { HookRule } from '../../types/hook';
 import { JobState, JobStatus } from '../../types/job';
 import {
   MultiResponseFlags,
   RedisMulti } from '../../types/redis';
 import { StringScalarType } from '../../types/serializer';
-import { HookRule } from '../../types/hook';
-import { Activity } from './activity';
-import { StreamStatus } from '../../types';
+import { StreamCode, StreamStatus } from '../../types/stream';
 
 /**
  * Listens for `webhook`, `timehook`, and `cycle` (repeat) signals
@@ -108,7 +108,7 @@ class Hook extends Activity {
   async registerHook(multi?: RedisMulti): Promise<string | void> {
     if (this.config.hook?.topic) {
       const signaler = new StoreSignaler(this.store, this.logger);
-      return await signaler.registerWebHook(this.config.hook.topic, this.context, multi);
+      return await signaler.registerWebHook(this.config.hook.topic, this.context, this.resolveDad(), multi);
     } else if (this.config.sleep) {
       const durationInSeconds = Pipe.resolve(this.config.sleep, this.context);
       const jobId = this.context.metadata.jid;
@@ -119,19 +119,22 @@ class Hook extends Activity {
     }
   }
 
-  async processWebHookEvent(): Promise<JobStatus | void> {
+  async processWebHookEvent(status: StreamStatus = StreamStatus.SUCCESS, code: StreamCode = 200): Promise<JobStatus | void> {
     this.logger.debug('hook-process-web-hook-event', {
       topic: this.config.hook.topic,
-      aid: this.metadata.aid
+      aid: this.metadata.aid,
+      status,
+      code,
     });
     const signaler = new 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(StreamStatus.SUCCESS, code, 'hook', jobId);
-      if (code === 200) {
+    const signal = await signaler.processWebHookSignal(this.config.hook.topic, data);
+    if (signal) {
+      const [jobId, aid, dad] = signal;
+      this.context.metadata.jid = jobId;
+      this.context.metadata.dad = dad;
+      await this.processEvent(status, code, 'hook');
+      if (code === 200) { //otherwise 202 for pending/keepalive
         await signaler.deleteWebHookSignal(this.config.hook.topic, data);
       }
     } //else => already resolved

package/services/activities/signal.ts

@@ -10,7 +10,7 @@ import {
   ActivityMetadata,
   SignalActivity } from '../../types/activity';
 import { JobState } from '../../types/job';
-import { MultiResponseFlags, RedisMulti } from '../../types/redis';
+import { MultiResponseFlags } from '../../types/redis';
 import { StringScalarType } from '../../types/serializer';
 import { JobStatsInput } from '../../types/stats';
 
@@ -50,8 +50,11 @@ class Signal extends Activity {
       await this.setStatus(this.adjacencyList.length - 1, multi);
       const multiResponse = await multi.exec() as MultiResponseFlags;
 
-      //signal to awaken all paused jobs that share the targeted job key
-      await this.hookAll();
+      if (this.config.subtype === 'all') {
+        await this.hookAll();
+      } else {
+        await this.hookOne();
+      }
 
       //transition to adjacent activities
       const jobStatus = this.resolveStatus(multiResponse);
@@ -92,6 +95,17 @@ class Signal extends Activity {
     }
   }
 
+  /**
+   * The signal activity will hook one
+   */
+  async hookOne(): Promise<string> {
+    const topic = Pipe.resolve(this.config.topic, this.context);
+    const signalInputData = this.mapSignalData();
+    const status = Pipe.resolve(this.config.status, this.context);
+    const code = Pipe.resolve(this.config.code, this.context);
+    return await this.engine.hook(topic, signalInputData, status, code);
+  }
+
   /**
    * The signal activity will hook all paused jobs that share the same job key.
    */

package/services/durable/client.ts

@@ -1,55 +1,17 @@
 import { nanoid } from 'nanoid';
-import { APP_ID, APP_VERSION, DEFAULT_COEFFICIENT, SUBSCRIBES_TOPIC, getWorkflowYAML } from './factory';
+import { APP_ID, APP_VERSION, DEFAULT_COEFFICIENT, getWorkflowYAML } from './factory';
 import { WorkflowHandleService } from './handle';
 import { HotMeshService as HotMesh } from '../hotmesh';
 import {
   ClientConfig,
   Connection,
+  HookOptions,
   WorkflowOptions, 
   WorkflowSearchOptions} from '../../types/durable';
 import { JobState } from '../../types/job';
 import { KeyService, KeyType } from '../../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);
-});
-
-*/
+import { Search } from './search';
+import { StreamStatus } from '../../types';
 
 export class ClientService {
 
@@ -61,14 +23,14 @@ export class ClientService {
     this.connection = config.connection;
   }
 
-  getHotMeshClient = async (worflowTopic: string) => {
+  getHotMeshClient = async (worflowTopic: string, namespace?: string) => {
     //NOTE: every unique topic inits a new engine
     if (ClientService.instances.has(worflowTopic)) {
       return await ClientService.instances.get(worflowTopic);
     }
 
     const hotMeshClient = HotMesh.init({
-      appId: APP_ID,
+      appId: namespace ?? APP_ID,
       engine: {
         redis: {
           class: this.connection.class,
@@ -80,14 +42,14 @@ export class ClientService {
 
     //since the YAML topic is dynamic, it MUST be manually created before use
     const store = (await hotMeshClient).engine.store;
-    const params = { appId: APP_ID, topic: worflowTopic };
+    const params = { appId: namespace ?? APP_ID, topic: worflowTopic };
     const streamKey = store.mintKey(KeyType.STREAMS, params);
     try {
       await store.xgroup('CREATE', streamKey, 'WORKER', '$', 'MKSTREAM');
     } catch (err) {
       //ignore if already exists
     }
-    await this.activateWorkflow(await hotMeshClient);
+    await this.activateWorkflow(await hotMeshClient, namespace ?? APP_ID);
     return hotMeshClient;
   }
 
@@ -96,11 +58,11 @@ export class ClientService {
    * this method will configure the search index for the workflow.
    */
   configureSearchIndex = async (hotMeshClient: HotMesh, search?: WorkflowSearchOptions): Promise<void> => {
-    if (search) {
+    if (search?.schema) {
       const store = hotMeshClient.engine.store;
       const schema: string[] = [];
       for (const [key, value] of Object.entries(search.schema)) {
-        //prefix with a comma (avoids collisions with hotmesh reserved words)
+        //prefix with an underscore (avoids collisions with hotmesh reserved symbols)
         schema.push(`_${key}`);
         schema.push(value.type);
         if (value.sortable) {
@@ -134,7 +96,7 @@ export class ClientService {
       const spn = options.workflowSpan;
       //topic is concat of taskQueue and workflowName
       const workflowTopic = `${taskQueueName}-${workflowName}`;
-      const hotMeshClient = await this.getHotMeshClient(workflowTopic);
+      const hotMeshClient = await this.getHotMeshClient(workflowTopic, options.namespace);
       this.configureSearchIndex(hotMeshClient, options.search)
       const payload = {
         arguments: [...options.args],
@@ -145,25 +107,55 @@ export class ClientService {
       }
       const context = { metadata: { trc, spn }, data: {}};
       const jobId = await hotMeshClient.pub(
-        SUBSCRIBES_TOPIC,
+        `${options.namespace ?? APP_ID}.execute`,
         payload,
         context as JobState);
+       if (jobId && options.search?.data) {
+        //job successfully kicked off; there is default job data to persist
+        const searchSessionId = `-search-0`;
+        const search = new Search(jobId, hotMeshClient, searchSessionId);
+        for (const [key, value] of Object.entries(options.search.data)) {
+          search.set(key, value);
+        }
+      }
       return new WorkflowHandleService(hotMeshClient, workflowTopic, jobId);
     },
 
-    signal: async (signalId: string, data: Record<any, any>): Promise<string> => {
-      return await (await this.getHotMeshClient('durable.wfs.signal')).hook('durable.wfs.signal', { id: signalId, data });
+    /**
+     * send a message to a running workflow that is paused and awaiting the signal
+     */
+    signal: async (signalId: string, data: Record<any, any>, namespace?: string): Promise<string> => {
+      const topic = `${namespace ?? APP_ID}.wfs.signal`;
+      return await (await this.getHotMeshClient(topic, namespace)).hook(topic, { id: signalId, data });
+    },
+
+    /**
+     * send a message to spawn an parallel in-process thread of execution
+     * with the same job state as the main thread but bound to a different
+     * handler function. All job state will be journaled to the same hash
+     * as is used by the main thread.
+     */
+    hook: async (options: HookOptions): Promise<string> => {
+      const workflowTopic = `${options.taskQueue}-${options.workflowName}`;
+      const payload = {
+        arguments: [...options.args],
+        id: options.workflowId,
+        workflowTopic,
+        backoffCoefficient: options.config?.backoffCoefficient || DEFAULT_COEFFICIENT,
+      }
+      const hotMeshClient = await this.getHotMeshClient(workflowTopic, options.namespace);
+      return await hotMeshClient.hook(`${hotMeshClient.appId}.flow.signal`, payload, StreamStatus.PENDING, 202);
     },
 
-    getHandle: async (taskQueue: string, workflowName: string, workflowId: string): Promise<WorkflowHandleService> => {
+    getHandle: async (taskQueue: string, workflowName: string, workflowId: string, namespace?: string): Promise<WorkflowHandleService> => {
       const workflowTopic = `${taskQueue}-${workflowName}`;
-      const hotMeshClient = await this.getHotMeshClient(workflowTopic);
+      const hotMeshClient = await this.getHotMeshClient(workflowTopic, namespace);
       return new WorkflowHandleService(hotMeshClient, workflowTopic, workflowId);
     },
 
-    search: async (taskQueue: string, workflowName: string, index: string, ...query: string[]): Promise<string[]> => {
+    search: async (taskQueue: string, workflowName: string, namespace: null | string, index: string, ...query: string[]): Promise<string[]> => {
       const workflowTopic = `${taskQueue}-${workflowName}`;
-      const hotMeshClient = await this.getHotMeshClient(workflowTopic);
+      const hotMeshClient = await this.getHotMeshClient(workflowTopic, namespace);
       try {
         return await this.search(hotMeshClient, index, query);
       } catch (err) {