@hotmeshio/hotmesh 0.0.2 → 0.0.4

package/services/engine/index.ts

@@ -63,6 +63,7 @@ import {
   StreamError,
   StreamRole,
   StreamStatus } from '../../types/stream';
+import { StringStringType } from '../../types';
 
 //wait time to see if a job is complete
 const OTT_WAIT_TIME = 1000;
@@ -408,21 +409,37 @@ class EngineService {
   }
 
   // ****************** `HOOK` ACTIVITY RE-ENTRY POINT *****************
-  async hook(topic: string, data: JobData): Promise<JobStatus | void> {
+  async hook(topic: string, data: JobData, dad?: string): Promise<JobStatus | void> {
     const hookRule = await this.storeSignaler.getHookRule(topic);
+    const [aid, schema] = await this.getSchema(`.${hookRule.to}`);
+    if (!dad) {
+      //assume dimensional address is singular (0)
+      // for ancestors and self if not provided
+      // todo: register
+      dad = ',0'.repeat(schema.ancestors.length + 1);
+    }
     const streamData: StreamData = {
       type: StreamDataType.WEBHOOK,
-      metadata: { aid: `${hookRule.to}`, topic },
+      metadata: {
+        //jid is unknown at this point; will be resolved using the data
+        aid,
+        dad,
+        topic
+      },
       data,
     };
     await this.streamSignaler.publishMessage(null, streamData);
   }
   async hookTime(jobId: string, activityId: string): Promise<JobStatus | void> {
+    //the activityid is concatenated with its dimensional address (dad); split to resolve
+    const [aid, ...dimensions] = activityId.split(',');
+    const dad = `,${dimensions.join(',')}`;
     const streamData: StreamData = {
       type: StreamDataType.TIMEHOOK,
       metadata: {
         jid: jobId,
-        aid: activityId,
+        aid,
+        dad,
       },
       data: { timestamp: Date.now() },
     };
@@ -586,12 +603,13 @@ class EngineService {
   //      (e.g, if {dimensions:true}, use hscan to deliver
   //      the full set of dimensional job data)
   async getState(topic: string, jobId: string): Promise<JobOutput> {
-    const { id: appId } = await this.getVID();
     const jobSymbols = await this.store.getSymbols(`$${topic}`);
     const consumes: Consumes = {
       [`$${topic}`]: Object.keys(jobSymbols)
     }
-    const output = await this.store.getState(jobId, consumes);
+    //job data exists at the 'zero' dimension; pass an empty object
+    const dIds = {} as StringStringType;
+    const output = await this.store.getState(jobId, consumes, dIds);
     if (!output) {
       throw new Error(`not found ${jobId}`);
     }

package/services/hotmesh/index.ts

@@ -161,9 +161,9 @@ class HotMeshService {
   }
 
   // ****** `HOOK` ACTIVITY RE-ENTRY POINT ******
-  async hook(topic: string, data: JobData): Promise<JobStatus | void> {
+  async hook(topic: string, data: JobData, dad?: string): Promise<JobStatus | void> {
     //return collation int
-    return await this.engine?.hook(topic, data);
+    return await this.engine?.hook(topic, data, dad);
   }
   async hookAll(hookTopic: string, data: JobData, query: JobStatsInput, queryFacets: string[] = []): Promise<string[]> {
     return await this.engine?.hookAll(hookTopic, data, query, queryFacets);

package/services/mapper/index.ts

@@ -80,5 +80,4 @@ class MapperService {
   }
 }
 
-
 export { MapperService }

package/services/serializer/index.ts

@@ -1,4 +1,5 @@
 import { getSymVal } from '../../modules/utils';
+import { Consumes } from '../../types/activity';
 import {
   StringStringType,
   StringAnyType,
@@ -26,16 +27,53 @@ export const MDATA_SYMBOLS = {
 };
 
 export class SerializerService {
+  dIds: StringStringType;
   symKeys: SymbolMaps;
   symReverseKeys: SymbolMaps;
   symValMaps: SymbolMap;
   symValReverseMaps: SymbolMap;
 
   constructor() {
-    this.resetSymbols({}, {});
+    this.resetSymbols({}, {}, {});
   }
 
-  resetSymbols(symKeys: SymbolSets, symVals: Symbols): void {
+  abbreviate(consumes: Consumes, symbolNames: string[], fields: string[] = []): string[] {
+    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: string): string {
+    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: string): boolean {
+    return path.startsWith('data/') || path.startsWith('metadata/');
+  }
+
+  resetSymbols(symKeys: SymbolSets, symVals: Symbols, dIds: StringStringType): void {
     this.symKeys = new Map();
     this.symReverseKeys = new Map();
     for (const id in symKeys) {
@@ -43,6 +81,7 @@ export class SerializerService {
     }
     this.symValMaps = new Map(Object.entries(symVals));
     this.symValReverseMaps = this.getReverseValueMap(this.symValMaps);
+    this.dIds = dIds;
   }
 
   getReverseKeyMap(keyMap: SymbolMap, id?: string): SymbolMap {
@@ -87,25 +126,23 @@ export class SerializerService {
     if (this.symKeys.size === 0) {
       return document;
     }
-    let result: StringStringType = { ...document };
+    let source: StringStringType = { ...document };
+    let result: StringStringType = { };
 
-    const compressWithMap = (abbreviationMap: SymbolMap) => {
-      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];
+    const compressWithMap = (abbreviationMap: SymbolMap, id: string) => {
+      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;
@@ -120,14 +157,12 @@ export class SerializerService {
     const inflateWithMap = (abbreviationMap: SymbolMap, id: string) => {
       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/services/signaler/stream.ts

@@ -150,6 +150,7 @@ class StreamSignaler {
     try {
       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/services/store/index.ts

@@ -310,7 +310,11 @@ abstract class StoreService<T, U extends AbstractRedisClient> {
       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];
         }
@@ -448,12 +452,12 @@ abstract class StoreService<T, U extends AbstractRedisClient> {
     return Number(status);
   }
 
-  async setState({ ...state }: StringAnyType, status: number | null, jobId: string, appId: string, symbolNames: string[], multi? : U): Promise<string> {
+  async setState({ ...state }: StringAnyType, status: number | null, jobId: string, symbolNames: string[], dIds: StringStringType, multi? : U): Promise<string> {
     delete state['metadata/js'];
-    const hashKey = this.mintKey(KeyType.JOB_STATE, { appId, jobId });
+    const hashKey = this.mintKey(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) {
@@ -465,26 +469,14 @@ abstract class StoreService<T, U extends AbstractRedisClient> {
     return jobId;
   }
 
-  async getState(jobId: string, consumes: Consumes): Promise<[StringAnyType, number] | undefined> {
-    //todo: refactor into semantic submethods
+  async getState(jobId: string, consumes: Consumes, dIds: StringStringType): Promise<[StringAnyType, number] | undefined> {
+    //get abbreviated field list (the symbols for the paths)
     const key = this.mintKey(KeyType.JOB_STATE, { appId: this.appId, jobId });
     const symbolNames = Object.keys(consumes);
     const symKeys = await this.getSymbolKeys(symbolNames);
+    this.serializer.resetSymbols(symKeys, {}, dIds);
+    const fields = this.serializer.abbreviate(consumes, 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);
-        }
-      }
-    }
     const jobDataArray = await this.redisClient[this.commands.hmget](key, fields);
     const jobData: StringAnyType = {};
     let atLeast1 = false; //if status field (':') isn't present assume 404
@@ -496,7 +488,7 @@ abstract class StoreService<T, U extends AbstractRedisClient> {
     });
     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[':']) {
@@ -508,13 +500,13 @@ abstract class StoreService<T, U extends AbstractRedisClient> {
     }
   }
 
-  async collate(jobId: string, activityId: string, amount: number, multi? : U): Promise<number> {
+  async collate(jobId: string, activityId: string, amount: number, dIds: StringStringType, multi? : U): Promise<number> {
     const jobKey = this.mintKey(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);

package/types/activity.ts

@@ -26,6 +26,7 @@ interface BaseActivity {
   subscribes?: string;                 //compiler
   trigger?: string;                    //compiler
   parent?: string;                     //compiler
+  ancestors?: string[];                //compiler
 }
 
 interface Measure {

package/types/hotmesh.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;