@hotmeshio/hotmesh 0.0.54 → 0.0.56

package/services/durable/exporter.ts

@@ -1,232 +0,0 @@
-import { restoreHierarchy } from '../../modules/utils';
-import { ILogger } from '../logger';
-import { SerializerService } from '../serializer';
-import { StoreService } from '../store';
-import {
-  ExportOptions,
-  DurableJobExport, 
-  TimelineType,
-  TransitionType, 
-  ExportFields} from '../../types/exporter';
-import { RedisClient, RedisMulti } from '../../types/redis';
-import { StringAnyType, StringStringType, Symbols } from "../../types/serializer";
-
-class ExporterService {
-  appId: string;
-  logger: ILogger;
-  store: StoreService<RedisClient, RedisMulti>;
-  symbols: Promise<Symbols> | Symbols;
-  private static symbols: Map<string, Symbols> = new Map();
-
-  constructor(appId: string, store: StoreService<RedisClient, RedisMulti>, logger: ILogger) {
-    this.appId = appId;
-    this.logger = logger;
-    this.store = store;
-  }
-
-  /**
-   * Convert the job hash from its compiles format into a DurableJobExport object with
-   * facets that describe the workflow in terms relevant to narrative storytelling.
-   */
-  async export(jobId: string, options: ExportOptions = {}): Promise<DurableJobExport> {
-    if (!ExporterService.symbols.has(this.appId)) {
-      const symbols: Symbols | Promise<Symbols> = this.store.getAllSymbols();
-      ExporterService.symbols.set(this.appId, await symbols);
-    }
-    const jobData = await this.store.getRaw(jobId);
-    const jobExport = this.inflate(jobData, options);
-    return jobExport;
-  }
-
-  /**
-   * Inflates the job data from Redis into a DurableJobExport object
-   * @param jobHash - the job data from Redis
-   * @param dependencyList - the list of dependencies for the job
-   * @returns - the inflated job data
-   */
-  inflate(jobHash: StringStringType, options: ExportOptions): DurableJobExport {
-    const timeline: TimelineType[] = [];
-    const state: StringAnyType = {};
-    const data: StringStringType = {};
-    const transitionsObject: Record<string, TransitionType> = {};
-    const regex = /^([a-zA-Z]{3}),(\d+(?:,\d+)*)/;
-
-    Object.entries(jobHash).forEach(([key, value]) => {
-      const match = key.match(regex);
-
-      if (match) {
-        //transitions
-        this.inflateTransition(match, value, transitionsObject);
-
-      } else if (key.length === 3) {
-        //state
-        state[this.inflateKey(key)] = SerializerService.fromString(value);
-
-      } else if (key.startsWith('_')) {
-        //data
-        data[key.substring(1)] = value;
-
-      } else if (key.startsWith('-')) {
-        //timeline
-        const keyParts = this.keyToObject(key); //key parts have meaning
-        timeline.push({
-          ...keyParts,
-          key,
-          value: this.resolveValue(value, options.values),
-        });
-      }
-    });
-
-    return this.filterFields({
-      data: restoreHierarchy(data),
-      state: Object.entries(restoreHierarchy(state))[0][1],
-      status: parseInt(jobHash[':'], 10),
-      timeline: this.sortParts(timeline),
-      transitions: this.sortEntriesByCreated(transitionsObject),
-    }, options.block, options.allow);
-  }
-
-  resolveValue(raw: string, withValues: boolean): Record<string, any> | string | number | null {
-    const resolved = SerializerService.fromString(raw);
-    if (withValues !== false) {
-      return resolved;
-    }
-    if (resolved && typeof resolved === 'object') {
-      if ('data' in resolved) {
-        resolved.data = {};
-      }
-      if ('$error' in resolved) {
-        resolved.$error = {};
-      }
-    }
-    return resolved;
-  }
-
-  /**
-   * Inflates the key from Redis, 3-character symbol
-   * into a human-readable JSON path, reflecting the
-   * tree-like structure of the unidimensional Hash
-   * @private
-   */
-  inflateKey(key: string): string {
-    const symbols = ExporterService.symbols.get(this.appId);
-    if (key in symbols) {
-      const path = symbols[key];
-      const parts = path.split('/');
-      return parts.join('/');
-    }
-    return key;
-  }
-
- filterFields(fullObject: DurableJobExport, block: ExportFields[] = [], allow: ExportFields[] = []): Partial<DurableJobExport> {
-    let result: Partial<DurableJobExport> = {};
-    if (allow && allow.length > 0) {
-      allow.forEach(field => {
-        if (field in fullObject) {
-          result[field] = fullObject[field] as StringAnyType & number & TimelineType[] & TransitionType[];
-        }
-      });
-    } else {
-      result = { ...fullObject };
-    }
-    if (block && block.length > 0) {
-      block.forEach(field => {
-        if (field in result) {
-          delete result[field];
-        }
-      });
-    }
-    return result as DurableJobExport;
-  }
-
-  inflateTransition(match: RegExpMatchArray, value: string, transitionsObject: Record<string, TransitionType>) {
-    const [_, letters, dimensions] = match;
-    const path = this.inflateKey(letters);
-    const parts = path.split('/');
-    const activity = parts[0];
-    const isCreate = path.endsWith('/output/metadata/ac');
-    const isUpdate = path.endsWith('/output/metadata/au');
-    //for now only export activity start/stop; activity data would also be interesting
-    if (isCreate || isUpdate) {
-      const targetName = `${activity},${dimensions}`;
-      let target = transitionsObject[targetName];
-      if (!target) {
-        transitionsObject[targetName] = {
-          activity,
-          dimensions,
-          created: isCreate ? value : null,
-          updated: isUpdate ? value : null,
-        };
-      } else {
-        target[isCreate ? 'created' : 'updated'] = value;
-      }
-    }
-  }
-
-  sortEntriesByCreated(obj: { [key: string]: TransitionType }): TransitionType[] {
-    const entriesArray: TransitionType[] = Object.values(obj);
-    entriesArray.sort((a, b) => {
-      return (a.created || a.updated).localeCompare(b.created || b.updated);
-    });
-    return entriesArray;
-  }
-
-  /**
-   * marker names are overloaded with details like sequence, type, etc
-   */
-  keyToObject(key: string): {index: number, dimension?: string, secondary?: number} {
-    function extractDimension(label: string): string {
-      const parts = label.split(',');
-      if (parts.length > 1) {
-        parts.shift();
-        return parts.join(',');
-      }
-    }
-    const parts = key.split('-');
-    if (parts.length === 4) {
-      //-proxy-5-     -search-1-1-
-      return {
-        index: parseInt(parts[2], 10),
-        dimension: extractDimension(parts[1]),
-      }
-    } else {
-      //-search,0,0-1-1-    -proxy,0,0-1-
-      return {
-        index: parseInt(parts[2], 10),
-        secondary: parseInt(parts[3], 10),
-        dimension: extractDimension(parts[1]),
-      }
-    }
-  }
-
-  /**
-   * idem list has a complicated sort order based on indexes and dimensions
-   */
-  sortParts(parts: TimelineType[]): TimelineType[] {
-    return parts.sort((a, b) => {
-      const { dimension: aDim, index: aIdx, secondary: aSec } = a;
-      const { dimension: bDim, index: bIdx, secondary: bSec } = b;
-  
-      if (aDim === undefined && bDim !== undefined) return -1;
-      if (aDim !== undefined && bDim === undefined) return 1;
-      if (aDim !== undefined && bDim !== undefined) {
-        if (aDim < bDim) return -1;
-        if (aDim > bDim) return 1;
-      }
-  
-      if (aIdx < bIdx) return -1;
-      if (aIdx > bIdx) return 1;
-  
-      if (aSec === undefined && bSec !== undefined) return -1;
-      if (aSec !== undefined && bSec === undefined) return 1;
-      if (aSec !== undefined && bSec !== undefined) {
-        if (aSec < bSec) return -1;
-        if (aSec > bSec) return 1;
-      }
-  
-      return 0;
-    });
-  };
-}
-
-export { ExporterService };

package/services/durable/handle.ts

@@ -1,160 +0,0 @@
-import { ExporterService } from './exporter';
-import { HotMeshService as HotMesh } from '../hotmesh';
-import { DurableJobExport, ExportOptions } from '../../types/exporter';
-import { JobInterruptOptions, JobOutput } from '../../types/job';
-import { StreamError } from '../../types/stream';
-
-export class WorkflowHandleService {
-  exporter: ExporterService
-  hotMesh: HotMesh;
-  workflowTopic: string;
-  workflowId: string;
-
-  constructor(hotMesh: HotMesh, workflowTopic: string, workflowId: string) {
-    this.workflowTopic = workflowTopic;
-    this.workflowId = workflowId;
-    this.hotMesh = hotMesh;
-    this.exporter = new ExporterService(
-      this.hotMesh.appId,
-      this.hotMesh.engine.store,
-      this.hotMesh.engine.logger,
-    );
-  }
-
-  async export(options?: ExportOptions): Promise<DurableJobExport>  {
-    return this.exporter.export(this.workflowId, options);
-  }
-
-  /**
-   * Sends a signal to the workflow. This is a way to send
-   * a message to a workflow that is paused due to having
-   * executed `Durable.workflow.waitFor`. The workflow
-   * will awaken if no other signals are pending.
-   */
-  async signal(signalId: string, data: Record<any, any>): Promise<void> {
-    await this.hotMesh.hook(`${this.hotMesh.appId}.wfs.signal`, { id: signalId, data });
-  }
-
-  /**
-   * Returns the job state of the workflow. If the workflow has completed
-   * this is also the job output. If the workflow is still running, this
-   * is the current state of the job, but it may change depending upon
-   * the activities that remain.
-   */
-  async state(metadata = false): Promise<Record<string, any>> {
-    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;
-  }
-
-  /**
-   * Returns the current search state of the workflow. This is
-   * different than the job state or individual activity state.
-   * Search state represents name/value pairs that were added
-   * to the workflow. As the workflow is stored in a Redis hash,
-   * this is a way to store additional data that is indexed
-   * and searchable using the RediSearch module.
-   */
-  async queryState(fields: string[]): Promise<Record<string, any>> {
-    return await this.hotMesh.getQueryState(this.workflowId, fields);
-  }
-
-  /**
-   * Returns the current status of the workflow. This is a semaphore
-   * value that represents the current state of the workflow, where
-   * 0 is complete and a negative value represents that the flow was
-   * interrupted.
-   */
-  async status(): Promise<number> {
-    return await this.hotMesh.getStatus(this.workflowId);
-  }
-
-  /**
-   * Interrupts a running workflow. Standard Job Completion tasks will
-   * run. Subscribers will be notified and the job hash will be expired. 
-   */
-  async interrupt(options?: JobInterruptOptions): Promise<string> {
-    return await this.hotMesh.interrupt(`${this.hotMesh.appId}.execute`, this.workflowId, options);
-  }
-
-  /**
-   * Waits for the workflow to complete and returns the result. If
-   * the workflow response includes an error, this method will rethrow
-   * the error, including the stack trace if available. 
-   * Wrap calls in a try/catch as necessary to avoid unhandled exceptions.
-   */
-  async result<T>(config?: {state?: boolean, throwOnError?: boolean}): Promise<T | StreamError> {
-    const topic = `${this.hotMesh.appId}.executed.${this.workflowId}`;
-    let isResolved = false;
-
-    return new Promise(async (resolve, reject) => {
-
-      /**
-       * rejects/resolves the promise based on the `throwOnError`
-       * default behavior is to throw if error
-       */
-      const safeReject = (err: StreamError) => {
-        if (config?.throwOnError === false) {
-          return resolve(err);
-        }
-        reject(err);
-      };
-
-      /**
-       * Common completion function that unsubscribes from the topic/returns
-       */
-      const complete = async (response?: T, err?: StreamError) => {
-        if (isResolved) return;
-        isResolved = true;
-
-        if (err) {
-          return safeReject(err as StreamError);
-        } else if (!response) {
-          const state = await this.hotMesh.getState(`${this.hotMesh.appId}.execute`, this.workflowId);
-          if (state.data?.done && !state.data?.$error) {
-            return resolve(state.data.response as T);
-          } else if (state.data?.$error) {
-            return safeReject(state.data.$error as StreamError)
-          } else if (state.metadata.err) {
-            return safeReject(JSON.parse(state.metadata.err) as StreamError);
-          }
-          response = state.data?.response as T;
-        }
-        resolve(response as T);
-      };
-
-      //more expensive; fetches the entire job, not just the `status`
-      if (config?.state) {
-        const state = await this.hotMesh.getState(`${this.hotMesh.appId}.execute`, this.workflowId);
-        if (state?.data?.done && !state.data?.$error) {
-          return complete(state.data.response as T);
-        } else if (state.data?.$error) {
-          return complete(null, state.data.$error as StreamError);
-        } else if (state.metadata.err) {
-          return complete(null, JSON.parse(state.metadata.err) as StreamError);
-        }
-      }
-
-      //subscribe to 'done' topic
-      this.hotMesh.sub(topic, async (_topic: string, state: JobOutput) => {
-        this.hotMesh.unsub(topic);
-        if (state.data.done && !state.data?.$error) {
-          await complete(state.data?.response as T);
-        } else if (state.data?.$error) {
-          return complete(null, state.data.$error as StreamError)
-        } else if (state.metadata.err) {
-          const error = JSON.parse(state.metadata.err) as StreamError;
-          return await complete(null, error);
-        }
-      });
-
-      //check state in case completed during wiring
-      const status = await this.hotMesh.getStatus(this.workflowId);
-      if (status <= 0) {
-        await complete();
-      }
-    });
-  }
-}

package/services/durable/index.ts

@@ -1,27 +0,0 @@
-import { ClientService } from './client';
-import { ConnectionService } from './connection';
-import { Search } from './search';
-import { WorkerService } from './worker';
-import { WorkflowService } from './workflow';
-import { HotMeshService } from '../hotmesh';
-import { ContextType } from '../../types/durable';
-
-export const Durable = {
-  Client: ClientService,
-  Connection: ConnectionService,
-  Search,
-  Worker: WorkerService,
-  workflow: WorkflowService,
-
-  /**
-   * Shutdown everything. All connections, workers, and clients will be closed.
-   * Include in your signal handlers to ensure a clean shutdown.
-   */
-  async shutdown(): Promise<void> {
-    await ClientService.shutdown();
-    await WorkerService.shutdown();
-    await HotMeshService.stop();
-  }
-};
-
-export type { ContextType };