@swizzyweb/swizzy-web-service/dist/router/web-router.d.ts

Web service framework for swizzy dyn serve

import { ILogger } from "@swizzyweb/swizzy-common";
import { Router } from "@swizzyweb/express";
import { SwizzyMiddleware } from "../middleware/index.js";
import { NewWebControllerClass } from "../controller/index.js";
import { StateConverter } from "../state/index.js";
export type NewWebRouterClass<APP_STATE, ROUTER_STATE> = new (props: IWebRouterProps<APP_STATE, ROUTER_STATE>) => IWebRouter<APP_STATE, ROUTER_STATE>;
export type isWebRouter = {
    isWebRouter: boolean;
};
export type SwizzyWebRouterClass<APP_STATE, ROUTER_STATE> = NewWebRouterClass<APP_STATE, ROUTER_STATE> & isWebRouter;
export interface IWebRouter<APP_STATE, ROUTER_STATE> {
    readonly name: string;
    initialize(props: IWebRouterInitProps<APP_STATE>): Promise<void>;
    router(): any;
    getState(): ROUTER_STATE;
    path: string;
    toJson(): any;
    toString(): string;
}
export interface IWebRouterProps<APP_STATE, ROUTER_STATE> {
    /**
     * TODO: make required
     */
    logger: ILogger<any>;
}
export interface IInternalWebRouterProps<APP_STATE, ROUTER_STATE> extends IWebRouterProps<APP_STATE, ROUTER_STATE> {
    name: string;
    webControllerClasses: NewWebControllerClass<ROUTER_STATE, any>[];
    path: string;
    stateConverter: StateConverter<APP_STATE, ROUTER_STATE>;
    middleware?: SwizzyMiddleware<ROUTER_STATE>[];
}
export interface IWebRouterInitProps<APP_STATE> {
    appState: APP_STATE;
}
export declare abstract class WebRouter<APP_STATE, ROUTER_STATE> implements IWebRouter<APP_STATE, ROUTER_STATE> {
    /**
     * Flag for if this is a webrouter, alwaus true for
     * all web routers
     */
    static isWebRouter: boolean;
    /**
     * Web router name
     */
    readonly name: string;
    readonly path: string;
    /**
     * Actual express router initialized in initialize method
     */
    actualRouter?: Router;
    state?: ROUTER_STATE;
    /**
     * logger
     */
    protected logger: ILogger<any>;
    /**
     * Router middleware
     */
    protected readonly middleware: SwizzyMiddleware<ROUTER_STATE>[];
    /**
     * Controller classes to be attached to this router
     */
    protected readonly webControllerClasses: NewWebControllerClass<ROUTER_STATE, any>[];
    /**
     * Installed web controllers, initialized in initialize()
     */
    private readonly installedControllers;
    /**
     * State converter that converts app state to router state
     */
    private stateConverter;
    constructor(props: IInternalWebRouterProps<APP_STATE, ROUTER_STATE>);
    /**
     * Initializes router, needs to be called before calling router() method.
     */
    initialize(props: IWebRouterInitProps<APP_STATE>): Promise<void>;
    isInitialized(): boolean;
    /**
     * overide this to configure your router, ensuring you call super first.
     */
    protected getInitializedRouter(props: IWebRouterInitProps<APP_STATE>): Promise<Router>;
    private installControllers;
    private installController;
    router(): Router;
    getState(): ROUTER_STATE;
    protected installMiddleware(props: IInstallRouterMiddlewareProps): Promise<void>;
    protected getMiddleware(): SwizzyMiddleware<ROUTER_STATE>[];
    toJson(): {
        name: string;
        logger: undefined;
        webControllerClasses: NewWebControllerClass<ROUTER_STATE, any>[];
        installedControllers: any[];
        path: string;
        middleware: any[];
        stateConverter: {
            name: string;
        };
    };
    toString(): string;
}
export interface IPackageStateProps<APP_STATE> {
    appState: APP_STATE;
}
export interface IInstallRouterMiddlewareProps {
    router: Router;
    logger: ILogger<any>;
}