@micro.ts/core/server/OptionsBuilder.d.ts

Microservice framework with Typescript

import { Action, Class, ServerOptions, BrokerConnectionErrorHandler, OnRotueListener, BaseRouteDefinition } from './types';
import { AppErrorHandler, AppMiddleware, AuthorizeOptions, ParamDescription } from '..';
import { IConfiguration } from './IConfiguration';
import { IBroker } from '../brokers/IBroker';
import { ILogger } from './Logger';
import { BaseContainer } from '../di/BaseContainer';
import { MainAppError } from '../errors';
export declare type CurrentUserCheckerFunction<TUser> = (action: Action, broker?: IBroker) => TUser | Promise<TUser>;
export declare type AuthorizationFunction = (action: Action, options?: AuthorizeOptions) => boolean | Promise<boolean>;
export declare type GetNotAuthorizedErrorFuntion = (action: Action, options?: AuthorizeOptions) => MainAppError | Promise<MainAppError>;
export declare type MicroPlugin = (builder: OptionsBuilder) => void;
export declare type TransformerFunction = <T>(clazz: Class<T>, value: T, description?: ParamDescription, def?: BaseRouteDefinition, action?: Action) => T;
export declare type ValidateFunction = <T>(value: any, type: Class<T>) => Promise<T>;
export declare type StartupHook = () => Promise<void>;
export declare class OptionsBuilder {
    config: IConfiguration;
    private container;
    beforeStartHooks: StartupHook[];
    afterStartHooks: StartupHook[];
    constructor(config: IConfiguration, container: BaseContainer);
    options: ServerOptions;
    addBeforeStartHook(hook: StartupHook): OptionsBuilder;
    addAfterStartHook(hook: StartupHook): OptionsBuilder;
    /**
     * Return the built options
     */
    get serverOptions(): ServerOptions;
    /**
     * Enable or disable developer mode
     * Returns the full error stack (Not yet implemented)
     * @param val
     */
    setDevMode(val: boolean): OptionsBuilder;
    /**
     * Base path for all the endpoints
     * @param val
     */
    setBasePath(val: string): OptionsBuilder;
    /**
     * Enable or disable request logging
     * @param val
     */
    setLogRequests(val: boolean): OptionsBuilder;
    onRoute(fn: OnRotueListener): OptionsBuilder;
    /**
     * Enable or disable server errors logging
     * @param val
     */
    setLogErrors(val: boolean): OptionsBuilder;
    /**
     * Add a prebuilt broker
     * @param broker
     */
    addBroker(broker: IBroker): OptionsBuilder;
    /**
     * Add a list of controllers to the server
     * @param controllers
     */
    addControllers(...controllers: Class<any>[]): OptionsBuilder;
    /**
     * Add middlewares that get executed before any request handling, on all requests
     * @param middlewares
     */
    addBeforeMiddlewares(...middlewares: AppMiddleware[]): OptionsBuilder;
    /**
     * Add middlewares that get executed after all successfully handled requests
     * @param middlewares
     */
    addAfterMiddlewares(...middlewares: AppMiddleware[]): OptionsBuilder;
    /**
     * Add global error handlers
     * @param handlers
     */
    addErrorHandlers(...handlers: AppErrorHandler[]): OptionsBuilder;
    /**
     * Add authorization function to be called on @Authorized routes
     * @param handler
     */
    useAuthorization(handler: AuthorizationFunction): OptionsBuilder;
    /**
     * Add authorization error function to be called if @Authorized routes are not authorized
     * @param handler
     */
    setAuthorizationError(handler: GetNotAuthorizedErrorFuntion): OptionsBuilder;
    /**
     * Add user returning function for all the requests
     * @param checker
     */
    useAuthentication<TUser>(checker: CurrentUserCheckerFunction<TUser>): OptionsBuilder;
    /**
     * Set validate function
     * @param func
     */
    setValidateFunction(func: ValidateFunction): OptionsBuilder;
    /**
     * Set logger in container
     * @param logger
     */
    setLogger(logger: ILogger): OptionsBuilder;
    setTimeout(timeout: number): OptionsBuilder;
    /**
     * Set broker connection error handler
     * @param handler
     */
    setConnectionErrorHandler(handler: BrokerConnectionErrorHandler): OptionsBuilder;
    setGenerateSwagger(value: boolean): OptionsBuilder;
    addPlugin(plugin: MicroPlugin): OptionsBuilder;
    useTypeTransformer(fn: TransformerFunction): OptionsBuilder;
}