@hotmeshio/hotmesh 0.0.8 → 0.0.9

package/build/esm/services/durable/workflow.js

@@ -1,132 +0,0 @@
-import ms from 'ms';
-import { asyncLocalStorage } from './asyncLocalStorage';
-import { WorkerService } from './worker';
-import { ClientService as Client } from './client';
-import { ConnectionService as Connection } from './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);
-}
-*/
-export class WorkflowService {
-    static async executeChild(options) {
-        const store = 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({
-            connection: await Connection.connect(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(WorkerService.activityRegistry);
-        if (keys.length) {
-            keys.forEach((key) => {
-                const activityFunction = WorkerService.activityRegistry[key];
-                proxy[key] = WorkflowService.wrapActivity(key, options);
-            });
-        }
-        return proxy;
-    }
-    static wrapActivity(activityName, options) {
-        return async function () {
-            const store = 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 WorkerService.getHotMesh(activityTopic);
-                activityState = await hmshInstance.getState(activityTopic, activityJobId);
-                if (activityState.metadata.err) {
-                    await hmshInstance.scrub(activityJobId);
-                    throw new Error(activityState.metadata.err);
-                }
-                else if (activityState.metadata.js === 0) {
-                    //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 = ms(options?.startToCloseTimeout || '1 minute');
-                const payload = {
-                    arguments: Array.from(arguments),
-                    workflowId: activityJobId,
-                    workflowTopic,
-                    activityName,
-                };
-                //start the job
-                const hmshInstance = await WorkerService.getHotMesh(activityTopic);
-                const context = { metadata: { trc, spn }, data: {} };
-                const jobOutput = await hmshInstance.pubsub(activityTopic, payload, context, duration);
-                return jobOutput.data.response;
-            }
-        };
-    }
-}

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

@@ -1,82 +0,0 @@
-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, dad?: string): 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 };