moleculer-api/dist/broker/broker.d.ts

A dynamic API Gateway for MoleculerJS which updates REST endpoints and aggregated GraphQL schema, access control policy for each action calls from metadata of remote services schema without restart or deployment.

import { RecursivePartial } from "../interface";
import { Logger } from "../logger";
import { APIRequestContext } from "../server";
import { ServiceRegistryOptions, Service, ServiceAction, ServiceNode } from "./registry";
import { Reporter, ReporterOptions } from "./reporter";
import { EventPacket, EventListener } from "./pubsub";
import { ParamsMapper, ParamsMapperProps } from "./params";
import { BatchingPoolOptions } from "./batching";
import { InlineFunctionOptions, InlineFunctionProps } from "./function";
import { ServiceBrokerDelegatorConstructorOptions } from "./delegator";
export declare type ServiceBrokerOptions = {
    registry: ServiceRegistryOptions;
    batching: BatchingPoolOptions;
    function: InlineFunctionOptions;
    reporter: ReporterOptions;
    log: {
        event: boolean;
        call: boolean;
    };
} & ServiceBrokerDelegatorConstructorOptions;
export declare type ServiceBrokerProps = {
    id: string;
    logger: Logger;
};
export declare type ServiceBrokerListeners = {
    connected: (service: Readonly<Service>) => void;
    disconnected: (service: Readonly<Service>) => void;
    nodePoolUpdated: (service: Readonly<Service>) => void;
};
export declare type CallArgs = {
    action: Readonly<ServiceAction>;
    params?: any;
    batchingParams?: any;
    disableCache: boolean;
};
export declare type EventPublishArgs = Omit<EventPacket, "from">;
export declare type DelegatedCallArgs = Omit<CallArgs, "batchingParams"> & {
    node: Readonly<ServiceNode>;
    batchedParamsLength?: number;
};
export declare type DelegatedEventPublishArgs = EventPublishArgs;
export declare class ServiceBroker<DelegatorContext = any> {
    protected readonly props: ServiceBrokerProps;
    private readonly registry;
    private readonly delegator;
    private readonly delegatorSymbol;
    private readonly discoveryPubSub;
    private readonly eventPubSub;
    private readonly opts;
    constructor(props: ServiceBrokerProps, opts?: RecursivePartial<ServiceBrokerOptions>);
    private working;
    get delegatedBroker(): any;
    start(listeners: ServiceBrokerListeners): Promise<void>;
    stop(): Promise<void>;
    protected emitEvent(packet: EventPacket): Promise<void>;
    protected emitServiceConnected(service: Service): Promise<void>;
    protected emitServiceDisconnected(service: Service, nodeId: string): Promise<void>;
    private getDelegatorContext;
    private static EventSubscriptionSymbol;
    private getEventSubscriptions;
    private static BatchingPoolSymbol;
    private getBatchingPool;
    call(context: APIRequestContext, args: CallArgs): Promise<any>;
    clearActionCache(action: Readonly<ServiceAction>): Promise<void>;
    clearServiceCache(service: Readonly<Service>): Promise<void>;
    clearAllCache(): Promise<void>;
    subscribeEvent<Listener extends EventListener | null>(context: APIRequestContext, eventNamePattern: string, listener: Listener): Promise<Listener extends EventListener ? void : AsyncIterator<Readonly<EventPacket>>>;
    unsubscribeEvent(subscription: number | AsyncIterator<EventPacket>): Promise<void>;
    publishEvent(context: APIRequestContext, args: EventPublishArgs): Promise<void>;
    createParamsMapper<MappableArgs>(opts: ParamsMapperProps): ParamsMapper<MappableArgs>;
    createInlineFunction<MappableArgs, Return>(props: InlineFunctionProps<MappableArgs, Return>): (args: MappableArgs) => Return;
    createReporter(service: Readonly<Service>): Reporter;
    matchActionName(name: string, namePattern: string): boolean;
    matchEventName(name: string, namePattern: string): boolean;
    healthCheckService(service: Readonly<Service>): Promise<import("./registry").ServiceStatus>;
    healthCheckCall(action: Readonly<ServiceAction>): Promise<import("./registry").ServiceStatus>;
    healthCheckPublish(args: Omit<EventPublishArgs, "params">): Promise<import("./registry").ServiceStatus>;
    healthCheckSubscribe(): Promise<import("./registry").ServiceStatus>;
}