moost 0.0.1-beta.0

package/dist/moost.d.ts

@@ -0,0 +1,274 @@
+import { Mate } from '@prostojs/mate';
+import { TProstoMetadata } from '@prostojs/mate';
+import { TProstoParamsMetadata } from '@prostojs/mate';
+import { TProvideFn } from '@prostojs/infact';
+import { TProvideRegistry } from '@prostojs/infact';
+import { TValidoDtoOptions } from '@prostojs/valido';
+import { TValidoFn } from '@prostojs/valido';
+import { TWooksOptions } from 'wooks';
+import { validoIsBoolean } from '@prostojs/valido';
+import { validoIsNumber } from '@prostojs/valido';
+import { validoIsString } from '@prostojs/valido';
+import { Wooks } from 'wooks';
+
+export declare const All: (path?: string) => MethodDecorator;
+
+export declare function Body(): ParameterDecorator;
+
+export declare function Circular<T = unknown>(resolver: () => TClassConstructor<T>): ParameterDecorator;
+
+export declare function Const(value: unknown, label?: string): ParameterDecorator;
+
+export declare function Controller(prefix?: string): ClassDecorator;
+
+export declare function Cookie(name: string): ParameterDecorator;
+
+export declare const Delete: (path?: string) => MethodDecorator;
+
+export declare function Dto(dtoOptions?: TValidoDtoOptions): ClassDecorator;
+
+export declare const genericTypesCastPipe: (strict?: boolean) => TPipeFn;
+
+export declare const Get: (path?: string) => MethodDecorator;
+
+export declare function getMoostMate(): Mate<TMoostMetadata>;
+
+export declare function Header(name: string): ParameterDecorator;
+
+export declare function HttpMethod(method: '*' | 'GET' | 'PUT' | 'POST' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS', path?: string): MethodDecorator;
+
+export declare function ImportController(controller: TFunction | TObject, provide?: TProvideRegistry): ClassDecorator;
+
+export declare function ImportController(prefix: string, controller: TFunction | TObject, provide?: TProvideRegistry): ClassDecorator;
+
+export declare function Inject(type: string | TClassConstructor): ParameterDecorator;
+
+export declare function Injectable(scope?: true | TInjectableScope): ClassDecorator;
+
+export declare function Intercept(handler: TCallableClassFunction<TInterceptorFn>, priority?: TInterceptorPriority): ClassDecorator & MethodDecorator;
+
+export declare function Ip(opts?: {
+    trustProxy: boolean;
+}): ParameterDecorator;
+
+export declare function IpList(): ParameterDecorator;
+
+export declare function IsArray<T = unknown>(opts?: TValidateArrayOptions<T>): PropertyDecorator & ParameterDecorator;
+
+export declare function IsBoolean(...args: Parameters<typeof validoIsBoolean>): PropertyDecorator & ParameterDecorator;
+
+export declare function IsNumber(...args: Parameters<typeof validoIsNumber>): PropertyDecorator & ParameterDecorator;
+
+export declare function IsString(...args: Parameters<typeof validoIsString>): PropertyDecorator & ParameterDecorator;
+
+export declare function IsTypeOf(type: 'string' | 'object' | 'number' | 'boolean', errorText?: string): PropertyDecorator & ParameterDecorator;
+
+export declare function Label(value: string): MethodDecorator & ClassDecorator & ParameterDecorator & PropertyDecorator;
+
+export declare function Method(): ParameterDecorator;
+
+export declare class Moost {
+    protected options?: TMoostOptions | undefined;
+    pipes: TPipeData[];
+    interceptors: TInterceptorData[];
+    provide: TProvideRegistry;
+    constructor(options?: TMoostOptions | undefined);
+    protected wooksApp?: Wooks;
+    protected unregisteredControllers: (TObject | TFunction)[];
+    listen(): Promise<Wooks>;
+    listen(port: number): Promise<Wooks>;
+    listen(port: number, cb: () => void): Promise<Wooks>;
+    listen(port: number, hostname: string): Promise<Wooks>;
+    listen(port: number, hostname: string, cb: () => void): Promise<Wooks>;
+    close(): Promise<unknown> | undefined;
+    private init;
+    protected bindControllers(): Promise<void>;
+    protected bindController(controller: TFunction | TObject, provide: TProvideRegistry, globalPrefix: string, replaceOwnPrefix?: string): Promise<void>;
+    applyGlobalPipes(...items: (TPipeFn | TPipeData)[]): this;
+    applyGlobalInterceptors(...items: (TInterceptorData['handler'] | TInterceptorData)[]): this;
+    setProvideRegistry(provide: TProvideRegistry): this;
+    registerControllers(...controllers: (TObject | TFunction)[]): this;
+}
+
+export declare function Optional(): MethodDecorator & ClassDecorator & ParameterDecorator & PropertyDecorator;
+
+export declare function Param(name: string): ParameterDecorator;
+
+export declare function Params(): ParameterDecorator;
+
+export declare const Patch: (path?: string) => MethodDecorator;
+
+export declare const Post: (path?: string) => MethodDecorator;
+
+export declare function Provide(type: string | TClassConstructor, fn: TProvideFn): ClassDecorator;
+
+export declare const Put: (path?: string) => MethodDecorator;
+
+export declare function Query(name?: string): ParameterDecorator;
+
+export declare function RawBody(): ParameterDecorator;
+
+export declare function Req(): ParameterDecorator;
+
+export declare function ReqId(): ParameterDecorator;
+
+declare function Required_2(): MethodDecorator & ClassDecorator & ParameterDecorator & PropertyDecorator;
+export { Required_2 as Required }
+
+export declare function Res(options?: {
+    passthrough: boolean;
+}): ParameterDecorator;
+
+export declare function Resolve(resolver: () => unknown, label?: string): ParameterDecorator;
+
+export declare const resolvePipe: TPipeFn;
+
+declare type TAny = any;
+
+declare type TAnyFn = {
+    (...a: TAny[]): unknown;
+};
+
+export declare type TCallableClassFunction<T extends TAnyFn = TAnyFn> = T | TClassFunctionConstructor;
+
+declare type TClassConstructor<T = unknown> = new (...args: TAny[]) => T;
+
+export declare interface TClassFunction<T extends TAnyFn = TAnyFn> {
+    handler: T;
+}
+
+declare interface TClassFunctionConstructor<T extends TAnyFn = TAnyFn> {
+    new (...a: TAny[]): TClassFunction<T>;
+}
+
+declare interface TCommonMetaFields {
+    label?: string;
+    optional?: boolean;
+    required?: boolean;
+}
+
+declare interface TCommonMoostMeta {
+    pipes?: TPipeData[];
+}
+
+declare type TFunction = Function;
+
+export declare type TInjectableScope = 'FOR_REQUEST' | 'SINGLETON';
+
+export declare type TInterceptorAfter = (response: TAny, reply: (response: TAny) => void) => void | Promise<void>;
+
+export declare type TInterceptorBefore = (reply: (response: TAny) => void) => void | Promise<void>;
+
+export declare interface TInterceptorData {
+    handler: TCallableClassFunction<TInterceptorFn>;
+    priority: TInterceptorPriority;
+}
+
+export declare type TInterceptorFn = {
+    (before: (fn: TInterceptorBefore) => void, after: (fn: TInterceptorAfter) => void, onError: (fn: TInterceptorOnError) => void): void | Promise<void>;
+    priority?: TInterceptorPriority;
+};
+
+export declare type TInterceptorOnError = (error: Error, reply: (response: TAny) => void) => void | Promise<void>;
+
+export declare enum TInterceptorPriority {
+    BEFORE_ALL = 0,
+    BEFORE_GUARD = 1,
+    GUARD = 2,
+    AFTER_GUARD = 3,
+    INTERCEPTOR = 4,
+    CATCH_ERROR = 5,
+    AFTER_ALL = 6
+}
+
+export declare interface TMoostMetadata extends TProstoAndCommonMetadata {
+    inherit?: boolean;
+    dto?: TValidoDtoOptions;
+    requiredProps?: (string | symbol)[];
+    controller?: {
+        prefix?: string;
+    };
+    importController?: {
+        prefix?: string;
+        typeResolver?: TClassConstructor | (() => TClassConstructor | TObject | Promise<TClassConstructor | TObject>);
+        provide?: TProvideRegistry;
+    }[];
+    injectable?: true | TInjectableScope;
+    interceptors?: TInterceptorData[];
+    httpHandler?: {
+        method: '*' | 'GET' | 'PUT' | 'POST' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS';
+        path: string;
+    }[];
+    validators?: TValidoFn[];
+    validatorsOfItem?: TValidoFn[];
+    arrayType?: true | TValidateArrayOptions;
+    provide?: TProvideRegistry;
+}
+
+export declare interface TMoostOptions {
+    globalPrefix?: string;
+    port?: number | string;
+    hostname?: string;
+    wooksOptions?: TWooksOptions;
+}
+
+export declare interface TMoostParamsMetadata extends TProstoParamsAndCommonMetadata {
+    validators?: TValidoFn[];
+    validatorsOfItem?: TValidoFn[];
+    arrayType?: true | TValidateArrayOptions;
+    resolver?: TFunction;
+    circular?: () => TAny;
+    inject?: string | symbol;
+}
+
+declare type TObject = object;
+
+export declare interface TPipeData {
+    handler: TPipeFn;
+    priority: TPipePriority;
+}
+
+export declare type TPipeFn<T extends TMoostParamsMetadata = TMoostParamsMetadata> = {
+    (value: unknown, meta: T): unknown | Promise<unknown>;
+    priority?: TPipePriority;
+};
+
+export declare enum TPipePriority {
+    BEFORE_RESOLVE = 0,
+    RESOLVE = 1,
+    AFTER_RESOLVE = 2,
+    BEFORE_TRANSFORM = 3,
+    TRANSFORM = 4,
+    AFTER_TRANSFORM = 5,
+    BEFORE_VALIDATE = 6,
+    VALIDATE = 7,
+    AFTER_VALIDATE = 8
+}
+
+declare type TProstoAndCommonMetadata<T extends TMoostParamsMetadata = TMoostParamsMetadata> = TProstoMetadata<T> & TCommonMetaFields & TCommonMoostMeta;
+
+declare type TProstoParamsAndCommonMetadata = TProstoParamsMetadata & TCommonMetaFields & TCommonMoostMeta;
+
+export declare interface TValidateArrayOptions<T = unknown> {
+    itemType?: (item: T, index: number) => Promise<TFunction> | TFunction;
+    itemValidators?: () => (PropertyDecorator | ParameterDecorator)[];
+    minLength?: number;
+    maxLength?: number;
+}
+
+declare interface TValidatePipeOptions {
+    errorLimit?: number;
+}
+
+export declare function Url(): ParameterDecorator;
+
+export declare function useControllerMeta<T extends TMoostMetadata = TMoostMetadata>(): {
+    getClassMeta: () => T | undefined;
+    getMethodMeta: () => T | undefined;
+};
+
+export declare function Validate<T = unknown>(validator: TValidoFn<T>): PropertyDecorator & ParameterDecorator;
+
+export declare const validatePipe: (opts?: TValidatePipeOptions) => TPipeFn;
+
+export { }