@hotmeshio/hotmesh 0.0.1

package/build/services/durable/workflow.js

@@ -0,0 +1,135 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowService = void 0;
+const ms_1 = __importDefault(require("ms"));
+const asyncLocalStorage_1 = require("./asyncLocalStorage");
+const worker_1 = require("./worker");
+const client_1 = require("./client");
+const connection_1 = require("./connection");
+/*
+`proxyActivities` returns a wrapped instance of the
+target activity, so that when the workflow calls a
+proxied activity, it is actually calling the proxy
+function, which in turn calls the activity function.
+
+`proxyActivities` must be called AFTER the activities
+have been registered in order to work properly.
+If the activities are not already registered,
+`proxyActivities` will throw an error. This is OK.
+
+The `client` (client.ts) is equivalent to the
+HotMesh `engine`. The jobs it creates will be
+put in the taskQueue. When the `worker` (worker.ts)
+is eventually initialized (if it happens to be inited later),
+it will see the items in the queue and process them. If it happens
+to already be inited, the jobs will immediately be dequeued and
+processed. In either case, the jobs will be processed.
+
+Here is an example of how the methods in this file are used:
+
+./workflows.ts
+
+import { Durable } from '@hotmeshio/hotmesh';
+import type * as activities from './activities';
+const { greet } = Durable.workflow.proxyActivities<typeof activities>({
+  startToCloseTimeout: '1 minute',
+  retryPolicy: {
+    initialInterval: '5 seconds',  // Initial delay between retries
+    maximumAttempts: 3,            // Max number of retry attempts
+    backoffCoefficient: 2.0,       // Backoff factor for delay between retries: delay = initialInterval * (backoffCoefficient ^ retry_attempt)
+    maximumInterval: '30 seconds', // Max delay between retries
+  },
+});
+
+export async function example(name: string): Promise<string> {
+  return await greet(name);
+}
+*/
+class WorkflowService {
+    static async executeChild(options) {
+        const store = asyncLocalStorage_1.asyncLocalStorage.getStore();
+        if (!store) {
+            throw new Error('durable-store-not-found');
+        }
+        const workflowId = store.get('workflowId');
+        const workflowTrace = store.get('workflowTrace');
+        const workflowSpan = store.get('workflowSpan');
+        const client = new client_1.ClientService({
+            connection: await connection_1.ConnectionService.connect(worker_1.WorkerService.connection),
+        });
+        //todo: should I allow-cross/app callback (pj:'@DURABLE@hello-world@<pjid>'/pa: <paid>/pd: <pdad>)
+        const handle = await client.workflow.start({
+            ...options,
+            workflowId: `${workflowId}${options.workflowId}`,
+            workflowTrace,
+            workflowSpan,
+        });
+        const result = await handle.result();
+        return result;
+    }
+    static proxyActivities(options) {
+        const proxy = {};
+        const keys = Object.keys(worker_1.WorkerService.activityRegistry);
+        if (keys.length) {
+            keys.forEach((key) => {
+                const activityFunction = worker_1.WorkerService.activityRegistry[key];
+                proxy[key] = WorkflowService.wrapActivity(key, options);
+            });
+        }
+        return proxy;
+    }
+    static wrapActivity(activityName, options) {
+        return async function () {
+            const store = asyncLocalStorage_1.asyncLocalStorage.getStore();
+            if (!store) {
+                throw new Error('durable-store-not-found');
+            }
+            const COUNTER = store.get('counter');
+            //increment by state (not value) to avoid race conditions
+            const execIndex = COUNTER.counter = COUNTER.counter + 1;
+            const workflowId = store.get('workflowId');
+            const workflowTopic = store.get('workflowTopic');
+            const trc = store.get('workflowTrace');
+            const spn = store.get('workflowSpan');
+            const activityTopic = `${workflowTopic}-activity`;
+            const activityJobId = `${workflowId}-${activityName}-${execIndex}`;
+            let activityState;
+            try {
+                const hmshInstance = await worker_1.WorkerService.getHotMesh(activityTopic);
+                activityState = await hmshInstance.getState(activityTopic, activityJobId);
+                if (activityState.metadata.js == 1) {
+                    //return immediately
+                    return activityState.data?.response;
+                }
+                //one time subscription
+                return await new Promise((resolve, reject) => {
+                    hmshInstance.sub(activityTopic, async (topic, message) => {
+                        const response = message.data?.response;
+                        hmshInstance.unsub(activityTopic);
+                        // Resolve the Promise when the callback is triggered with a message
+                        resolve(response);
+                    });
+                });
+            }
+            catch (e) {
+                //expected; thrown by `getState` when the job cannot be found
+                const duration = (0, ms_1.default)(options?.startToCloseTimeout || '1 minute');
+                const payload = {
+                    arguments: Array.from(arguments),
+                    workflowId: activityJobId,
+                    workflowTopic,
+                    activityName,
+                };
+                //start the job
+                const hmshInstance = await worker_1.WorkerService.getHotMesh(activityTopic);
+                const context = { metadata: { trc, spn }, data: {} };
+                const jobOutput = await hmshInstance.pubsub(activityTopic, payload, context, duration);
+                return jobOutput.data.response;
+            }
+        };
+    }
+}
+exports.WorkflowService = WorkflowService;

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

@@ -0,0 +1,82 @@
+import { Activity } from '../activities/activity';
+import { ILogger } from '../logger';
+import { StoreSignaler } from '../signaler/store';
+import { StreamSignaler } from '../signaler/stream';
+import { StoreService } from '../store';
+import { StreamService } from '../stream';
+import { SubService } from '../sub';
+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 } from '../../types/job';
+import { HotMeshApps, HotMeshConfig, HotMeshManifest, HotMeshSettings } from '../../types/hotmesh';
+import { JobMessageCallback } from '../../types/quorum';
+import { RedisClient, RedisMulti } from '../../types/redis';
+import { GetStatsOptions, IdsResponse, JobStatsInput, StatsResponse } from '../../types/stats';
+import { StreamData, StreamDataResponse, StreamError } from '../../types/stream';
+declare class EngineService {
+    namespace: string;
+    apps: HotMeshApps | null;
+    appId: string;
+    guid: string;
+    store: StoreService<RedisClient, RedisMulti> | null;
+    stream: StreamService<RedisClient, RedisMulti> | null;
+    subscribe: SubService<RedisClient, RedisMulti> | null;
+    storeSignaler: StoreSignaler | null;
+    streamSignaler: StreamSignaler | null;
+    task: TaskService | null;
+    logger: ILogger;
+    cacheMode: CacheMode;
+    untilVersion: string | null;
+    jobCallbacks: Record<string, JobMessageCallback>;
+    reporting: boolean;
+    jobId: number;
+    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>;
+    initStreamSignaler(config: HotMeshConfig): StreamSignaler;
+    getVID(vid?: AppVID): Promise<AppVID>;
+    setCacheMode(cacheMode: CacheMode, untilVersion: string): void;
+    routeToSubscribers(topic: string, message: JobOutput): Promise<void>;
+    processWebHooks(): Promise<void>;
+    processTimeHooks(): Promise<void>;
+    throttle(delayInMillis: number): Promise<void>;
+    initActivity(topic: string, data?: JobData, context?: JobState): Promise<Activity>;
+    getSchema(topic: string): Promise<[activityId: string, schema: ActivityType]>;
+    getSettings(): Promise<HotMeshSettings>;
+    isPrivate(topic: string): boolean;
+    plan(pathOrYAML: string): Promise<HotMeshManifest>;
+    deploy(pathOrYAML: string): Promise<HotMeshManifest>;
+    getStats(topic: string, query: JobStatsInput): Promise<StatsResponse>;
+    getIds(topic: string, query: JobStatsInput, queryFacets?: any[]): Promise<IdsResponse>;
+    resolveQuery(topic: string, query: JobStatsInput): Promise<GetStatsOptions>;
+    processStreamMessage(streamData: StreamDataResponse): Promise<void>;
+    execAdjacentParent(context: JobState, jobOutput: JobOutput): Promise<string>;
+    hasParentJob(context: JobState): boolean;
+    resolveError(metadata: JobMetadata): StreamError | undefined;
+    scrub(jobId: string): Promise<void>;
+    hook(topic: string, data: JobData): Promise<JobStatus | void>;
+    hookTime(jobId: string, activityId: string): Promise<JobStatus | void>;
+    hookAll(hookTopic: string, data: JobData, query: JobStatsInput, queryFacets?: string[]): Promise<string[]>;
+    pub(topic: string, data: JobData, context?: JobState): Promise<string>;
+    sub(topic: string, callback: JobMessageCallback): Promise<void>;
+    unsub(topic: string): Promise<void>;
+    psub(wild: string, callback: JobMessageCallback): Promise<void>;
+    punsub(wild: string): Promise<void>;
+    pubsub(topic: string, data: JobData, context?: JobState | null, timeout?: number): Promise<JobOutput>;
+    resolveOneTimeSubscription(context: JobState, jobOutput: JobOutput): Promise<void>;
+    getPublishesTopic(context: JobState): Promise<string>;
+    resolvePersistentSubscriptions(context: JobState, jobOutput: JobOutput): Promise<void>;
+    add(streamData: StreamData | StreamDataResponse): Promise<string>;
+    registerJobCallback(jobId: string, jobCallback: JobMessageCallback): void;
+    delistJobCallback(jobId: string): void;
+    hasOneTimeSubscription(context: JobState): boolean;
+    runJobCompletionTasks(context: JobState): Promise<void>;
+    getStatus(jobId: string): Promise<JobStatus>;
+    getState(topic: string, jobId: string): Promise<JobOutput>;
+    compress(terms: string[]): Promise<boolean>;
+}
+export { EngineService };