@nattyjs/core 0.0.1-beta.7 → 0.0.1-beta.70

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { NattyConfig, UserIdentity } from '@nattyjs/common';
+import { NattyConfig, UserIdentity, ClassType, ExceptionFilter } from '@nattyjs/common';
 import { GlobalConfig } from '@nattyjs/common/interfaces/global-config';
 
 interface DecoratorInfo$1 {
@@ -8,8 +8,9 @@ interface DecoratorInfo$1 {
 
 interface TypeInfo$1 {
     name: string;
-    documentation: string;
-    type: string;
+    documentation?: string;
+    type?: string;
+    tokenKey?: string;
 }
 
 interface ParameterInfo {
@@ -53,9 +54,9 @@ declare function route(path: string): (target: any, propertyKey?: string, parame
 
 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 post(path?: string): (target: any, propertyKey?: string, descriptor?: any) => void;
 
-declare function put(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;
 
@@ -68,6 +69,7 @@ interface TypeInfo {
     name: string;
     documentation?: string;
     type?: string;
+    tokenKey?: string;
 }
 interface MethodInfo extends TypeInfo {
     parameters?: TypeInfo[];
@@ -81,6 +83,7 @@ type HttpRequestBodyInfo = {
     number?: number | number[];
     boolean?: boolean | boolean[];
     FormData?: FormData;
+    buffer?: any;
     ArrayBuffer?: ArrayBuffer;
     Blob?: Blob;
     json?: {
@@ -120,6 +123,7 @@ interface HttpResponseInit {
     headers?: HeadersInit;
     cookies?: Cookie[];
     enableContentNegotiation?: boolean;
+    isBuffer?: boolean;
 }
 
 interface ProblemDetail {
@@ -192,47 +196,32 @@ interface IHttpResult {
 
 interface RouteConfig {
     controller: Function;
-    parameters: Array<{
-        name: string;
-        type: string;
-    }>;
+    parameters: TypeInfo$1[];
     get: {
         [key: string]: {
             name: string;
-            parameters: Array<{
-                name: string;
-                type: string;
-            }>;
+            parameters: TypeInfo$1[];
             returnType: string;
         };
     };
     post: {
         [key: string]: {
             name: string;
-            parameters: Array<{
-                name: string;
-                type: string;
-            }>;
+            parameters: TypeInfo$1[];
             returnType: string;
         };
     };
     put: {
         [key: string]: {
             name: string;
-            parameters: Array<{
-                name: string;
-                type: string;
-            }>;
+            parameters: TypeInfo$1[];
             returnType: string;
         };
     };
     delete: {
         [key: string]: {
             name: string;
-            parameters: Array<{
-                name: string;
-                type: string;
-            }>;
+            parameters: TypeInfo$1[];
             returnType: string;
         };
     };
@@ -242,10 +231,11 @@ declare function init(config: NattyConfig, appConfig: {
     routes: {
         [key: string]: RouteConfig;
     };
+    types?: TypesInfo;
     envTsDefinition: {
         [key: string]: string;
     };
-    types?: TypesInfo;
+    resolver?: (path: any) => any;
 }): any;
 
 declare class HttpRequest {
@@ -264,6 +254,7 @@ declare class HttpResponse {
     private _headers;
     private _body;
     private _status;
+    private _isBuffer;
     constructor(response?: HttpResponseInit);
     private setValues;
     addCookie(cookie: Cookie): void;
@@ -276,6 +267,83 @@ declare class HttpResponse {
     write(responseInit: HttpResponseInit): void;
 }
 
+type DIClassType<T = any> = new (...args: any[]) => T;
+
+type Token<T = any> = DIClassType<T> | symbol | string;
+
+interface ServiceProvider {
+    get<T>(token: Token<T>): T;
+    tryGet<T>(token: Token<T>): T | undefined;
+    set<T>(token: Token<T>, value: T): void;
+    createScope(): Scope;
+}
+
+interface Scope extends ServiceProvider {
+    dispose(): Promise<void> | void;
+}
+
+type Factory<T = any> = (sp: ServiceProvider) => T;
+
+declare enum Lifetime {
+    Singleton = "singleton",
+    Scoped = "scoped",
+    Transient = "transient"
+}
+
+type Descriptor<T = any> = {
+    lifetime: Lifetime.Singleton;
+    useValue?: T;
+    useClass?: DIClassType<T>;
+    useFactory?: Factory<T>;
+} | {
+    lifetime: Lifetime.Scoped;
+    useClass?: DIClassType<T>;
+    useFactory?: Factory<T>;
+} | {
+    lifetime: Lifetime.Transient;
+    useClass?: DIClassType<T>;
+    useFactory?: Factory<T>;
+};
+
+type ClearRegistrationsResult = {
+    metadataKeys: string[];
+    tokens: Token[];
+};
+declare class NattyContainer implements ServiceProvider {
+    private readonly regs;
+    private readonly singletons;
+    private readonly tokenSources;
+    private readonly sourceTokens;
+    private readonly metadataKeySources;
+    private readonly sourceMetadataKeys;
+    register<T>(token: Token<T>, desc: Descriptor<T>, sourceFile?: string): void;
+    addTransient<T>(token: Token<T>, useClass?: DIClassType<T>, useFactory?: Factory<T>, sourceFile?: string): void;
+    addScoped<T>(token: Token<T>, useClass?: DIClassType<T>, useFactory?: Factory<T>, sourceFile?: string): void;
+    addSingleton<T>(token: Token<T>, useClass?: DIClassType<T>, useFactory?: Factory<T>, sourceFile?: string): void;
+    addInstance<T>(token: Token<T>, value: T, sourceFile?: string): void;
+    createScope(): NattyScope;
+    set<T>(_token: Token<T>, _value: T): void;
+    tryGet<T>(token: Token<T>): T | undefined;
+    get<T>(token: Token<T>): T;
+    construct<T>(Cls: DIClassType<T>, sp: ServiceProvider): T;
+    _getDescriptor<T>(token: Token<T>): Descriptor<T> | undefined;
+    trackMetadataKey(sourceFile: string, key: string): void;
+    clearRegistrationsFromSource(sourceFile: string): ClearRegistrationsResult;
+    private trackTokenSource;
+}
+
+declare class NattyScope implements Scope {
+    private readonly root;
+    private readonly scoped;
+    private readonly disposables;
+    constructor(root: NattyContainer);
+    createScope(): NattyScope;
+    set<T>(token: Token<T>, value: T): void;
+    tryGet<T>(token: Token<T>): T | undefined;
+    get<T>(token: Token<T>): T;
+    dispose(): Promise<void>;
+}
+
 declare class HttpContext {
     constructor(request: HttpRequestInit, context: any);
     request: HttpRequest;
@@ -286,6 +354,7 @@ declare class HttpContext {
         [key: string]: RouteConfig;
     };
     user: UserIdentity<any>;
+    services: NattyScope;
 }
 
 declare class HttpHandler {
@@ -297,8 +366,11 @@ interface HttpModule {
     init: (config: NattyConfig) => void;
 }
 
-declare function injectable<T = unknown>(): Function;
-declare function injectable<T = unknown>(options: any): Function;
+declare function injectable<T = unknown>(): ClassDecorator;
+declare function injectable<T = unknown>(options: {
+    lifetime?: Lifetime;
+    token?: Token<T>;
+}): ClassDecorator;
 
 declare function $request(request: HttpRequestInit): Promise<HttpResponse>;
 
@@ -330,6 +402,7 @@ declare abstract class BaseResponse {
     badRequest(): void;
     success(body: any): HttpResponse;
     notFound(): void;
+    protected normalizeHttpResponse(result: any): any;
 }
 
 declare abstract class ParameterTypeConverter extends BaseResponse {
@@ -370,10 +443,11 @@ declare class ModelBindingContext extends ParameterTypeConverter {
     private type;
     private typeInfo;
     private data;
+    private throwOnValidationError;
     root: any;
     parent: any;
     instance: any;
-    constructor(type: string, typeInfo: TypeInfo[], data: any);
+    constructor(type: string, typeInfo: TypeInfo[], data: any, throwOnValidationError?: boolean);
     private serialize;
     get isValid(): boolean;
     get errors(): {};
@@ -397,47 +471,134 @@ declare abstract class BaseController {
     httpContext: HttpContext;
 }
 
+type ResponseExtras = Pick<HttpResponseInit, "headers" | "cookies">;
 declare abstract class BaseResult {
-    private response;
-    constructor(response: HttpResponseInit, responseHeaders?: Pick<HttpResponseInit, "headers" | "cookies">);
+    protected response: HttpResponseInit;
+    constructor(response: HttpResponseInit, extras?: ResponseExtras);
     getResponse(): HttpResponseInit;
 }
 
-declare class OkResult extends BaseResult {
-    value: any;
-    constructor(value: any, response?: Pick<HttpResponseInit, "headers" | "cookies">);
+declare class OkResult<T = unknown> extends BaseResult implements IHttpResult {
+    constructor(value?: T, extras?: ResponseExtras);
+}
+declare function ok<T = unknown>(value?: T, extras?: ResponseExtras): OkResult<T>;
+
+declare class CreatedResult<T = unknown> extends BaseResult implements IHttpResult {
+    constructor(value?: T, extras?: ResponseExtras);
 }
-declare function ok(value?: any, response?: Pick<HttpResponseInit, "headers" | "cookies">): OkResult;
+declare function created<T = unknown>(value?: T, extras?: ResponseExtras): CreatedResult<T>;
+declare function createdWith<T = unknown>(location: string, value?: T, extras?: ResponseExtras): CreatedResult<T>;
+declare function createdAt<T = unknown>(location: string, value?: T, extras?: ResponseExtras): CreatedResult<T>;
 
-declare class NotFoundResult extends BaseResult implements IHttpResult {
-    constructor(response?: Pick<HttpResponseInit, "headers" | "cookies">);
+declare class AcceptedResult<T = unknown> extends BaseResult implements IHttpResult {
+    value?: T;
+    constructor(value?: T, extras?: ResponseExtras);
 }
-declare function notFound(response?: Pick<HttpResponseInit, "headers" | "cookies">): NotFoundResult;
+declare function accepted<T = unknown>(value?: T, extras?: ResponseExtras): AcceptedResult<T>;
 
 declare class NoContentResult extends BaseResult implements IHttpResult {
-    constructor(response?: Pick<HttpResponseInit, "headers" | "cookies">);
+    constructor(extras?: ResponseExtras);
+}
+declare function noContent(extras?: ResponseExtras): NoContentResult;
+
+declare class BadRequestResult<T = ExceptionTypeInfo> extends BaseResult implements IHttpResult {
+    value?: T;
+    constructor(value?: T, extras?: ResponseExtras);
+}
+declare function badRequest<T = ExceptionTypeInfo>(value?: T, extras?: ResponseExtras): BadRequestResult<T>;
+
+declare class UnAuthorizedResult<T = ExceptionTypeInfo> extends BaseResult implements IHttpResult {
+    value?: T;
+    constructor(value?: T, extras?: ResponseExtras);
+}
+declare function unAuthorized<T = ExceptionTypeInfo>(value?: T, extras?: ResponseExtras): UnAuthorizedResult<T>;
+
+declare class ForbiddenAccessInfoResult<T = unknown> extends BaseResult implements IHttpResult {
+    constructor(value?: ExceptionTypeInfo, extras?: ResponseExtras);
+}
+declare function forbiddenAccessInfo(value?: ExceptionTypeInfo, extras?: ResponseExtras): ForbiddenAccessInfoResult<unknown>;
+declare function forbiddenAccess<T = unknown>(value?: ExceptionTypeInfo, extras?: ResponseExtras): ForbiddenAccessInfoResult<unknown>;
+
+declare class NotFoundResult<T = unknown> extends BaseResult implements IHttpResult {
+    constructor(value?: T, extras?: ResponseExtras);
+}
+declare function notFound(extras?: ResponseExtras): NotFoundResult<any>;
+declare function notFoundWith<T = unknown>(value?: T, extras?: ResponseExtras): NotFoundResult<T>;
+
+declare class ConflictResult<T = unknown> extends BaseResult implements IHttpResult {
+    value?: T;
+    constructor(value?: T, extras?: ResponseExtras);
 }
-declare function noContent(response?: Pick<HttpResponseInit, "headers" | "cookies">): NoContentResult;
+declare function conflict<T = unknown>(value?: T, extras?: ResponseExtras): ConflictResult<T>;
 
-declare class ForbiddenAccessInfoResult extends BaseResult implements IHttpResult {
-    constructor(value?: ExceptionTypeInfo, response?: Pick<HttpResponseInit, "headers" | "cookies">);
+declare class UnprocessableEntityResult<T = unknown> extends BaseResult implements IHttpResult {
+    value?: T;
+    constructor(value?: T, extras?: ResponseExtras);
 }
-declare function forbiddenAccessInfo(value?: ExceptionTypeInfo, response?: Pick<HttpResponseInit, "headers" | "cookies">): ForbiddenAccessInfoResult;
+declare function unprocessableEntity<T = unknown>(value?: T, extras?: ResponseExtras): UnprocessableEntityResult<T>;
 
-declare class CreatedResult extends BaseResult implements IHttpResult {
-    constructor(response?: Pick<HttpResponseInit, "headers" | "cookies">);
+declare class TooManyRequestsResult<T = unknown> extends BaseResult implements IHttpResult {
+    value?: T;
+    constructor(value?: T, retryAfterSeconds?: number, extras?: ResponseExtras);
 }
-declare function created(response?: Pick<HttpResponseInit, "headers" | "cookies">): CreatedResult;
+declare function tooManyRequests<T = unknown>(value?: T, retryAfterSeconds?: number, extras?: ResponseExtras): TooManyRequestsResult<T>;
 
-declare class BadRequestResult extends BaseResult implements IHttpResult {
-    value: ExceptionTypeInfo;
-    constructor(value: ExceptionTypeInfo, response?: Pick<HttpResponseInit, "headers" | "cookies">);
+declare class RedirectResult extends BaseResult implements IHttpResult {
+    constructor(location: string, permanent?: boolean, extras?: ResponseExtras);
 }
-declare function badRequest(value?: ExceptionTypeInfo, response?: Pick<HttpResponseInit, "headers" | "cookies">): BadRequestResult;
+declare function redirect(location: string, extras?: ResponseExtras): RedirectResult;
+declare function redirectPermanent(location: string, extras?: ResponseExtras): RedirectResult;
+
+/**
+ * RFC7807 problem details.
+ */
+type ProblemDetails = ProblemDetail & {
+    status?: number;
+    errors?: Record<string, string[]>;
+    [key: string]: any;
+};
+
+declare class ProblemResult extends BaseResult implements IHttpResult {
+    constructor(problem: ProblemDetails, extras?: ResponseExtras);
+}
+declare function problem(problem: ProblemDetails, extras?: ResponseExtras): ProblemResult;
+declare function validationProblem(errors: Record<string, string[]>, detail?: string, extras?: ResponseExtras): ProblemResult;
+
+declare class FileResult extends BaseResult implements IHttpResult {
+    constructor(buffer?: Buffer, extras?: ResponseExtras);
+}
+declare function file(buffer?: Buffer, extras?: ResponseExtras): FileResult;
+
+declare class StatusCodeResult<T = unknown> extends BaseResult implements IHttpResult {
+    constructor(status: number, value?: T, extras?: ResponseExtras);
+}
+
+declare const Results: {
+    readonly ok: <T = unknown>(value?: T, extras?: ResponseExtras) => OkResult<T>;
+    readonly created: <T_1 = unknown>(value?: T_1, extras?: ResponseExtras) => CreatedResult<T_1>;
+    readonly createdWith: <T_2 = unknown>(location: string, value?: T_2, extras?: ResponseExtras) => CreatedResult<T_2>;
+    readonly createdAt: <T_3 = unknown>(location: string, value?: T_3, extras?: ResponseExtras) => CreatedResult<T_3>;
+    readonly accepted: <T_4 = unknown>(value?: T_4, extras?: ResponseExtras) => AcceptedResult<T_4>;
+    readonly noContent: (extras?: ResponseExtras) => NoContentResult;
+    readonly file: (buffer?: Buffer, extras?: ResponseExtras) => FileResult;
+    readonly statusCode: <T_5 = unknown>(status: number, value?: T_5, extras?: ResponseExtras) => StatusCodeResult<T_5>;
+    readonly badRequest: <T_6 = ExceptionTypeInfo>(value?: T_6, extras?: ResponseExtras) => BadRequestResult<T_6>;
+    readonly notFound: (extras?: ResponseExtras) => NotFoundResult<any>;
+    readonly notFoundWith: <T_7 = unknown>(value?: T_7, extras?: ResponseExtras) => NotFoundResult<T_7>;
+    readonly unAuthorized: <T_8 = ExceptionTypeInfo>(value?: T_8, extras?: ResponseExtras) => UnAuthorizedResult<T_8>;
+    readonly forbid: <T_9 = ExceptionTypeInfo>(value?: T_9, extras?: ResponseExtras) => ForbiddenAccessInfoResult<unknown>;
+    readonly conflict: <T_10 = unknown>(value?: T_10, extras?: ResponseExtras) => ConflictResult<T_10>;
+    readonly unprocessableEntity: <T_11 = unknown>(value?: T_11, extras?: ResponseExtras) => UnprocessableEntityResult<T_11>;
+    readonly tooManyRequests: <T_12 = unknown>(value?: T_12, retryAfterSeconds?: number, extras?: ResponseExtras) => TooManyRequestsResult<T_12>;
+    readonly redirect: (location: string, extras?: ResponseExtras) => RedirectResult;
+    readonly redirectPermanent: (location: string, extras?: ResponseExtras) => RedirectResult;
+    readonly problem: (p: ProblemDetails, extras?: ResponseExtras) => ProblemResult;
+    readonly validationProblem: (errors: Record<string, string[]>, detail?: string, extras?: ResponseExtras) => ProblemResult;
+};
 
-declare class HttpException {
+declare class HttpException extends Error {
     private httpResponse;
-    constructor(response: HttpResponseInit);
+    constructor(response: HttpResponseInit, message?: string);
     getResponse(): HttpResponse;
 }
 
@@ -457,10 +618,103 @@ declare class UnauthorizedAccessException extends HttpException {
     constructor(data?: ExceptionTypeInfo);
 }
 
+declare class AcceptedException extends HttpException {
+    constructor(data?: ExceptionTypeInfo);
+}
+
+declare class HttpConflictException extends HttpException {
+    constructor(data?: ExceptionTypeInfo);
+}
+
+declare class HttpUnprocessableEntityException extends HttpException {
+    constructor(data?: ExceptionTypeInfo);
+}
+
+type RetryAfter = number | string | Date;
+declare class TooManyRequestsException extends HttpException {
+    constructor(data?: ExceptionTypeInfo, retryAfter?: RetryAfter);
+}
+
+declare class RedirectException extends HttpException {
+    constructor(location: string, data?: ExceptionTypeInfo);
+}
+
+declare class RedirectPermanentException extends HttpException {
+    constructor(location: string, data?: ExceptionTypeInfo);
+}
+
+declare class ProblemDetailsException extends HttpException {
+    constructor(problem: ProblemDetails, status?: number, headers?: Record<string, string>);
+}
+declare class ValidationProblemDetailsException extends ProblemDetailsException {
+    constructor(errors: Record<string, string[]>, detail?: string, status?: number);
+}
+
 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 };
+declare function onException(exceptionFilter: ClassType<ExceptionFilter>): (target: any, propertyKey?: string, descriptor?: any) => void;
+
+declare function setEnvInfo(envTsDefinition: {
+    [key: string]: string;
+}, envValueInfo: {
+    [key: string]: any;
+}): void;
+
+declare enum HttpStatusCode {
+    success = 200,
+    created = 201,
+    accepted = 202,
+    noContent = 204,
+    movedPermanently = 301,
+    found = 302,
+    badRequest = 400,
+    unAuthorized = 401,
+    forbiddenAccess = 403,
+    notFound = 404,
+    conflict = 409,
+    unprocessableEntity = 422,
+    tooManyRequests = 429,
+    serverError = 500
+}
+
+declare function authorize(permission: {
+    [key: string]: any;
+}): (target: any, propertyKey?: string, descriptor?: any) => void;
+
+declare function CreateProblemDetail(modelName: string, detail: any): ProblemDetail;
+
+declare function scoped<T = unknown>(): ClassDecorator;
+
+declare function transient<T = unknown>(): ClassDecorator;
+
+declare function singleton<T = unknown>(): ClassDecorator;
+
+interface DiOptions {
+    lifetime?: Lifetime;
+}
+
+declare function di<T = unknown>(token: Token<T> | unknown): ClassDecorator;
+declare function di<T = unknown>(token: Token<T> | unknown, options: DiOptions): ClassDecorator;
+
+declare function registerType<T>(): unknown;
+
+declare function createServiceScope(): NattyScope;
+
+declare function clearHotReloadRegistrations(files: string[]): void;
+
+declare function clearHotReloadControllerMetadata(controllerNames: string[]): void;
+
+interface RuntimeManifest {
+    routes: {
+        [key: string]: RouteConfig;
+    };
+    resolver?: (path: string) => any;
+}
+
+declare function replaceRoutes(manifest: RuntimeManifest): void;
+
+export { $request, AbstractModelState, AcceptedException, AcceptedResult, BadRequestResult, BaseController, BaseResult, BuildOptions, ClassTypeInfo, ConflictResult, CreateProblemDetail, CreatedResult, Delete, DiOptions, FileResult, ForbiddenAccessException, ForbiddenAccessInfoResult, HttpBadRequestException, HttpConflictException, HttpContext, HttpException, HttpHandler, HttpModule, HttpNotFoundException, HttpResponse, HttpStatusCode, HttpUnprocessableEntityException, Lifetime, MethodInfo$1 as MethodInfo, ModelBindingContext, NoContentResult, NotFoundResult, OkResult, ParameterInfo, ProblemDetailsException, ProblemResult, RedirectException, RedirectPermanentException, RedirectResult, ResponseExtras, Results, RetryAfter, RunOn, RuntimeManifest, TooManyRequestsException, TooManyRequestsResult, TypeInfo$1 as TypeInfo, UnAuthorizedResult, UnauthorizedAccessException, UnprocessableEntityResult, ValidationProblemDetailsException, accepted, anonymous, authenticationOnly, authorize, badRequest, clearHotReloadControllerMetadata, clearHotReloadRegistrations, conflict, createServiceScope, created, createdAt, createdWith, defineNattyConfig, di, entityContainer, file, filter, forbiddenAccess, forbiddenAccessInfo, get, init, injectable, noContent, notFound, notFoundWith, ok, onException, post, problem, put, redirect, redirectPermanent, registerDecorator, registerType, replaceRoutes, route, scoped, setEnvInfo, singleton, tooManyRequests, transient, unAuthorized, unprocessableEntity, useFilter, validationProblem };