@hotmeshio/hotmesh 0.0.23 → 0.0.25

package/services/durable/factory.ts

@@ -264,11 +264,11 @@ const getWorkflowYAML = (app: string, version: string) => {
                   - ['{@string.concat}']
               cycleWorkflowId:
                 '@pipe':
-                  - ['{$job.metadata.jid}', '-$wfc', '{sig.output.metadata.dad}', '-', '{sigw1.output.data.index}']
+                  - ['-', '{$job.metadata.jid}', '-$wfc', '{sig.output.metadata.dad}', '-', '{sigw1.output.data.index}']
                   - ['{@string.concat}']
               baseWorkflowId:
                 '@pipe':
-                  - ['{$job.metadata.jid}', '-$wfs', '{sig.output.metadata.dad}', '-']
+                  - ['-', '{$job.metadata.jid}', '-$wfs', '{sig.output.metadata.dad}', '-']
                   - ['{@string.concat}']
           output:
             schema:
@@ -312,7 +312,7 @@ const getWorkflowYAML = (app: string, version: string) => {
                   - ['{@string.concat}']
               workflowId:
                 '@pipe':
-                  - ['{$job.metadata.jid}', '-$sleep', '{sig.output.metadata.dad}', '-', '{sigw1.output.data.index}']
+                  - ['-', '{$job.metadata.jid}', '-$sleep', '{sig.output.metadata.dad}', '-', '{sigw1.output.data.index}']
                   - ['{@string.concat}']
           output:
             schema:
@@ -382,11 +382,11 @@ const getWorkflowYAML = (app: string, version: string) => {
                   - ['{@string.concat}']
               cycleWorkflowId:
                 '@pipe':
-                  - ['{$job.metadata.jid}', '-$wfc-', '{w1.output.data.index}']
+                  - ['-', '{$job.metadata.jid}', '-$wfc-', '{w1.output.data.index}']
                   - ['{@string.concat}']
               baseWorkflowId:
                 '@pipe':
-                  - ['{$job.metadata.jid}', '-$wfs-']
+                  - ['-', '{$job.metadata.jid}', '-$wfs-']
                   - ['{@string.concat}']
           output:
             schema:
@@ -430,7 +430,7 @@ const getWorkflowYAML = (app: string, version: string) => {
                   - ['{@string.concat}']
               workflowId:
                 '@pipe':
-                  - ['{$job.metadata.jid}', '-$sleep-', '{w1.output.data.index}']
+                  - ['-', '{$job.metadata.jid}', '-$sleep-', '{w1.output.data.index}']
                   - ['{@string.concat}']
           output:
             schema:

package/services/durable/handle.ts

@@ -39,10 +39,8 @@ export class WorkflowHandleService {
         throw new Error(JSON.parse(state.metadata.err));
       }
       if (state?.data?.done) {
-        //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 triggers this
+        //child flows are never 'done'; they use a hook
+        //that only closes upon parent flow completion.
         return state.data.response;
       }
     }

package/services/durable/index.ts

@@ -1,6 +1,6 @@
 import { ClientService } from './client';
 import { ConnectionService } from './connection';
-import { MeshDBService } from './meshdb';
+import { MeshOSService } from './meshos';
 import { WorkerService } from './worker';
 import { WorkflowService } from './workflow';
 import { ContextType } from '../../types/durable';
@@ -8,7 +8,7 @@ import { ContextType } from '../../types/durable';
 export const Durable = {
   Client: ClientService,
   Connection: ConnectionService,
-  MeshDB: MeshDBService,
+  MeshOS: MeshOSService,
   Worker: WorkerService,
   workflow: WorkflowService,
 };

package/services/durable/meshos.ts

@@ -0,0 +1,366 @@
+import { nanoid } from 'nanoid';
+
+import { Durable } from '.';
+import { asyncLocalStorage } from './asyncLocalStorage';
+import { ClientService as Client } from './client';
+import { WorkflowHandleService } from './handle';
+import { Search } from './search';
+import { WorkerService as Worker } from './worker';
+import { WorkflowService } from './workflow';
+import { StreamSignaler } from '../signaler/stream';
+import {
+  FindOptions,
+  MeshOSActivityOptions,
+  MeshOSConfig,
+  MeshOSOptions,
+  MeshOSWorkerOptions,
+  WorkflowSearchOptions } from '../../types/durable';
+import { RedisOptions, RedisClass } from '../../types/redis';
+import { StringAnyType } from '../../types/serializer';
+
+/**
+ * The base class for running MeshOS workflows.
+ * Extend this class, add your Redis config, and add functions to
+ * execute as durable `hooks`, `workflows`, and `activities`.
+ */
+
+export class MeshOSService {
+
+  /**
+   * 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 = 'durable';
+
+  /**
+   * 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. Callers can specify the taskQue to when
+   * starting a job to call those workers.
+   */
+  taskQueue = 'default';
+
+  /**
+   * These methods run as durable workflows
+   */
+  workflowFunctions: Array<MeshOSOptions | string> = [];
+
+  /**
+   * These methods run as hooks (hook into a running workflow)
+   */
+  hookFunctions: Array<MeshOSOptions | string> = [];
+
+  /**
+   * These methods run as proxied activities (and are safely memoized)
+   */
+  proxyFunctions: Array<MeshOSActivityOptions | string> = [];
+
+  /**
+   * The workflow GUID. Workflows will be persisted to
+   * Redis using the pattern hmsh:<namespace>:j:<id>.
+   */
+  id: string;
+
+  /**
+   * The Redis connection options. NOTE: Redis and IORedis
+   * use different formats for their connection config.
+   */
+  redisOptions: RedisOptions = {
+    host: 'localhost',
+    port: 6379,
+    password: '',
+    db: 0,
+  };
+
+  /**
+   * The Redis connection class.
+   * 
+   * @example
+   * import Redis from 'ioredis';
+   * import * as Redis from 'redis';
+   */
+  redisClass: RedisClass;
+
+  /**
+   * Optional model declaration (custom workflow state)
+   */
+  model: StringAnyType;
+
+  /**
+   * Optional configuration for Redis FT search
+   */
+  search: WorkflowSearchOptions;
+
+  static MeshOS = WorkflowService
+
+  static async getHotMeshClient (redisClass: RedisClass, redisOptions: RedisOptions, namespace: string, taskQueue: string) {
+    const client = new Client({
+      connection: {
+        class: redisClass,
+        options: redisOptions,
+      }
+    });
+    return await client.getHotMeshClient(taskQueue, namespace);
+  }
+
+  /**
+   * mints a workflow ID, using the search prefix.
+   * NOTE: The prefix is necesary when indexing
+   *       HASHes when FT search is enabled.
+   * @returns {string}
+   */
+  static mintGuid(): string {
+    const my = new this();
+    return `${my.search?.prefix?.[0]}${nanoid()}}`;
+  }
+
+  /**
+   * Creates an FT search index
+   */
+  static async createIndex() {
+    const my = new this();
+    const hmClient = await MeshOSService.getHotMeshClient(my.redisClass, my.redisOptions, my.namespace, my.taskQueue);
+    Search.configureSearchIndex(hmClient, my.search)
+  }
+
+  /**
+   * stop the workers
+   * @returns {Promise<void>}
+   */
+  static async stopWorkers(): Promise<void> {
+    await Durable.Client.shutdown();
+    await Durable.Worker.shutdown();
+    await StreamSignaler.stopConsuming();
+  }
+
+  /**
+   * Initializes the worker(s). This is a static
+   * method that allows for optional task Queue targeting.
+   * An `allowList` may be optionally provided to start
+   * specific `worker` and `hook` methods. 
+   * @param {MeshOSWorkerOptions} [options]
+   */
+  static async startWorkers(options?: MeshOSWorkerOptions) {
+    const taskQueue = options && options.taskQueue;
+    const allowList = options && options.allowList || [];
+    const my = new this();
+
+    //helper functions
+    const resolveFunctionNames = (arr: any[]) => arr.map(item => typeof item === 'string' ? item : item.name);
+    const belongsTo = (name: string, target: Array<MeshOSOptions | MeshOSActivityOptions | string>): boolean => {
+      const isWorkflow = target.find((item: MeshOSOptions | string) => {
+        return typeof item === 'string' ? item === name : item.name === name;
+      });
+      return isWorkflow !== undefined;
+    };
+
+    // proxy registered activities
+    const proxyFunctionNames = resolveFunctionNames([...my.proxyFunctions]);
+    if (proxyFunctionNames.length) {
+      const proxyActivities = proxyFunctionNames.reduce((acc, funcName) => {
+        let originalMethod = my[funcName];
+        if (typeof originalMethod === 'function') {
+          acc[funcName] = async (...args: any[]) => {
+            return await originalMethod.apply(my, args);
+          }
+        }
+        return acc;
+      }, {});
+      const proxiedActivities = Durable.workflow.proxyActivities({
+        activities: proxyActivities
+      });
+      Object.assign(my, proxiedActivities);
+    }
+
+    const functionsToIterate = allowList.length ? resolveFunctionNames(allowList) : resolveFunctionNames([...my.workflowFunctions, ...my.hookFunctions]);
+
+    // Iterating through the functions sequentially
+    for (const funcName of functionsToIterate) {
+      const originalMethod = my[funcName];
+      if (typeof originalMethod === 'function') {
+
+        //wrap the function to return
+        const wrappedFunction = {
+          [funcName]: async (...args: any[]) => {
+            const store = asyncLocalStorage.getStore();
+            const workflowId = store.get('workflowId');
+
+            //use a Proxy to wrap hook methods
+            const context = new Proxy(my, {
+              get: (target, prop, receiver) => {
+                if (prop === 'id') {
+                  return workflowId;
+                } else if (typeof target[prop] === 'function') {
+                  return (...args: any[]) => {
+                    return new Promise(async (resolve, reject) => {
+                      if (belongsTo(prop as string, my.hookFunctions)) {
+                        return WorkflowService.hook({
+                          namespace: my.namespace,
+                          taskQueue: my.taskQueue,
+                          workflowName: prop as string,
+                          workflowId,
+                          args,
+                        }).then(resolve).catch(reject);
+                      }
+                      //otherwise, call the method as a standard instance method.
+                      target[prop].apply(this, args).then(resolve).catch(reject);
+                    });
+                  }
+                }
+                return Reflect.get(target, prop, receiver);
+              },
+            });
+            return await originalMethod.apply(context, args);
+          }
+        };
+
+        //start the worker
+        await Worker.create({
+          namespace: my.namespace,
+          connection: {
+            class: my.redisClass,
+            options: my.redisOptions,
+          },
+          taskQueue: taskQueue ?? my.taskQueue,
+          workflow: wrappedFunction,
+        });
+      }
+    }
+  }
+
+  /**
+   * executes the redis FT search query
+   * @example '@_quantity:[89 89]'
+   * @param {any[]} args
+   * @returns {string}
+   */
+  static async find(options: FindOptions, ...args: string[]): Promise<string[] | [number]> {
+    const my = new this();
+    const client = new Client({ connection: {
+      class: my.redisClass,
+      options: my.redisOptions 
+    }});
+    //workflow name is the function name driving the workflow
+    let workflowName: string;
+    if (options?.workflowName) {
+      workflowName = options?.workflowName
+    } else if(my.workflowFunctions?.length) {
+      let target = my.workflowFunctions[0];
+      if (typeof target === 'string') {
+        workflowName = target;
+      } else {
+        workflowName = target.name;
+      }
+    }
+    return await client.workflow.search(
+      options?.taskQueue ?? my.taskQueue,
+      workflowName,
+      my.namespace,
+      my.search.index,
+      ...args,
+    ); //[count, [id, fields[], id, fields[], id, fields[], ...]]
+  }
+
+  /**
+   * returns the workflow handle. The handle can then be
+   * used to query for status, state, custom state, etc.
+   * @param {string} id 
+   * @returns {Promise<WorkflowHandleService>}
+   */
+  static async get(id: string): Promise<WorkflowHandleService> {
+    const my = new this();
+    const client = new Client({ connection: {
+      class: my.redisClass,
+      options: my.redisOptions 
+    }});
+    let workflowName: string;
+    let target = my.workflowFunctions[0];
+    if (typeof target === 'string') {
+      workflowName = target;
+    } else {
+      workflowName = target.name;
+    }
+    return await client.workflow.getHandle(
+      my.taskQueue,
+      workflowName,
+      id,
+      my.namespace,
+    );
+  }
+
+  /**
+   * Optionally include a target taskQueue to exec the
+   * workflow's call on a specific worker queue.
+   */
+  constructor(id?: string | MeshOSConfig, options?: MeshOSConfig) {
+    if (typeof(id) === 'string') {
+      this.id = id;
+    } else if (id?.id) {
+      this.id = id.id;
+      options = id;
+      id = undefined;
+    };
+    if (options?.taskQueue) {
+      this.taskQueue = options.taskQueue;
+    } else if (!id && !options?.taskQueue) {
+      return this;
+    }
+
+    function belongsTo(name: string, target: Array<MeshOSOptions | MeshOSActivityOptions | string>): boolean {
+      const isWorkflow = target.find((item: MeshOSOptions | string) => {
+        return typeof item === 'string' ? item === name : item.name === name;
+      });
+      return isWorkflow !== undefined;
+    }
+
+    return new Proxy(this, {
+      get: (target, prop, receiver) => {
+        if (typeof target[prop] === 'function') {
+          return (...args: any[]) => {
+            return new Promise(async (resolve, reject) => {
+              const client = new Client({ connection: {
+                class: this.redisClass,
+                options: this.redisOptions 
+              }});
+              if (belongsTo(prop as string, this.workflowFunctions)) {
+                //start a new workflow
+                const handle = await client.workflow.start({
+                  namespace: this.namespace,
+                  args,
+                  taskQueue: this.taskQueue,
+                  workflowName: prop as string,
+                  workflowId: this.id,
+                });
+                if (options?.await) {
+                  //wait for the workflow to complete
+                  const result = await handle.result();
+                  return resolve(result);
+                } else {
+                  //return the workflow handle
+                  return resolve(handle);
+                }
+              } else if (belongsTo(prop as string, this.hookFunctions)) {
+                //hook into a running workflow
+                return client.workflow.hook({
+                  namespace: this.namespace,
+                  taskQueue: this.taskQueue,
+                  workflowName: prop as string,
+                  workflowId: this.id,
+                  args,
+                }).then(resolve).catch(reject);
+              }
+              //otherwise, call the method as a standard instance method.
+              target[prop].apply(this, args).then(resolve).catch(reject);
+            });
+          };
+        }
+        return Reflect.get(target, prop, receiver);
+      },
+    });
+  }
+}

package/services/durable/search.ts

@@ -44,7 +44,6 @@ export class Search {
         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 });
       }
     }

package/services/durable/worker.ts

@@ -72,13 +72,15 @@ export class WorkerService {
       Object.keys(activities).forEach(key => {
         if (activities[key].name && typeof WorkerService.activityRegistry[activities[key].name] !== 'function') {
           WorkerService.activityRegistry[activities[key].name] = (activities as any)[key] as Function;
+        } else if (typeof (activities as any)[key] === 'function') {
+          WorkerService.activityRegistry[key] = (activities as any)[key] as Function;
         }
       });
     }
     return WorkerService.activityRegistry;
   }
 
-  static async create(config: WorkerConfig) {
+  static async create(config: WorkerConfig): Promise<WorkerService> {
     WorkerService.connection = config.connection;
     const workflow = config.workflow;
     const [workflowFunctionName, workflowFunction] = WorkerService.resolveWorkflowTarget(workflow);
@@ -95,16 +97,17 @@ export class WorkerService {
     return worker;
   }
 
-  static resolveWorkflowTarget(workflow: object | Function): [string, Function] {
+  static resolveWorkflowTarget(workflow: object | Function, name?: string): [string, Function] {
     let workflowFunction: Function;
     if (typeof workflow === 'function') {
       workflowFunction = workflow;
+      return [workflowFunction.name ?? name, workflowFunction];
     } else {
       const workflowFunctionNames = Object.keys(workflow);
-      workflowFunction = workflow[workflowFunctionNames[workflowFunctionNames.length - 1]];
-      return WorkerService.resolveWorkflowTarget(workflowFunction);
+      const lastFunctionName = workflowFunctionNames[workflowFunctionNames.length - 1];
+      workflowFunction = workflow[lastFunctionName];
+      return WorkerService.resolveWorkflowTarget(workflowFunction, lastFunctionName);
     }
-    return [workflowFunction.name, workflowFunction];
   }
 
   async run() {

package/services/durable/workflow.ts

@@ -37,7 +37,7 @@ export class WorkflowService {
     //this is risky but MUST be allowed. Users MAY set the workflowId,
     //but if there is a naming collision, the data from the target entity will be used
     //as there is know way of knowing if the item was generated via a prior run of the workflow
-    const childJobId = options.workflowId ?? `${workflowId}-$${options.workflowName}${workflowDimension}-${execIndex}`;
+    const childJobId = options.workflowId ?? `-${workflowId}-$${options.workflowName}${workflowDimension}-${execIndex}`;
     const parentWorkflowId = `${workflowId}-f`;
 
     const client = new Client({
@@ -80,7 +80,7 @@ export class WorkflowService {
     const workflowSpan = store.get('workflowSpan');
     const COUNTER = store.get('counter');
     const execIndex = COUNTER.counter = COUNTER.counter + 1;
-    const childJobId = options.workflowId ?? `${workflowId}-$${options.workflowName}${workflowDimension}-${execIndex}`;
+    const childJobId = options.workflowId ?? `-${workflowId}-$${options.workflowName}${workflowDimension}-${execIndex}`;
     const parentWorkflowId = `${workflowId}-f`;
     const workflowTopic = `${options.taskQueue}-${options.workflowName}`;
 
@@ -111,7 +111,7 @@ export class WorkflowService {
    */
   static proxyActivities<ACT>(options?: ActivityConfig): ProxyType<ACT> {
     if (options.activities) {
-      WorkerService.registerActivities(options.activities)
+      WorkerService.registerActivities(options.activities);
     }
 
     const proxy: any = {};
@@ -142,6 +142,16 @@ export class WorkflowService {
     return new Search(workflowId, hotMeshClient, searchSessionId);
   }
 
+  /**
+   * return a handle to the hotmesh client currently running the workflow
+   */
+  static async getHotMesh(): Promise<HotMesh> {
+    const store = asyncLocalStorage.getStore();
+    const workflowTopic = store.get('workflowTopic');
+    const namespace = store.get('namespace');
+    return await WorkerService.getHotMesh(workflowTopic, { namespace });
+  }
+
   /**
    * those methods that may only be called once must be protected by flagging
    * their execution with a unique key (the key is stored in the HASH alongside
@@ -169,8 +179,11 @@ export class WorkflowService {
    */
   static async signal(signalId: string, data: Record<any, any>): Promise<string> {
     const store = asyncLocalStorage.getStore();
+    const workflowTopic = store.get('workflowTopic');
     const namespace = store.get('namespace');
-    const hotMeshClient = await WorkerService.getHotMesh(`${namespace}.wfs.signal`, { namespace });
+    const hotMeshClient = await WorkerService.getHotMesh(workflowTopic, { namespace });
+    //todo: this particular one is better patterned as a get/set,
+    //since the receipt is a meaningful string (the stream id)
     if (await WorkflowService.isSideEffectAllowed(hotMeshClient, 'signal')) {
       return await hotMeshClient.hook(`${namespace}.wfs.signal`, { id: signalId, data });
     }
@@ -183,8 +196,9 @@ export class WorkflowService {
    */
   static async hook(options: HookOptions): Promise<string> {
     const store = asyncLocalStorage.getStore();
+    const workflowTopic = store.get('workflowTopic');
     const namespace = store.get('namespace');
-    const hotMeshClient = await WorkerService.getHotMesh(`${namespace}.flow.signal`, { namespace });
+    const hotMeshClient = await WorkerService.getHotMesh(workflowTopic, { namespace });
     if (await WorkflowService.isSideEffectAllowed(hotMeshClient, 'hook')) {
       const store = asyncLocalStorage.getStore();
       const workflowId = options.workflowId ?? store.get('workflowId');
@@ -212,7 +226,7 @@ export class WorkflowService {
     const workflowTopic = store.get('workflowTopic');
     const workflowDimension = store.get('workflowDimension') ?? '';
     const namespace = store.get('namespace');
-    const sleepJobId = `${workflowId}-$sleep${workflowDimension}-${execIndex}`;
+    const sleepJobId = `-${workflowId}-$sleep${workflowDimension}-${execIndex}`;
 
     try {
       const hotMeshClient = await WorkerService.getHotMesh(workflowTopic, { namespace });
@@ -220,9 +234,8 @@ export class WorkflowService {
       //if no error is thrown, we've already slept, return the delay
       return seconds;
     } catch (e) {
-      //if an error, the sleep job was not found...rethrow error; sleep job
-      // will be automatically created according to the DAG rules (they
       // spawn a new sleep job if error code 595 is thrown by the worker)
+      // NOTE: If this message shows up in your stack trace, you forgot to await `Durable.workflow.sleep()` in your workflow code.
       throw new DurableSleepError(workflowId, seconds, execIndex, workflowDimension);
     }
   }
@@ -242,7 +255,7 @@ export class WorkflowService {
     const signalResults: any[] = [];
     for (const signal of signals) {
       const execIndex = COUNTER.counter = COUNTER.counter + 1;
-      const wfsJobId = `${workflowId}-$wfs${workflowDimension}-${execIndex}`;
+      const wfsJobId = `-${workflowId}-$wfs${workflowDimension}-${execIndex}`;
       try {
         if (allAreComplete) {
           const state = await hotMeshClient.getState(`${hotMeshClient.appId}.wfs.execute`, wfsJobId);
@@ -289,7 +302,7 @@ export class WorkflowService {
       const spn = store.get('workflowSpan');
       const namespace = store.get('namespace');
       const activityTopic = `${workflowTopic}-activity`;
-      const activityJobId = `${workflowId}-$${activityName}${workflowDimension}-${execIndex}`;
+      const activityJobId = `-${workflowId}-$${activityName}${workflowDimension}-${execIndex}`;
 
       let activityState: JobOutput
       try {

package/services/signaler/stream.ts

@@ -61,7 +61,7 @@ class StreamSignaler {
     try {
       await this.store.xgroup('CREATE', stream, group, '$', 'MKSTREAM');
     } catch (err) {
-      this.logger.info('consumer-group-exists', { stream, group });
+      this.logger.debug('consumer-group-exists', { stream, group });
     }
   }
 
@@ -150,7 +150,6 @@ class StreamSignaler {
     try {
       output = await callback(input);
     } catch (error) {
-      console.error(error);
       this.logger.error(`stream-call-function-error`, { error });
       output = this.structureUnhandledError(input, error);
     }

package/services/store/clients/ioredis.ts

@@ -5,7 +5,6 @@ import { Cache } from '../cache';
 import { StoreService } from '../index';
 import { RedisClientType, RedisMultiType } from '../../../types/ioredisclient';
 import { ReclaimedMessageType } from '../../../types/stream';
-import { type } from 'os';
 
 class IORedisStoreService extends StoreService<RedisClientType, RedisMultiType> {
   redisClient: RedisClientType;
@@ -60,14 +59,14 @@ class IORedisStoreService extends StoreService<RedisClientType, RedisMultiType>
       try {
         return (await this.redisClient.xgroup(command, key, groupName, id, mkStream)) === 'OK';
       } catch (err) {
-        this.logger.info(`Consumer group not created with MKSTREAM for key: ${key} and group: ${groupName}`);
+        this.logger.debug(`Consumer group not created with MKSTREAM for key: ${key} and group: ${groupName}`);
         throw err;
       }
     } else {
       try {
         return (await this.redisClient.xgroup(command, key, groupName, id)) === 'OK';
       } catch (err) {
-        this.logger.info(`Consumer group not created for key: ${key} and group: ${groupName}`);
+        this.logger.debug(`Consumer group not created for key: ${key} and group: ${groupName}`);
         throw err;
       }
     }

package/services/store/clients/redis.ts

@@ -46,8 +46,7 @@ class RedisStoreService extends StoreService<RedisClientType, RedisMultiType> {
   }
 
   getMulti(): RedisMultiType {
-    const multi = this.redisClient.MULTI();
-    return multi as unknown as RedisMultiType;
+    return this.redisClient.multi() as unknown as RedisMultiType;
   }
 
   async exec(...args: any[]): Promise<string|string[]|string[][]> {
@@ -86,7 +85,7 @@ class RedisStoreService extends StoreService<RedisClientType, RedisMultiType> {
       return (await this.redisClient.sendCommand(['XGROUP', 'CREATE', key, groupName, id, ...args])) === 1;
     } catch (error) {
       const streamType = mkStream === 'MKSTREAM' ? 'with MKSTREAM' : 'without MKSTREAM';
-      this.logger.info(`x-group-error ${streamType} for key: ${key} and group: ${groupName}`, { error });
+      this.logger.debug(`x-group-error ${streamType} for key: ${key} and group: ${groupName}`, { error });
       throw error;
     }
   }

package/services/stream/clients/redis.ts

@@ -21,7 +21,7 @@ class RedisStreamService extends StreamService<RedisClientType, RedisMultiType>
   }
 
   getMulti(): RedisMultiType {
-    return this.redisClient.MULTI() as unknown as RedisMultiType;
+    return this.redisClient.multi() as unknown as RedisMultiType;
   }
 
   mintKey(type: KeyType, params: KeyStoreParams): string {

package/services/sub/clients/redis.ts

@@ -21,7 +21,7 @@ class RedisSubService extends SubService<RedisClientType, RedisMultiType> {
   }
 
   getMulti(): RedisMultiType {
-    const multi = this.redisClient.MULTI();
+    const multi = this.redisClient.multi();
     return multi as unknown as RedisMultiType;
   }