@hotmeshio/hotmesh 0.4.0 → 0.4.1

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

@@ -0,0 +1,264 @@
+import { Await } from '../activities/await';
+import { Cycle } from '../activities/cycle';
+import { Hook } from '../activities/hook';
+import { Interrupt } from '../activities/interrupt';
+import { Signal } from '../activities/signal';
+import { Worker } from '../activities/worker';
+import { Trigger } from '../activities/trigger';
+import { ExporterService } from '../exporter';
+import { ILogger } from '../logger';
+import { Router } from '../router';
+import { SearchService } from '../search';
+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 { JobExport } from '../../types/exporter';
+import { JobState, JobData, JobMetadata, JobOutput, JobStatus, JobInterruptOptions, JobCompletionOptions, ExtensionType } from '../../types/job';
+import { HotMeshApps, HotMeshConfig, HotMeshManifest, HotMeshSettings } from '../../types/hotmesh';
+import { ProviderClient, ProviderTransaction } from '../../types/provider';
+import { JobMessageCallback } from '../../types/quorum';
+import { StringAnyType, StringStringType } from '../../types/serializer';
+import { GetStatsOptions, IdsResponse, JobStatsInput, StatsResponse } from '../../types/stats';
+import { StreamCode, StreamData, StreamDataResponse, StreamError, StreamStatus } from '../../types/stream';
+import { WorkListTaskType } from '../../types/task';
+declare class EngineService {
+    namespace: string;
+    apps: HotMeshApps | null;
+    appId: string;
+    guid: string;
+    exporter: ExporterService | null;
+    search: SearchService<ProviderClient> | null;
+    store: StoreService<ProviderClient, ProviderTransaction> | null;
+    stream: StreamService<ProviderClient, ProviderTransaction> | null;
+    subscribe: SubService<ProviderClient> | null;
+    router: Router<typeof this.stream> | null;
+    taskService: TaskService | null;
+    logger: ILogger;
+    cacheMode: CacheMode;
+    untilVersion: string | null;
+    jobCallbacks: Record<string, JobMessageCallback>;
+    reporting: boolean;
+    jobId: number;
+    inited: string;
+    /**
+     * @private
+     */
+    constructor();
+    /**
+     * @private
+     */
+    static init(namespace: string, appId: string, guid: string, config: HotMeshConfig, logger: ILogger): Promise<EngineService>;
+    /**
+     * @private
+     */
+    verifyEngineFields(config: HotMeshConfig): void;
+    /**
+     * @private
+     */
+    initSearchChannel(search: ProviderClient, store?: ProviderClient): Promise<void>;
+    /**
+     * @private
+     */
+    initStoreChannel(store: ProviderClient): Promise<void>;
+    /**
+     * @private
+     */
+    initSubChannel(sub: ProviderClient, store: ProviderClient): Promise<void>;
+    /**
+     * @private
+     */
+    initStreamChannel(stream: ProviderClient, store: ProviderClient): Promise<void>;
+    /**
+     * @private
+     */
+    initRouter(config: HotMeshConfig): Promise<Router<StreamService<ProviderClient, ProviderTransaction>>>;
+    /**
+     * resolves the distributed executable version using a delay
+     * to allow deployment race conditions to resolve
+     * @private
+     */
+    fetchAndVerifyVID(vid: AppVID, count?: number): Promise<AppVID>;
+    getVID(vid?: AppVID): Promise<AppVID>;
+    /**
+     * @private
+     */
+    setCacheMode(cacheMode: CacheMode, untilVersion: string): void;
+    /**
+     * @private
+     */
+    routeToSubscribers(topic: string, message: JobOutput): Promise<void>;
+    /**
+     * @private
+     */
+    processWebHooks(): Promise<void>;
+    /**
+     * @private
+     */
+    processTimeHooks(): Promise<void>;
+    /**
+     * @private
+     */
+    throttle(delayInMillis: number): Promise<void>;
+    /**
+     * @private
+     */
+    initActivity(topic: string, data?: JobData, context?: JobState): Promise<Await | Cycle | Hook | Signal | Trigger | Worker | Interrupt>;
+    getSchema(topic: string): Promise<[activityId: string, schema: ActivityType]>;
+    /**
+     * @private
+     */
+    getSettings(): Promise<HotMeshSettings>;
+    /**
+     * @private
+     */
+    isPrivate(topic: string): boolean;
+    /**
+     * @private
+     */
+    plan(pathOrYAML: string): Promise<HotMeshManifest>;
+    /**
+     * @private
+     */
+    deploy(pathOrYAML: string): Promise<HotMeshManifest>;
+    /**
+     * @private
+     */
+    getStats(topic: string, query: JobStatsInput): Promise<StatsResponse>;
+    /**
+     * @private
+     */
+    getIds(topic: string, query: JobStatsInput, queryFacets?: any[]): Promise<IdsResponse>;
+    /**
+     * @private
+     */
+    resolveQuery(topic: string, query: JobStatsInput): Promise<GetStatsOptions>;
+    /**
+     * @private
+     */
+    processStreamMessage(streamData: StreamDataResponse): Promise<void>;
+    /**
+     * @private
+     */
+    execAdjacentParent(context: JobState, jobOutput: JobOutput, emit?: boolean): Promise<string>;
+    /**
+     * @private
+     */
+    hasParentJob(context: JobState, checkSevered?: boolean): boolean;
+    /**
+     * @private
+     */
+    resolveError(metadata: JobMetadata): StreamError | undefined;
+    /**
+     * @private
+     */
+    interrupt(topic: string, jobId: string, options?: JobInterruptOptions): Promise<string>;
+    /**
+     * @private
+     */
+    scrub(jobId: string): Promise<void>;
+    /**
+     * @private
+     */
+    hook(topic: string, data: JobData, status?: StreamStatus, code?: StreamCode): Promise<string>;
+    /**
+     * @private
+     */
+    hookTime(jobId: string, gId: string, topicOrActivity: string, type?: WorkListTaskType): Promise<string | void>;
+    /**
+     * @private
+     */
+    hookAll(hookTopic: string, data: JobData, keyResolver: JobStatsInput, queryFacets?: string[]): Promise<string[]>;
+    /**
+     * @private
+     */
+    pub(topic: string, data: JobData, context?: JobState, extended?: ExtensionType): Promise<string>;
+    /**
+     * @private
+     */
+    sub(topic: string, callback: JobMessageCallback): Promise<void>;
+    /**
+     * @private
+     */
+    unsub(topic: string): Promise<void>;
+    /**
+     * @private
+     */
+    psub(wild: string, callback: JobMessageCallback): Promise<void>;
+    /**
+     * @private
+     */
+    punsub(wild: string): Promise<void>;
+    /**
+     * @private
+     */
+    pubsub(topic: string, data: JobData, context?: JobState | null, timeout?: number): Promise<JobOutput>;
+    /**
+     * @private
+     */
+    pubOneTimeSubs(context: JobState, jobOutput: JobOutput, emit?: boolean): Promise<void>;
+    /**
+     * @private
+     */
+    getPublishesTopic(context: JobState): Promise<string>;
+    /**
+     * @private
+     */
+    pubPermSubs(context: JobState, jobOutput: JobOutput, emit?: boolean): Promise<void>;
+    /**
+     * @private
+     */
+    add(streamData: StreamData | StreamDataResponse): Promise<string>;
+    /**
+     * @private
+     */
+    registerJobCallback(jobId: string, jobCallback: JobMessageCallback): void;
+    /**
+     * @private
+     */
+    delistJobCallback(jobId: string): void;
+    /**
+     * @private
+     */
+    hasOneTimeSubscription(context: JobState): boolean;
+    /**
+     * @private
+     */
+    runJobCompletionTasks(context: JobState, options?: JobCompletionOptions): Promise<string | void>;
+    /**
+     * Job hash expiration is typically reliant on the metadata field
+     * if the activity concludes normally. However, if the job is `interrupted`,
+     * it will be expired immediately.
+     * @private
+     */
+    resolveExpires(context: JobState, options: JobCompletionOptions): number;
+    /**
+     * @private
+     */
+    export(jobId: string): Promise<JobExport>;
+    /**
+     * @private
+     */
+    getRaw(jobId: string): Promise<StringStringType>;
+    /**
+     * @private
+     */
+    getStatus(jobId: string): Promise<JobStatus>;
+    /**
+     * @private
+     */
+    getState(topic: string, jobId: string): Promise<JobOutput>;
+    /**
+     * @private
+     */
+    getQueryState(jobId: string, fields: string[]): Promise<StringAnyType>;
+    /**
+     * @private
+     * @deprecated
+     */
+    compress(terms: string[]): Promise<boolean>;
+}
+export { EngineService };