@hotmeshio/hotmesh 0.0.55 → 0.0.56

package/services/durable/search.ts

@@ -1,196 +0,0 @@
-import { HotMeshService as HotMesh } from '../hotmesh'
-import { RedisClient, RedisMulti } from '../../types/redis';
-import { StoreService } from '../store';
-import { KeyService, KeyType } from '../../modules/key';
-import { WorkflowSearchOptions } from '../../types/durable';
-import { asyncLocalStorage } from '../../modules/storage';
-
-export class Search {
-  jobId: string;
-  searchSessionId: string;
-  searchSessionIndex: number = 0;
-  hotMeshClient: HotMesh;
-  store: StoreService<RedisClient, RedisMulti> | null;
-
-  constructor(workflowId: string, hotMeshClient: HotMesh, searchSessionId: string) {
-    const keyParams = {
-      appId: hotMeshClient.appId,
-      jobId: workflowId
-    }
-    this.jobId = KeyService.mintKey(hotMeshClient.namespace, KeyType.JOB_STATE, keyParams);
-    this.searchSessionId = searchSessionId;
-    this.hotMeshClient = hotMeshClient;
-    this.store = hotMeshClient.engine.store as StoreService<RedisClient, RedisMulti>;
-  }
-
-  safeKey(key:string): string {
-    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: HotMesh, search?: WorkflowSearchOptions): Promise<void> {
-    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)
-        schema.push(`_${key}`);
-        schema.push(value.type);
-        if (value.sortable) {
-          schema.push('SORTABLE');
-        }
-      }
-      try {
-        const keyParams = {
-          appId: hotMeshClient.appId,
-          jobId: ''
-        }
-        const hotMeshPrefix = KeyService.mintKey(hotMeshClient.namespace, 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 (error) {
-        hotMeshClient.engine.logger.info('durable-client-search-err', { ...error });
-      }
-    }
-  }
-
-  /**
-   * For those deployments with a redis stack backend (with the FT module),
-   * this method will list all search indexes.
-   * @param {HotMesh} hotMeshClient - the hotmesh client
-   * @returns {Promise<string[]>} - the list of search indexes
-   */
-  static async listSearchIndexes(hotMeshClient: HotMesh): Promise<string[]> {
-    try {
-      const store = hotMeshClient.engine.store;
-      const searchIndexes = await store.exec('FT._LIST');
-      return searchIndexes as string[];
-    } catch (error) {
-      hotMeshClient.engine.logger.info('durable-client-search-list-err', { ...error });
-      return [];
-    }
-  }
-
-  /**
-   * increments the index to return a unique search session guid when
-   * calling any method that produces side effects (changes the value)
-   */
-  getSearchSessionGuid(): string {
-    //return the search session as it would exist in the search session index
-    return `${this.searchSessionId}-${this.searchSessionIndex++}-`;
-  }
-
-  /**
-   * Sets the fields listed in args. Returns the
-   * count of new fields that were set (does not
-   * count fields that were updated)
-   */
-  async set(...args: string[]): Promise<number> {
-    const ssGuid = this.getSearchSessionGuid();
-    const store = asyncLocalStorage.getStore();
-    const replay = store?.get('replay') ?? {};
-    if (ssGuid in replay) {
-      return Number(replay[ssGuid]);
-    }
-    const safeArgs: string[] = [];
-    for (let i = 0; i < args.length; i += 2) {
-      const key = this.safeKey(args[i]);
-      const value = args[i+1].toString();
-      safeArgs.push(key, value);
-    }
-    const fieldCount = await this.store.exec('HSET', this.jobId, ...safeArgs);
-    //no need to wait; set this interim value in the replay
-    this.store.exec('HSET', this.jobId, ssGuid, fieldCount.toString());
-    return Number(fieldCount);
-  }
-
-  async get(key: string): Promise<string> {
-    try {
-      return await this.store.exec('HGET',this.jobId, this.safeKey(key)) as string;
-    } catch (error) {
-      this.hotMeshClient.logger.error('durable-search-get-error', { ...error });
-      return '';
-    }
-  }
-
-  async mget(...args: string[]): Promise<string[]> {
-    const safeArgs: string[] = [];
-    for (let i = 0; i < args.length; i++) {
-      safeArgs.push(this.safeKey(args[i]));
-    }
-    try {
-      return await this.store.exec('HMGET', this.jobId, ...safeArgs) as string[];
-    } catch (error) {
-      this.hotMeshClient.logger.error('durable-search-mget-error', { ...error });
-      return [];
-    }
-  }
-
-  /**
-   * Deletes the fields listed in args. Returns the
-   * count of fields that were deleted.
-   */
-  async del(...args: string[]): Promise<number | void> {
-    const ssGuid = this.getSearchSessionGuid();
-    const store = asyncLocalStorage.getStore();
-    const replay = store?.get('replay') ?? {};
-    if (ssGuid in replay) {
-      return Number(replay[ssGuid]);
-    }
-    const safeArgs: string[] = [];
-    for (let i = 0; i < args.length; i++) {
-      safeArgs.push(this.safeKey(args[i]));
-    }
-    const response = await this.store.exec('HDEL', this.jobId, ...safeArgs);
-    const formattedResponse = isNaN(response as unknown as number) ? 0 : Number(response);
-    //no need to wait; set this interim value in the replay
-    this.store.exec('HSET', this.jobId, ssGuid, formattedResponse.toString());
-    return formattedResponse;
-  }
-
-  /**
-   * Increments the value of a field by the given amount. Returns the
-   * new value of the field after the increment. Can be
-   * used to decrement the value of a field by specifying a negative.
-   */
-  async incr(key: string, val: number): Promise<number> {
-    const ssGuid = this.getSearchSessionGuid();
-    const store = asyncLocalStorage.getStore();
-    const replay = store?.get('replay') ?? {};
-    if (ssGuid in replay) {
-      return Number(replay[ssGuid]);
-    }
-    const num = await this.store.exec('HINCRBYFLOAT', this.jobId, this.safeKey(key), val.toString()) as string;
-    //no need to wait; set this interim value in the replay
-    this.store.exec('HSET', this.jobId, ssGuid, num.toString());
-    return Number(num);
-  }
-
-  /**
-   * Multiplies the value of a field by the given amount. Returns the
-   * new value of the field after the multiplication. NOTE:
-   * this is exponential multiplication.
-   */
-  async mult(key: string, val: number): Promise<number> {
-    const ssGuid = this.getSearchSessionGuid();
-    const store = asyncLocalStorage.getStore();
-    const replay = store?.get('replay') ?? {};
-    if (ssGuid in replay) {
-      return Math.exp(Number(replay[ssGuid]));
-    }
-    const ssGuidValue = Number(await this.store.exec('HINCRBYFLOAT', this.jobId, ssGuid, '1') as string);
-    if (ssGuidValue === 1) {
-      const log = Math.log(val);
-      const logTotal = await this.store.exec('HINCRBYFLOAT', this.jobId, this.safeKey(key), log.toString()) as string;
-      //no need to wait; set this interim value in the replay
-      this.store.exec('HSET', this.jobId, ssGuid, logTotal.toString());
-      return Math.exp(Number(logTotal));
-    }
-  }
-}

package/services/durable/worker.ts

@@ -1,401 +0,0 @@
-import ms from 'ms';
-import {
-  HMSH_CODE_DURABLE_ALL,
-  HMSH_CODE_DURABLE_RETRYABLE,
-  HMSH_DURABLE_EXP_BACKOFF,
-  HMSH_DURABLE_MAX_INTERVAL,
-  HMSH_DURABLE_MAX_ATTEMPTS,
-  HMSH_LOGLEVEL } from '../../modules/enums';
-import {
-  DurableChildError,
-  DurableFatalError,
-  DurableMaxedError,
-  DurableProxyError,
-  DurableRetryError,
-  DurableSleepError,
-  DurableTimeoutError, 
-  DurableWaitForError } from '../../modules/errors';
-import { asyncLocalStorage } from '../../modules/storage';
-import { APP_ID, APP_VERSION, getWorkflowYAML } from './schemas/factory';
-import { HotMeshService as HotMesh } from '../hotmesh';
-import {
-  ActivityWorkflowDataType,
-  Connection,
-  Registry,
-  WorkerConfig,
-  WorkerOptions,
-  WorkflowDataType } from '../../types/durable';
-import { RedisClass, RedisOptions } from '../../types/redis';
-import { Search } from './search';
-import {
-  StreamData,
-  StreamDataResponse,
-  StreamStatus } from '../../types/stream';
-import { formatISODate } from '../../modules/utils';
-
-export class WorkerService {
-  static activityRegistry: Registry = {}; //user's activities
-  static connection: Connection;
-  static instances = new Map<string, HotMesh | Promise<HotMesh>>();
-  workflowRunner: HotMesh;
-  activityRunner: HotMesh;
-
-  static getHotMesh = async (workflowTopic: string, config?: Partial<WorkerConfig>, options?: WorkerOptions) => {
-    if (WorkerService.instances.has(workflowTopic)) {
-      return await WorkerService.instances.get(workflowTopic);
-    }
-    const hotMeshClient = HotMesh.init({
-      logLevel: options?.logLevel ?? HMSH_LOGLEVEL,
-      appId: config.namespace ?? APP_ID,
-      engine: { redis: { ...WorkerService.connection } }
-    });
-    WorkerService.instances.set(workflowTopic, hotMeshClient);
-    await WorkerService.activateWorkflow(await hotMeshClient);
-    return hotMeshClient;
-  }
-
-  static async activateWorkflow(hotMesh: HotMesh) {
-    const app = await hotMesh.engine.store.getApp(hotMesh.engine.appId);
-    const appVersion = app?.version;
-    if(!appVersion) {
-      try {
-        await hotMesh.deploy(getWorkflowYAML(hotMesh.engine.appId, APP_VERSION));
-        await hotMesh.activate(APP_VERSION);
-      } catch (err) {
-        hotMesh.engine.logger.error('durable-worker-deploy-activate-err', err);
-        throw err;
-      }
-    } else if(app && !app.active) {
-      try {
-        await hotMesh.activate(APP_VERSION);
-      } catch (err) {
-        hotMesh.engine.logger.error('durable-worker-activate-err', err);
-        throw err;
-      }
-    }
-  }
-
-  static registerActivities<ACT>(activities: ACT): Registry  {
-    if (typeof activities === 'function' && typeof WorkerService.activityRegistry[activities.name] !== 'function') {
-      WorkerService.activityRegistry[activities.name] = activities as Function;
-    } else {
-      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): Promise<WorkerService> {
-    WorkerService.connection = config.connection;
-    const workflow = config.workflow;
-    const [workflowFunctionName, workflowFunction] = WorkerService.resolveWorkflowTarget(workflow);
-    const baseTopic = `${config.taskQueue}-${workflowFunctionName}`;
-    const activityTopic = `${baseTopic}-activity`;
-    const workflowTopic = `${baseTopic}`;
-
-    //initialize supporting workflows
-    const worker = new WorkerService();
-    worker.activityRunner = await worker.initActivityWorker(config, activityTopic);
-    worker.workflowRunner = await worker.initWorkflowWorker(config, workflowTopic, workflowFunction);
-    Search.configureSearchIndex(worker.workflowRunner, config.search);
-    await WorkerService.activateWorkflow(worker.workflowRunner);
-    return worker;
-  }
-
-  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);
-      const lastFunctionName = workflowFunctionNames[workflowFunctionNames.length - 1];
-      workflowFunction = workflow[lastFunctionName];
-      return WorkerService.resolveWorkflowTarget(workflowFunction, lastFunctionName);
-    }
-  }
-
-  async run() {
-    this.workflowRunner.engine.logger.info('WorkerService is running');
-  }
-
-  async initActivityWorker(config: WorkerConfig, activityTopic: string): Promise<HotMesh> {
-    const redisConfig = {
-      class: config.connection.class as RedisClass,
-      options: config.connection.options as RedisOptions
-    };
-    const hotMeshWorker = await HotMesh.init({
-      logLevel: config.options?.logLevel ?? HMSH_LOGLEVEL,
-      appId: config.namespace ?? APP_ID,
-      engine: { redis: redisConfig },
-      workers: [
-        { topic: activityTopic,
-          redis: redisConfig,
-          callback: this.wrapActivityFunctions().bind(this)
-        }
-      ]
-    });
-    WorkerService.instances.set(activityTopic, hotMeshWorker);
-    return hotMeshWorker;
-  }
-
-  //this is the linked worker function in the reentrant workflow test
-  wrapActivityFunctions(): Function {
-    return async (data: StreamData): Promise<StreamDataResponse> => {
-      try {
-        //always run the activity function when instructed; return the response
-        const activityInput = data.data as unknown as ActivityWorkflowDataType;
-        const activityName = activityInput.activityName;
-        const activityFunction = WorkerService.activityRegistry[activityName];
-        const pojoResponse = await activityFunction.apply(this, activityInput.arguments);
-
-        return {
-          status: StreamStatus.SUCCESS,
-          metadata: { ...data.metadata },
-          data: { response: pojoResponse }
-        };
-      } catch (err) {
-        this.activityRunner.engine.logger.error('durable-worker-activity-err', { name: err.name, message: err.message, stack: err.stack });
-        if (!(err instanceof DurableTimeoutError) &&
-          !(err instanceof DurableMaxedError) &&
-          !(err instanceof DurableFatalError)) {
-
-            //use code 599 as a proxy for all retryable errors
-            // (basically anything not 596, 597, 598)
-            return {
-              status: StreamStatus.SUCCESS,
-              code: HMSH_CODE_DURABLE_RETRYABLE,
-              metadata: { ...data.metadata },
-              data: {
-                $error: {
-                  message: err.message,
-                  stack: err.stack,
-                  timestamp: formatISODate(new Date()),
-                }
-              },
-            } as StreamDataResponse;
-        }
-
-        return {
-          //always returrn success (the Durable module is just fine);
-          //  it's the user's function that has failed
-          status: StreamStatus.SUCCESS,
-          code: err.code,
-          stack: err.stack,
-          metadata: { ...data.metadata },
-          data: {
-            $error: {
-              message: err.message,
-              stack: err.stack,
-              timestamp: formatISODate(new Date()),
-              code: err.code,
-            }
-          },
-        } as StreamDataResponse;
-      }
-    }
-  }
-
-  async initWorkflowWorker(config: WorkerConfig, workflowTopic: string, workflowFunction: Function): Promise<HotMesh> {
-    const redisConfig = {
-      class: config.connection.class as RedisClass,
-      options: config.connection.options as RedisOptions
-    };
-    const hotMeshWorker = await HotMesh.init({
-      logLevel: config.options?.logLevel ?? HMSH_LOGLEVEL,
-      appId: config.namespace ?? APP_ID,
-      engine: { redis: redisConfig },
-      workers: [{
-        topic: workflowTopic,
-        redis: redisConfig,
-        callback: this.wrapWorkflowFunction(workflowFunction, workflowTopic, config).bind(this)
-      }]
-    });
-    WorkerService.instances.set(workflowTopic, hotMeshWorker);
-    return hotMeshWorker;
-  }
-
-  static Context = {
-    info: () => {
-      return {
-        workflowId: '',
-        workflowTopic: '',
-      }
-    },
-  };
-
-  wrapWorkflowFunction(workflowFunction: Function, workflowTopic: string, config: WorkerConfig): Function {
-    return async (data: StreamData): Promise<StreamDataResponse> => {
-      const counter = { counter: 0 };
-      const interruptionRegistry: any[] = [];
-      try {
-        //incoming data payload has arguments and workflowId
-        const workflowInput = data.data as unknown as WorkflowDataType;
-        const context = new Map();
-        context.set('canRetry', workflowInput.canRetry);
-        context.set('counter', counter);
-        context.set('interruptionRegistry', interruptionRegistry);
-        context.set('namespace', config.namespace ?? APP_ID);
-        context.set('raw', data);
-        context.set('workflowId', workflowInput.workflowId);
-        if (workflowInput.originJobId) {
-          //if present there is an origin job to which this job is subordinated; 
-          // garbage collect (expire) this job when originJobId is expired
-          context.set('originJobId', workflowInput.originJobId);
-        }
-        let replayQuery = '';
-        if (workflowInput.workflowDimension) {
-          //every hook function runs in an isolated dimension controlled
-          //by the index assigned when the signal was received; even if the
-          //hook function re-runs, its scope will always remain constant
-          context.set('workflowDimension', workflowInput.workflowDimension);
-          replayQuery = `-*${workflowInput.workflowDimension}-*`;
-        } else {
-          //last letter of words like 'hook', 'sleep', 'wait', 'signal', 'search', 'start', 'proxy', 'child', 'collator'
-          replayQuery = '-*[ehklptydr]-*';
-        }
-        context.set('workflowTopic', workflowTopic);
-        context.set('workflowName', workflowTopic.split('-').pop());
-        context.set('workflowTrace', data.metadata.trc);
-        context.set('workflowSpan', data.metadata.spn);
-        const store = this.workflowRunner.engine.store;
-        const [cursor, replay] = await store.findJobFields(
-          workflowInput.workflowId,
-          replayQuery,
-          50_000,
-          5_000,);
-        context.set('replay', replay);
-        context.set('cursor', cursor); // if != 0, more remain
-        const workflowResponse = await asyncLocalStorage.run(context, async () => {
-          return await workflowFunction.apply(this, workflowInput.arguments);
-        });
-
-        return {
-          code: 200,
-          status: StreamStatus.SUCCESS,
-          metadata: { ...data.metadata },
-          data: { response: workflowResponse, done: true }
-        };
-      } catch (err) {
-        if (err instanceof DurableWaitForError || interruptionRegistry.length > 1) {
-
-          //NOTE: this type is spawned when `Promise.all` is used OR if the interruption is a `waitFor`
-          const workflowInput = data.data as unknown as WorkflowDataType;
-          const execIndex = counter.counter - interruptionRegistry.length + 1;
-          const { workflowId, workflowTopic, workflowDimension, originJobId } = workflowInput;
-          const collatorFlowId = `-${workflowId}-$${workflowDimension || ''}-$${execIndex}`;
-          return {
-            status: StreamStatus.SUCCESS,
-            code: HMSH_CODE_DURABLE_ALL,
-            metadata: { ...data.metadata },
-            data: {
-              code: HMSH_CODE_DURABLE_ALL,
-              items: [...interruptionRegistry],
-              size: interruptionRegistry.length,
-              workflowDimension: workflowDimension || '',
-              index: execIndex,
-              originJobId: originJobId || workflowId,
-              parentWorkflowId: workflowId,
-              workflowId: collatorFlowId,
-              workflowTopic: workflowTopic,
-            },
-          } as StreamDataResponse;
-
-        } else if (err instanceof DurableSleepError) {
-          //return the sleep interruption
-          return {
-            status: StreamStatus.SUCCESS,
-            code: err.code,
-            metadata: { ...data.metadata },
-            data: {
-              code: err.code,
-              message: JSON.stringify({ duration: err.duration, index: err.index, workflowDimension: err.workflowDimension }),
-              duration: err.duration,
-              index: err.index,
-              workflowDimension: err.workflowDimension,  
-            }
-          } as StreamDataResponse;
-
-        } else if (err instanceof DurableProxyError) {
-          //return the proxyActivity interruption
-          return {
-            status: StreamStatus.SUCCESS,
-            code: err.code,
-            metadata: { ...data.metadata },
-            data: {
-              code: err.code,
-              message: JSON.stringify({ message: err.message, workflowId: err.workflowId, activityName: err.activityName, dimension: err.workflowDimension }),
-              arguments: err.arguments,
-              workflowDimension: err.workflowDimension,
-              index: err.index,
-              originJobId: err.originJobId,
-              parentWorkflowId: err.parentWorkflowId,
-              workflowId: err.workflowId,
-              workflowTopic: err.workflowTopic,
-              activityName: err.activityName,
-              backoffCoefficient: err.backoffCoefficient,
-              maximumAttempts: err.maximumAttempts,
-              maximumInterval: err.maximumInterval,
-            }
-          } as StreamDataResponse;
-
-        } else if (err instanceof DurableChildError) {
-          //return the child interruption
-          const msg = {
-            message: err.message,
-            workflowId: err.workflowId,
-            dimension: err.workflowDimension
-          };
-          return {
-            status: StreamStatus.SUCCESS,
-            code: err.code,
-            metadata: { ...data.metadata },
-            data: {
-              arguments: err.arguments,
-              await: err.await,
-              backoffCoefficient: err.backoffCoefficient || HMSH_DURABLE_EXP_BACKOFF ,
-              code: err.code,
-              index: err.index,
-              message: JSON.stringify(msg),
-              maximumAttempts: err.maximumAttempts || HMSH_DURABLE_MAX_ATTEMPTS,
-              maximumInterval: err.maximumInterval || ms(HMSH_DURABLE_MAX_INTERVAL) / 1000,
-              originJobId: err.originJobId,
-              parentWorkflowId: err.parentWorkflowId,
-              workflowDimension: err.workflowDimension,
-              workflowId: err.workflowId,
-              workflowTopic: err.workflowTopic,
-            }
-          } as StreamDataResponse;
-        }
-
-        // ALL other errors are actual fatal errors (598, 597, 596)
-        //  OR will be retried (599)
-        return {
-          status: StreamStatus.SUCCESS,
-          code: err.code || new DurableRetryError(err.message).code,
-          metadata: { ...data.metadata },
-          data: {
-            $error: {
-              message: err.message,
-              type: err.name,
-              name: err.name,
-              stack: err.stack,
-              code: err.code || new DurableRetryError(err.message).code,
-            }
-          }
-        } as StreamDataResponse;
-      }
-    }
-  }
-
-  static async shutdown(): Promise<void> {
-    for (const [_, hotMeshInstance] of WorkerService.instances) {
-      (await hotMeshInstance).stop();
-    }
-  }
-}