@nattyjs/core 0.0.1-beta.0

package/dist/index.d.ts

@@ -0,0 +1,468 @@
+import { NattyConfig, UserIdentity } from '@nattyjs/common';
+import { GlobalConfig } from '@nattyjs/common/interfaces/global-config';
+
+interface DecoratorInfo$1 {
+    method: string;
+    route: string;
+}
+
+interface TypeInfo$1 {
+    name: string;
+    documentation: string;
+    type: string;
+}
+
+interface ParameterInfo {
+    parameters: TypeInfo$1[];
+    returnType: string;
+    documentation: string;
+}
+interface MethodInfo$1 extends TypeInfo$1 {
+    info?: ParameterInfo[];
+    route?: DecoratorInfo$1;
+}
+
+interface ClassTypeInfo extends TypeInfo$1 {
+    filePath?: string;
+    constructors?: TypeInfo$1[];
+    methods?: MethodInfo$1[];
+    properties?: TypeInfo$1[];
+    route?: DecoratorInfo$1;
+}
+
+interface BuildOptions {
+    mode: string;
+    rootDir: string;
+    port: number;
+    commandName: string;
+    buildVersion: number;
+}
+
+declare function defineNattyConfig(config: NattyConfig | ((buildOptions?: BuildOptions) => NattyConfig | Promise<NattyConfig>)): NattyConfig | ((buildOptions?: BuildOptions) => NattyConfig | Promise<NattyConfig>);
+
+declare enum RunOn {
+    AzureFunction = 0,
+    ExpressJs = 1,
+    Koa = 2,
+    FastifyJs = 3,
+    GoogleFunction = 4,
+    Lambda = 5
+}
+
+declare function route(path: string): (target: any, propertyKey?: string, parameterIndex?: any) => any;
+
+declare function get(path: string): (target: any, propertyKey?: string, descriptor?: any) => void;
+
+declare function post(path: string): (target: any, propertyKey?: string, descriptor?: any) => void;
+
+declare function put(path: string): (target: any, propertyKey?: string, descriptor?: any) => void;
+
+declare function Delete(): (target: any, propertyKey?: string, descriptor?: any) => void;
+
+interface DecoratorInfo {
+    httpMethod: string;
+    route: string;
+}
+
+interface TypeInfo {
+    name: string;
+    documentation?: string;
+    type?: string;
+}
+interface MethodInfo extends TypeInfo {
+    parameters?: TypeInfo[];
+    returnType?: string;
+    route?: DecoratorInfo;
+}
+
+type HttpRequestBodyInfo = {
+    Uint8Array?: Uint8Array | Uint8Array[];
+    string?: string | string[];
+    number?: number | number[];
+    boolean?: boolean | boolean[];
+    FormData?: FormData;
+    ArrayBuffer?: ArrayBuffer;
+    Blob?: Blob;
+    json?: {
+        [key: string]: any;
+    } | Array<{
+        [key: string]: any;
+    }>;
+};
+
+interface Cookie {
+    name: string;
+    value: string;
+    domain?: string;
+    path?: string;
+    expires?: Date | number;
+    secure?: boolean;
+    httpOnly?: boolean;
+    sameSite?: 'Strict' | 'Lax' | 'None' | undefined;
+    maxAge?: number;
+}
+
+interface HttpRequestInit {
+    method?: string;
+    url?: string;
+    pathName?: string;
+    host?: string;
+    body?: HttpRequestBodyInfo;
+    cookies?: Cookie[];
+    headers?: Headers;
+    query?: Record<string, string>;
+    params?: Record<string, string>;
+}
+
+interface HttpResponseInit {
+    body?: any;
+    status?: number;
+    headers?: HeadersInit;
+    cookies?: Cookie[];
+    enableContentNegotiation?: boolean;
+}
+
+interface ProblemDetail {
+    type: string;
+    title: string;
+    detail?: string | number | boolean | {
+        [key: string]: any;
+    } | Array<{
+        [key: string]: any;
+    }>;
+}
+
+type ExceptionTypeInfo = string | number | boolean | {
+    [key: string]: any;
+} | Array<{
+    [key: string]: any;
+}> | ProblemDetail;
+
+type TypesInfo = {
+    [key: string]: {
+        path?: string | any | Function;
+        props?: Array<TypeInfo>;
+        values?: Array<any>;
+    };
+};
+
+interface DecoratorParams {
+    target: Function;
+    propertyKey?: string;
+    descriptor?: PropertyDescriptor;
+}
+
+interface ModelConfig {
+    tableName?: string;
+}
+
+interface DbFieldConfig {
+    name?: string;
+    type?: number;
+    defaultValue?: any;
+    isPrimaryKey?: boolean;
+    foreignKey?: any;
+    oneToMany?: FieldRelationConfig;
+    oneToOne?: FieldRelationConfig;
+}
+interface FieldRelationConfig {
+    model: any;
+    foreignKey: string;
+}
+
+interface PropConfig {
+    db?: DbFieldConfig;
+}
+
+interface PropertyDecoratorConfig {
+    decoratorParams: DecoratorParams;
+    validatorConfig?: any;
+    propConfig?: PropConfig;
+    modelConfig?: ModelConfig;
+    sanitizerConfig?: {
+        name: string;
+        config: any;
+        sanitizer: Function;
+    };
+}
+
+interface IHttpResult {
+    getResponse(): HttpResponseInit;
+}
+
+interface RouteConfig {
+    controller: Function;
+    parameters: Array<{
+        name: string;
+        type: string;
+    }>;
+    get: {
+        [key: string]: {
+            name: string;
+            parameters: Array<{
+                name: string;
+                type: string;
+            }>;
+            returnType: string;
+        };
+    };
+    post: {
+        [key: string]: {
+            name: string;
+            parameters: Array<{
+                name: string;
+                type: string;
+            }>;
+            returnType: string;
+        };
+    };
+    put: {
+        [key: string]: {
+            name: string;
+            parameters: Array<{
+                name: string;
+                type: string;
+            }>;
+            returnType: string;
+        };
+    };
+    delete: {
+        [key: string]: {
+            name: string;
+            parameters: Array<{
+                name: string;
+                type: string;
+            }>;
+            returnType: string;
+        };
+    };
+}
+
+declare function init(config: NattyConfig, appConfig: {
+    routes: {
+        [key: string]: RouteConfig;
+    };
+    envTsDefinition: {
+        [key: string]: string;
+    };
+    types?: TypesInfo;
+}): {
+    [key: string]: RouteConfig;
+};
+
+declare class HttpRequest {
+    private httpRequest;
+    constructor(http: HttpRequestInit);
+    get cookies(): Cookie[];
+    get url(): string;
+    get method(): string;
+    get headers(): Headers;
+    get user(): any;
+    get body(): HttpRequestBodyInfo;
+}
+
+declare class HttpResponse {
+    private _cookies;
+    private _headers;
+    private _body;
+    private _status;
+    constructor(response?: HttpResponseInit);
+    private setValues;
+    addCookie(cookie: Cookie): void;
+    get cookies(): Cookie[];
+    get status(): number;
+    set status(value: number);
+    get headers(): Headers;
+    get body(): HttpRequestBodyInfo;
+    set body(value: any);
+    write(responseInit: HttpResponseInit): void;
+}
+
+declare class HttpContext {
+    constructor(request: HttpRequestInit, context: any);
+    request: HttpRequest;
+    response: HttpResponse;
+    context: any;
+    config: NattyConfig;
+    routes: {
+        [key: string]: RouteConfig;
+    };
+    user: UserIdentity<any>;
+}
+
+declare class HttpHandler {
+    constructor();
+    processRequest(httpContext: HttpContext): Promise<HttpResponse>;
+}
+
+interface HttpModule {
+    init: (config: NattyConfig) => void;
+}
+
+declare function injectable<T = unknown>(): Function;
+declare function injectable<T = unknown>(options: any): Function;
+
+declare function $request(request: HttpRequestInit): Promise<HttpResponse>;
+
+interface ConfigureAt {
+    authentication?: boolean;
+    authorization?: boolean;
+    onException?: boolean;
+    filterExecutionIndex?: number;
+}
+interface FilterConfig {
+    configureAtGlobal?: ConfigureAt;
+}
+
+declare function filter(config?: FilterConfig): ClassDecorator;
+
+declare function registerDecorator(config: PropertyDecoratorConfig): void;
+
+declare abstract class AbstractModelState {
+    private _errors;
+    get isValid(): boolean;
+    get errors(): {
+        [key: string]: any;
+    };
+    private runValidators;
+}
+
+declare abstract class BaseResponse {
+    protected httpContext: HttpContext;
+    badRequest(): void;
+    success(body: any): HttpResponse;
+    notFound(): void;
+}
+
+declare abstract class ParameterTypeConverter extends BaseResponse {
+    sanitizer: {
+        number: (value: any) => any;
+        boolean: (value: any) => any;
+        string: (value: any) => any;
+        date: (value: any) => any;
+    };
+    get types(): TypesInfo;
+    getObjectTypeInfo(typeName: string): {
+        path?: any;
+        props?: TypeInfo[];
+        values?: any[];
+    };
+    isArrayType(typeName: string): boolean;
+    getTypeName(typeName: string): string;
+    castObject(requestBody: any, properties: TypeInfo[]): {
+        body: any;
+        invalidProps: any;
+    };
+    private setValue;
+    convert(methodInfo: MethodInfo, jObject: {
+        [key: string]: any;
+    } | Array<{
+        [key: string]: any;
+    }>): {
+        [key: string]: any;
+    } | {
+        [key: string]: any;
+    }[];
+    convertToInstance(entityName: string, data: any): any;
+    private getClassTarget;
+    mapToInstanceProperties(requestBody: any, instance: any, properties: TypeInfo[]): void;
+}
+
+declare class ModelBindingContext extends ParameterTypeConverter {
+    private type;
+    private typeInfo;
+    private data;
+    root: any;
+    parent: any;
+    instance: any;
+    constructor(type: string, typeInfo: TypeInfo[], data: any);
+    private serialize;
+    get isValid(): boolean;
+    get errors(): {};
+}
+
+type ValidatorInfo = {
+    [key: string]: any;
+};
+
+declare const entityContainer: {
+    register(config: PropertyDecoratorConfig): any;
+    getPropertyValidators(entityName: string, propName: string): ValidatorInfo;
+    getTarget(entityName: any): Function;
+    getPrimaryKeys(entityName: any): Array<string>;
+    getModelConfig(entityName: any): ModelConfig;
+    getProperties(entityName: string): TypeInfo[];
+    getPropsDbConfig(entityName: any): Map<string, DbFieldConfig>;
+};
+
+declare abstract class BaseController {
+    httpContext: HttpContext;
+}
+
+declare abstract class BaseResult {
+    private response;
+    constructor(response: HttpResponseInit, responseHeaders?: Pick<HttpResponseInit, "headers" | "cookies">);
+    getResponse(): HttpResponseInit;
+}
+
+declare class OkResult extends BaseResult {
+    value: any;
+    constructor(value: any, response?: Pick<HttpResponseInit, "headers" | "cookies">);
+}
+declare function ok(value?: any, response?: Pick<HttpResponseInit, "headers" | "cookies">): OkResult;
+
+declare class NotFoundResult extends BaseResult implements IHttpResult {
+    constructor(response?: Pick<HttpResponseInit, "headers" | "cookies">);
+}
+declare function notFound(response?: Pick<HttpResponseInit, "headers" | "cookies">): NotFoundResult;
+
+declare class NoContentResult extends BaseResult implements IHttpResult {
+    constructor(response?: Pick<HttpResponseInit, "headers" | "cookies">);
+}
+declare function noContent(response?: Pick<HttpResponseInit, "headers" | "cookies">): NoContentResult;
+
+declare class ForbiddenAccessInfoResult extends BaseResult implements IHttpResult {
+    constructor(value?: ExceptionTypeInfo, response?: Pick<HttpResponseInit, "headers" | "cookies">);
+}
+declare function forbiddenAccessInfo(value?: ExceptionTypeInfo, response?: Pick<HttpResponseInit, "headers" | "cookies">): ForbiddenAccessInfoResult;
+
+declare class CreatedResult extends BaseResult implements IHttpResult {
+    constructor(response?: Pick<HttpResponseInit, "headers" | "cookies">);
+}
+declare function created(response?: Pick<HttpResponseInit, "headers" | "cookies">): CreatedResult;
+
+declare class BadRequestResult extends BaseResult implements IHttpResult {
+    value: ExceptionTypeInfo;
+    constructor(value: ExceptionTypeInfo, response?: Pick<HttpResponseInit, "headers" | "cookies">);
+}
+declare function badRequest(value?: ExceptionTypeInfo, response?: Pick<HttpResponseInit, "headers" | "cookies">): BadRequestResult;
+
+declare class HttpException {
+    private httpResponse;
+    constructor(response: HttpResponseInit);
+    getResponse(): HttpResponse;
+}
+
+declare class ForbiddenAccessException extends HttpException {
+    constructor(data?: ExceptionTypeInfo);
+}
+
+declare class HttpBadRequestException extends HttpException {
+    constructor(data?: ExceptionTypeInfo);
+}
+
+declare class HttpNotFoundException extends HttpException {
+    constructor(data?: ExceptionTypeInfo);
+}
+
+declare class UnauthorizedAccessException extends HttpException {
+    constructor(data?: ExceptionTypeInfo);
+}
+
+declare function useFilter(config: GlobalConfig): (target: any, propertyKey?: string, descriptor?: any) => void;
+
+declare function anonymous(): (target: any, propertyKey?: string, descriptor?: any) => void;
+
+declare function authenticationOnly(): (target: any, propertyKey?: string, descriptor?: any) => void;
+
+export { $request, AbstractModelState, BadRequestResult, BaseController, BuildOptions, ClassTypeInfo, CreatedResult, Delete, ForbiddenAccessException, ForbiddenAccessInfoResult, HttpBadRequestException, HttpContext, HttpException, HttpHandler, HttpModule, HttpNotFoundException, HttpResponse, MethodInfo$1 as MethodInfo, ModelBindingContext, NoContentResult, NotFoundResult, OkResult, ParameterInfo, RunOn, TypeInfo$1 as TypeInfo, UnauthorizedAccessException, anonymous, authenticationOnly, badRequest, created, defineNattyConfig, entityContainer, filter, forbiddenAccessInfo, get, init, injectable, noContent, notFound, ok, post, put, registerDecorator, route, useFilter };