inversify-express-utils/lib/esm/interfaces.d.ts

Some utilities for the development of express applications with Inversify

import type { Application, NextFunction, Request, RequestHandler, Response } from 'express';
import { interfaces as inversifyInterfaces } from 'inversify';
import { HTTP_VERBS_ENUM, PARAMETER_TYPE } from './constants';
import { HttpResponseMessage } from './httpResponseMessage';
type Prototype<T> = {
    [P in keyof T]: T[P] extends NewableFunction ? T[P] : T[P] | undefined;
} & {
    constructor: NewableFunction;
};
interface ConstructorFunction<T = Record<string, unknown>> {
    prototype: Prototype<T>;
    new (...args: unknown[]): T;
}
export type DecoratorTarget<T = unknown> = ConstructorFunction<T> | Prototype<T>;
export type Middleware = inversifyInterfaces.ServiceIdentifier | RequestHandler;
export interface MiddlewareMetaData {
    [identifier: string]: Middleware[];
}
export type ControllerHandler = (...params: unknown[]) => unknown;
export interface Controller {
}
export interface ControllerMetadata {
    middleware: Middleware[];
    path: string;
    target: DecoratorTarget;
}
export interface ControllerMethodMetadata extends ControllerMetadata {
    key: string;
    method: HTTP_VERBS_ENUM;
}
export interface ControllerParameterMetadata {
    [methodName: string]: ParameterMetadata[];
}
export interface ParameterMetadata {
    index: number;
    injectRoot: boolean;
    parameterName?: string | symbol | undefined;
    type: PARAMETER_TYPE;
}
export type ExtractedParameters = ParameterMetadata[] | [Request, Response, NextFunction] | unknown[];
export type HandlerDecorator = (target: DecoratorTarget, key: string, value: unknown) => void;
export type ConfigFunction = (app: Application) => void;
export interface RoutingConfig {
    rootPath: string;
}
export interface Principal<T = unknown> {
    details: T;
    isAuthenticated(): Promise<boolean>;
    isInRole(role: string): Promise<boolean>;
    isResourceOwner(resourceId: unknown): Promise<boolean>;
}
export interface AuthProvider {
    getUser(req: Request, res: Response, next: NextFunction): Promise<Principal>;
}
export interface HttpContext<T = unknown> {
    container: inversifyInterfaces.Container;
    request: Request;
    response: Response;
    user: Principal<T>;
}
export interface IHttpActionResult {
    executeAsync(): Promise<HttpResponseMessage>;
}
export interface RouteDetails {
    args?: string[];
    route: string;
}
export interface RouteInfo {
    controller: string;
    endpoints: RouteDetails[];
}
export interface RawMetadata {
    controllerMetadata: ControllerMetadata;
    methodMetadata: ControllerMethodMetadata[];
    parameterMetadata: ControllerParameterMetadata;
}
export {};
//# sourceMappingURL=interfaces.d.ts.map