@hotmeshio/hotmesh 0.0.52 → 0.0.54

package/build/services/durable/client.js

@@ -1,14 +1,19 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ClientService = void 0;
-const factory_1 = require("./factory");
+const ms_1 = __importDefault(require("ms"));
+const factory_1 = require("./schemas/factory");
+const enums_1 = require("../../modules/enums");
+const utils_1 = require("../../modules/utils");
 const handle_1 = require("./handle");
 const hotmesh_1 = require("../hotmesh");
 const key_1 = require("../../modules/key");
 const search_1 = require("./search");
 const types_1 = require("../../types");
-const enums_1 = require("../../modules/enums");
-const utils_1 = require("../../modules/utils");
 class ClientService {
     constructor(config) {
         this.getHotMeshClient = async (workflowTopic, namespace) => {
@@ -18,7 +23,7 @@ class ClientService {
                 await this.verifyWorkflowActive(hotMeshClient, targetNS);
                 if (!ClientService.topics.includes(workflowTopic)) {
                     ClientService.topics.push(workflowTopic);
-                    await this.createStream(hotMeshClient, workflowTopic, namespace);
+                    await ClientService.createStream(hotMeshClient, workflowTopic, namespace);
                 }
                 return hotMeshClient;
             }
@@ -34,27 +39,10 @@ class ClientService {
                 }
             });
             ClientService.instances.set(targetNS, hotMeshClient);
-            await this.createStream(await hotMeshClient, workflowTopic, namespace);
+            await ClientService.createStream(await hotMeshClient, workflowTopic, namespace);
             await this.activateWorkflow(await hotMeshClient, targetNS);
             return hotMeshClient;
         };
-        /**
-         * Creates a stream (Redis `XGROUP.CREATE`) where events can be published (XADD).
-         * It is possible that the worker that will read from this stream channel
-         * has not yet been initialized, so this call ensures that the channel
-         * exists and is ready to serve as a container for events.
-         */
-        this.createStream = async (hotMeshClient, workflowTopic, namespace) => {
-            const store = hotMeshClient.engine.store;
-            const params = { appId: namespace ?? factory_1.APP_ID, topic: workflowTopic };
-            const streamKey = store.mintKey(key_1.KeyType.STREAMS, params);
-            try {
-                await store.xgroup('CREATE', streamKey, 'WORKER', '$', 'MKSTREAM');
-            }
-            catch (err) {
-                //ignore if already exists
-            }
-        };
         /**
          * For those deployments with a redis stack backend (with the FT module),
          * this method will configure the search index for the workflow.
@@ -80,8 +68,8 @@ class ClientService {
                     const prefixes = search.prefix.map((prefix) => `${hotMeshPrefix}${prefix}`);
                     await store.exec('FT.CREATE', `${search.index}`, 'ON', 'HASH', 'PREFIX', prefixes.length, ...prefixes, 'SCHEMA', ...schema);
                 }
-                catch (err) {
-                    hotMeshClient.engine.logger.info('durable-client-search-err', { err });
+                catch (error) {
+                    hotMeshClient.engine.logger.info('durable-client-search-err', { ...error });
                 }
             }
         };
@@ -110,17 +98,12 @@ class ClientService {
                     parentWorkflowId: options.parentWorkflowId,
                     workflowId: options.workflowId || hotmesh_1.HotMeshService.guid(),
                     workflowTopic: workflowTopic,
-                    backoffCoefficient: options.config?.backoffCoefficient || factory_1.DEFAULT_COEFFICIENT,
+                    backoffCoefficient: options.config?.backoffCoefficient || enums_1.HMSH_DURABLE_EXP_BACKOFF,
+                    maximumAttempts: options.config?.maximumAttempts || enums_1.HMSH_DURABLE_MAX_ATTEMPTS,
+                    maximumInterval: (0, ms_1.default)(options.config?.maximumInterval || enums_1.HMSH_DURABLE_MAX_INTERVAL) / 1000,
                 };
                 const context = { metadata: { trc, spn }, data: {} };
-                const jobId = await hotMeshClient.pub(`${options.namespace ?? factory_1.APP_ID}.execute`, payload, context);
-                // Seed search data
-                if (jobId && options.search?.data) {
-                    const searchSessionId = `-search-0`;
-                    const search = new search_1.Search(jobId, hotMeshClient, searchSessionId);
-                    const entries = Object.entries(options.search.data).flat();
-                    await search.set(...entries);
-                }
+                const jobId = await hotMeshClient.pub(`${options.namespace ?? factory_1.APP_ID}.execute`, payload, context, { search: options?.search?.data, marker: options?.marker });
                 return new handle_1.WorkflowHandleService(hotMeshClient, workflowTopic, jobId);
             },
             /**
@@ -142,7 +125,9 @@ class ClientService {
                     arguments: [...options.args],
                     id: options.workflowId,
                     workflowTopic,
-                    backoffCoefficient: options.config?.backoffCoefficient || factory_1.DEFAULT_COEFFICIENT,
+                    backoffCoefficient: options.config?.backoffCoefficient || enums_1.HMSH_DURABLE_EXP_BACKOFF,
+                    maximumAttempts: options.config?.maximumAttempts || enums_1.HMSH_DURABLE_MAX_ATTEMPTS,
+                    maximumInterval: (0, ms_1.default)(options.config?.maximumInterval || enums_1.HMSH_DURABLE_MAX_INTERVAL) / 1000,
                 };
                 //seed search data if presentthe hook before entering
                 const hotMeshClient = await this.getHotMeshClient(workflowTopic, options.namespace);
@@ -166,9 +151,9 @@ class ClientService {
                 try {
                     return await this.search(hotMeshClient, index, query);
                 }
-                catch (err) {
-                    hotMeshClient.engine.logger.error('durable-client-search-err', { err });
-                    throw err;
+                catch (error) {
+                    hotMeshClient.engine.logger.error('durable-client-search-err', { ...error });
+                    throw error;
                 }
             }
         };
@@ -195,7 +180,7 @@ class ClientService {
                 await hotMesh.activate(version);
             }
             catch (error) {
-                hotMesh.engine.logger.error('durable-client-deploy-activate-err', { error });
+                hotMesh.engine.logger.error('durable-client-deploy-activate-err', { ...error });
                 throw error;
             }
         }
@@ -215,6 +200,40 @@ class ClientService {
         }
     }
 }
+_a = ClientService;
 ClientService.topics = [];
 ClientService.instances = new Map();
+/**
+ * Creates a stream (Redis `XGROUP.CREATE`) where events can be published (XADD).
+ * It is possible that the worker that will read from this stream channel
+ * has not yet been initialized, so this call ensures that the channel
+ * exists and is ready to serve as a container for events.
+ */
+ClientService.createStream = async (hotMeshClient, workflowTopic, namespace) => {
+    const store = hotMeshClient.engine.store;
+    const params = { appId: namespace ?? factory_1.APP_ID, topic: workflowTopic };
+    const streamKey = store.mintKey(key_1.KeyType.STREAMS, params);
+    try {
+        await store.xgroup('CREATE', streamKey, 'WORKER', '$', 'MKSTREAM');
+    }
+    catch (err) {
+        //ignore if already exists
+    }
+};
+/**
+ * It is possible for a client to invoke a workflow without first
+ * creating the stream. This method will verify that the stream
+ * exists and if not, create it.
+ */
+ClientService.verifyStream = async (workflowTopic, namespace) => {
+    const targetNS = namespace ?? factory_1.APP_ID;
+    if (ClientService.instances.has(targetNS)) {
+        const hotMeshClient = await ClientService.instances.get(targetNS);
+        if (!ClientService.topics.includes(workflowTopic)) {
+            ClientService.topics.push(workflowTopic);
+            await ClientService.createStream(hotMeshClient, workflowTopic, namespace);
+        }
+        return hotMeshClient;
+    }
+};
 exports.ClientService = ClientService;

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

@@ -1,105 +1,51 @@
 import { ILogger } from '../logger';
 import { StoreService } from '../store';
-import { StringStringType, Symbols } from "../../types";
+import { ExportOptions, DurableJobExport, TimelineType, TransitionType, ExportFields } from '../../types/exporter';
 import { RedisClient, RedisMulti } from '../../types/redis';
-import { ActivityAction, DependencyExport, ExportItem, ExportOptions, JobAction, JobActionExport, DurableJobExport, JobTimeline } from '../../types/exporter';
-import { SerializerService } from '../serializer';
-/**
- * Downloads job data from Redis (hscan, hmget, hgetall)
- * Splits, Inflates, and Sorts the job data for use in durable contexts
- */
+import { StringStringType, Symbols } from "../../types/serializer";
 declare class ExporterService {
     appId: string;
     logger: ILogger;
-    serializer: SerializerService;
     store: StoreService<RedisClient, RedisMulti>;
     symbols: Promise<Symbols> | Symbols;
-    /**
-     * Friendly names for the activity ids
-     */
-    activitySymbols: Symbols;
-    transitions: {
-        trigger: string[];
-        pivot: string[];
-        worker: string[];
-        sleeper: string[];
-        awaiter: string[];
-        retryer: string[];
-        hook: string[];
-        hook_pivot: string[];
-        hook_worker: string[];
-        hook_sleeper: string[];
-        hook_awaiter: string[];
-        hook_retryer: string[];
-    };
-    cycles: {
-        sleep_cycler: string[];
-        await_cycler: string[];
-        retry_cycler: string[];
-        hook_sleep_cycler: string[];
-        hook_await_cycler: string[];
-        hook_retry_cycler: string[];
-    };
+    private static symbols;
     constructor(appId: string, store: StoreService<RedisClient, RedisMulti>, logger: ILogger);
     /**
-     * Convert the job hash and dependency list into a DurableJobExport object.
-     * This object contains various facets that describe the interaction
-     * in terms relevant to narrative storytelling.
+     * Convert the job hash from its compiles format into a DurableJobExport object with
+     * facets that describe the workflow in terms relevant to narrative storytelling.
      */
     export(jobId: string, options?: ExportOptions): Promise<DurableJobExport>;
     /**
-     * Interleave actions into the replay timeline to create
-     * a time-ordered timeline of the entire interaction, beginning
-     * with the entry trigger and concluding with the scrubber
-     * activity. Using the returned timeline, it is possible to
-     * create an animated narrative of the job, highlighting
-     * activities in the graph according to the timeline's
-     * activity-created (/ac) and activity-updated (/au) entries.
-     */
-    createTimeline(replay: ExportItem[], actions: JobActionExport): JobTimeline[];
-    /**
-     * Interleave actions into the 'worker' and 'hook_worker'
-     * activities (between their /ac and /au entries)
+     * Inflates the job data from Redis into a DurableJobExport object
+     * @param jobHash - the job data from Redis
+     * @param dependencyList - the list of dependencies for the job
+     * @returns - the inflated job data
      */
-    interleaveActions(target: JobAction, actions: ActivityAction[]): void;
-    isPausingAction(actionType: string): boolean;
-    isMainEntry(key: string): boolean;
-    isHookEntry(key: string): boolean;
+    inflate(jobHash: StringStringType, options: ExportOptions): DurableJobExport;
+    resolveValue(raw: string, withValues: boolean): Record<string, any> | string | number | null;
     /**
      * Inflates the key from Redis, 3-character symbol
      * into a human-readable JSON path, reflecting the
      * tree-like structure of the unidimensional Hash
+     * @private
      */
     inflateKey(key: string): string;
+    filterFields(fullObject: DurableJobExport, block?: ExportFields[], allow?: ExportFields[]): Partial<DurableJobExport>;
+    inflateTransition(match: RegExpMatchArray, value: string, transitionsObject: Record<string, TransitionType>): void;
+    sortEntriesByCreated(obj: {
+        [key: string]: TransitionType;
+    }): TransitionType[];
+    /**
+     * marker names are overloaded with details like sequence, type, etc
+     */
+    keyToObject(key: string): {
+        index: number;
+        dimension?: string;
+        secondary?: number;
+    };
     /**
-     * Inflates the dependency data from Redis into a DurableJobExport 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[];
-    /**
-     * Adds historical actions (proxyActivity, executeChild)
-     * using the `dependency list` to determine
-     * after-the-fact what happened within the 'black-box'
-     * worker function. This is necessary to interleave the
-     * actions into the replay timeline, given that it isn't
-     * really possible to know the inner-workings of the user's
-     * function
-     *
-     */
-    seedActions(type: 'flow' | 'hook' | 'other', action: string, topic: string, dep: string, prefix: string, dimensionKey: string, actions: JobActionExport, jobId: string): void;
-    /**
-     * Inflates the job data from Redis into a DurableJobExport object
-     * @param jobHash - the job data from Redis
-     * @param dependencyList - the list of dependencies for the job
-     * @returns - the inflated job data
+     * idem list has a complicated sort order based on indexes and dimensions
      */
-    inflate(jobHash: StringStringType, dependencyList: string[]): DurableJobExport;
-    inflateProcess(match: RegExpMatchArray, value: string, replay: ExportItem[]): void;
-    inflateActions(key: string, value: string, actions: JobActionExport): void;
-    reverseSort(aKey: ExportItem, bKey: ExportItem): 1 | -1 | 0;
-    dateSort(aKey: ExportItem, bKey: ExportItem): 1 | -1 | 0;
+    sortParts(parts: TimelineType[]): TimelineType[];
 }
 export { ExporterService };