@hotmeshio/hotmesh 0.1.14 → 0.1.16

package/build/services/meshcall/schemas/factory.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWorkflowYAML = exports.VERSION = void 0;
+const key_1 = require("../../../modules/key");
+exports.VERSION = '1';
+const getWorkflowYAML = (appId = key_1.HMNS, version = exports.VERSION) => {
+    return `app:
+  id: ${appId}
+  version: '${version}'
+  graphs:
+    - subscribes: ${appId}.call
+
+      expire: '{trigger.output.data.expire}'
+
+      input:
+        schema:
+          type: object
+          properties:
+            id:
+              type: string
+              description: unique id for this workflow
+            expire:
+              type: number
+              description: time in seconds to expire the completed job and remove it from the cache
+            topic:
+              type: string
+              description: topic assigned to locate the worker
+            args:
+              type: array
+              description: arguments to pass to the worker function
+              items:
+                type: any
+
+      output:
+        schema:
+          type: object
+          properties:
+            response:
+              type: any
+
+      activities:
+        trigger:
+          type: trigger
+
+          stats:
+            id: '{$self.input.data.id}'
+
+        worker:
+          type: worker
+          topic: '{trigger.output.data.topic}'
+          input:
+            schema:
+              type: object
+              properties:
+                args:
+                  type: any
+            maps:
+              args: '{trigger.output.data.args}'
+          output:
+            schema:
+              type: object
+              properties:
+                response:
+                  type: any
+          job:
+            maps:
+              response: '{$self.output.data.response}'
+
+      transitions:
+        trigger:
+          - to: worker
+
+    - subscribes: ${appId}.cron
+
+      expire: 120
+
+      input:
+        schema:
+          type: object
+          properties:
+            id:
+              type: string
+              description: unique id for this workflow
+            delay:
+              type: number
+              description: time in seconds to sleep before invoking the first cycle
+            interval:
+              type: number
+              description: time in seconds to sleep before the next cycle
+            topic:
+              type: string
+              description: topic assigned to locate the worker
+            args:
+              type: array
+              description: arguments to pass to the worker function
+              items:
+                type: any
+            maxCycles:
+              type: number
+              description: maximum number of cycles to run before stopping
+            maxDuration:
+              type: integer
+              description: timevalue (GMT) ceiling. If the current time exceeds this value, the cron will stop.
+              example: 1630000000000
+
+      output:
+        schema:
+          type: object
+          properties:
+            response:
+              type: any
+
+      activities:
+        trigger_cron:
+          type: trigger
+          stats:
+            id: '{$self.input.data.id}'
+        
+        cycle_hook_cron:
+          type: hook
+          output:
+            schema:
+              type: object
+              properties:
+                sleepSeconds:
+                  type: number
+            maps:
+              sleepSeconds:
+                '@pipe':
+                  - ['{trigger_cron.output.data.delay}', '{@symbol.undefined}']
+                  - ['{@conditional.nullish}']
+              iterationCount: 1
+
+        sleep_cron:
+          type: hook
+          sleep: '{cycle_hook_cron.output.data.sleepSeconds}'
+        
+        worker_cron:
+          type: worker
+          topic: '{trigger_cron.output.data.topic}'
+          input:
+            schema:
+              type: object
+              properties:
+                args:
+                  type: any
+            maps:
+              args: '{trigger_cron.output.data.args}'
+
+        cycle_cron:
+          type: cycle
+          ancestor: cycle_hook_cron
+          input:
+            maps:
+              sleepSeconds: '{trigger_cron.output.data.interval}'
+              iterationCount:
+                '@pipe':
+                  - ['{cycle_hook_cron.output.data.iterationCount}', 1]
+                  - ['{@math.add}']
+
+      transitions:
+        trigger_cron:
+          - to: cycle_hook_cron
+        cycle_hook_cron:
+          - to: sleep_cron
+        sleep_cron:
+          - to: worker_cron
+        worker_cron:
+          - to: cycle_cron
+            conditions:
+              match:
+                - expected: true
+                  actual: 
+                    '@pipe':
+                      - ['{cycle_hook_cron.output.data.iterationCount}', '{trigger_cron.output.data.maxCycles}']
+                      - ['{@conditional.less_than}']
+`;
+};
+exports.getWorkflowYAML = getWorkflowYAML;

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

@@ -0,0 +1,75 @@
+import { HotMesh } from '../hotmesh';
+import { WorkflowOptions, WorkflowSearchOptions, FindJobsOptions, FindOptions, FindWhereOptions, SearchResults, FindWhereQuery } from '../../types/meshflow';
+import { CallOptions, ConnectionInput, ConnectOptions, ExecInput, HookInput } from '../../types/meshdata';
+import { RedisClass, RedisOptions } from '../../types/redis';
+import { StringAnyType, StringStringType } from '../../types/serializer';
+import { JobInterruptOptions, JobOutput } from '../../types/job';
+import { QuorumMessage, QuorumMessageCallback, QuorumProfile, RollCallOptions, SubscriptionOptions, ThrottleOptions } from '../../types/quorum';
+import { MeshFlowJobExport, ExportOptions } from '../../types/exporter';
+declare class MeshData {
+    connectionSignatures: StringStringType;
+    redisOptions: RedisOptions;
+    redisClass: RedisClass;
+    instances: Map<string, (Promise<HotMesh> | HotMesh)>;
+    search: WorkflowSearchOptions;
+    static workflow: {
+        sleep: typeof import("../meshflow/workflow").WorkflowService.sleepFor;
+        sleepFor: typeof import("../meshflow/workflow").WorkflowService.sleepFor;
+        signal: typeof import("../meshflow/workflow").WorkflowService.signal;
+        hook: typeof import("../meshflow/workflow").WorkflowService.hook;
+        waitForSignal: typeof import("../meshflow/workflow").WorkflowService.waitFor;
+        waitFor: typeof import("../meshflow/workflow").WorkflowService.waitFor;
+        getHotMesh: typeof import("../meshflow/workflow").WorkflowService.getHotMesh;
+        random: typeof import("../meshflow/workflow").WorkflowService.random;
+        search: typeof import("../meshflow/workflow").WorkflowService.search;
+        getContext: typeof import("../meshflow/workflow").WorkflowService.getContext;
+        once: typeof import("../meshflow/workflow").WorkflowService.once;
+        interrupt: (entity: string, id: string, options?: JobInterruptOptions) => Promise<void>;
+        execChild: <T>(options?: Partial<WorkflowOptions>) => Promise<T>;
+        executeChild: <T_1>(options?: Partial<WorkflowOptions>) => Promise<T_1>;
+        startChild: (options?: Partial<WorkflowOptions>) => Promise<string>;
+    };
+    constructor(redisClass: Partial<RedisClass>, redisOptions: Partial<RedisOptions>, search?: WorkflowSearchOptions);
+    validate(entity: string): void;
+    getConnection(): Promise<import("../../types/meshflow").ConnectionConfig>;
+    getClient(): import("../meshflow/client").ClientService;
+    safeKey(key: string): string;
+    arrayToHash(input: [number, ...Array<string | string[]>]): StringStringType[];
+    toString(value: any): string | undefined;
+    static mintGuid(entity: string, id?: string): string;
+    getHotMesh(namespace?: string): Promise<HotMesh>;
+    mintKey(entity: string, workflowId: string, namespace?: string): Promise<string>;
+    mesh: {
+        sub: (callback: QuorumMessageCallback, options?: SubscriptionOptions) => Promise<void>;
+        pub: (message: QuorumMessage, options?: SubscriptionOptions) => Promise<void>;
+        unsub: (callback: QuorumMessageCallback, options?: SubscriptionOptions) => Promise<void>;
+    };
+    connect<T>({ entity, target, options }: ConnectionInput<T>): Promise<boolean>;
+    bindCallOptions(args: any[], options: ConnectOptions, callOptions?: CallOptions): StringAnyType;
+    pauseForTTL<T>(result: T, options: CallOptions): Promise<void>;
+    publishDone<T>(result: T, hotMesh: HotMesh, options: CallOptions): Promise<void>;
+    flush(entity: string, id: string, namespace?: string): Promise<string | void>;
+    interrupt(entity: string, id: string, options?: JobInterruptOptions, namespace?: string): Promise<void>;
+    signal(guid: string, payload: StringAnyType, namespace?: string): Promise<string>;
+    rollCall(options?: RollCallOptions): Promise<QuorumProfile[]>;
+    throttle(options: ThrottleOptions): Promise<boolean>;
+    hook({ entity, id, hookEntity, hookArgs, options }: HookInput): Promise<string>;
+    exec<T>({ entity, args, options }: ExecInput): Promise<T>;
+    info(entity: string, id: string, options?: CallOptions): Promise<JobOutput>;
+    export(entity: string, id: string, options?: ExportOptions, namespace?: string): Promise<MeshFlowJobExport>;
+    get(entity: string, id: string, options?: CallOptions): Promise<StringAnyType>;
+    all(entity: string, id: string, options?: CallOptions): Promise<StringAnyType>;
+    raw(entity: string, id: string, options?: CallOptions): Promise<StringAnyType>;
+    set(entity: string, id: string, options?: CallOptions): Promise<number>;
+    incr(entity: string, id: string, field: string, amount: number, options?: CallOptions): Promise<number>;
+    del(entity: string, id: string, options: CallOptions): Promise<number>;
+    findJobs(options?: FindJobsOptions): Promise<[string, string[]]>;
+    find(entity: string, options: FindOptions, ...args: string[]): Promise<string[] | [number] | Array<string | number | string[]>>;
+    findWhere(entity: string, options: FindWhereOptions): Promise<SearchResults | number>;
+    generateSearchQuery(query: FindWhereQuery[] | string, search?: WorkflowSearchOptions): string;
+    createSearchIndex(entity: string, options?: CallOptions, searchOptions?: WorkflowSearchOptions): Promise<void>;
+    listSearchIndexes(): Promise<string[]>;
+    static proxyActivities: typeof import("../meshflow/workflow").WorkflowService.proxyActivities;
+    static shutdown(): Promise<void>;
+}
+export { MeshData };