vulcain-corejs/dist/pipeline/actions.d.ts

Vulcain micro-service framework

import { IContainer } from '../di/resolvers';
import { Domain } from '../schemas/schema';
import { CommonRequestData, CommonMetadata, CommonRequestResponse, CommonActionMetadata, IManager, ServiceHandlerMetadata } from './common';
import { RequestContext } from '../servers/requestContext';
import * as RX from 'rx';
import { EventHandlerFactory } from './eventHandlerFactory';
export interface ActionData extends CommonRequestData {
    service: string;
    status?: "Error" | "Success" | "Pending";
    taskId?: string;
    startedAt: string;
}
export interface ConsumeEventMetadata {
    description: string;
    subscribeToDomain?: string;
    subscribeToAction?: string;
    subscribeToSchema?: string;
    filter?: (observable: RX.Observable<EventData>) => RX.Observable<EventData>;
}
export interface EventMetadata extends CommonMetadata {
    subscribeToDomain?: string;
}
export declare enum EventNotificationMode {
    always = 0,
    successOnly = 1,
    never = 2,
}
/**
 * Declare default action handler definition
 *
 * @export
 * @interface ActionHandlerMetadata
 * @extends {ServiceHandlerMetadata}
 */
export interface ActionHandlerMetadata extends ServiceHandlerMetadata {
    /**
     *
     *
     * @type {boolean}
     * @memberOf ActionHandlerMetadata
     */
    async?: boolean;
    /**
     *
     *
     * @type {EventNotificationMode}
     * @memberOf ActionHandlerMetadata
     */
    eventMode?: EventNotificationMode;
}
/**
 *
 *
 * @export
 * @interface ActionMetadata
 * @extends {CommonActionMetadata}
 */
export interface ActionMetadata extends CommonActionMetadata {
    async?: boolean;
    eventMode?: EventNotificationMode;
    outputSchema: string | Function;
}
export interface ActionResponse<T> extends CommonRequestResponse<T> {
    correlationId: string;
    startedAt: string;
    completedAt?: string;
    service: string;
    taskId?: string;
    status: "Error" | "Success" | "Pending";
    commandMode?: string;
}
/**
 * Response for event
 *
 * @export
 * @interface EventData
 * @extends {ActionResponse<any>}
 */
export interface EventData extends ActionResponse<any> {
}
export declare class CommandManager implements IManager {
    container: IContainer;
    private messageBus;
    private _domain;
    private _hostname;
    private _serviceId;
    private _initialized;
    private _serviceDescriptors;
    static eventHandlersFactory: EventHandlerFactory;
    /**
     * Get the current domain model
     * @returns {Domain}
     */
    domain: Domain;
    serviceId: string;
    constructor(container: IContainer);
    startMessageBus(hasAsyncTasks: boolean): void;
    private createResponse(ctx, command, error?);
    private validateRequestData(info, command);
    getInfoHandler(command: CommonRequestData, container?: IContainer): {
        handler: any;
        metadata: ActionMetadata;
        method: string;
        kind: "action" | "query" | "event";
    };
    runAsync(command: ActionData, ctx: RequestContext): Promise<any>;
    consumeTaskAsync(command: ActionData): Promise<void>;
    subscribeToEvents(): void;
    bindEventHandler(metadata: ConsumeEventMetadata): void;
}