@hotmeshio/hotmesh 0.0.21 → 0.0.23

package/README.md

@@ -226,9 +226,6 @@ Exchanging data between activities is central to HotMesh. For detailed informati
 ## Composition
 While the simplest graphs are linear, detailing a consistent sequence of non-cyclical activities, graphs can be layered to represent intricate business scenarios. Some can even be designed to accommodate long-lasting workflows that span months. For more details, check out the [Composable Workflow Guide](https://github.com/hotmeshio/sdk-typescript/blob/main/docs/composable_workflow.md).
 
-## Architectural First Principles
-For a deep dive into HotMesh's distributed orchestration philosophy, refer to the [Architectural First Principles Overview](https://github.com/hotmeshio/sdk-typescript/blob/main/docs/architecture.md).
-
 ## Distributed Orchestration
 HotMesh is a distributed orchestration engine. Refer to the [Distributed Orchestration Guide](https://github.com/hotmeshio/sdk-typescript/blob/main/docs/distributed_orchestration.md) for a detailed breakdown of the approach.
 

package/build/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hotmeshio/hotmesh",
-    "version": "0.0.21",
+    "version": "0.0.23",
     "description": "Unbreakable Workflows",
     "main": "build/index.js",
     "types": "build/index.d.ts",
@@ -43,6 +43,7 @@
         "test:sub:redis": "NODE_ENV=test jest ./tests/functional/sub/clients/redis.test.ts --detectOpenHandles --forceExit --verbose",
         "test:sub:ioredis": "NODE_ENV=test jest ./tests/functional/sub/clients/ioredis.test.ts --detectOpenHandles --forceExit --verbose",
         "test:durable": "NODE_ENV=test jest ./tests/durable/*/index.test.ts --detectOpenHandles --forceExit --verbose",
+        "test:durable:meshdb": "NODE_ENV=test jest ./tests/durable/meshdb/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",

package/build/services/durable/connection.js

@@ -1,45 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConnectionService = void 0;
-/*
-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 { 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(example, {
-    taskQueue: 'hello-world',
-    args: ['HotMesh'],
-    workflowName: 'example',
-    workflowId: nanoid(),
-  });
-
-  console.log(`Started workflow ${handle.workflowId}`);
-  console.log(await handle.result());
-}
-
-run().catch((err) => {
-  console.error(err);
-  process.exit(1);
-});
-
-*/
 class ConnectionService {
     static async connect(config) {
         return {

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

@@ -2,11 +2,13 @@
  * NOTE: Using `maxSystemRetries = 3` and `backoffCoefficient = 10`, errant
  *       workflows will be retried on the following schedule (8 times in 27 hours):
  *       => 10ms, 100ms, 1000ms, 10s, 100s, 1_000s, 10_000s, 100_000s
+ * TODO: Max Interval, Min Interval, Initial Interval
  *
- * 594: waitforsignal
- * 595: sleep
- * 596, 597, 598: fatal
- * 599: retry
+ * ERROR CODES:
+ *      594: waitforsignal
+ *      595: sleep
+ *      596, 597, 598: fatal
+ *      599: retry
  */
 declare const getWorkflowYAML: (app: string, version: string) => string;
 declare const APP_VERSION = "1";

package/build/services/durable/factory.js

@@ -5,11 +5,13 @@ exports.DEFAULT_COEFFICIENT = exports.APP_ID = exports.APP_VERSION = exports.get
  * NOTE: Using `maxSystemRetries = 3` and `backoffCoefficient = 10`, errant
  *       workflows will be retried on the following schedule (8 times in 27 hours):
  *       => 10ms, 100ms, 1000ms, 10s, 100s, 1_000s, 10_000s, 100_000s
+ * TODO: Max Interval, Min Interval, Initial Interval
  *
- * 594: waitforsignal
- * 595: sleep
- * 596, 597, 598: fatal
- * 599: retry
+ * ERROR CODES:
+ *      594: waitforsignal
+ *      595: sleep
+ *      596, 597, 598: fatal
+ *      599: retry
  */
 const getWorkflowYAML = (app, version) => {
     return `app:

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

@@ -5,5 +5,8 @@ export declare class WorkflowHandleService {
     workflowId: string;
     constructor(hotMesh: HotMesh, workflowTopic: string, workflowId: string);
     signal(signalId: string, data: Record<any, any>): Promise<void>;
+    state(metadata?: boolean): Promise<Record<string, any>>;
+    queryState(fields: string[]): Promise<Record<string, any>>;
+    status(): Promise<number>;
     result(loadState?: boolean): Promise<any>;
 }

package/build/services/durable/handle.js

@@ -10,6 +10,19 @@ class WorkflowHandleService {
     async signal(signalId, data) {
         await this.hotMesh.hook(`${this.hotMesh.appId}.wfs.signal`, { id: signalId, data });
     }
+    async state(metadata = false) {
+        const state = await this.hotMesh.getState(`${this.hotMesh.appId}.execute`, this.workflowId);
+        if (!state.data && state.metadata.err) {
+            throw new Error(JSON.parse(state.metadata.err));
+        }
+        return metadata ? state : state.data;
+    }
+    async queryState(fields) {
+        return await this.hotMesh.getQueryState(this.workflowId, fields);
+    }
+    async status() {
+        return await this.hotMesh.getStatus(this.workflowId);
+    }
     async result(loadState) {
         if (loadState) {
             const state = await this.hotMesh.getState(`${this.hotMesh.appId}.execute`, this.workflowId);
@@ -20,8 +33,7 @@ class WorkflowHandleService {
                 //child flows are never technically 'done' as they have an open hook
                 //that is tied to the parent flow's completion. so, we need to check
                 //the 'done' flag on the child flow's payload (not the 'js' metadata field
-                //which is typically used); the loadState parameter ensures this
-                //check happens early
+                //which is typically used); the `loadState` parameter triggers this
                 return state.data.response;
             }
         }

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

@@ -1,56 +1,13 @@
 import { ClientService } from './client';
 import { ConnectionService } from './connection';
-import { NativeConnectionService } from './native';
+import { MeshDBService } from './meshdb';
 import { WorkerService } from './worker';
 import { WorkflowService } from './workflow';
 import { ContextType } from '../../types/durable';
-/**
- * As a durable integration platform, HotMesh
- * can model and emulate other durable systems
- * (like Temporal). As you review the code in
- * this file, note the following:
- *
- * 1) There is no central governing server.
- * HotMesh is a client-side SDK that connects to Redis
- * using CQRS principles to implicitly drive
- * orchestrations using a headless quorum. Stream
- * semantics guarantee that all events are
- * processed by the quorum of connected clients.
- *
- * 2) Every developer-defined `workflow` function
- * is assigned a HotMesh workflow (which runs in
- * the background) to support it.
- *
- * If the HotMesh workflow is not yet defined,
- * it will be deployed and activated on-the-fly.
- * (The generated DAG will have one Trigger Activity
- * and one Worker Activity.) The Worker Activity
- * is configured to catch execution errors and
- * return them, using a 'pending' status to
- * indicate that the workflow is still running.
- * It is possible for workflow activities to throw
- * errors that will force the entire workflow to
- * fail. This is not the case here. The workflow will
- * continue to run until it is completed or cancelled.
- *
- * 2) Every developer-defined `activity` function
- * is assigned a HotMesh workflow (which runs in
- * the background) to support it.
- *
- * (The generated DAG will have one Trigger Activity and one
- * Worker Activity.) The JOB ID for Worker Activity executions
- * is derived from the containing JOB ID,
- * allowing Activity state to be 'replayed' when the workflow
- * is run again. The Activity Function Runner (activity proxy)
- * is configured similar to how the workflow worker is and will
- * catch execution errors and return them to the caller, using a
- * 'pending' status to indicate that the activity is still running.
- * This allows the activity to be retried until it succeeds.
- */
 export declare const Durable: {
     Client: typeof ClientService;
     Connection: typeof ConnectionService;
-    NativeConnection: typeof NativeConnectionService;
+    MeshDB: typeof MeshDBService;
     Worker: typeof WorkerService;
     workflow: typeof WorkflowService;
 };

package/build/services/durable/index.js

@@ -3,56 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Durable = void 0;
 const client_1 = require("./client");
 const connection_1 = require("./connection");
-const native_1 = require("./native");
+const meshdb_1 = require("./meshdb");
 const worker_1 = require("./worker");
 const workflow_1 = require("./workflow");
-/**
- * As a durable integration platform, HotMesh
- * can model and emulate other durable systems
- * (like Temporal). As you review the code in
- * this file, note the following:
- *
- * 1) There is no central governing server.
- * HotMesh is a client-side SDK that connects to Redis
- * using CQRS principles to implicitly drive
- * orchestrations using a headless quorum. Stream
- * semantics guarantee that all events are
- * processed by the quorum of connected clients.
- *
- * 2) Every developer-defined `workflow` function
- * is assigned a HotMesh workflow (which runs in
- * the background) to support it.
- *
- * If the HotMesh workflow is not yet defined,
- * it will be deployed and activated on-the-fly.
- * (The generated DAG will have one Trigger Activity
- * and one Worker Activity.) The Worker Activity
- * is configured to catch execution errors and
- * return them, using a 'pending' status to
- * indicate that the workflow is still running.
- * It is possible for workflow activities to throw
- * errors that will force the entire workflow to
- * fail. This is not the case here. The workflow will
- * continue to run until it is completed or cancelled.
- *
- * 2) Every developer-defined `activity` function
- * is assigned a HotMesh workflow (which runs in
- * the background) to support it.
- *
- * (The generated DAG will have one Trigger Activity and one
- * Worker Activity.) The JOB ID for Worker Activity executions
- * is derived from the containing JOB ID,
- * allowing Activity state to be 'replayed' when the workflow
- * is run again. The Activity Function Runner (activity proxy)
- * is configured similar to how the workflow worker is and will
- * catch execution errors and return them to the caller, using a
- * 'pending' status to indicate that the activity is still running.
- * This allows the activity to be retried until it succeeds.
- */
 exports.Durable = {
     Client: client_1.ClientService,
     Connection: connection_1.ConnectionService,
-    NativeConnection: native_1.NativeConnectionService,
+    MeshDB: meshdb_1.MeshDBService,
     Worker: worker_1.WorkerService,
     workflow: workflow_1.WorkflowService,
 };

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

@@ -0,0 +1,113 @@
+import { WorkflowHandleService } from './handle';
+import { WorkflowSearchOptions } from '../../types/durable';
+import { RedisOptions, RedisClass } from '../../types/redis';
+/**
+ * A base class for configuration and setup of
+ * a reentrant process database. Entities modeled as
+ * subclasses of this class will execute as reentrant
+ * processes with a 'main' execution thread and 'n'
+ * parallel hook threads.
+ *
+ * @example
+ * //RUN (start a workflow)
+ * const myInstance = new MeshDB('someIdempotentGuid');
+ * const handle = await myInstance.create(100);
+ * await handle.result(); //100
+ *
+ * //UPDATE (update a workflow)
+ * const result = await myInstance.decrement(11);
+ */
+export declare class MeshDBService {
+    /**
+     * The name of the main method. When this method
+     * is invoked/proxied, it is assumed that a new
+     * workflow instance is being created. In all other
+     * cases, the call is assumed to be a hook/update
+     */
+    main: string;
+    /**
+     * The GUID for the workflow (assigned when created). This
+     * value should be idempotent and will be rejected if an
+     * instance is already running with the same id.
+     */
+    id: string;
+    /**
+     * test value
+     */
+    value: number;
+    /**
+     * The top-level Redis isolation. All workflow data is
+     * isolated within this namespace. Values should be
+     * lower-case with no spaces (e.g, 'staging', 'prod', 'test',
+     * 'routing-stagig', 'reporting-prod', etc.).
+     *  1) only url-safe values are allowed;
+     *  2) the 'a' symbol is reserved by HotMesh for indexing apps
+     */
+    namespace: string;
+    /**
+     * The second-level isolation. Data is routed to workers
+     * that specify this task queue. Setting the task queue
+     * when the worker is created will ensure that the worker
+     * only receives messages destined for the queue. This
+     * allows callers to specify specific workers/containers
+     * for specific tasks. Only url-safe values are allowed.
+     */
+    taskQueue: string;
+    /**
+     * The Redis connection options. NOTE: Redis and IORedis
+     * use different formats for their connection config.
+     */
+    redisOptions: RedisOptions;
+    /**
+     * The Redis connection class. Import as follows
+     * within the base subclass as follows:
+     *
+     * @example
+     * import Redis from 'ioredis';
+     * import * as Redis from 'redis';
+     */
+    redisClass: RedisClass | null;
+    /**
+     * Configuration for the the Redis FT search index.
+     */
+    search: WorkflowSearchOptions;
+    static getHotMeshClient(redisClass: RedisClass, redisOptions: RedisOptions, namespace: string, taskQueue: string): Promise<import("../hotmesh").HotMeshService>;
+    /**
+     * mints a new key, using the provided search prefix, ensuring
+     * new workflows are properly indexed
+     * @returns {string}
+     */
+    static mintGuid(): string;
+    /**
+     * Creates an FT search index
+     */
+    static createIndex(): Promise<void>;
+    /**
+     * Initialize the worker(s) for the entity. This is a static
+     * method that allows for optional task Queue targeting.
+     * NOTE: Allow List may be optionally used
+     * @param {string} taskQueue
+     * @param {string[]} allowList
+     */
+    static doWork(taskQueue?: string, allowList?: string[]): Promise<void>;
+    /**
+     * executes the redis FT search query
+     * @example '@_quantity:[89 89]'
+     * @param {any[]} args
+     * @returns {string}
+     */
+    static find(...args: string[]): Promise<string[] | [number]>;
+    /**
+     * returns the workflow handle (use the handle to call:
+     * `state`, `status`, `queryStatus`, and `result`)
+     * @param {string} id
+     * @returns {Promise<WorkflowHandleService>}
+     */
+    static get(id: string): Promise<WorkflowHandleService>;
+    /**
+     * Initialize with an idempotent workflow identifier.
+     * Optionally include a target taskQueue to send
+     * events to a specific worker.
+     */
+    constructor(id?: string, taskQueue?: string);
+}

package/build/services/durable/meshdb.js

@@ -0,0 +1,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MeshDBService = void 0;
+const nanoid_1 = require("nanoid");
+const client_1 = require("./client");
+const search_1 = require("./search");
+const worker_1 = require("./worker");
+/**
+ * A base class for configuration and setup of
+ * a reentrant process database. Entities modeled as
+ * subclasses of this class will execute as reentrant
+ * processes with a 'main' execution thread and 'n'
+ * parallel hook threads.
+ *
+ * @example
+ * //RUN (start a workflow)
+ * const myInstance = new MeshDB('someIdempotentGuid');
+ * const handle = await myInstance.create(100);
+ * await handle.result(); //100
+ *
+ * //UPDATE (update a workflow)
+ * const result = await myInstance.decrement(11);
+ */
+class MeshDBService {
+    static async getHotMeshClient(redisClass, redisOptions, namespace, taskQueue) {
+        const client = new client_1.ClientService({
+            connection: {
+                class: redisClass,
+                options: redisOptions,
+            }
+        });
+        return await client.getHotMeshClient(taskQueue, namespace);
+    }
+    /**
+     * mints a new key, using the provided search prefix, ensuring
+     * new workflows are properly indexed
+     * @returns {string}
+     */
+    static mintGuid() {
+        const my = new this();
+        return `${my.search?.prefix?.[0]}${(0, nanoid_1.nanoid)()}}`;
+    }
+    /**
+     * Creates an FT search index
+     */
+    static async createIndex() {
+        const my = new this();
+        const hmClient = await MeshDBService.getHotMeshClient(my.redisClass, my.redisOptions, my.namespace, my.taskQueue);
+        search_1.Search.configureSearchIndex(hmClient, my.search);
+    }
+    /**
+     * Initialize the worker(s) for the entity. This is a static
+     * method that allows for optional task Queue targeting.
+     * NOTE: Allow List may be optionally used
+     * @param {string} taskQueue
+     * @param {string[]} allowList
+     */
+    static async doWork(taskQueue, allowList) {
+        const my = new this();
+        let prototype = Object.getPrototypeOf(my);
+        const durablePromises = [];
+        const found = [];
+        while (prototype !== null && !Object.getOwnPropertyNames(prototype).includes('__proto__')) {
+            const promises = Object.getOwnPropertyNames(prototype).map((prop) => {
+                if (found.includes(prop) || ['constructor'].includes(prop) || (allowList && !allowList.includes(prop))) {
+                    return;
+                }
+                const originalMethod = my[prop];
+                if (typeof originalMethod === 'function') {
+                    found.push(prop);
+                    return worker_1.WorkerService.create({
+                        namespace: my.namespace,
+                        connection: {
+                            class: my.redisClass,
+                            options: my.redisOptions,
+                        },
+                        taskQueue: taskQueue ?? my.taskQueue,
+                        workflow: originalMethod,
+                    });
+                }
+            }).filter(p => p !== undefined); // filter out undefined values
+            durablePromises.push(...promises);
+            prototype = Object.getPrototypeOf(prototype);
+        }
+        await Promise.all(durablePromises);
+    }
+    /**
+     * executes the redis FT search query
+     * @example '@_quantity:[89 89]'
+     * @param {any[]} args
+     * @returns {string}
+     */
+    static async find(...args) {
+        const my = new this();
+        const client = new client_1.ClientService({ connection: {
+                class: my.redisClass,
+                options: my.redisOptions
+            } });
+        return await client.workflow.search(my.taskQueue, my.main, my.namespace, my.search.index, ...args);
+        //[count, [id, fields[], id, fields[], id, fields[], ...]]
+    }
+    /**
+     * returns the workflow handle (use the handle to call:
+     * `state`, `status`, `queryStatus`, and `result`)
+     * @param {string} id
+     * @returns {Promise<WorkflowHandleService>}
+     */
+    static async get(id) {
+        const my = new this();
+        const client = new client_1.ClientService({ connection: {
+                class: my.redisClass,
+                options: my.redisOptions
+            } });
+        return await client.workflow.getHandle(my.taskQueue, my.main, id, my.namespace);
+    }
+    /**
+     * Initialize with an idempotent workflow identifier.
+     * Optionally include a target taskQueue to send
+     * events to a specific worker.
+     */
+    constructor(id, taskQueue) {
+        /**
+         * The name of the main method. When this method
+         * is invoked/proxied, it is assumed that a new
+         * workflow instance is being created. In all other
+         * cases, the call is assumed to be a hook/update
+         */
+        this.main = 'create';
+        /**
+         * The top-level Redis isolation. All workflow data is
+         * isolated within this namespace. Values should be
+         * lower-case with no spaces (e.g, 'staging', 'prod', 'test',
+         * 'routing-stagig', 'reporting-prod', etc.).
+         *  1) only url-safe values are allowed;
+         *  2) the 'a' symbol is reserved by HotMesh for indexing apps
+         */
+        this.namespace = 'durable';
+        /**
+         * The second-level isolation. Data is routed to workers
+         * that specify this task queue. Setting the task queue
+         * when the worker is created will ensure that the worker
+         * only receives messages destined for the queue. This
+         * allows callers to specify specific workers/containers
+         * for specific tasks. Only url-safe values are allowed.
+         */
+        this.taskQueue = 'default';
+        /**
+         * The Redis connection options. NOTE: Redis and IORedis
+         * use different formats for their connection config.
+         */
+        this.redisOptions = {
+            host: 'localhost',
+            port: 6379,
+            password: '',
+            db: 0,
+        };
+        /**
+         * The Redis connection class. Import as follows
+         * within the base subclass as follows:
+         *
+         * @example
+         * import Redis from 'ioredis';
+         * import * as Redis from 'redis';
+         */
+        this.redisClass = null;
+        this.id = id;
+        if (taskQueue) {
+            this.taskQueue = taskQueue;
+        }
+        else if (!id && !taskQueue) {
+            return this;
+        }
+        return new Proxy(this, {
+            get: (target, prop, receiver) => {
+                if (typeof target[prop] === 'function') {
+                    return (...args) => {
+                        return new Promise(async (resolve, reject) => {
+                            const client = new client_1.ClientService({ connection: {
+                                    class: this.redisClass,
+                                    options: this.redisOptions
+                                } });
+                            if (prop === this.main) {
+                                //start a new workflow (main method was called)
+                                return client.workflow.start({
+                                    namespace: this.namespace,
+                                    args,
+                                    taskQueue: this.taskQueue,
+                                    workflowName: prop,
+                                    workflowId: this.id,
+                                }).then(resolve).catch(reject);
+                            }
+                            else if (prop !== 'constructor') {
+                                //update an existing workflow (hook/signal-in)
+                                return client.workflow.hook({
+                                    namespace: this.namespace,
+                                    taskQueue: this.taskQueue,
+                                    workflowName: prop,
+                                    workflowId: this.id,
+                                    args,
+                                }).then(resolve).catch(reject);
+                            }
+                            target[prop].apply(this, args).then(resolve).catch(reject);
+                        });
+                    };
+                }
+                return Reflect.get(target, prop, receiver);
+            },
+        });
+    }
+}
+exports.MeshDBService = MeshDBService;

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

@@ -1,6 +1,7 @@
 import { HotMeshService as HotMesh } from '../hotmesh';
 import { RedisClient, RedisMulti } from '../../types/redis';
 import { StoreService } from '../store';
+import { WorkflowSearchOptions } from '../../types/durable';
 export declare class Search {
     jobId: string;
     searchSessionId: string;
@@ -8,6 +9,14 @@ export declare class Search {
     hotMeshClient: HotMesh;
     store: StoreService<RedisClient, RedisMulti> | null;
     safeKey(key: string): string;
+    /**
+     * For those deployments with a redis stack backend (with the FT module),
+     * this method will configure the search index for the workflow. For all
+     * others, this method will exit/fail gracefully and not index
+     * the fields in the HASH. However, all values are still available
+     * in the HASH.
+     */
+    static configureSearchIndex(hotMeshClient: HotMesh, search?: WorkflowSearchOptions): Promise<void>;
     constructor(workflowId: string, hotMeshClient: HotMesh, searchSessionId: string);
     /**
      * increments the index to return a unique search session guid when

package/build/services/durable/search.js

@@ -4,10 +4,43 @@ 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
+        //note: protect the execution namespace with a prefix
         return `_${key}`;
     }
+    /**
+     * For those deployments with a redis stack backend (with the FT module),
+     * this method will configure the search index for the workflow. For all
+     * others, this method will exit/fail gracefully and not index
+     * the fields in the HASH. However, all values are still available
+     * in the HASH.
+     */
+    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.toString(), ...prefixes, 'SCHEMA', ...schema);
+            }
+            catch (err) {
+                console.error(err);
+                hotMeshClient.engine.logger.info('durable-client-search-err', { err });
+            }
+        }
+    }
     constructor(workflowId, hotMeshClient, searchSessionId) {
         this.searchSessionIndex = 0;
         const keyParams = {