@hotmeshio/hotmesh 0.1.14 → 0.1.16

package/build/services/compiler/deployer.js

@@ -7,8 +7,8 @@ const collator_1 = require("../collator");
 const serializer_1 = require("../serializer");
 const pipe_1 = require("../pipe");
 const validator_1 = require("./validator");
-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)
+const DEFAULT_METADATA_RANGE_SIZE = 26;
+const DEFAULT_DATA_RANGE_SIZE = 260;
 const DEFAULT_RANGE_SIZE = DEFAULT_METADATA_RANGE_SIZE + DEFAULT_DATA_RANGE_SIZE;
 class Deployer {
     constructor(manifest) {
@@ -41,21 +41,18 @@ class Deployer {
         };
     }
     async generateSymKeys() {
-        //note: symbol ranges are additive (per version); path assignments are immutable
         for (const graph of this.manifest.app.graphs) {
-            //generate JOB symbols
             const [, trigger] = this.findTrigger(graph);
             const topic = trigger.subscribes;
             const [lower, upper, symbols] = await this.store.reserveSymbolRange(`$${topic}`, DEFAULT_RANGE_SIZE, 'JOB');
-            const prefix = ''; //job meta/data is NOT namespaced
+            const prefix = '';
             const newSymbols = this.bindSymbols(lower, upper, symbols, prefix, trigger.PRODUCES);
             if (Object.keys(newSymbols).length) {
                 await this.store.addSymbols(`$${topic}`, newSymbols);
             }
-            //generate ACTIVITY symbols
             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
+                const prefix = `${activityId}/`;
                 this.bindSelf(activity.consumes, activity.produces, activityId);
                 const newSymbols = this.bindSymbols(lower, upper, symbols, prefix, activity.produces);
                 if (Object.keys(newSymbols).length) {
@@ -65,7 +62,6 @@ class Deployer {
         }
     }
     bindSelf(consumes, produces, activityId) {
-        //bind self-referential mappings
         for (const selfId of [activityId, '$self']) {
             const selfConsumes = consumes[selfId];
             if (selfConsumes) {
@@ -89,7 +85,7 @@ class Deployer {
                 const symbol = (0, utils_1.getSymKey)(startIndex);
                 startIndex++;
                 newSymbols[fullPath] = symbol;
-                currentSymbols[fullPath] = symbol; // update the currentSymbols to include this new symbol
+                currentSymbols[fullPath] = symbol;
             }
         }
         return newSymbols;
@@ -102,20 +98,16 @@ class Deployer {
             if (!jobSchema && !outputSchema)
                 continue;
             const activities = graph.activities;
-            // Find the trigger activity and bind the job schema to it
-            // at execution time, the trigger is a standin for the job
             for (const activityKey in activities) {
                 if (activities[activityKey].type === 'trigger') {
                     const trigger = activities[activityKey];
                     if (jobSchema) {
-                        //possible for trigger to have job mappings
                         if (!trigger.job) {
                             trigger.job = {};
                         }
                         trigger.job.schema = jobSchema;
                     }
                     if (outputSchema) {
-                        //impossible for trigger to have output mappings.
                         trigger.output = { schema: outputSchema };
                     }
                 }
@@ -136,8 +128,6 @@ class Deployer {
             }
         }
     }
-    //the cycle/goto activity includes and ancestor target;
-    //update with the cycle flag, so it can be rerun
     bindCycleTarget() {
         for (const graph of this.manifest.app.graphs) {
             const activities = graph.activities;
@@ -149,8 +139,6 @@ class Deployer {
             }
         }
     }
-    //it's more intuitive for SDK users to use 'topic',
-    //but the compiler is desiged to be generic and uses the attribute, 'subtypes'
     convertTopicsToTypes() {
         for (const graph of this.manifest.app.graphs) {
             const activities = graph.activities;
@@ -164,7 +152,6 @@ class Deployer {
             }
         }
     }
-    //legacy; remove at beta (assume no legacy refs to 'activity' at that point)
     convertActivitiesToHooks() {
         for (const graph of this.manifest.app.graphs) {
             const activities = graph.activities;
@@ -184,11 +171,8 @@ class Deployer {
                     const toTransitions = graph.transitions[fromActivity];
                     for (const transition of toTransitions) {
                         const to = transition.to;
-                        //DAGs have one parent; easy to optimize for
                         graph.activities[to].parent = fromActivity;
                     }
-                    //temporarily bind the transitions to the parent activity,
-                    // so the consumer/producer registrar picks up the bindings
                     graph.activities[fromActivity].transitions = toTransitions;
                 }
             }
@@ -248,10 +232,6 @@ class Deployer {
                         traverse(obj[key], newPath);
                     }
                     else {
-                        //wildcard mapping (e.g., 'friends[25]')
-                        //when this is resolved, it will be expanded to
-                        //`'friends/0', ..., 'friends/24'`, providing 25 dynamic
-                        //slots in the flow's output data
                         const pathName = [...path, key].join('/');
                         if (!pathName.includes('[')) {
                             const finalPath = `data/${pathName}`;
@@ -261,17 +241,15 @@ class Deployer {
                         }
                         else {
                             const [left, right] = pathName.split('[');
-                            //check if this variable isLiteralKeyType (#, -, or _)
                             const [amount, _] = right.split(']');
                             if (!isNaN(parseInt(amount))) {
-                                //loop to create all possible paths (0 to amount)
                                 for (let i = 0; i < parseInt(amount); i++) {
                                     const finalPath = `data/${left}/${i}`;
                                     if (!result.includes(finalPath)) {
                                         result.push(finalPath);
                                     }
                                 }
-                            } //else ignore (amount might be '-' or '_')  `-` is marker data;   `_` is job data;
+                            }
                         }
                     }
                 }
@@ -293,7 +271,6 @@ class Deployer {
     }
     resolveMappingDependencies() {
         const dynamicMappingRules = [];
-        //recursive function to descend into the object and find all dynamic mapping rules
         function traverse(obj, consumes) {
             for (const key in obj) {
                 if (typeof obj[key] === 'string') {
@@ -323,7 +300,6 @@ class Deployer {
             }
         }
         const groupedRules = this.groupMappingRules(dynamicMappingRules);
-        // Iterate through the graph and add 'produces' field to each activity
         for (const graph of graphs) {
             const activities = graph.activities;
             for (const activityId in activities) {
@@ -334,7 +310,6 @@ class Deployer {
     }
     groupMappingRules(rules) {
         rules = Array.from(new Set(rules)).sort();
-        // Group by the first symbol before the period (this is the activity name)
         const groupedRules = {};
         for (const rule of rules) {
             const [group, resolved] = this.resolveMappableValue(rule);
@@ -353,7 +328,6 @@ class Deployer {
             return [group, path.join('/')];
         }
         else {
-            //normalize paths to be relative to the activity
             const [group, type, subtype, ...path] = parts;
             const prefix = {
                 hook: 'hook/data',
@@ -370,7 +344,6 @@ class Deployer {
             const activities = graph.activities;
             for (const activityKey in activities) {
                 const target = activities[activityKey];
-                //remove transitions; no longer necessary for runtime
                 delete target.transitions;
                 activitySchemas[activityKey] = target;
             }
@@ -383,7 +356,6 @@ class Deployer {
         for (const graph of graphs) {
             const activities = graph.activities;
             const subscribesTopic = graph.subscribes;
-            // Find the activity ID associated with the subscribes topic
             for (const activityKey in activities) {
                 if (activities[activityKey].type === 'trigger') {
                     publicSubscriptions[subscribesTopic] = activityKey;
@@ -446,7 +418,6 @@ class Deployer {
                         if (!targetActivity.hook) {
                             targetActivity.hook = {};
                         }
-                        //create back-reference to the hook topic
                         targetActivity.hook.topic = topic;
                     }
                 }
@@ -455,7 +426,6 @@ class Deployer {
         await this.store.setHookRules(hookRules);
     }
     async deployConsumerGroups() {
-        //create one engine group
         const params = { appId: this.manifest.app.id };
         const key = this.store.mintKey(key_1.KeyType.STREAMS, params);
         await this.deployConsumerGroup(key, 'ENGINE');
@@ -463,12 +433,10 @@ class Deployer {
             const activities = graph.activities;
             for (const activityKey in activities) {
                 const activity = activities[activityKey];
-                //only precreate if the topic is concrete and not `mappable`
                 if (activity.type === 'worker' &&
                     pipe_1.Pipe.resolve(activity.subtype, {}) === activity.subtype) {
                     params.topic = activity.subtype;
                     const key = this.store.mintKey(key_1.KeyType.STREAMS, params);
-                    //create one worker group per unique activity subtype (the topic)
                     await this.deployConsumerGroup(key, 'WORKER');
                 }
             }

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

@@ -2,28 +2,13 @@ import { ILogger } from '../logger';
 import { StoreService } from '../store';
 import { HotMeshManifest } from '../../types/hotmesh';
 import { RedisClient, RedisMulti } from '../../types/redis';
-/**
- * The compiler service converts a graph into a executable program.
- */
 declare class CompilerService {
     store: StoreService<RedisClient, RedisMulti> | null;
     logger: ILogger;
     constructor(store: StoreService<RedisClient, RedisMulti>, logger: ILogger);
-    /**
-     * verifies and plans the deployment of an app to Redis; the app is not deployed yet
-     * @param path
-     */
     plan(mySchemaOrPath: string): Promise<HotMeshManifest>;
     isPath(input: string): boolean;
-    /**
-     * deploys an app to Redis but does NOT activate it.
-     */
     deploy(mySchemaOrPath: string): Promise<HotMeshManifest>;
-    /**
-     * activates a deployed version of an app;
-     * @param appId
-     * @param appVersion
-     */
     activate(appId: string, appVersion: string): Promise<boolean>;
     saveAsJSON(originalPath: string, schema: HotMeshManifest): Promise<void>;
 }

package/build/services/compiler/index.js

@@ -33,18 +33,11 @@ const json_schema_ref_parser_1 = __importDefault(require("@apidevtools/json-sche
 const js_yaml_1 = __importDefault(require("js-yaml"));
 const deployer_1 = require("./deployer");
 const validator_1 = require("./validator");
-/**
- * The compiler service converts a graph into a executable program.
- */
 class CompilerService {
     constructor(store, logger) {
         this.store = store;
         this.logger = logger;
     }
-    /**
-     * verifies and plans the deployment of an app to Redis; the app is not deployed yet
-     * @param path
-     */
     async plan(mySchemaOrPath) {
         try {
             let schema;
@@ -54,10 +47,8 @@ class CompilerService {
             else {
                 schema = js_yaml_1.default.load(mySchemaOrPath);
             }
-            // 1) validate the manifest file
             const validator = new validator_1.Validator(schema);
             validator.validate(this.store);
-            // 2) todo: add a PlannerService module that will plan the deployment (what might break, drift, etc)
             return schema;
         }
         catch (err) {
@@ -67,9 +58,6 @@ class CompilerService {
     isPath(input) {
         return !input.trim().startsWith('app:');
     }
-    /**
-     * deploys an app to Redis but does NOT activate it.
-     */
     async deploy(mySchemaOrPath) {
         try {
             let schema;
@@ -80,13 +68,10 @@ class CompilerService {
             else {
                 schema = js_yaml_1.default.load(mySchemaOrPath);
             }
-            // 2) validate the manifest file (synchronous operation...no callbacks)
             const validator = new validator_1.Validator(schema);
             validator.validate(this.store);
-            // 3) deploy the schema (segment, optimize, etc; save to Redis)
             const deployer = new deployer_1.Deployer(schema);
             await deployer.deploy(this.store);
-            // 4) save the app version to Redis (so it can be activated later)
             await this.store.setApp(schema.app.id, schema.app.version);
             return schema;
         }
@@ -94,11 +79,6 @@ class CompilerService {
             this.logger.error('compiler-deploy-error', err);
         }
     }
-    /**
-     * activates a deployed version of an app;
-     * @param appId
-     * @param appVersion
-     */
     async activate(appId, appVersion) {
         return await this.store.activateAppVersion(appId, appVersion);
     }

package/build/services/compiler/validator.d.ts

@@ -10,9 +10,6 @@ declare class Validator {
     static SYS_VARS: string[];
     static CONTEXT_VARS: string[];
     constructor(manifest: HotMeshManifest);
-    /**
-     * validate the manifest file
-     */
     validate(store: StoreService<RedisClient, RedisMulti>): Promise<void>;
     validateActivityIds(): void;
     isMappingStatement(value: string): boolean;

package/build/services/compiler/validator.js

@@ -10,9 +10,6 @@ class Validator {
         this.store = null;
         this.manifest = manifest;
     }
-    /**
-     * validate the manifest file
-     */
     async validate(store) {
         this.store = store;
         this.getMappingStatements();
@@ -28,12 +25,10 @@ class Validator {
         this.validateHooks();
         this.validateConditionalStatements();
     }
-    // 1.1) Validate the manifest file activity ids are unique (no duplicates)
     validateActivityIds() {
         const activityIdsSet = new Set();
         this.manifest.app.graphs.forEach((graph) => {
             const ids = Object.keys(graph.activities);
-            // Check for duplicates and add ids to the set
             ids.forEach((id) => {
                 if (activityIdsSet.has(id)) {
                     throw new Error(`Duplicate activity id found: ${id}`);
@@ -72,9 +67,7 @@ class Validator {
         });
         this.mappingStatements = mappingStatements;
     }
-    // 1.2) Validate no activity ids are referenced that don't exist
     validateReferencedActivityIds() {
-        // get list of all mapping statements and validate
         const mappingStatements = this.mappingStatements;
         const activityIds = this.activityIds;
         for (const activity in mappingStatements) {
@@ -99,41 +92,23 @@ class Validator {
     isContextVariable(value) {
         return ['{$input}', '{$output}', '{$item}', '{$key}', '{$index}'].includes(value);
     }
-    // 1.3) Validate the mapping/@pipe statements are valid
     validateMappingStatements() {
-        // Implement the method content
     }
-    // 1.4) Validate the transitions are valid
     validateTransitions() {
-        // Implement the method content
     }
-    // 1.5) Validate the transition conditions are valid
     validateTransitionConditions() {
-        // Implement the method content
     }
-    // 1.6) Validate the stats
     validateStats() {
-        // Implement the method content
     }
-    // 1.7) Validate the schemas
     validateSchemas() {
-        // Implement the method content
     }
-    // 1.8) Validate the topics are unique and handled
     validateUniqueHandledTopics() {
-        // Implement the method content
     }
-    // 1.9) Validate that every graph has publishes and subscribes
     validateGraphPublishSubscribe() {
-        // Implement the method content
     }
-    // 1.10) Validate hooks, including mapping statements
     validateHooks() {
-        // Implement the method content
     }
-    // 1.11) Validate conditional statements
     validateConditionalStatements() {
-        // Implement the method content
     }
 }
 exports.Validator = Validator;

package/build/services/connector/clients/ioredis.js

@@ -45,6 +45,4 @@ RedisConnection.instances = new Map();
 RedisConnection.clientOptions = {
     host: 'localhost',
     port: 6379,
-    //password: config.REDIS_PASSWORD,
-    //db: config.REDIS_DATABASE,
 };

package/build/services/connector/clients/redis.js

@@ -57,6 +57,4 @@ RedisConnection.clientOptions = {
         port: 6379,
         tls: false,
     },
-    //password: config.REDIS_PASSWORD,
-    //database: config.REDIS_DATABASE,
 };

package/build/services/connector/index.js

@@ -5,8 +5,6 @@ const utils_1 = require("../../modules/utils");
 const ioredis_1 = require("../connector/clients/ioredis");
 const redis_1 = require("../connector/clients/redis");
 class ConnectorService {
-    //1) Initialize `store`, `stream`, and `subscription` Redis clients.
-    //2) Bind to the target if not already present
     static async initRedisClients(Redis, options, target) {
         if (!target.store || !target.stream || !target.sub) {
             const instances = [];

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

@@ -42,17 +42,13 @@ declare class EngineService {
     reporting: boolean;
     jobId: number;
     inited: string;
+    constructor();
     static init(namespace: string, appId: string, guid: string, config: HotMeshConfig, logger: ILogger): Promise<EngineService>;
     verifyEngineFields(config: HotMeshConfig): void;
     initStoreChannel(store: RedisClient): Promise<void>;
     initSubChannel(sub: RedisClient): Promise<void>;
     initStreamChannel(stream: RedisClient): Promise<void>;
     initRouter(config: HotMeshConfig): Promise<Router>;
-    /**
-     * resolves the distributed executable version using a delay
-     * to allow deployment race conditions to resolve
-     * @private
-     */
     fetchAndVerifyVID(vid: AppVID, count?: number): Promise<AppVID>;
     getVID(vid?: AppVID): Promise<AppVID>;
     setCacheMode(cacheMode: CacheMode, untilVersion: string): void;
@@ -92,11 +88,6 @@ declare class EngineService {
     delistJobCallback(jobId: string): void;
     hasOneTimeSubscription(context: JobState): boolean;
     runJobCompletionTasks(context: JobState, options?: JobCompletionOptions): Promise<string | void>;
-    /**
-     * Job hash expiration is typically reliant on the metadata field
-     * if the activity concludes normally. However, if the job is `interrupted`,
-     * it will be expired immediately.
-     */
     resolveExpires(context: JobState, options: JobCompletionOptions): number;
     export(jobId: string): Promise<JobExport>;
     getRaw(jobId: string): Promise<StringStringType>;

package/build/services/engine/index.js

@@ -94,11 +94,6 @@ class EngineService {
             throttle,
         }, this.stream, this.store, this.logger);
     }
-    /**
-     * resolves the distributed executable version using a delay
-     * to allow deployment race conditions to resolve
-     * @private
-     */
     async fetchAndVerifyVID(vid, count = 0) {
         if (isNaN(Number(vid.version))) {
             const app = await this.store.getApp(vid.id, true);
@@ -122,7 +117,6 @@ class EngineService {
         if (this.cacheMode === 'nocache') {
             const app = await this.store.getApp(this.appId, true);
             if (app.version.toString() === this.untilVersion.toString()) {
-                //new version is deployed; OK to cache again
                 if (!this.apps)
                     this.apps = {};
                 this.apps[this.appId] = app;
@@ -171,7 +165,6 @@ class EngineService {
             this.logger.error('engine-throttle-error', { error: e });
         }
     }
-    // ************* METADATA/MODEL METHODS *************
     async initActivity(topic, data = {}, context) {
         const [activityId, schema] = await this.getSchema(topic);
         const ActivityHandler = activities_1.default[utils_1.polyfill.resolveActivityType(schema.type)];
@@ -197,13 +190,11 @@ class EngineService {
             throw new Error(`no app found for id ${this.appId}`);
         }
         if (this.isPrivate(topic)) {
-            //private subscriptions use the schema id (.activityId)
             const activityId = topic.substring(1);
             const schema = await this.store.getSchema(activityId, await this.getVID(app));
             return [activityId, schema];
         }
         else {
-            //public subscriptions use a topic (a.b.c) that is associated with a schema id
             const activityId = await this.store.getSubscription(topic, await this.getVID(app));
             if (activityId) {
                 const schema = await this.store.getSchema(activityId, await this.getVID(app));
@@ -218,7 +209,6 @@ class EngineService {
     isPrivate(topic) {
         return topic.startsWith('.');
     }
-    // ************* COMPILER METHODS *************
     async plan(pathOrYAML) {
         const compiler = new compiler_1.CompilerService(this.store, this.logger);
         return await compiler.plan(pathOrYAML);
@@ -227,7 +217,6 @@ class EngineService {
         const compiler = new compiler_1.CompilerService(this.store, this.logger);
         return await compiler.deploy(pathOrYAML);
     }
-    // ************* REPORTER METHODS *************
     async getStats(topic, query) {
         const { id, version } = await this.getVID();
         const reporter = new reporter_1.ReporterService({ id, version }, this.store, this.logger);
@@ -252,7 +241,6 @@ class EngineService {
             sparse: query.sparse,
         };
     }
-    // ****************** STREAM RE-ENTRY POINT *****************
     async processStreamMessage(streamData) {
         this.logger.debug('engine-process', {
             jid: streamData.metadata.jid,
@@ -274,22 +262,18 @@ class EngineService {
             data: streamData.data,
         };
         if (streamData.type === stream_1.StreamDataType.TIMEHOOK) {
-            //TIMEHOOK AWAKEN
             const activityHandler = (await this.initActivity(`.${streamData.metadata.aid}`, context.data, context));
             await activityHandler.processTimeHookEvent(streamData.metadata.jid);
         }
         else if (streamData.type === stream_1.StreamDataType.WEBHOOK) {
-            //WEBHOOK AWAKEN (SIGNAL IN)
             const activityHandler = (await this.initActivity(`.${streamData.metadata.aid}`, context.data, context));
             await activityHandler.processWebHookEvent(streamData.status, streamData.code);
         }
         else if (streamData.type === stream_1.StreamDataType.TRANSITION) {
-            //TRANSITION (ADJACENT ACTIVITY)
-            const activityHandler = (await this.initActivity(`.${streamData.metadata.aid}`, context.data, context)); //todo: `as Activity` (type is more generic)
+            const activityHandler = (await this.initActivity(`.${streamData.metadata.aid}`, context.data, context));
             await activityHandler.process();
         }
         else if (streamData.type === stream_1.StreamDataType.AWAIT) {
-            //TRIGGER JOB
             context.metadata = {
                 ...context.metadata,
                 pj: streamData.metadata.jid,
@@ -304,12 +288,10 @@ class EngineService {
             await activityHandler.process();
         }
         else if (streamData.type === stream_1.StreamDataType.RESULT) {
-            //AWAIT RESULT
             const activityHandler = (await this.initActivity(`.${context.metadata.aid}`, streamData.data, context));
             await activityHandler.processEvent(streamData.status, streamData.code);
         }
         else {
-            //WORKER RESULT
             const activityHandler = (await this.initActivity(`.${streamData.metadata.aid}`, streamData.data, context));
             await activityHandler.processEvent(streamData.status, streamData.code, 'output');
         }
@@ -319,10 +301,8 @@ class EngineService {
             aid: streamData.metadata.aid,
         });
     }
-    // ***************** `AWAIT` ACTIVITY RETURN RESPONSE ****************
     async execAdjacentParent(context, jobOutput, emit = false) {
         if (this.hasParentJob(context)) {
-            //errors are stringified `StreamError` objects
             const error = this.resolveError(jobOutput.metadata);
             const spn = context['$self']?.output?.metadata?.l2s ||
                 context['$self']?.output?.metadata?.l1s;
@@ -367,11 +347,8 @@ class EngineService {
             return JSON.parse(metadata.err);
         }
     }
-    // ****************** `INTERRUPT` ACTIVE JOBS *****************
     async interrupt(topic, jobId, options = {}) {
-        //immediately interrupt the job, going directly to the data source
         await this.store.interrupt(topic, jobId, options);
-        //now that the job is interrupted, we can clean up
         const context = (await this.getState(topic, jobId));
         const completionOpts = {
             interrupt: options.descend,
@@ -379,12 +356,9 @@ class EngineService {
         };
         return (await this.runJobCompletionTasks(context, completionOpts));
     }
-    // ****************** `SCRUB` CLEAN COMPLETED JOBS *****************
     async scrub(jobId) {
-        //todo: do not allow scrubbing of non-existent or actively running job
         await this.store.scrub(jobId);
     }
-    // ****************** `HOOK` ACTIVITY RE-ENTRY POINT *****************
     async hook(topic, data, status = stream_1.StreamStatus.SUCCESS, code = 200) {
         const hookRule = await this.taskService.getHookRule(topic);
         const [aid] = await this.getSchema(`.${hookRule.to}`);
@@ -447,8 +421,6 @@ class EngineService {
             throw new Error(`unable to find hook rule for topic ${hookTopic}`);
         }
     }
-    // ********************** PUB/SUB ENTRY POINT **********************
-    //publish (returns just the job id)
     async pub(topic, data, context, extended) {
         const activityHandler = await this.initActivity(topic, data, context);
         if (activityHandler) {
@@ -458,29 +430,24 @@ class EngineService {
             throw new Error(`unable to process activity for topic ${topic}`);
         }
     }
-    //subscribe to all jobs for a topic
     async sub(topic, callback) {
         const subscriptionCallback = async (topic, message) => {
             callback(message.topic, message.job);
         };
         return await this.subscribe.subscribe(key_1.KeyType.QUORUM, subscriptionCallback, this.appId, topic);
     }
-    //unsubscribe to all jobs for a topic
     async unsub(topic) {
         return await this.subscribe.unsubscribe(key_1.KeyType.QUORUM, this.appId, topic);
     }
-    //subscribe to all jobs for a wildcard topic
     async psub(wild, callback) {
         const subscriptionCallback = async (topic, message) => {
             callback(message.topic, message.job);
         };
         return await this.subscribe.psubscribe(key_1.KeyType.QUORUM, subscriptionCallback, this.appId, wild);
     }
-    //unsubscribe to all jobs for a wildcard topic
     async punsub(wild) {
         return await this.subscribe.punsubscribe(key_1.KeyType.QUORUM, this.appId, wild);
     }
-    //publish and await (returns the job and data (if ready)); throws error with jobid if not
     async pubsub(topic, data, context, timeout = enums_1.HMSH_OTT_WAIT_TIME) {
         context = {
             metadata: {
@@ -504,7 +471,6 @@ class EngineService {
                 }
             });
             setTimeout(() => {
-                //note: job is still active (the subscriber timed out)
                 this.delistJobCallback(jobId);
                 reject({
                     code: enums_1.HMSH_CODE_TIMEOUT,
@@ -515,7 +481,6 @@ class EngineService {
         });
     }
     async pubOneTimeSubs(context, jobOutput, emit = false) {
-        //todo: subscriber should query for the job...only publish minimum context needed
         if (this.hasOneTimeSubscription(context)) {
             const message = {
                 type: 'job',
@@ -554,9 +519,7 @@ class EngineService {
     hasOneTimeSubscription(context) {
         return Boolean(context.metadata.ngn);
     }
-    // ********** JOB COMPLETION/CLEANUP (AND JOB EMIT) ***********
     async runJobCompletionTasks(context, options = {}) {
-        //'emit' indicates the job is still active
         const isAwait = this.hasParentJob(context, true);
         const isOneTimeSub = this.hasOneTimeSubscription(context);
         const topic = await this.getPublishesTopic(context);
@@ -572,15 +535,9 @@ class EngineService {
         }
         return msgId;
     }
-    /**
-     * Job hash expiration is typically reliant on the metadata field
-     * if the activity concludes normally. However, if the job is `interrupted`,
-     * it will be expired immediately.
-     */
     resolveExpires(context, options) {
         return options.expire ?? context.metadata.expire ?? enums_1.HMSH_EXPIRE_JOB_SECONDS;
     }
-    // ****** GET JOB STATE/COLLATION STATUS BY ID *********
     async export(jobId) {
         return await this.exporter.export(jobId);
     }
@@ -591,15 +548,11 @@ class EngineService {
         const { id: appId } = await this.getVID();
         return await this.store.getStatus(jobId, appId);
     }
-    //todo: add 'options' parameter;
-    //      (e.g, if {dimensions:true}, use hscan to deliver
-    //      the full set of dimensional job data)
     async getState(topic, jobId) {
         const jobSymbols = await this.store.getSymbols(`$${topic}`);
         const consumes = {
             [`$${topic}`]: Object.keys(jobSymbols),
         };
-        //job data exists at the 'zero' dimension; pass an empty object
         const dIds = {};
         const output = await this.store.getState(jobId, consumes, dIds);
         if (!output) {