@hotmeshio/hotmesh 0.0.1

package/services/activities/iterate.ts

@@ -0,0 +1,26 @@
+import { EngineService } from '../engine';
+import { Activity, ActivityType } from './activity';
+import {
+  ActivityData,
+  ActivityMetadata,
+  IterateActivity } from '../../types/activity';
+
+class Iterate extends Activity {
+  config: IterateActivity;
+
+  constructor(
+    config: ActivityType,
+    data: ActivityData,
+    metadata: ActivityMetadata,
+    hook: ActivityData | null,
+    engine: EngineService
+    ) {
+      super(config, data, metadata, hook, engine);
+  }
+
+  async mapInputData(): Promise<void> {
+    this.logger.info('iterate-map-input-data');
+  }
+}
+
+export { Iterate };

package/services/activities/trigger.ts

@@ -0,0 +1,196 @@
+import { nanoid } from 'nanoid';
+import { DuplicateJobError } from '../../modules/errors';
+import { formatISODate, getTimeSeries } from '../../modules/utils';
+import { Activity } from './activity';
+import { CollatorService } from '../collator';
+import { DimensionService } from '../dimension';
+import { EngineService } from '../engine';
+import { Pipe } from '../pipe';
+import { ReporterService } from '../reporter';
+import { MDATA_SYMBOLS } from '../serializer';
+import { TelemetryService } from '../telemetry';
+import {
+  ActivityData,
+  ActivityMetadata,
+  ActivityType,
+  TriggerActivity } from '../../types/activity';
+import { JobState } from '../../types/job';
+import { RedisMulti } from '../../types/redis';
+import { StringScalarType } from '../../types/serializer';
+
+class Trigger extends Activity {
+  config: TriggerActivity;
+
+  constructor(
+    config: ActivityType,
+    data: ActivityData,
+    metadata: ActivityMetadata,
+    hook: ActivityData | null,
+    engine: EngineService,
+    context?: JobState) {
+      super(config, data, metadata, hook, engine, context);
+  }
+
+  async process(): Promise<string> {
+    this.logger.debug('trigger-process', { subscribes: this.config.subscribes });
+    let telemetry: TelemetryService;
+    try {
+      this.setLeg(2);
+      await this.getState();
+      telemetry = new TelemetryService(this.engine.appId, this.config, this.metadata, this.context);
+      telemetry.startJobSpan();
+      telemetry.startActivitySpan(this.leg);
+      this.mapJobData();
+      await this.setStateNX();
+      this.adjacencyList = await this.filterAdjacent();
+      await this.setStatus(this.adjacencyList.length);
+
+      const multi = this.store.getMulti();
+      await this.setState(multi);
+      await this.setStats(multi);
+      await multi.exec();
+
+      telemetry.mapActivityAttributes();
+      const jobStatus = Number(this.context.metadata.js);
+      telemetry.setJobAttributes({ 'app.job.jss': jobStatus });
+      const attrs: StringScalarType = { 'app.job.jss': jobStatus };
+      const messageIds = await this.transition(this.adjacencyList, jobStatus);
+      if (messageIds.length) {
+        attrs['app.activity.mids'] = messageIds.join(',')
+      }
+      telemetry.setActivityAttributes(attrs);
+      return this.context.metadata.jid;
+    } catch (error) {
+      if (error instanceof DuplicateJobError) {
+        this.logger.error('duplicate-job-error', error);
+      } else {
+        this.logger.error('trigger-process-error', error);
+      }
+      telemetry.setActivityError(error.message);
+      throw error;
+    } finally {
+      telemetry.endJobSpan();
+      telemetry.endActivitySpan();
+      this.logger.debug('trigger-process-end', { subscribes: this.config.subscribes, jid: this.context.metadata.jid });
+    }
+  }
+
+  async setStatus(amount: number): Promise<void> {
+    this.context.metadata.js = amount;
+  }
+
+  createInputContext(): Partial<JobState> {
+    const input = { 
+      [this.metadata.aid]: {
+        input: { data: this.data }
+      },
+      '$self': {
+        input: { data: this.data },
+        output: { data: this.data }
+      },
+    } as Partial<JobState>;
+    return input
+  }
+
+  async getState(): Promise<void> {
+    const inputContext = this.createInputContext();
+    const jobId = this.resolveJobId(inputContext);
+    const jobKey = this.resolveJobKey(inputContext);
+
+    const utc = formatISODate(new Date());
+    const { id, version } = await this.engine.getVID();
+    this.initDimensionalAddress(DimensionService.getSeed());
+    const activityMetadata = {
+      ...this.metadata,
+      jid: jobId,
+      key: jobKey,
+      as: CollatorService.getTriggerSeed(),
+    };
+    this.context = {
+      metadata: {
+        ...this.metadata,
+        ngn: this.context.metadata.ngn,
+        pj: this.context.metadata.pj,
+        pd: this.context.metadata.pd,
+        pa: this.context.metadata.pa,
+        app: id,
+        vrs: version,
+        tpc: this.config.subscribes,
+        trc: this.context.metadata.trc,
+        spn: this.context.metadata.spn,
+        jid: jobId,
+        dad: DimensionService.getSeed(), //top-level job implicitly uses `,0`
+        key: jobKey,
+        jc: utc,
+        ju: utc,
+        ts: getTimeSeries(this.resolveGranularity()),
+        js: 0,
+      },
+      data: {},
+      [this.metadata.aid]: { 
+        input: { 
+          data: this.data,
+          metadata: activityMetadata
+        },
+        output: { 
+          data: this.data,
+          metadata: activityMetadata
+        },
+        settings: { data: {} },
+        errors: { data: {} },
+       },
+    };
+    this.context['$self'] = this.context[this.metadata.aid];
+  }
+
+  bindJobMetadataPaths(): string[] {
+    return MDATA_SYMBOLS.JOB.KEYS.map((key) => `metadata/${key}`);
+  }
+
+  bindActivityMetadataPaths(): string[] {
+    return MDATA_SYMBOLS.ACTIVITY.KEYS.map((key) => `output/metadata/${key}`);
+  }
+
+  resolveGranularity(): string {
+    return ReporterService.DEFAULT_GRANULARITY;
+  }
+
+  getJobStatus(): number {
+    return this.context.metadata.js;
+  }
+
+  resolveJobId(context: Partial<JobState>): string {
+    const jobId = this.config.stats?.id;
+    return jobId ? Pipe.resolve(jobId, context) : nanoid();
+  }
+
+  resolveJobKey(context: Partial<JobState>): string {
+    const jobKey = this.config.stats?.key;
+    return jobKey ? Pipe.resolve(jobKey, context) : '';
+  }
+
+  async setStateNX(): Promise<void> {
+    const jobId = this.context.metadata.jid;
+    if (!await this.store.setStateNX(jobId, this.engine.appId)) {
+      throw new DuplicateJobError(jobId);
+    }
+  }
+
+  async setStats(multi?: RedisMulti): Promise<void> {
+    const md = this.context.metadata;
+    if (this.config.stats?.measures) {
+      const config = await this.engine.getVID();
+      const reporter = new ReporterService(config, this.store, this.logger);
+      await this.store.setStats(
+        md.key,
+        md.jid,
+        md.ts,
+        reporter.resolveTriggerStatistics(this.config, this.context),
+        config,
+        multi
+      );
+    }
+  }
+}
+
+export { Trigger };

package/services/activities/worker.ts

@@ -0,0 +1,190 @@
+import { GetStateError } from '../../modules/errors';
+import { Activity } from './activity';
+import { CollatorService } from '../collator';
+import { EngineService } from '../engine';
+import {
+  ActivityData,
+  ActivityMetadata,
+  ActivityType,
+  WorkerActivity } from '../../types/activity';
+import { JobState } from '../../types/job';
+import { MultiResponseFlags } from '../../types/redis';
+import { StringScalarType } from '../../types/serializer';
+import {
+  StreamCode,
+  StreamData,
+  StreamStatus } from '../../types/stream';
+import { TelemetryService } from '../telemetry';
+
+class Worker extends Activity {
+  config: WorkerActivity;
+
+  constructor(
+    config: ActivityType,
+    data: ActivityData,
+    metadata: ActivityMetadata,
+    hook: ActivityData | null,
+    engine: EngineService,
+    context?: JobState) {
+      super(config, data, metadata, hook, engine, context);
+  }
+
+  //********  INITIAL ENTRY POINT (A)  ********//
+  async process(): Promise<string> {
+    this.logger.debug('worker-process', { jid: this.context.metadata.jid, aid: this.metadata.aid });
+    let telemetry: TelemetryService;
+    try {
+      this.setLeg(1);
+      await CollatorService.notarizeEntry(this);
+
+      await this.getState();
+      telemetry = new TelemetryService(this.engine.appId, this.config, this.metadata, this.context);
+      telemetry.startActivitySpan(this.leg);
+      this.mapInputData();
+
+      const multi = this.store.getMulti();
+      //await this.registerTimeout();
+      await CollatorService.authorizeReentry(this, multi);
+      await this.setState(multi);
+      await this.setStatus(0, multi);
+      const multiResponse = await multi.exec() as MultiResponseFlags;
+
+      telemetry.mapActivityAttributes();
+      const jobStatus = this.resolveStatus(multiResponse);
+      const messageId = await this.execActivity();
+      telemetry.setActivityAttributes({
+        'app.activity.mid': messageId,
+        'app.job.jss': jobStatus
+      });
+      //TODO: UPDATE ACTIVITY STATE (LEG 1 EXIT)
+      return this.context.metadata.aid;
+    } catch (error) {
+      if (error instanceof GetStateError) {
+        this.logger.error('worker-get-state-error', error);
+      } else {
+        this.logger.error('worker-process-error', error);
+      }
+      telemetry.setActivityError(error.message);
+      throw error;
+    } finally {
+      telemetry.endActivitySpan();
+      this.logger.debug('worker-process-end', { jid: this.context.metadata.jid, aid: this.metadata.aid });
+    }
+  }
+
+  async execActivity(): Promise<string> {
+    const streamData: StreamData = {
+      metadata: {
+        jid: this.context.metadata.jid,
+        dad: this.metadata.dad,
+        aid: this.metadata.aid,
+        topic: this.config.subtype,
+        spn: this.context['$self'].output.metadata.l1s,
+        trc: this.context.metadata.trc,
+      },
+      data: this.context.data
+    };
+    if (this.config.retry) {
+      streamData.policies = {
+        retry: this.config.retry
+      };
+    }
+    return (await this.engine.streamSignaler?.publishMessage(this.config.subtype, streamData)) as string;
+  }
+
+
+  //********  SIGNAL RE-ENTRY POINT (DUPLEX LEG 2 of 2)  ********//
+  async processEvent(status: StreamStatus = StreamStatus.SUCCESS, code: StreamCode = 200): Promise<void> {
+    this.setLeg(2);
+    const jid = this.context.metadata.jid;
+    const aid = this.metadata.aid;
+    this.status = status;
+    this.code = code;
+    this.logger.debug('worker-process-event', { topic: this.config.subtype, jid, aid, status, code });
+    let telemetry: TelemetryService;
+    try {
+      await this.getState();
+      const aState = await CollatorService.notarizeReentry(this);
+      this.adjacentIndex = CollatorService.getDimensionalIndex(aState);
+
+      telemetry = new TelemetryService(this.engine.appId, this.config, this.metadata, this.context);
+      let isComplete = CollatorService.isActivityComplete(this.context.metadata.js);
+      if (isComplete) {
+        this.logger.warn('worker-process-event-duplicate', { jid, aid });
+        this.logger.debug('worker-process-event-duplicate-resolution', { resolution: 'Increase HotMesh config `reclaimDelay` timeout.' });
+        return;
+      }
+      telemetry.startActivitySpan(this.leg);
+      if (status === StreamStatus.PENDING) {
+        await this.processPending(telemetry);
+      } else if (status === StreamStatus.SUCCESS) {
+        await this.processSuccess(telemetry);
+      } else {
+        await this.processError(telemetry);
+      }
+    } catch (error) {
+      this.logger.error('worker-process-event-error', error);
+      telemetry.setActivityError(error.message);
+      throw error;
+    } finally {
+      telemetry.endActivitySpan();
+      this.logger.debug('worker-process-event-end', { jid, aid });
+    }
+  }
+
+  async processPending(telemetry: TelemetryService): Promise<void> {
+    this.bindActivityData('output');
+    this.adjacencyList = await this.filterAdjacent();
+    this.mapJobData();
+    const multi = this.store.getMulti();
+    await this.setState(multi);
+    await CollatorService.notarizeContinuation(this, multi);
+
+    await this.setStatus(0, multi);
+    const multiResponse = await multi.exec() as MultiResponseFlags;
+    telemetry.mapActivityAttributes();
+    const jobStatus = this.resolveStatus(multiResponse);
+    telemetry.setActivityAttributes({ 'app.job.jss': jobStatus });
+  }
+
+  async processSuccess(telemetry: TelemetryService): Promise<void> {
+    this.bindActivityData('output');
+    this.adjacencyList = await this.filterAdjacent();
+    this.mapJobData();
+    const multi = this.store.getMulti();
+    await this.setState(multi);
+    await CollatorService.notarizeCompletion(this, multi);
+
+    await this.setStatus(this.adjacencyList.length - 1, multi);
+    const multiResponse = await multi.exec() as MultiResponseFlags;
+    telemetry.mapActivityAttributes();
+    const jobStatus = this.resolveStatus(multiResponse);
+    const attrs: StringScalarType = { 'app.job.jss': jobStatus };
+    const messageIds = await this.transition(this.adjacencyList, jobStatus);
+    if (messageIds.length) {
+      attrs['app.activity.mids'] = messageIds.join(',')
+    }
+    telemetry.setActivityAttributes(attrs);
+  }
+
+  async processError(telemetry: TelemetryService): Promise<void> {
+    this.bindActivityError(this.data);
+    this.adjacencyList = await this.filterAdjacent();
+    const multi = this.store.getMulti();
+    await this.setState(multi);
+    await CollatorService.notarizeCompletion(this, multi);
+
+    await this.setStatus(this.adjacencyList.length - 1, multi);
+    const multiResponse = await multi.exec() as MultiResponseFlags;
+    telemetry.mapActivityAttributes();
+    const jobStatus = this.resolveStatus(multiResponse);
+    const attrs: StringScalarType = { 'app.job.jss': jobStatus };
+    const messageIds = await this.transition(this.adjacencyList, jobStatus);
+    if (messageIds.length) {
+      attrs['app.activity.mids'] = messageIds.join(',')
+    }
+    telemetry.setActivityAttributes(attrs);
+  }
+}
+
+export { Worker };

package/services/collator/README.md

@@ -0,0 +1,102 @@
+# Activity State Tracking
+
+This document explains how HotMesh guarantees activity state management using a 15-digit integer. This mechanism is crucial for monitoring and controlling the activity's lifecycle across two legs (Leg1 and Leg2) and ensures that duplicate activities are never processed. The process further ensures that catastrophic, in-process failures will be automatically resolved with respect to idempotency, makig it possible to build 100% fault-tolerant workflows.
+
+## Overview
+
+The 15-digit integer serves as a semaphore, starting with the value `999000000000000`. Each digit has a specific purpose:
+
+- The first three digits track the lifecycle status for Legs 1 and 2.
+- The last 12 digits represent 1 million possible dimensional threads that can be spawned by this activity.
+
+### Digit Details
+
+    999000000000000
+    ^-------------- Leg1 Entry Status
+     ^------------- Leg1 Exit Status
+       ^^^^^^------ Leg2 Dimensional Thread Entry Count
+             ^^^^^^ Leg2 Dimensional Thread Exit Count
+      ^------------ Leg2 Exit Status
+
+>*Dimensional Threads* isolate and track those activities in the workflow that run in a *cycle*. They ensure that no naming collisions occur, even if the same activity is run multiple times.
+
+## Leg1 Lifecycle
+
+### Initialization
+
+The parent activity initializes the integer value (`999000000000000`) and saves it to Redis upon saving its own state. The parent then adds the child activity to the proper stream channel for eventual processing.
+
+>Streams are used when executing an activity (such as transitioning to a child activity) as they guarantee that the child activity will be fully created and initialized before the request is marked for deletion. Even if the system has a catastrophic failure, the chain of custody can be guaranteed through the use of streams when the system comes online.
+
+### Beginning of Leg1
+
+When Leg1 begins (when an activity is dequeued from its stream channel), the integer is decremented by 100 trillion:
+
+    HINCRBY -100000000000000
+
+Result:
+
+    899000000000000
+
+### Conclusion of Leg1
+
+At the conclusion of Leg1, the integer is decremented by 10 trillion:
+
+    HINCRBY -10000000000000
+
+Result:
+
+    889000000000000
+
+### Error Handling
+
+- If the value upon entering is `799############` (after decrementing the integer), Leg1 began but crashed before completion. The activity will perform the necessary cleanup and re-run the activity.
+- If the value upon entering is `789############` (after decrementing the integer), Leg1 completed successfully and the activity should end. It is likely that the system crashed last time before acking and deleting. Verify transitions succeeded and resolve as necessary.
+
+## Leg2 Lifecycle
+
+Leg2 supports multiple inputs and repeated responses. A worker can respond with a 'pending' status, allowing multiple inputs.
+
+### Beginning of Leg2
+
+On the first Leg2 input, the integer is incremented by 1 million:
+
+    HINCRBY 1000000
+
+Result:
+
+    889000001000000
+
+### Pending Status
+
+If the call status is 'pending', the digit is updated to reflect the successful completion of Leg2 but the third digit from the left will be untouched as the activity is pending and Leg2 should not end quite yet:
+
+    HINCRBY 1
+
+Result:
+
+    889000001000001
+
+### Success Status
+
+If the next message call to Leg2 entry is 'success', the process will begin as before, and the integer will be incremented by 1 million:
+
+    HINCRBY 1000000
+
+Result:
+
+    889000002000001
+
+ But because this is not a 'pending' message, the integer should be updated differently, targeting both the dimensional thread counter as well as the third digit from the left that tracks Leg2 status (e.g., `1 - 1000000000 = -999999999`).
+
+    HINCRBY -999999999999
+
+Result:
+
+    888000002000002
+
+>If an additional Leg2 call were to be received after this point, the result would be `888000003000002`. However, becuase the third digit is `8`, Leg2 access is not allowed and the system will conclude by decrementing the value it just set and returning immediately, so that the calling worker can mark and delete the stream entry.
+
+## Conclusion
+
+This 15-digit integer allows sophisticated tracking of complex activities across two legs, with error handling and support for cycles using multiple dimensional threads.

package/services/collator/index.ts

@@ -0,0 +1,182 @@
+import { CollationError } from "../../modules/errors";
+import { RedisMulti } from "../../types/redis";
+import { CollationFaultType, CollationStage } from "../../types/collator";
+import { ActivityDuplex } from "../../types/activity";
+import { HotMeshGraph } from "../../types/hotmesh";
+import { Activity } from "../activities/activity";
+
+class CollatorService {
+
+  //max int digit count that supports `hincrby`
+  static targetLength = 15; 
+
+  static async notarizeEntry(activity: Activity, multi?: RedisMulti): Promise<number> {
+    //decrement by -100_000_000_000_000
+    const amount = await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, -100_000_000_000_000, multi);
+    this.verifyInteger(amount, 1, 'enter');
+    return amount;
+  };
+
+  static async authorizeReentry(activity: Activity, multi?: RedisMulti): Promise<number> {
+    //set second digit to 8, allowing for re-entry
+    //decrement by -10_000_000_000_000
+    const amount = await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, -10_000_000_000_000, multi);
+    //this.verifyInteger(amount, 1, 'exit');
+    return amount;
+  }
+
+  static async notarizeEarlyCompletion(activity: Activity, multi?: RedisMulti): Promise<number> {
+    //initialize both `possible` (1m) and `actualized` (1) zero dimension, while decrementing the 2nd and 3rd digits to deactivate the activity
+    return await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, 1_000_001 - 11_000_000_000_000, multi);
+  };
+
+  static async notarizeReentry(activity: Activity, multi?: RedisMulti): Promise<number> {
+    //increment by 1_000_000 (indicates re-entry and is used to drive the 'dimensional address' for adjacent activities (minus 1))
+    const amount = await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, 1_000_000, multi);
+    this.verifyInteger(amount, 2, 'enter');
+    return amount;
+  };
+
+  static async notarizeContinuation(activity: Activity, multi?: RedisMulti): Promise<number> {
+    //keep open; actualize the leg2 dimension (+1)
+    return await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, 1, multi);
+  };
+
+  static async notarizeCompletion(activity: Activity, multi?: RedisMulti): Promise<number> {
+    //close out; actualize leg2 dimension (+1) and decrement the 3rd digit (-1_000_000_000_000)
+    return await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, 1 - 1_000_000_000_000, multi);
+  };
+
+  static getDigitAtIndex(num: number, targetDigitIndex: number): number | null {
+    const numStr = num.toString();
+    if (targetDigitIndex < 0 || targetDigitIndex >= numStr.length) {
+      return null;
+    }
+    const digit = parseInt(numStr[targetDigitIndex], 10);
+    return digit;
+  }
+
+  static getDimensionalIndex(num: number): number | null {
+    const numStr = num.toString();
+    if (numStr.length < 9) {
+      return null;
+    }
+    const extractedStr = numStr.substring(3, 9);
+    const extractedInt = parseInt(extractedStr, 10);
+    return extractedInt - 1;
+  }
+
+  static isDuplicate(num: number, targetDigitIndex: number): boolean {
+    return this.getDigitAtIndex(num, targetDigitIndex) < 8;
+  }
+
+  static isInactive(num: number): boolean {
+    return this.getDigitAtIndex(num, 2) < 9;
+  }
+
+  static isPrimed(amount: number, leg: ActivityDuplex): boolean {
+    //activity entry is not allowed if paths not properly pre-set
+    if (leg == 1) {
+      return amount != -100_000_000_000_000;
+    } else {
+      return this.getDigitAtIndex(amount, 0) < 9 &&
+        this.getDigitAtIndex(amount, 1) < 9;
+    }
+  }
+
+  static verifyInteger(amount: number, leg: ActivityDuplex, stage: CollationStage): void {
+    let faultType: CollationFaultType | undefined;
+    if (leg === 1 && stage === 'enter') {
+      if (!this.isPrimed(amount, 1)) {
+        faultType = CollationFaultType.MISSING;
+      } else if (this.isDuplicate(amount, 0)) {
+        faultType = CollationFaultType.DUPLICATE;
+      } else if (amount != 899_000_000_000_000) {
+        faultType = CollationFaultType.INVALID;
+      }
+    } else if (leg === 1 && stage === 'exit') {
+      if (amount === -10_000_000_000_000) {
+        faultType = CollationFaultType.MISSING;
+      } else if (this.isDuplicate(amount, 1)) {
+        faultType = CollationFaultType.DUPLICATE;
+      }
+    } else if (leg === 2 && stage === 'enter') {
+      if (!this.isPrimed(amount, 2)) {
+        faultType = CollationFaultType.FORBIDDEN;
+      } else if (this.isInactive(amount)) {
+        faultType = CollationFaultType.INACTIVE;
+      }
+    }
+    if (faultType) {
+      throw new CollationError(amount, leg, stage, faultType);
+    }
+  }
+
+  /**
+   * All non-trigger activities are assigned a status seed by their parent
+   */
+  static getSeed(): string {
+    return '999000000000000';
+  }
+
+  /**
+   * All trigger activities are assigned a status seed in a completed state
+   */
+  static getTriggerSeed(): string {
+    return '888000001000001';
+  }
+
+  /**
+   * entry point for compiler-type activities. This is called by the compiler
+   * to bind the sorted activity IDs to the trigger activity. These are then used
+   * at runtime by the activities to track job/activity status.
+   * @param graphs
+   */
+  static compile(graphs: HotMeshGraph[]) {
+    CollatorService.bindAncestorArray(graphs);
+  }
+
+  /**
+   * binds the ancestor array to each activity.
+   * Used in conjunction with the dimensional
+   *  address (dad). If dad is `,0,1,0,0` and the
+   * ancestor array is `['t1', 'a1', 'a2']` for
+   * activity 'a3', then the SAVED DAD
+   * will always have the trailing
+   * 0's removed. This ensures that the addressing
+   * remains consistent even if the graph changes.
+   *   id    DAD           SAVED DAD
+   * * t1 => ,0        =>  [empty]
+   * * a1 => ,0,1      =>  ,0,1
+   * * a2 => ,0,1,0    =>  ,0,1
+   * * a3 => ,0,1,0,0  =>  ,0,1
+   * 
+   */
+  static bindAncestorArray(graphs: HotMeshGraph[]) {
+    graphs.forEach((graph) => {
+      const ancestors: Record<string, string[]> = {};
+        const startingNode = Object.keys(graph.activities).find(
+        (activity) => graph.activities[activity].type === 'trigger'
+      );
+      if (!startingNode) {
+        throw new Error('collator-trigger-activity-not-found');
+      }
+      const dfs = (node: string, parentList: string[]) => {
+        ancestors[node] = parentList;
+        graph.activities[node]['ancestors'] = parentList;
+        const transitions = graph.transitions?.[node] || [];
+        transitions.forEach((transition) => {
+          dfs(transition.to, [...parentList, node]);
+        });
+      };
+      // Start the DFS traversal
+      dfs(startingNode, []);
+    });
+  }
+
+  static isActivityComplete(status: number): boolean {
+    return (status - 0) <= 0;
+  }
+}
+
+export { CollatorService };