@hotmeshio/hotmesh 0.0.53 → 0.0.55

package/build/services/durable/handle.js

@@ -9,8 +9,8 @@ class WorkflowHandleService {
         this.hotMesh = hotMesh;
         this.exporter = new exporter_1.ExporterService(this.hotMesh.appId, this.hotMesh.engine.store, this.hotMesh.engine.logger);
     }
-    async export() {
-        return this.exporter.export(this.workflowId);
+    async export(options) {
+        return this.exporter.export(this.workflowId, options);
     }
     /**
      * Sends a signal to the workflow. This is a way to send

package/build/services/durable/worker.js

@@ -231,7 +231,7 @@ class WorkerService {
                     const workflowInput = data.data;
                     const execIndex = counter.counter - interruptionRegistry.length + 1;
                     const { workflowId, workflowTopic, workflowDimension, originJobId } = workflowInput;
-                    const collatorFlowId = `-${workflowId}-$COLLATOR${workflowDimension || ''}-${execIndex}`;
+                    const collatorFlowId = `-${workflowId}-$${workflowDimension || ''}-$${execIndex}`;
                     return {
                         status: stream_1.StreamStatus.SUCCESS,
                         code: enums_1.HMSH_CODE_DURABLE_ALL,

package/build/services/durable/workflow.d.ts

@@ -2,17 +2,33 @@ import { Search } from './search';
 import { HotMeshService as HotMesh } from '../hotmesh';
 import { ActivityConfig, HookOptions, ProxyType, WorkflowContext, WorkflowOptions } from "../../types/durable";
 import { JobInterruptOptions } from '../../types/job';
+import { DurableChildErrorType, DurableProxyErrorType } from '../../types/error';
 export declare class WorkflowService {
     /**
-     * Return a handle to the hotmesh client currently running the workflow
-     * @returns {Promise<HotMesh>} - a hotmesh client
+     * Returns the synchronous output from the activity (replay)
+     * if available locally, revealing whether or not the activity already
+     * ran during a prior execution cycle
+     * @param {string} prefix - one of: proxy, child, start, wait etc
+     * @returns
      */
-    static getHotMesh(): Promise<HotMesh>;
+    static didRun(prefix: string): Promise<[boolean, number, any]>;
+    /**
+     * Those methods that may only be called once must be protected by flagging
+     * their execution with a unique key (the key is stored in the HASH alongside
+     * process state and job state)
+     * @private
+     */
+    static isSideEffectAllowed(hotMeshClient: HotMesh, prefix: string): Promise<boolean>;
     /**
      * Returns the current workflow context restored
      * from Redis
      */
     static getContext(): WorkflowContext;
+    /**
+     * Return a handle to the hotmesh client hosting the workflow execution
+     * @returns {Promise<HotMesh>} - a hotmesh client
+     */
+    static getHotMesh(): Promise<HotMesh>;
     /**
      * Spawns a child workflow and awaits the return.
      * @template T - the result type
@@ -22,6 +38,11 @@ export declare class WorkflowService {
      * const result = await Durable.workflow.execChild<typeof resultType>({ ...options });
      */
     static execChild<T>(options: WorkflowOptions): Promise<T>;
+    /**
+     * constructs the payload necessary to spawn a child job
+     * @private
+     */
+    static getChildInterruptPayload(context: WorkflowContext, options: WorkflowOptions, execIndex: number): DurableChildErrorType;
     /**
      * Spawns a child workflow and returns the child Job ID.
      * This method guarantees the spawned child has reserved the Job ID,
@@ -53,26 +74,17 @@ export declare class WorkflowService {
      */
     static proxyActivities<ACT>(options?: ActivityConfig): ProxyType<ACT>;
     static wrapActivity<T>(activityName: string, options?: ActivityConfig): T;
+    /**
+      * constructs the payload necessary to spawn a proxyActivity job
+      * @private
+      */
+    static getProxyInterruptPayload(context: WorkflowContext, activityName: string, execIndex: number, args: any[], options?: ActivityConfig): DurableProxyErrorType;
     /**
      * Returns a search session for use when reading/writing to the workflow HASH.
      * The search session provides access to methods like `get`, `mget`, `set`, `del`, and `incr`.
      * @returns {Promise<Search>} - a search session
      */
     static search(): Promise<Search>;
-    /**
-     * Returns the synchronous output from the activity (replay)
-     * if available locally
-     * @param {string} prefix - one of: proxy, child, start, wait etc
-     * @returns
-     */
-    static didRun(prefix: string): Promise<[boolean, number, any]>;
-    /**
-     * Those methods that may only be called once must be protected by flagging
-     * their execution with a unique key (the key is stored in the HASH alongside
-     * process state and job state)
-     * @private
-     */
-    static isSideEffectAllowed(hotMeshClient: HotMesh, prefix: string): Promise<boolean>;
     /**
      * Returns a random number between 0 and 1. This number is deterministic
      * and will never vary for a given seed. This is useful for randomizing

package/build/services/durable/workflow.js

@@ -11,19 +11,51 @@ const storage_1 = require("../../modules/storage");
 const utils_1 = require("../../modules/utils");
 const search_1 = require("./search");
 const worker_1 = require("./worker");
+const serializer_1 = require("../serializer");
 const stream_1 = require("../../types/stream");
 const enums_1 = require("../../modules/enums");
-const serializer_1 = require("../serializer");
 class WorkflowService {
     /**
-     * Return a handle to the hotmesh client currently running the workflow
-     * @returns {Promise<HotMesh>} - a hotmesh client
+     * Returns the synchronous output from the activity (replay)
+     * if available locally, revealing whether or not the activity already
+     * ran during a prior execution cycle
+     * @param {string} prefix - one of: proxy, child, start, wait etc
+     * @returns
      */
-    static async getHotMesh() {
+    static async didRun(prefix) {
+        const { COUNTER, replay, workflowDimension, } = WorkflowService.getContext();
+        const execIndex = COUNTER.counter = COUNTER.counter + 1;
+        const sessionId = `-${prefix}${workflowDimension}-${execIndex}-`;
+        if (sessionId in replay) {
+            const restored = serializer_1.SerializerService.fromString(replay[sessionId]);
+            return [true, execIndex, restored];
+        }
+        return [false, execIndex, null];
+    }
+    /**
+     * Those methods that may only be called once must be protected by flagging
+     * their execution with a unique key (the key is stored in the HASH alongside
+     * process state and job state)
+     * @private
+     */
+    static async isSideEffectAllowed(hotMeshClient, prefix) {
         const store = storage_1.asyncLocalStorage.getStore();
-        const workflowTopic = store.get('workflowTopic');
-        const namespace = store.get('namespace');
-        return await worker_1.WorkerService.getHotMesh(workflowTopic, { namespace });
+        const workflowId = store.get('workflowId');
+        const workflowDimension = store.get('workflowDimension') ?? '';
+        const COUNTER = store.get('counter');
+        const execIndex = COUNTER.counter = COUNTER.counter + 1;
+        const sessionId = `-${prefix}${workflowDimension}-${execIndex}-`;
+        const replay = store.get('replay');
+        if (sessionId in replay) {
+            return false;
+        }
+        const keyParams = {
+            appId: hotMeshClient.appId,
+            jobId: workflowId
+        };
+        const workflowGuid = key_1.KeyService.mintKey(hotMeshClient.namespace, key_1.KeyType.JOB_STATE, keyParams);
+        const guidValue = Number(await hotMeshClient.engine.store.exec('HINCRBYFLOAT', workflowGuid, sessionId, '1'));
+        return guidValue === 1;
     }
     /**
      * Returns the current workflow context restored
@@ -34,9 +66,11 @@ class WorkflowService {
         const workflowId = store.get('workflowId');
         const replay = store.get('replay');
         const cursor = store.get('cursor');
+        const interruptionRegistry = store.get('interruptionRegistry');
         const workflowDimension = store.get('workflowDimension') ?? '';
         const workflowTopic = store.get('workflowTopic');
         const namespace = store.get('namespace');
+        const originJobId = store.get('originJobId');
         const workflowTrace = store.get('workflowTrace');
         const canRetry = store.get('canRetry');
         const workflowSpan = store.get('workflowSpan');
@@ -47,7 +81,9 @@ class WorkflowService {
             COUNTER,
             counter: COUNTER.counter,
             cursor,
+            interruptionRegistry,
             namespace,
+            originJobId,
             raw,
             replay,
             workflowId,
@@ -57,6 +93,16 @@ class WorkflowService {
             workflowSpan,
         };
     }
+    /**
+     * Return a handle to the hotmesh client hosting the workflow execution
+     * @returns {Promise<HotMesh>} - a hotmesh client
+     */
+    static async getHotMesh() {
+        const store = storage_1.asyncLocalStorage.getStore();
+        const workflowTopic = store.get('workflowTopic');
+        const namespace = store.get('namespace');
+        return await worker_1.WorkerService.getHotMesh(workflowTopic, { namespace });
+    }
     /**
      * Spawns a child workflow and awaits the return.
      * @template T - the result type
@@ -69,13 +115,14 @@ class WorkflowService {
         //SYNC
         //check if the activity already ran (check $error/done)
         const isStartChild = options.await === false;
-        const [didRun, execIndex, result] = await WorkflowService.didRun(isStartChild ? 'start' : 'child');
-        const store = storage_1.asyncLocalStorage.getStore();
-        const canRetry = store.get('canRetry');
+        const prefix = isStartChild ? 'start' : 'child';
+        const [didRun, execIndex, result] = await WorkflowService.didRun(prefix);
+        const context = WorkflowService.getContext();
+        const { canRetry, interruptionRegistry } = context;
         if (didRun) {
             if (result?.$error && (!result.$error.is_stream_error || (result.$error.is_stream_error && !canRetry))) {
                 if (options?.config?.throwOnError !== false) {
-                    //rethrow remote execution error (simulates throw)
+                    //rethrow remote execution error (simulates local failure)
                     const code = result.$error.code;
                     const message = result.$error.message;
                     const stack = result.$error.stack;
@@ -98,18 +145,38 @@ class WorkflowService {
                 return result.data;
             }
         }
-        //package the interruption inputs
-        const interruptionRegistry = store.get('interruptionRegistry');
-        const workflowId = store.get('workflowId');
-        const originJobId = store.get('originJobId');
-        const workflowDimension = store.get('workflowDimension') ?? '';
-        const entityOrEmptyString = options.entity ?? '';
-        const childJobId = options.workflowId ?? `${entityOrEmptyString}-${workflowId}-$${options.entity ?? options.workflowName}${workflowDimension}-${execIndex}`;
+        const interruptionMessage = WorkflowService.getChildInterruptPayload(context, options, execIndex);
+        //push the packaged inputs to the registry
+        interruptionRegistry.push({
+            code: enums_1.HMSH_CODE_DURABLE_CHILD,
+            ...interruptionMessage,
+        });
+        //ASYNC
+        //sleep (allow others to be packaged / registered) and throw the error
+        await (0, utils_1.sleepFor)(0);
+        throw new errors_1.DurableChildError(interruptionMessage);
+    }
+    /**
+     * constructs the payload necessary to spawn a child job
+     * @private
+     */
+    static getChildInterruptPayload(context, options, execIndex) {
+        const { workflowId, originJobId, workflowDimension } = context;
+        let childJobId;
+        if (options.workflowId) {
+            childJobId = options.workflowId;
+        }
+        else if (options.entity) {
+            childJobId = `${options.entity}-${workflowId.substring(0, 7)}-${(0, utils_1.guid)()}-${workflowDimension}-${execIndex}`;
+        }
+        else {
+            childJobId = `-${options.workflowName}-${(0, utils_1.guid)()}-${workflowDimension}-${execIndex}`;
+        }
         const parentWorkflowId = workflowId;
         const taskQueueName = options.entity ?? options.taskQueue;
         const workflowName = options.entity ?? options.workflowName;
         const workflowTopic = `${taskQueueName}-${workflowName}`;
-        const interruptionMessage = {
+        return {
             arguments: [...(options.args || [])],
             await: options?.await ?? true,
             backoffCoefficient: options?.config?.backoffCoefficient ?? enums_1.HMSH_DURABLE_EXP_BACKOFF,
@@ -122,15 +189,6 @@ class WorkflowService {
             workflowId: childJobId,
             workflowTopic,
         };
-        //push the packaged inputs to the registry
-        interruptionRegistry.push({
-            code: enums_1.HMSH_CODE_DURABLE_CHILD,
-            ...interruptionMessage,
-        });
-        //ASYNC
-        //sleep (allow others to be packaged / registered) and throw the error
-        await (0, utils_1.sleepFor)(0);
-        throw new errors_1.DurableChildError(interruptionMessage);
     }
     /**
      * Spawns a child workflow and returns the child Job ID.
@@ -144,7 +202,7 @@ class WorkflowService {
      * const childJobId = await Durable.workflow.startChild({ ...options });
      */
     static async startChild(options) {
-        return this.execChild({ ...options, await: false });
+        return WorkflowService.execChild({ ...options, await: false });
     }
     /**
      * Wraps activities in a proxy that durably runs/re-runs them to completion.
@@ -204,31 +262,9 @@ class WorkflowService {
                 return result.data;
             }
             //package the interruption inputs
-            const store = storage_1.asyncLocalStorage.getStore();
-            const interruptionRegistry = store.get('interruptionRegistry');
-            const workflowDimension = store.get('workflowDimension') ?? '';
-            const workflowId = store.get('workflowId');
-            const originJobId = store.get('originJobId');
-            const workflowTopic = store.get('workflowTopic');
-            const activityTopic = `${workflowTopic}-activity`;
-            const activityJobId = `-${workflowId}-$${activityName}${workflowDimension}-${execIndex}`;
-            let maximumInterval;
-            if (options.retryPolicy?.maximumInterval) {
-                maximumInterval = (0, ms_1.default)(options.retryPolicy.maximumInterval) / 1000;
-            }
-            const interruptionMessage = {
-                arguments: Array.from(arguments),
-                workflowDimension: workflowDimension,
-                index: execIndex,
-                originJobId: originJobId || workflowId,
-                parentWorkflowId: workflowId,
-                workflowId: activityJobId,
-                workflowTopic: activityTopic,
-                activityName,
-                backoffCoefficient: options?.retryPolicy?.backoffCoefficient ?? undefined,
-                maximumAttempts: options?.retryPolicy?.maximumAttempts ?? undefined,
-                maximumInterval: maximumInterval ?? undefined,
-            };
+            const context = WorkflowService.getContext();
+            const { interruptionRegistry } = context;
+            const interruptionMessage = WorkflowService.getProxyInterruptPayload(context, activityName, execIndex, Array.from(arguments), options);
             //push the packaged inputs to the registry
             interruptionRegistry.push({
                 code: enums_1.HMSH_CODE_DURABLE_PROXY,
@@ -240,6 +276,32 @@ class WorkflowService {
             throw new errors_1.DurableProxyError(interruptionMessage);
         };
     }
+    /**
+      * constructs the payload necessary to spawn a proxyActivity job
+      * @private
+      */
+    static getProxyInterruptPayload(context, activityName, execIndex, args, options) {
+        const { workflowDimension, workflowId, originJobId, workflowTopic } = context;
+        const activityTopic = `${workflowTopic}-activity`;
+        const activityJobId = `-${workflowId}-$${activityName}${workflowDimension}-${execIndex}`;
+        let maximumInterval;
+        if (options.retryPolicy?.maximumInterval) {
+            maximumInterval = (0, ms_1.default)(options.retryPolicy.maximumInterval) / 1000;
+        }
+        return {
+            arguments: args,
+            workflowDimension: workflowDimension,
+            index: execIndex,
+            originJobId: originJobId || workflowId,
+            parentWorkflowId: workflowId,
+            workflowId: activityJobId,
+            workflowTopic: activityTopic,
+            activityName,
+            backoffCoefficient: options?.retryPolicy?.backoffCoefficient ?? undefined,
+            maximumAttempts: options?.retryPolicy?.maximumAttempts ?? undefined,
+            maximumInterval: maximumInterval ?? undefined,
+        };
+    }
     /**
      * Returns a search session for use when reading/writing to the workflow HASH.
      * The search session provides access to methods like `get`, `mget`, `set`, `del`, and `incr`.
@@ -258,46 +320,6 @@ class WorkflowService {
         const searchSessionId = `-search${workflowDimension}-${execIndex}`;
         return new search_1.Search(workflowId, hotMeshClient, searchSessionId);
     }
-    /**
-     * Returns the synchronous output from the activity (replay)
-     * if available locally
-     * @param {string} prefix - one of: proxy, child, start, wait etc
-     * @returns
-     */
-    static async didRun(prefix) {
-        const { COUNTER, replay, workflowDimension, } = WorkflowService.getContext();
-        const execIndex = COUNTER.counter = COUNTER.counter + 1;
-        const sessionId = `-${prefix}${workflowDimension}-${execIndex}-`;
-        if (sessionId in replay) {
-            return [true, execIndex, serializer_1.SerializerService.fromString(replay[sessionId])];
-        }
-        return [false, execIndex, null];
-    }
-    /**
-     * Those methods that may only be called once must be protected by flagging
-     * their execution with a unique key (the key is stored in the HASH alongside
-     * process state and job state)
-     * @private
-     */
-    static async isSideEffectAllowed(hotMeshClient, prefix) {
-        const store = storage_1.asyncLocalStorage.getStore();
-        const workflowId = store.get('workflowId');
-        const workflowDimension = store.get('workflowDimension') ?? '';
-        const COUNTER = store.get('counter');
-        const execIndex = COUNTER.counter = COUNTER.counter + 1;
-        const sessionId = `-${prefix}${workflowDimension}-${execIndex}-`;
-        const replay = store.get('replay');
-        if (sessionId in replay) {
-            return false;
-        }
-        const keyParams = {
-            appId: hotMeshClient.appId,
-            jobId: workflowId
-        };
-        const workflowGuid = key_1.KeyService.mintKey(hotMeshClient.namespace, key_1.KeyType.JOB_STATE, keyParams);
-        const guidValue = Number(await hotMeshClient.engine.store.exec('HINCRBYFLOAT', workflowGuid, sessionId, '1'));
-        return guidValue === 1;
-    }
     /**
      * Returns a random number between 0 and 1. This number is deterministic
      * and will never vary for a given seed. This is useful for randomizing
@@ -388,9 +410,7 @@ class WorkflowService {
      * Interrupts a running job
      */
     static async interrupt(jobId, options = {}) {
-        const store = storage_1.asyncLocalStorage.getStore();
-        const workflowTopic = store.get('workflowTopic');
-        const namespace = store.get('namespace');
+        const { workflowTopic, namespace } = WorkflowService.getContext();
         const hotMeshClient = await worker_1.WorkerService.getHotMesh(workflowTopic, { namespace });
         if (await WorkflowService.isSideEffectAllowed(hotMeshClient, 'interrupt')) {
             return await hotMeshClient.interrupt(`${hotMeshClient.appId}.execute`, jobId, options);

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

@@ -15,7 +15,7 @@ import { TaskService } from '../task';
 import { AppVID } from '../../types/app';
 import { ActivityType } from '../../types/activity';
 import { CacheMode } from '../../types/cache';
-import { JobState, JobData, JobMetadata, JobOutput, JobStatus, JobInterruptOptions, JobCompletionOptions } from '../../types/job';
+import { JobState, JobData, JobMetadata, JobOutput, JobStatus, JobInterruptOptions, JobCompletionOptions, ExtensionType } from '../../types/job';
 import { HotMeshApps, HotMeshConfig, HotMeshManifest, HotMeshSettings } from '../../types/hotmesh';
 import { JobMessageCallback } from '../../types/quorum';
 import { RedisClient, RedisMulti } from '../../types/redis';
@@ -72,7 +72,7 @@ declare class EngineService {
     hook(topic: string, data: JobData, status?: StreamStatus, code?: StreamCode): Promise<string>;
     hookTime(jobId: string, gId: string, topicOrActivity: string, type?: WorkListTaskType): Promise<string | void>;
     hookAll(hookTopic: string, data: JobData, keyResolver: JobStatsInput, queryFacets?: string[]): Promise<string[]>;
-    pub(topic: string, data: JobData, context?: JobState): Promise<string>;
+    pub(topic: string, data: JobData, context?: JobState, extended?: ExtensionType): Promise<string>;
     sub(topic: string, callback: JobMessageCallback): Promise<void>;
     unsub(topic: string): Promise<void>;
     psub(wild: string, callback: JobMessageCallback): Promise<void>;

package/build/services/engine/index.js

@@ -408,10 +408,10 @@ class EngineService {
     }
     // ********************** PUB/SUB ENTRY POINT **********************
     //publish (returns just the job id)
-    async pub(topic, data, context) {
+    async pub(topic, data, context, extended) {
         const activityHandler = await this.initActivity(topic, data, context);
         if (activityHandler) {
-            return await activityHandler.process();
+            return await activityHandler.process(extended);
         }
         else {
             throw new Error(`unable to process activity for topic ${topic}`);

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

@@ -2,7 +2,7 @@ import { EngineService } from '../engine';
 import { ILogger } from '../logger';
 import { QuorumService } from '../quorum';
 import { WorkerService } from '../worker';
-import { JobState, JobData, JobOutput, JobStatus, JobInterruptOptions } from '../../types/job';
+import { JobState, JobData, JobOutput, JobStatus, JobInterruptOptions, ExtensionType } from '../../types/job';
 import { HotMeshConfig, HotMeshManifest } from '../../types/hotmesh';
 import { JobMessageCallback, QuorumProfile, ThrottleOptions } from '../../types/quorum';
 import { JobStatsInput, GetStatsOptions, IdsResponse, StatsResponse } from '../../types/stats';
@@ -25,7 +25,7 @@ declare class HotMeshService {
     initEngine(config: HotMeshConfig, logger: ILogger): Promise<void>;
     initQuorum(config: HotMeshConfig, engine: EngineService, logger: ILogger): Promise<void>;
     doWork(config: HotMeshConfig, logger: ILogger): Promise<void>;
-    pub(topic: string, data?: JobData, context?: JobState): Promise<string>;
+    pub(topic: string, data?: JobData, context?: JobState, extended?: ExtensionType): Promise<string>;
     sub(topic: string, callback: JobMessageCallback): Promise<void>;
     unsub(topic: string): Promise<void>;
     psub(wild: string, callback: JobMessageCallback): Promise<void>;

package/build/services/hotmesh/index.js

@@ -68,8 +68,8 @@ class HotMeshService {
         this.workers = await worker_1.WorkerService.init(this.namespace, this.appId, this.guid, config, logger);
     }
     // ************* PUB/SUB METHODS *************
-    async pub(topic, data = {}, context) {
-        return await this.engine?.pub(topic, data, context);
+    async pub(topic, data = {}, context, extended) {
+        return await this.engine?.pub(topic, data, context, extended);
     }
     async sub(topic, callback) {
         return await this.engine?.sub(topic, callback);

package/build/types/durable.d.ts

@@ -1,6 +1,6 @@
 import { LogLevel } from './logger';
 import { RedisClass, RedisOptions } from './redis';
-import { StringStringType } from './serializer';
+import { StringAnyType, StringStringType } from './serializer';
 import { StreamData, StreamError } from './stream';
 /**
  * Type definition for workflow configuration.
@@ -56,6 +56,14 @@ type WorkflowContext = {
      * the HotMesh App namespace. `durable` is the default.
      */
     namespace: string;
+    /**
+     * holds list of interruption payloads; if list is longer than 1 when the error is thrown, a `collator` subflow will be used
+     */
+    interruptionRegistry: any[];
+    /**
+     * entry point ancestor flow; might be the parent; will never be self
+     */
+    originJobId: string;
     /**
      * the workflow/job ID
      */
@@ -94,7 +102,7 @@ type WorkflowSearchOptions = {
         sortable?: boolean;
     }>;
     /** Additional data as a key-value record */
-    data?: Record<string, string>;
+    data?: StringStringType;
 };
 type WorkflowOptions = {
     /**
@@ -141,6 +149,10 @@ type WorkflowOptions = {
      * the full-text-search (RediSearch) options for the workflow
      */
     search?: WorkflowSearchOptions;
+    /**
+     * marker data (begins with a -)
+     */
+    marker?: StringStringType;
     /**
      * the workflow configuration object
      */
@@ -191,7 +203,7 @@ type SignalOptions = {
     /**
      * Input data for the signal (any serializable object)
      */
-    data: Record<string, any>;
+    data: StringAnyType;
     /**
      * Execution ID, also known as the job ID
      */

package/build/types/error.d.ts

@@ -0,0 +1,48 @@
+export type DurableChildErrorType = {
+    arguments: string[];
+    await?: boolean;
+    backoffCoefficient?: number;
+    index: number;
+    maximumAttempts?: number;
+    maximumInterval?: number;
+    originJobId: string | null;
+    parentWorkflowId: string;
+    workflowDimension: string;
+    workflowId: string;
+    workflowTopic: string;
+};
+export type DurableWaitForAllErrorType = {
+    items: string[];
+    workflowId: string;
+    workflowTopic: string;
+    parentWorkflowId: string;
+    originJobId: string | null;
+    size: number;
+    index: number;
+    workflowDimension: string;
+};
+export type DurableProxyErrorType = {
+    arguments: string[];
+    activityName: string;
+    backoffCoefficient?: number;
+    index: number;
+    maximumAttempts?: number;
+    maximumInterval?: number;
+    originJobId: string | null;
+    parentWorkflowId: string;
+    workflowDimension: string;
+    workflowId: string;
+    workflowTopic: string;
+};
+export type DurableWaitForErrorType = {
+    signalId: string;
+    index: number;
+    workflowDimension: string;
+    workflowId: string;
+};
+export type DurableSleepErrorType = {
+    duration: number;
+    index: number;
+    workflowDimension: string;
+    workflowId: string;
+};

package/build/types/error.js

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

package/build/types/exporter.d.ts

@@ -1,6 +1,23 @@
 import { StringAnyType } from "./serializer";
 export type ExportItem = [(string | null), string, any];
+/**
+ * job export data can be large, particularly transitions the timeline
+ */
+export type ExportFields = 'data' | 'state' | 'status' | 'timeline' | 'transitions';
 export interface ExportOptions {
+    /**
+     * limit the export byte size by specifying an allowlist
+     */
+    allow?: Array<ExportFields>;
+    /**
+     * limit the export byte size by specifying a block list
+     */
+    block?: Array<ExportFields>;
+    /**
+     * If false, do not return timeline values (like child job response, proxy activity response, etc)
+     * @default true
+     */
+    values?: boolean;
 }
 export type JobAction = {
     cursor: number;
@@ -37,36 +54,25 @@ export interface ExportTransitions {
 export interface ExportCycles {
     [key: string]: string[];
 }
-export type IdemParts = {
+export type TimelineType = {
+    key: string;
+    value: Record<string, any> | string | number | null;
     index: number;
     secondary?: number;
     dimension?: string;
 };
-export type IdemType = {
-    key: string;
-    value: string;
-    parts: IdemParts;
-};
-export interface TimelineEntry {
-    activity: string;
-    dimensions: string;
-    created: string;
-    updated: string;
-}
-export interface TimestampParts {
+export interface TransitionType {
     activity: string;
     dimensions: string;
     created: string;
     updated: string;
 }
 export interface DurableJobExport {
-    data: StringAnyType;
-    dependencies?: Record<string, any>[];
-    state: StringAnyType;
-    status: string;
-    timeline?: JobTimeline[];
-    idempotents: IdemType[];
-    replay: TimestampParts[];
+    data?: StringAnyType;
+    state?: StringAnyType;
+    status?: number;
+    timeline?: TimelineType[];
+    transitions?: TransitionType[];
 }
 export interface JobExport {
     dependencies: DependencyExport[];