@hotmeshio/hotmesh 0.0.2 → 0.0.4

package/build/services/serializer/index.js

@@ -20,9 +20,45 @@ exports.MDATA_SYMBOLS = {
 };
 class SerializerService {
     constructor() {
-        this.resetSymbols({}, {});
+        this.resetSymbols({}, {}, {});
     }
-    resetSymbols(symKeys, symVals) {
+    abbreviate(consumes, symbolNames, fields = []) {
+        for (const symbolName of symbolNames) {
+            const symbolSet = this.symKeys.get(symbolName);
+            const symbolPaths = consumes[symbolName];
+            for (const symbolPath of symbolPaths) {
+                const abbreviation = symbolSet.get(symbolPath);
+                if (abbreviation) {
+                    const dimensionalIndex = this.resolveDimensionalIndex(symbolPath);
+                    fields.push(`${abbreviation}${dimensionalIndex}`);
+                }
+                else {
+                    fields.push(symbolPath);
+                }
+            }
+        }
+        return fields;
+    }
+    resolveDimensionalIndex(path) {
+        if (this.isJobPath(path)) {
+            return '';
+        }
+        else {
+            const [activityId] = path.split('/');
+            if (activityId in this.dIds) {
+                return this.dIds[activityId];
+            }
+            else if ('$ADJACENT' in this.dIds) {
+                //else=> pre-authorizing adjacent activity entry
+                return this.dIds['$ADJACENT'];
+            }
+            return ',0';
+        }
+    }
+    isJobPath(path) {
+        return path.startsWith('data/') || path.startsWith('metadata/');
+    }
+    resetSymbols(symKeys, symVals, dIds) {
         this.symKeys = new Map();
         this.symReverseKeys = new Map();
         for (const id in symKeys) {
@@ -30,6 +66,7 @@ class SerializerService {
         }
         this.symValMaps = new Map(Object.entries(symVals));
         this.symValReverseMaps = this.getReverseValueMap(this.symValMaps);
+        this.dIds = dIds;
     }
     getReverseKeyMap(keyMap, id) {
         let map = this.symReverseKeys.get(id);
@@ -70,24 +107,22 @@ class SerializerService {
         if (this.symKeys.size === 0) {
             return document;
         }
-        let result = { ...document };
-        const compressWithMap = (abbreviationMap) => {
-            for (let key in result) {
-                let safeKey = abbreviationMap.get(key) || key;
-                let value = result[key];
-                let safeValue = abbreviationMap.get(value) || value;
-                if (safeKey !== key || safeValue !== value) {
-                    result[safeKey] = safeValue;
-                    if (safeKey !== key) {
-                        delete result[key];
-                    }
+        let source = { ...document };
+        let result = {};
+        const compressWithMap = (abbreviationMap, id) => {
+            for (let key in source) {
+                if (key.startsWith(`${id}/`) || (id.startsWith('$') && ['data', 'metadata'].includes(key.split('/')[0]))) {
+                    const dimensionalIndex = this.resolveDimensionalIndex(key);
+                    let shortKey = abbreviationMap.get(key) || key;
+                    const shortDimensionalKey = `${shortKey}${dimensionalIndex}`;
+                    result[shortDimensionalKey] = source[key];
                 }
             }
         };
         for (let id of ids) {
             const abbreviationMap = this.symKeys.get(id);
             if (abbreviationMap) {
-                compressWithMap(abbreviationMap);
+                compressWithMap(abbreviationMap, id);
             }
         }
         return result;
@@ -100,14 +135,12 @@ class SerializerService {
         const inflateWithMap = (abbreviationMap, id) => {
             const reversedAbbreviationMap = this.getReverseKeyMap(abbreviationMap, id);
             for (let key in result) {
-                let safeKey = reversedAbbreviationMap.get(key) || key;
-                let value = result[key];
-                let safeValue = reversedAbbreviationMap.get(value) || value;
-                if (safeKey !== key || safeValue !== value) {
-                    result[safeKey] = safeValue;
-                    if (safeKey !== key) {
-                        delete result[key];
-                    }
+                //strip dimensional index from key
+                const shortKey = key.split(',')[0];
+                let longKey = reversedAbbreviationMap.get(shortKey);
+                if (longKey) {
+                    result[longKey] = result[key];
+                    delete result[key];
                 }
             }
         };

package/build/services/signaler/stream.js

@@ -121,6 +121,7 @@ class StreamSignaler {
             output = await callback(input);
         }
         catch (err) {
+            console.error(err);
             this.logger.error(`stream-call-function-error`, { stream, id, err });
             output = this.structureUnhandledError(input, err);
         }

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

@@ -59,9 +59,9 @@ declare abstract class StoreService<T, U extends AbstractRedisClient> {
     getJobIds(indexKeys: string[], idRange: [number, number]): Promise<IdsData>;
     setStatus(collationKeyStatus: number, jobId: string, appId: string, multi?: U): Promise<any>;
     getStatus(jobId: string, appId: string): Promise<number>;
-    setState({ ...state }: StringAnyType, status: number | null, jobId: string, appId: string, symbolNames: string[], multi?: U): Promise<string>;
-    getState(jobId: string, consumes: Consumes): Promise<[StringAnyType, number] | undefined>;
-    collate(jobId: string, activityId: string, amount: number, multi?: U): Promise<number>;
+    setState({ ...state }: StringAnyType, status: number | null, jobId: string, symbolNames: string[], dIds: StringStringType, multi?: U): Promise<string>;
+    getState(jobId: string, consumes: Consumes, dIds: StringStringType): Promise<[StringAnyType, number] | undefined>;
+    collate(jobId: string, activityId: string, amount: number, dIds: StringStringType, multi?: U): Promise<number>;
     setStateNX(jobId: string, appId: string): Promise<boolean>;
     getSchema(activityId: string, appVersion: AppVID): Promise<ActivityType>;
     getSchemas(appVersion: AppVID): Promise<Record<string, ActivityType>>;

package/build/services/store/index.js

@@ -238,7 +238,12 @@ class StoreService {
             app = {};
             for (const field in sApp) {
                 try {
-                    app[field] = sApp[field];
+                    if (field === 'active') {
+                        app[field] = sApp[field] === 'true';
+                    }
+                    else {
+                        app[field] = sApp[field];
+                    }
                 }
                 catch (e) {
                     app[field] = sApp[field];
@@ -369,12 +374,12 @@ class StoreService {
         const status = await this.redisClient[this.commands.hget](jobKey, ':');
         return Number(status);
     }
-    async setState({ ...state }, status, jobId, appId, symbolNames, multi) {
+    async setState({ ...state }, status, jobId, symbolNames, dIds, multi) {
         delete state['metadata/js'];
-        const hashKey = this.mintKey(key_1.KeyType.JOB_STATE, { appId, jobId });
+        const hashKey = this.mintKey(key_1.KeyType.JOB_STATE, { appId: this.appId, jobId });
         const symKeys = await this.getSymbolKeys(symbolNames);
         const symVals = await this.getSymbolValues();
-        this.serializer.resetSymbols(symKeys, symVals);
+        this.serializer.resetSymbols(symKeys, symVals, dIds);
         const hashData = this.serializer.package(state, symbolNames);
         if (status !== null) {
             hashData[':'] = status.toString();
@@ -385,26 +390,13 @@ class StoreService {
         await (multi || this.redisClient)[this.commands.hset](hashKey, hashData);
         return jobId;
     }
-    async getState(jobId, consumes) {
-        //todo: refactor into semantic submethods
+    async getState(jobId, consumes, dIds) {
+        //get abbreviated field list (the symbols for the paths)
         const key = this.mintKey(key_1.KeyType.JOB_STATE, { appId: this.appId, jobId });
         const symbolNames = Object.keys(consumes);
         const symKeys = await this.getSymbolKeys(symbolNames);
-        //always fetch the job status (':') when fetching state
-        const fields = [':'];
-        for (const symbolName of symbolNames) {
-            const symbolSet = symKeys[symbolName];
-            const symbolPaths = consumes[symbolName];
-            for (const symbolPath of symbolPaths) {
-                const abbreviation = symbolSet[symbolPath];
-                if (abbreviation) {
-                    fields.push(abbreviation);
-                }
-                else {
-                    fields.push(symbolPath);
-                }
-            }
-        }
+        this.serializer.resetSymbols(symKeys, {}, dIds);
+        const fields = this.serializer.abbreviate(consumes, symbolNames, [':']);
         const jobDataArray = await this.redisClient[this.commands.hmget](key, fields);
         const jobData = {};
         let atLeast1 = false; //if status field (':') isn't present assume 404
@@ -416,7 +408,7 @@ class StoreService {
         });
         if (atLeast1) {
             const symVals = await this.getSymbolValues();
-            this.serializer.resetSymbols(symKeys, symVals);
+            this.serializer.resetSymbols(symKeys, symVals, dIds);
             const state = this.serializer.unpackage(jobData, symbolNames);
             let status = 0;
             if (state[':']) {
@@ -427,13 +419,13 @@ class StoreService {
             return [state, status];
         }
     }
-    async collate(jobId, activityId, amount, multi) {
+    async collate(jobId, activityId, amount, dIds, multi) {
         const jobKey = this.mintKey(key_1.KeyType.JOB_STATE, { appId: this.appId, jobId });
         const collationKey = `${activityId}/output/metadata/as`; //activity state
         const symbolNames = [activityId];
         const symKeys = await this.getSymbolKeys(symbolNames);
         const symVals = await this.getSymbolValues();
-        this.serializer.resetSymbols(symKeys, symVals);
+        this.serializer.resetSymbols(symKeys, symVals, dIds);
         const payload = { [collationKey]: amount.toString() };
         const hashData = this.serializer.package(payload, symbolNames);
         const targetId = Object.keys(hashData)[0];

package/build/types/activity.d.ts

@@ -23,6 +23,7 @@ interface BaseActivity {
     subscribes?: string;
     trigger?: string;
     parent?: string;
+    ancestors?: string[];
 }
 interface Measure {
     measure: MetricTypes;

package/build/types/hotmesh.d.ts

@@ -1,8 +1,8 @@
-import { ILogger } from "../services/logger";
-import { HotMeshService } from "../services/hotmesh";
-import { HookRules } from "./hook";
-import { RedisClass, RedisClient, RedisOptions } from "./redis";
-import { StreamData, StreamDataResponse } from "./stream";
+import { ILogger } from '../services/logger';
+import { HotMeshService } from '../services/hotmesh';
+import { HookRules } from './hook';
+import { RedisClass, RedisClient, RedisOptions } from './redis';
+import { StreamData, StreamDataResponse } from './stream';
 type HotMesh = typeof HotMeshService;
 type RedisConfig = {
     class: RedisClass;

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@hotmeshio/hotmesh",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "Durable Workflows",
   "main": "build/index.js",
   "types": "build/index.d.ts",
   "repository": {
     "type": "git",
-    "url": "https://github.com/hotmeshio/hotmesh.git"
+    "url": "https://github.com/hotmeshio/sdk-typescript.git"
   },
-  "homepage": "https://github.com/hotmeshio/hotmesh#readme",
+  "homepage": "https://github.com/hotmeshio/sdk-typescript#readme",
   "publishConfig": {
     "access": "public"
   },

package/services/activities/activity.ts

@@ -142,7 +142,8 @@ class Activity {
       const durationInSeconds = Pipe.resolve(this.config.sleep, this.context);
       const jobId = this.context.metadata.jid;
       const activityId = this.metadata.aid;
-      await this.engine.task.registerTimeHook(jobId, activityId, 'sleep', durationInSeconds);
+      const dId = this.metadata.dad;
+      await this.engine.task.registerTimeHook(jobId, `${activityId}${dId||''}`, 'sleep', durationInSeconds);
       return jobId;
     }
   }
@@ -206,6 +207,7 @@ class Activity {
       telemetry.setActivityAttributes(attrs);
       return jobStatus as number;
     } catch (error) {
+      console.error('this error?', error);
       this.logger.error('engine-process-hook-event-error', error);
       telemetry.setActivityError(error.message);
       throw error;
@@ -278,12 +280,11 @@ class Activity {
   }
 
   bindDimensionalAddress(state: StringAnyType) {
-    const { aid, dad } = this.metadata;
-    state[`${aid}/output/metadata/dad`] = dad;
+    const dad = this.resolveDad();
+    state[`${this.metadata.aid}/output/metadata/dad`] = dad;
   }
 
   async setState(multi?: RedisMulti): Promise<string> {
-    const { id: appId } = await this.engine.getVID();
     const jobId = this.context.metadata.jid;
     this.bindJobMetadata();
     this.bindActivityMetadata();
@@ -298,7 +299,8 @@ class Activity {
       this.metadata.aid,
       ...presets
     ];
-    return await this.store.setState(state, this.getJobStatus(), jobId, appId, symbolNames, multi);
+    const dIds = CollatorService.getDimensionsById([...this.config.ancestors, this.metadata.aid], this.resolveDad());
+    return await this.store.setState(state, this.getJobStatus(), jobId, symbolNames, dIds, multi);
   }
 
   bindJobMetadata(): void {
@@ -314,6 +316,7 @@ class Activity {
     if (this.status === StreamStatus.ERROR) {
       self.output.metadata.err = JSON.stringify(this.data);
     }
+    //todo: verify leg2 never overwrites leg1 `ac`
     self.output.metadata.ac = 
       self.output.metadata.au = formatISODate(new Date());
     self.output.metadata.atp = this.config.type;
@@ -386,10 +389,11 @@ class Activity {
       }
     }
     TelemetryService.addTargetTelemetryPaths(consumes, this.config, this.metadata, this.leg);
-    const { dad, jid } = this.context.metadata;
+    let { dad, jid } = this.context.metadata;
     jobId = jobId || jid;
     //`state` is a flat hash
-    const [state, status] = await this.store.getState(jobId, consumes);
+    const dIds = CollatorService.getDimensionsById([...this.config.ancestors, this.metadata.aid], dad);
+    const [state, status] = await this.store.getState(jobId, consumes, dIds);
     //`context` is a tree
     this.context = restoreHierarchy(state) as JobState;
     this.initDimensionalAddress(dad);
@@ -429,11 +433,26 @@ class Activity {
     this.context[this.metadata.aid][type].data = this.data;
   }
 
+  resolveDad(): string {
+    let dad = this.metadata.dad;
+    if (this.adjacentIndex > 0) {
+      //if adjacent index > 0 the activity is cycling; replace last index with cycle index
+      dad = `${dad.substring(0, dad.lastIndexOf(','))},${this.adjacentIndex}`
+    }
+    return dad;
+  }
+
+  resolveAdjacentDad(): string {
+    //concat self and child dimension (all children (leg 1) begin life at 0)
+    return `${this.resolveDad()}${DimensionService.getSeed(0)}`;
+  };
+
   async filterAdjacent(): Promise<StreamData[]> {
     const adjacencyList: StreamData[] = [];
     const transitions = await this.store.getTransitions(await this.engine.getVID());
     const transition = transitions[`.${this.metadata.aid}`];
-    const adjacentSuffix = DimensionService.getSeed(this.adjacentIndex);
+    //resolve the dimensional address for adjacent children
+    const adjacentDad = this.resolveAdjacentDad();
     if (transition) {
       for (const toActivityId in transition) {
         const transitionRule: boolean | TransitionRule = transition[toActivityId];
@@ -441,7 +460,7 @@ class Activity {
           adjacencyList.push({
             metadata: {
               jid: this.context.metadata.jid,
-              dad: `${this.metadata.dad}${adjacentSuffix}`,
+              dad: adjacentDad,
               aid: toActivityId,
               spn: this.context['$self'].output.metadata?.l2s,
               trc: this.context.metadata.trc,

package/services/activities/worker.ts

@@ -62,6 +62,7 @@ class Worker extends Activity {
       if (error instanceof GetStateError) {
         this.logger.error('worker-get-state-error', error);
       } else {
+        console.error(error);
         this.logger.error('worker-process-error', error);
       }
       telemetry.setActivityError(error.message);

package/services/collator/index.ts

@@ -1,18 +1,28 @@
-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";
+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 targetLength = 15;
+
+  static getDimensionalAddress(activity: Activity): Record<string, string> {
+    let dad = activity.context.metadata.dad || activity.metadata.dad;
+    //todo: unsure about this reset
+    // if (dad && activity.leg === 2) {
+    //   console.log('setting dad index back to 0=>', dad);
+    //   dad = `${dad.substring(0, dad.lastIndexOf(','))},0`;
+    // }
+    return CollatorService.getDimensionsById([...activity.config.ancestors, activity.metadata.aid], dad);
+  }
 
   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);
+    const amount = await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, -100_000_000_000_000, this.getDimensionalAddress(activity), multi);
     this.verifyInteger(amount, 1, 'enter');
     return amount;
   };
@@ -20,31 +30,31 @@ class CollatorService {
   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);
+    const amount = await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, -10_000_000_000_000, this.getDimensionalAddress(activity), 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);
+    return await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, 1_000_001 - 11_000_000_000_000, this.getDimensionalAddress(activity), 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);
+    const amount = await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, 1_000_000, this.getDimensionalAddress(activity), 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);
+    return await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, 1, this.getDimensionalAddress(activity), 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);
+    return await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, 1 - 1_000_000_000_000, this.getDimensionalAddress(activity), multi);
   };
 
   static getDigitAtIndex(num: number, targetDigitIndex: number): number | null {
@@ -112,6 +122,21 @@ class CollatorService {
     }
   }
 
+  static getDimensionsById(ancestors: string[], dad: string): Record<string, string> {
+    //ancestors is an ordered list of all ancestors, starting with the trigger (['t1', 'a1', 'a2'])
+    //dad is the dimensional address of the ancestors list (',0,5,3')
+    //loop through the ancestors list and create a map of the ancestor to the dimensional address.
+    //return { 't1': ',0', 'a1': ',0,5', 'a1': ',0,5,3', $ADJACENT: ',0,5,3,0' };
+    // `adjacent` is a special key that is used to track the dimensional address of adjacent activities
+    const map: Record<string, string> = { '$ADJACENT': `${dad},0` };
+    let dadStr = dad;
+    ancestors.reverse().forEach((ancestor) => {
+      map[ancestor] = dadStr;
+      dadStr = dadStr.substring(0, dadStr.lastIndexOf(','));
+    });
+    return map;
+  }
+
   /**
    * All non-trigger activities are assigned a status seed by their parent
    */

package/services/compiler/deployer.ts

@@ -1,13 +1,13 @@
-import { KeyStoreParams, KeyType } from "../../modules/key";
-import { getSymKey } from "../../modules/utils";
-import { CollatorService } from "../collator";
-import { SerializerService } from "../serializer";
+import { KeyStoreParams, KeyType } from '../../modules/key';
+import { getSymKey } from '../../modules/utils';
+import { CollatorService } from '../collator';
+import { SerializerService } from '../serializer';
 import { StoreService } from '../store';
-import { ActivityType } from "../../types/activity";
-import { HookRule } from "../../types/hook";
-import { HotMeshGraph, HotMeshManifest } from "../../types/hotmesh";
-import { RedisClient, RedisMulti } from "../../types/redis";
-import { StringAnyType, Symbols } from "../../types/serializer";
+import { ActivityType } from '../../types/activity';
+import { HookRule } from '../../types/hook';
+import { HotMeshGraph, HotMeshManifest } from '../../types/hotmesh';
+import { RedisClient, RedisMulti } from '../../types/redis';
+import { StringAnyType, Symbols } from '../../types/serializer';
 
 const DEFAULT_METADATA_RANGE_SIZE = 26; //metadata is 26 slots ([a-z] * 1)
 const DEFAULT_DATA_RANGE_SIZE = 260; //data is 260 slots ([a-zA-Z] * 5)
@@ -63,6 +63,7 @@ class Deployer {
       for (const [activityId, activity] of Object.entries(graph.activities)) {
         const [lower, upper, symbols] = await this.store.reserveSymbolRange(activityId, DEFAULT_RANGE_SIZE, 'ACTIVITY');
         const prefix = `${activityId}/`; //activity meta/data is namespaced
+        this.bindSelf(activity.consumes, activity.produces, activityId);
         const newSymbols = this.bindSymbols(lower, upper, symbols, prefix, activity.produces);
         if (Object.keys(newSymbols).length) {
           await this.store.addSymbols(activityId, newSymbols);
@@ -71,6 +72,20 @@ class Deployer {
     }
   }
 
+  bindSelf(consumes: Record<string, string[]>, produces: string[], activityId: string) {
+    //bind self-referential mappings
+    for (const selfId of [activityId, '$self']) {
+      const selfConsumes = consumes[selfId];
+      if (selfConsumes) {
+        for (const path of selfConsumes) {
+          if (!produces.includes(path)) {
+            produces.push(path);
+          }
+        }
+      }
+    }
+  }
+
   bindSymbols(startIndex: number, maxIndex: number, existingSymbols: Symbols, prefix: string, produces: string[]): Symbols {
     let newSymbols: Symbols = {};
     let currentSymbols: Symbols = {...existingSymbols};

package/services/dimension/index.ts

@@ -1,4 +1,4 @@
-import { HotMeshGraph } from "../../types/hotmesh";
+import { HotMeshGraph } from '../../types/hotmesh';
 
 class DimensionService {
 

package/services/durable/client.ts

@@ -1,8 +1,8 @@
-import { WorkflowHandleService } from "./handle";
-import { HotMeshService as HotMesh } from "../hotmesh";
-import { ClientConfig, Connection, WorkflowOptions } from "../../types/durable";
-import { getWorkflowYAML } from "./factory";
-import { JobState } from "../../types/job";
+import { WorkflowHandleService } from './handle';
+import { HotMeshService as HotMesh } from '../hotmesh';
+import { ClientConfig, Connection, WorkflowOptions } from '../../types/durable';
+import { getWorkflowYAML } from './factory';
+import { JobState } from '../../types/job';
 
 /*
 Here is an example of how the methods in this file are used:
@@ -101,7 +101,14 @@ export class ClientService {
         await hotMesh.deploy(getWorkflowYAML(workflowTopic, version));
         await hotMesh.activate(version);
       } catch (err) {
-        hotMesh.engine.logger.error('durable-client-workflow-activation-err', err);
+        hotMesh.engine.logger.error('durable-client-deploy-activate-err', err);
+        throw err;
+      }
+    } else if(app && !app.active) {
+      try {
+        await hotMesh.activate(version);
+      } catch (err) {
+        hotMesh.engine.logger.error('durable-client-activate-err', err);
         throw err;
       }
     }

package/services/durable/handle.ts

@@ -1,5 +1,5 @@
-import { JobOutput } from "../../types/job";
-import { HotMeshService as HotMesh } from "../hotmesh";
+import { JobOutput } from '../../types/job';
+import { HotMeshService as HotMesh } from '../hotmesh';
 
 export class WorkflowHandleService {
   hotMesh: HotMesh;

package/services/durable/worker.ts

@@ -67,7 +67,14 @@ export class WorkerService {
         await hotMesh.deploy(factory(topic, version));
         await hotMesh.activate(version);
       } catch (err) {
-        hotMesh.engine.logger.error('durable-worker-workflow-activation-error', err);
+        hotMesh.engine.logger.error('durable-worker-deploy-activate-err', err);
+        throw err;
+      }
+    } else if(app && !app.active) {
+      try {
+        await hotMesh.activate(version);
+      } catch (err) {
+        hotMesh.engine.logger.error('durable-worker-activate-err', err);
         throw err;
       }
     }
@@ -176,7 +183,14 @@ export class WorkerService {
         await hotMesh.deploy(getActivityYAML(activityTopic, version));
         await hotMesh.activate(version);
       } catch (err) {
-        console.log('durable-worker-activity-workflow-activation-error', err);
+        console.log('durable-worker-activity-deploy-activate-error', err);
+        throw err;
+      }
+    } else if(app && !app.active) {
+      try {
+        await hotMesh.activate(version);
+      } catch (err) {
+        hotMesh.engine.logger.error('durable-worker-activity-activate-err', err);
         throw err;
       }
     }