@hotmeshio/hotmesh 0.0.43 → 0.0.44

package/build/services/durable/workflow.js

@@ -37,7 +37,7 @@ class WorkflowService {
         const entityOrEmptyString = options.entity ?? '';
         //If the workflowId is not provided, it is generated from the entity and the workflow name
         const childJobId = options.workflowId ?? `${entityOrEmptyString}-${workflowId}-$${options.entity ?? options.workflowName}${workflowDimension}-${execIndex}`;
-        const parentWorkflowId = `${workflowId}-f`;
+        const parentWorkflowId = workflowId;
         const client = new client_1.ClientService({
             connection: await connection_1.ConnectionService.connect(worker_1.WorkerService.connection),
         });
@@ -75,32 +75,35 @@ class WorkflowService {
         const workflowSpan = store.get('workflowSpan');
         const COUNTER = store.get('counter');
         const execIndex = COUNTER.counter = COUNTER.counter + 1;
+        const sessionId = `-start${workflowDimension}-${execIndex}-`;
         //NOTE: this is the hash prefix; necessary for the search index to locate the entity
         const entityOrEmptyString = options.entity ?? '';
         //If the workflowId is not provided, it is generated from the entity and the workflow name
-        const childJobId = options.workflowId ?? `${entityOrEmptyString}-${workflowId}-$${options.entity ?? options.workflowName}${workflowDimension}-${execIndex}`;
-        const parentWorkflowId = `${workflowId}-f`;
+        const parentWorkflowId = workflowId;
         const workflowTopic = `${options.entity ?? options.taskQueue}-${options.entity ?? options.workflowName}`;
-        try {
-            //get the status; if there is no error, return childJobId (what was spawned)
-            const hotMeshClient = await worker_1.WorkerService.getHotMesh(workflowTopic, { namespace });
-            await hotMeshClient.getStatus(childJobId);
+        const hotMeshClient = await worker_1.WorkerService.getHotMesh(workflowTopic, { namespace });
+        const keyParams = { appId: hotMeshClient.appId, jobId: workflowId };
+        const workflowGuid = key_1.KeyService.mintKey(hotMeshClient.namespace, key_1.KeyType.JOB_STATE, keyParams);
+        let childJobId = await hotMeshClient.engine.store.exec('HGET', workflowGuid, sessionId);
+        if (childJobId) {
             return childJobId;
         }
-        catch (error) {
-            const client = new client_1.ClientService({
-                connection: await connection_1.ConnectionService.connect(worker_1.WorkerService.connection),
-            });
-            await client.workflow.start({
-                ...options,
-                namespace,
-                workflowId: childJobId,
-                parentWorkflowId,
-                workflowTrace,
-                workflowSpan,
-            });
-            return childJobId;
+        else {
+            childJobId = options.workflowId ?? `${entityOrEmptyString}-${workflowId}-$${options.entity ?? options.workflowName}${workflowDimension}-${execIndex}`;
         }
+        const client = new client_1.ClientService({
+            connection: await connection_1.ConnectionService.connect(worker_1.WorkerService.connection),
+        });
+        await client.workflow.start({
+            ...options,
+            namespace,
+            workflowId: childJobId,
+            parentWorkflowId,
+            workflowTrace,
+            workflowSpan,
+        });
+        await hotMeshClient.engine.store.exec('HSET', workflowGuid, sessionId, childJobId);
+        return childJobId;
     }
     /**
      * Wraps activities in a proxy that will durably run them
@@ -439,7 +442,7 @@ class WorkflowService {
                     arguments: Array.from(arguments),
                     //when the origin job is removed
                     originJobId: originJobId ?? workflowId,
-                    parentWorkflowId: `${workflowId}-a`,
+                    parentWorkflowId: workflowId,
                     workflowId: activityJobId,
                     workflowTopic: activityTopic,
                     activityName,

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

@@ -5,6 +5,7 @@ import { Interrupt } from '../activities/interrupt';
 import { Signal } from '../activities/signal';
 import { Worker } from '../activities/worker';
 import { Trigger } from '../activities/trigger';
+import { ExporterService } from '../exporter';
 import { ILogger } from '../logger';
 import { Router } from '../router';
 import { StoreService } from '../store';
@@ -18,15 +19,17 @@ import { JobState, JobData, JobMetadata, JobOutput, JobStatus, JobInterruptOptio
 import { HotMeshApps, HotMeshConfig, HotMeshManifest, HotMeshSettings } from '../../types/hotmesh';
 import { JobMessageCallback } from '../../types/quorum';
 import { RedisClient, RedisMulti } from '../../types/redis';
-import { StringAnyType } from '../../types/serializer';
+import { StringAnyType, StringStringType } from '../../types/serializer';
 import { GetStatsOptions, IdsResponse, JobStatsInput, StatsResponse } from '../../types/stats';
 import { StreamCode, StreamData, StreamDataResponse, StreamError, StreamStatus } from '../../types/stream';
 import { WorkListTaskType } from '../../types/task';
+import { JobExport } from '../../types/exporter';
 declare class EngineService {
     namespace: string;
     apps: HotMeshApps | null;
     appId: string;
     guid: string;
+    exporter: ExporterService | null;
     router: Router | null;
     store: StoreService<RedisClient, RedisMulti> | null;
     stream: StreamService<RedisClient, RedisMulti> | null;
@@ -88,6 +91,8 @@ declare class EngineService {
      * it will be expired immediately.
      */
     resolveExpires(context: JobState, options: JobCompletionOptions): number;
+    export(jobId: string): Promise<JobExport>;
+    getRaw(jobId: string): Promise<StringStringType>;
     getStatus(jobId: string): Promise<JobStatus>;
     getState(topic: string, jobId: string): Promise<JobOutput>;
     getQueryState(jobId: string, fields: string[]): Promise<StringAnyType>;

package/build/services/engine/index.js

@@ -9,6 +9,7 @@ const enums_1 = require("../../modules/enums");
 const utils_1 = require("../../modules/utils");
 const activities_1 = __importDefault(require("../activities"));
 const compiler_1 = require("../compiler");
+const exporter_1 = require("../exporter");
 const reporter_1 = require("../reporter");
 const router_1 = require("../router");
 const serializer_1 = require("../serializer");
@@ -41,8 +42,8 @@ class EngineService {
             await instance.initStreamChannel(config.engine.stream);
             instance.router = instance.initRouter(config);
             instance.router.consumeMessages(instance.stream.mintKey(key_1.KeyType.STREAMS, { appId: instance.appId }), 'ENGINE', instance.guid, instance.processStreamMessage.bind(instance));
-            //the task service is used by the engine to process `webhooks` and `timehooks`
             instance.taskService = new task_1.TaskService(instance.store, logger);
+            instance.exporter = new exporter_1.ExporterService(instance.appId, instance.store, logger);
             return instance;
         }
     }
@@ -526,9 +527,15 @@ class EngineService {
         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);
+    }
+    async getRaw(jobId) {
+        return await this.store.getRaw(jobId);
+    }
     async getStatus(jobId) {
         const { id: appId } = await this.getVID();
-        return this.store.getStatus(jobId, appId);
+        return await this.store.getStatus(jobId, appId);
     }
     //todo: add 'options' parameter;
     //      (e.g, if {dimensions:true}, use hscan to deliver

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

@@ -0,0 +1,46 @@
+import { ILogger } from '../logger';
+import { StoreService } from '../store';
+import { StringStringType, Symbols } from "../../types/serializer";
+import { RedisClient, RedisMulti } from '../../types/redis';
+import { DependencyExport, ExportOptions, JobActionExport, JobExport } from '../../types/exporter';
+import { SerializerService } from '../serializer';
+/**
+ * Downloads job data from Redis (hscan, hmget, hgetall)
+ * Expands process data and includes dependency list
+ */
+declare class ExporterService {
+    appId: string;
+    logger: ILogger;
+    serializer: SerializerService;
+    store: StoreService<RedisClient, RedisMulti>;
+    symbols: Promise<Symbols> | Symbols;
+    constructor(appId: string, store: StoreService<RedisClient, RedisMulti>, logger: ILogger);
+    /**
+     * Convert the job hash and dependency list into a JobExport object.
+     * This object contains various facets that describe the interaction
+     * in terms relevant to narrative storytelling.
+     */
+    export(jobId: string, options?: ExportOptions): Promise<JobExport>;
+    /**
+     * Inflates the key from Redis, 3-character symbol
+     * into a human-readable JSON path, reflecting the
+     * tree-like structure of the unidimensional Hash
+     */
+    inflateKey(key: string): string;
+    /**
+     * Inflates the job data from Redis into a JobExport object
+     * @param jobHash - the job data from Redis
+     * @param dependencyList - the list of dependencies for the job
+     * @returns - the inflated job data
+     */
+    inflate(jobHash: StringStringType, dependencyList: string[]): JobExport;
+    /**
+     * Inflates the dependency data from Redis into a JobExport object by
+     * organizing the dimensional isolate in sch a way asto interleave
+     * into a story
+     * @param data - the dependency data from Redis
+     * @returns - the organized dependency data
+     */
+    inflateDependencyData(data: string[], actions: JobActionExport): DependencyExport[];
+}
+export { ExporterService };

package/build/services/exporter/index.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExporterService = void 0;
+const serializer_1 = require("../serializer");
+const utils_1 = require("../../modules/utils");
+/**
+ * Downloads job data from Redis (hscan, hmget, hgetall)
+ * Expands process data and includes dependency list
+ */
+class ExporterService {
+    constructor(appId, store, logger) {
+        this.appId = appId;
+        this.logger = logger;
+        this.store = store;
+        this.serializer = new serializer_1.SerializerService();
+    }
+    /**
+     * Convert the job hash and dependency list into a JobExport object.
+     * This object contains various facets that describe the interaction
+     * in terms relevant to narrative storytelling.
+     */
+    async export(jobId, options = {}) {
+        if (!this.symbols) {
+            this.symbols = this.store.getAllSymbols();
+            this.symbols = await this.symbols;
+        }
+        const depData = await this.store.getDependencies(jobId);
+        const jobData = await this.store.getRaw(jobId);
+        const jobExport = this.inflate(jobData, depData);
+        return jobExport;
+    }
+    /**
+     * Inflates the key from Redis, 3-character symbol
+     * into a human-readable JSON path, reflecting the
+     * tree-like structure of the unidimensional Hash
+     */
+    inflateKey(key) {
+        return (key in this.symbols) ? this.symbols[key] : key;
+    }
+    /**
+     * Inflates the job data from Redis into a JobExport object
+     * @param jobHash - the job data from Redis
+     * @param dependencyList - the list of dependencies for the job
+     * @returns - the inflated job data
+     */
+    inflate(jobHash, dependencyList) {
+        //the list of actions taken in the workflow and hook functions
+        const actions = {
+            hooks: {},
+            main: {
+                cursor: -1,
+                items: []
+            }
+        };
+        const process = {};
+        const dependencies = this.inflateDependencyData(dependencyList, actions);
+        const regex = /^([a-zA-Z]{3}),(\d+(?:,\d+)*)/;
+        Object.entries(jobHash).forEach(([key, value]) => {
+            const match = key.match(regex);
+            if (match) {
+                //activity process state
+                const [_, letters, numbers] = match;
+                const path = this.inflateKey(letters);
+                const dimensions = `${numbers.replace(/,/g, '/')}`;
+                const resolved = this.serializer.fromString(value);
+                process[`${dimensions}/${path}`] = resolved;
+            }
+            else if (key.length === 3) {
+                //job state
+                process[this.inflateKey(key)] = this.serializer.fromString(value);
+            }
+        });
+        return {
+            dependencies,
+            process: (0, utils_1.restoreHierarchy)(process),
+            status: jobHash[':'],
+        };
+    }
+    /**
+     * Inflates the dependency data from Redis into a JobExport object by
+     * organizing the dimensional isolate in sch a way asto interleave
+     * into a story
+     * @param data - the dependency data from Redis
+     * @returns - the organized dependency data
+     */
+    inflateDependencyData(data, actions) {
+        const hookReg = /([0-9,]+)-(\d+)$/;
+        const flowReg = /-(\d+)$/;
+        return data.map((dependency, index) => {
+            const [action, topic, gid, ...jid] = dependency.split('::');
+            const jobId = jid.join('::');
+            const match = jobId.match(hookReg);
+            let prefix;
+            let type;
+            let dimensionKey = '';
+            if (match) {
+                //hook-originating dependency
+                const [_, dimension, counter] = match;
+                dimensionKey = dimension.split(',').join('/');
+                prefix = `${dimensionKey}[${counter}]`;
+                type = 'hook';
+            }
+            else {
+                const match = jobId.match(flowReg);
+                if (match) {
+                    //main workflow-originating dependency
+                    const [_, counter] = match;
+                    prefix = `[${counter}]`;
+                    type = 'flow';
+                }
+                else {
+                    //'other' types like signal cleanup
+                    prefix = '/';
+                    type = 'other';
+                }
+            }
+            return {
+                type: action,
+                topic,
+                gid,
+                jid: jobId,
+            };
+        });
+    }
+}
+exports.ExporterService = ExporterService;

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

@@ -7,7 +7,8 @@ import { HotMeshConfig, HotMeshManifest } from '../../types/hotmesh';
 import { JobMessageCallback, QuorumProfile } from '../../types/quorum';
 import { JobStatsInput, GetStatsOptions, IdsResponse, StatsResponse } from '../../types/stats';
 import { StreamCode, StreamData, StreamDataResponse, StreamStatus } from '../../types/stream';
-import { StringAnyType } from '../../types/serializer';
+import { StringAnyType, StringStringType } from '../../types/serializer';
+import { JobExport } from '../../types/exporter';
 declare class HotMeshService {
     namespace: string;
     appId: string;
@@ -35,6 +36,8 @@ declare class HotMeshService {
     plan(path: string): Promise<HotMeshManifest>;
     deploy(pathOrYAML: string): Promise<HotMeshManifest>;
     activate(version: string, delay?: number): Promise<boolean>;
+    export(jobId: string): Promise<JobExport>;
+    getRaw(jobId: string): Promise<StringStringType>;
     getStats(topic: string, query: JobStatsInput): Promise<StatsResponse>;
     getStatus(jobId: string): Promise<JobStatus>;
     getState(topic: string, jobId: string): Promise<JobOutput>;

package/build/services/hotmesh/index.js

@@ -104,6 +104,12 @@ class HotMeshService {
         return await this.quorum?.activate(version, delay);
     }
     // ************* REPORTER METHODS *************
+    async export(jobId) {
+        return await this.engine?.export(jobId);
+    }
+    async getRaw(jobId) {
+        return await this.engine?.getRaw(jobId);
+    }
     async getStats(topic, query) {
         return await this.engine?.getStats(topic, query);
     }

package/build/services/quorum/index.js

@@ -103,7 +103,8 @@ class QuorumService {
                 engine_id: this.guid,
                 namespace: this.namespace,
                 app_id: this.appId,
-                stream: this.engine.stream.mintKey(hotmesh_1.KeyType.STREAMS, { appId: this.appId })
+                stream: this.engine.stream.mintKey(hotmesh_1.KeyType.STREAMS, { appId: this.appId }),
+                counts: this.engine.router.counts,
             };
         }
         this.store.publish(hotmesh_1.KeyType.QUORUM, {

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

@@ -17,6 +17,9 @@ declare class Router {
     logger: ILogger;
     throttle: number;
     errorCount: number;
+    counts: {
+        [key: string]: number;
+    };
     currentTimerId: NodeJS.Timeout | null;
     shouldConsume: boolean;
     constructor(config: StreamConfig, stream: StreamService<RedisClient, RedisMulti>, store: StoreService<RedisClient, RedisMulti>, logger: ILogger);

package/build/services/router/index.js

@@ -10,6 +10,7 @@ class Router {
     constructor(config, stream, store, logger) {
         this.throttle = 0;
         this.errorCount = 0;
+        this.counts = {};
         this.currentTimerId = null;
         this.appId = config.appId;
         this.guid = config.guid;
@@ -146,6 +147,8 @@ class Router {
             else {
                 output.metadata.guid = (0, utils_1.guid)();
             }
+            const code = output.code || 200;
+            this.counts[code] = (this.counts[code] || 0) + 1;
             output.type = stream_1.StreamDataType.RESPONSE;
             return await this.publishMessage(null, output);
         }

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

@@ -51,6 +51,7 @@ declare abstract class StoreService<T, U extends AbstractRedisClient> {
     getSettings(bCreate?: boolean): Promise<HotMeshSettings>;
     setSettings(manifest: HotMeshSettings): Promise<any>;
     reserveSymbolRange(target: string, size: number, type: 'JOB' | 'ACTIVITY'): Promise<[number, number, Symbols]>;
+    getAllSymbols(): Promise<Symbols>;
     getSymbols(activityId: string): Promise<Symbols>;
     addSymbols(activityId: string, symbols: Symbols): Promise<boolean>;
     seedSymbols(target: string, type: 'JOB' | 'ACTIVITY', startIndex: number): StringStringType;
@@ -68,7 +69,7 @@ declare abstract class StoreService<T, U extends AbstractRedisClient> {
      * when `originJobId` is interrupted/expired, the items in the
      * list (added via RPUSH) will be interrupted/expired (removed via LPOPed).
      */
-    registerJobDependency(originJobId: string, topic: string, jobId: string, gId: string, multi?: U): Promise<any>;
+    registerJobDependency(depType: WorkListTaskType, originJobId: string, topic: string, jobId: string, gId: string, multi?: U): Promise<any>;
     /**
      * Ensures a `hook signal` is delisted when its parent activity/job
      * is interrupted/expired.
@@ -87,6 +88,7 @@ declare abstract class StoreService<T, U extends AbstractRedisClient> {
      */
     getQueryState(jobId: string, fields: string[]): Promise<StringAnyType>;
     getState(jobId: string, consumes: Consumes, dIds: StringStringType): Promise<[StringAnyType, number] | undefined>;
+    getRaw(jobId: string): Promise<StringStringType>;
     /**
      * collate is a generic method for incrementing a value in a hash
      * in order to track their progress during processing.
@@ -124,6 +126,7 @@ declare abstract class StoreService<T, U extends AbstractRedisClient> {
      * is a standard `expire` or an `interrupt`
      */
     registerDependenciesForCleanup(jobId: string, deletionTime: number, options: JobCompletionOptions): Promise<void>;
+    getDependencies(jobId: string): Promise<string[]>;
     /**
      * registers a hook activity to be awakened (uses ZSET to
      * store the 'sleep group' and LIST to store the events
@@ -140,7 +143,7 @@ declare abstract class StoreService<T, U extends AbstractRedisClient> {
      * generic LIST (lists typically contain target job ids)
      * @param {string} listKey - for example `::INTERRUPT::job123` or `job123`
      */
-    resolveTaskKeyContext(listKey: string): [('sleep' | 'expire' | 'interrupt' | 'delist'), string];
+    resolveTaskKeyContext(listKey: string): [WorkListTaskType, string];
     /**
      * Interrupts a job and sets sets a job error (410), if 'throw'!=false.
      * This method is called by the engine and not by an activity and is

package/build/services/store/index.js

@@ -164,6 +164,35 @@ class StoreService {
             return [actualLowerLimit, upperLimit, symbols];
         }
     }
+    async getAllSymbols() {
+        //get hash with all reserved symbol ranges
+        const rangeKey = this.mintKey(key_1.KeyType.SYMKEYS, { appId: this.appId });
+        const ranges = await this.redisClient[this.commands.hgetall](rangeKey);
+        const rangeKeys = Object.keys(ranges).sort();
+        delete rangeKeys[':cursor'];
+        const multi = this.getMulti();
+        for (const rangeKey of rangeKeys) {
+            const symbolKey = this.mintKey(key_1.KeyType.SYMKEYS, { activityId: rangeKey, appId: this.appId });
+            multi[this.commands.hgetall](symbolKey);
+        }
+        const results = await multi.exec();
+        const symbolSets = {};
+        results.forEach((result, index) => {
+            if (result) {
+                let vals;
+                if (Array.isArray(result) && result.length === 2) {
+                    vals = result[1];
+                }
+                else {
+                    vals = result;
+                }
+                for (const [key, value] of Object.entries(vals)) {
+                    symbolSets[value] = key.startsWith(rangeKeys[index]) ? key : `${rangeKeys[index]}/${key}`;
+                }
+            }
+        });
+        return symbolSets;
+    }
     async getSymbols(activityId) {
         let symbols = this.cache.getSymbols(this.appId, activityId);
         if (symbols) {
@@ -314,15 +343,15 @@ class StoreService {
      * when `originJobId` is interrupted/expired, the items in the
      * list (added via RPUSH) will be interrupted/expired (removed via LPOPed).
      */
-    async registerJobDependency(originJobId, topic, jobId, gId, multi) {
+    async registerJobDependency(depType, originJobId, topic, jobId, gId, multi) {
         const privateMulti = multi || this.getMulti();
         const dependencyParams = {
             appId: this.appId,
             jobId: originJobId,
         };
         const depKey = this.mintKey(key_1.KeyType.JOB_DEPENDENTS, dependencyParams);
-        //tasks have '4' segments
-        const expireTask = `expire::${topic}::${gId}::${jobId}`;
+        //items listed as job dependencies have different relationships
+        const expireTask = `${depType}::${topic}::${gId}::${jobId}`;
         privateMulti[this.commands.rpush](depKey, expireTask);
         if (!multi) {
             return await privateMulti.exec();
@@ -487,6 +516,14 @@ class StoreService {
             throw new errors_1.GetStateError(jobId);
         }
     }
+    async getRaw(jobId) {
+        const jobKey = this.mintKey(key_1.KeyType.JOB_STATE, { appId: this.appId, jobId });
+        const job = await this.redisClient[this.commands.hgetall](jobKey);
+        if (!job) {
+            throw new errors_1.GetStateError(jobId);
+        }
+        return job;
+    }
     /**
      * collate is a generic method for incrementing a value in a hash
      * in order to track their progress during processing.
@@ -720,6 +757,11 @@ class StoreService {
         const zsetKey = this.mintKey(key_1.KeyType.TIME_RANGE, { appId: this.appId });
         await this.zAdd(zsetKey, deletionTime.toString(), depKeyContext);
     }
+    async getDependencies(jobId) {
+        const depParams = { appId: this.appId, jobId };
+        const depKey = this.mintKey(key_1.KeyType.JOB_DEPENDENTS, depParams);
+        return this.redisClient[this.commands.lrange](depKey, 0, -1);
+    }
     /**
      * registers a hook activity to be awakened (uses ZSET to
      * store the 'sleep group' and LIST to store the events
@@ -742,12 +784,18 @@ class StoreService {
             let [pType, pKey] = this.resolveTaskKeyContext(listKey);
             const timeEvent = await this.redisClient[this.commands.lpop](pKey);
             if (timeEvent) {
-                //there are 4 time-related task
-                //1) sleep (awaken), 2) expire, 3) interrupt, 4) delist
-                const [type, activityId, gId, ...jobId] = timeEvent.split('::');
+                //there are task types
+                //1) sleep (awaken), 2) expire (OR expire-child), 3) interrupt, 4) delist, 5) child (just an index helper; no work to do)
+                let [type, activityId, gId, ...jobId] = timeEvent.split('::');
                 if (type === 'delist') {
                     pType = 'delist';
                 }
+                else if (type === 'child') {
+                    pType = 'child';
+                }
+                else if (type === 'expire-child') {
+                    type = 'expire'; //use the same logic as 'expire'
+                }
                 return [listKey, jobId.join('::'), gId, activityId, pType];
             }
             await this.redisClient[this.commands.zrem](zsetKey, listKey);

package/build/services/task/index.js

@@ -75,7 +75,11 @@ class TaskService {
                 const workListTask = await this.store.getNextTask(listKey);
                 if (Array.isArray(workListTask)) {
                     const [listKey, target, gId, activityId, type] = workListTask;
-                    if (type === 'delist') {
+                    if (type === 'child') {
+                        //continue; this child is listed here for convenience, but
+                        //  will be expired by an origin ancestor and is listed there
+                    }
+                    else if (type === 'delist') {
                         //delist the signalKey (target)
                         const key = this.store.mintKey(hotmesh_1.KeyType.SIGNALS, { appId: this.store.appId });
                         await this.store.redisClient[this.store.commands.hdel](key, target);

package/build/services/worker/index.js

@@ -2,16 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkerService = void 0;
 const key_1 = require("../../modules/key");
+const utils_1 = require("../../modules/utils");
+const connector_1 = require("../connector");
 const router_1 = require("../router");
-const redis_1 = require("../store/clients/redis");
 const ioredis_1 = require("../store/clients/ioredis");
-const redis_2 = require("../stream/clients/redis");
+const redis_1 = require("../store/clients/redis");
 const ioredis_2 = require("../stream/clients/ioredis");
+const redis_2 = require("../stream/clients/redis");
 const ioredis_3 = require("../sub/clients/ioredis");
 const redis_3 = require("../sub/clients/redis");
 const stream_1 = require("../../types/stream");
-const utils_1 = require("../../modules/utils");
-const connector_1 = require("../connector");
 class WorkerService {
     constructor() {
         this.reporting = false;
@@ -114,6 +114,7 @@ class WorkerService {
                 app_id: this.appId,
                 worker_topic: this.topic,
                 stream: this.stream.mintKey(key_1.KeyType.STREAMS, params),
+                counts: this.router.counts,
             };
         }
         this.store.publish(key_1.KeyType.QUORUM, {

package/build/types/activity.d.ts

@@ -33,13 +33,18 @@ interface Measure {
 }
 interface TriggerActivityStats {
     /**
-     * parent job; including this allows the parent's
+     * dependent parent job id; including this allows the parent's
      * expiration/interruption events to cascade; set
      * `expire` in the YAML for the dependent graph
      * to 0 and provide the parent for dependent,
      * cascading interruption and cleanup
      */
     parent?: string;
+    /**
+     * adjacent parent job id; this is the actual adjacent
+     * parent in the graph, but it is not used for cascading expiration
+     */
+    adjacent?: string;
     id?: {
         [key: string]: unknown;
     } | string;

package/build/types/exporter.d.ts

@@ -0,0 +1,51 @@
+import { StringAnyType } from "./serializer";
+export type ExportItem = [(string | null), string, any];
+export interface ExportOptions {
+}
+export type JobAction = {
+    cursor: number;
+    items: ExportItem[];
+};
+export interface JobActionExport {
+    hooks: {
+        [key: string]: JobAction;
+    };
+    main: JobAction;
+}
+export interface ActivityAction {
+    action: string;
+    target: string;
+}
+export interface JobTimeline {
+    activity: string;
+    dimension: string;
+    duplex: 'entry' | 'exit';
+    timestamp: string;
+    actions?: ActivityAction[];
+}
+export interface DependencyExport {
+    type: string;
+    topic: string;
+    gid: string;
+    jid: string;
+}
+export interface ExportTransitions {
+    [key: string]: string[];
+}
+export interface ExportCycles {
+    [key: string]: string[];
+}
+export interface DurableJobExport {
+    data: StringAnyType;
+    dependencies: DependencyExport[];
+    state: StringAnyType;
+    status: string;
+    timeline: JobTimeline[];
+    transitions: ExportTransitions;
+    cycles: ExportCycles;
+}
+export interface JobExport {
+    dependencies: DependencyExport[];
+    process: StringAnyType;
+    status: string;
+}

package/build/types/exporter.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+;
+;
+;
+;
+;
+;