@dooboostore/simple-boot-http-server 1.0.14

package/codes/HttpHeaders.js

@@ -0,0 +1,43 @@
+export var HttpHeaders;
+(function (HttpHeaders) {
+    HttpHeaders["ContentLength"] = "Content-Length";
+    HttpHeaders["ContentType"] = "Content-Type";
+    HttpHeaders["ContentEncoding"] = "Content-Encoding";
+    HttpHeaders["Accept"] = "Accept";
+    HttpHeaders["Authorization"] = "Authorization";
+    HttpHeaders["CacheControl"] = "Cache-Control";
+    HttpHeaders["Connection"] = "Connection";
+    HttpHeaders["Date"] = "Date";
+    HttpHeaders["Host"] = "Host";
+    HttpHeaders["Pragma"] = "Pragma";
+    HttpHeaders["Trailer"] = "Trailer";
+    HttpHeaders["TransferEncoding"] = "Transfer-Encoding";
+    HttpHeaders["Upgrade"] = "Upgrade";
+    HttpHeaders["Via"] = "Via";
+    HttpHeaders["Warning"] = "Warning";
+    HttpHeaders["AcceptCharset"] = "Accept-Charset";
+    HttpHeaders["AcceptEncoding"] = "Accept-Encoding";
+    HttpHeaders["AcceptLanguage"] = "Accept-Language";
+    HttpHeaders["AccessControlAllowOrigin"] = "Access-Control-Allow-Origin";
+    HttpHeaders["AccessControlAllowMethods"] = "Access-Control-Allow-Methods";
+    HttpHeaders["AccessControlAllowHeaders"] = "Access-Control-Allow-Headers";
+    HttpHeaders["AccessControlExposeHeaders"] = "Access-Control-Expose-Headers";
+    HttpHeaders["Expect"] = "Expect";
+    HttpHeaders["From"] = "From";
+    HttpHeaders["MaxForwards"] = "Max-Forwards";
+    HttpHeaders["Referer"] = "Referer";
+    HttpHeaders["UserAgent"] = "User-Agent";
+    HttpHeaders["Cookie"] = "Cookie";
+    HttpHeaders["SetCookie"] = "Set-Cookie";
+    HttpHeaders["Cookie2"] = "Cookie2";
+    HttpHeaders["SetCookie2"] = "Set-Cookie2";
+    HttpHeaders["Location"] = "Location";
+    HttpHeaders["IfModifiedSince"] = "If-Modified-Since";
+    HttpHeaders["IfUnmodifiedSince"] = "If-Unmodified-Since";
+    HttpHeaders["IfMatch"] = "If-Match";
+    HttpHeaders["IfNoneMatch"] = "If-None-Match";
+    HttpHeaders["IfRange"] = "If-Range";
+    HttpHeaders["Allow"] = "Allow";
+    HttpHeaders["Server"] = "Server";
+})(HttpHeaders || (HttpHeaders = {}));
+//# sourceMappingURL=HttpHeaders.js.map

package/codes/HttpMethod.d.ts

@@ -0,0 +1,12 @@
+export declare enum HttpMethod {
+    GET = "GET",
+    POST = "POST",
+    PUT = "PUT",
+    DELETE = "DELETE",
+    PATCH = "PATCH",
+    HEAD = "HEAD",
+    OPTIONS = "OPTIONS",
+    TRACE = "TRACE",
+    CONNECT = "CONNECT"
+}
+//# sourceMappingURL=HttpMethod.d.ts.map

package/codes/HttpMethod.js

@@ -0,0 +1,13 @@
+export var HttpMethod;
+(function (HttpMethod) {
+    HttpMethod["GET"] = "GET";
+    HttpMethod["POST"] = "POST";
+    HttpMethod["PUT"] = "PUT";
+    HttpMethod["DELETE"] = "DELETE";
+    HttpMethod["PATCH"] = "PATCH";
+    HttpMethod["HEAD"] = "HEAD";
+    HttpMethod["OPTIONS"] = "OPTIONS";
+    HttpMethod["TRACE"] = "TRACE";
+    HttpMethod["CONNECT"] = "CONNECT";
+})(HttpMethod || (HttpMethod = {}));
+//# sourceMappingURL=HttpMethod.js.map

package/codes/HttpStatus.d.ts

@@ -0,0 +1,20 @@
+export declare enum HttpStatus {
+    Ok = 200,
+    MovedPermanently = 301,
+    Found = 302,
+    SeeOther = 303,
+    NotModified = 304,
+    TemporaryRedirect = 307,
+    PermanentRedirect = 308,
+    BadRequest = 400,
+    Unauthorized = 401,
+    Forbidden = 403,
+    NotFound = 404,
+    InternalServerError = 500,
+    NotImplemented = 501,
+    BadGateway = 502,
+    ServiceUnavailable = 503,
+    GatewayTimeout = 504,
+    HttpVersionNotSupported = 505
+}
+//# sourceMappingURL=HttpStatus.d.ts.map

package/codes/HttpStatus.js

@@ -0,0 +1,21 @@
+export var HttpStatus;
+(function (HttpStatus) {
+    HttpStatus[HttpStatus["Ok"] = 200] = "Ok";
+    HttpStatus[HttpStatus["MovedPermanently"] = 301] = "MovedPermanently";
+    HttpStatus[HttpStatus["Found"] = 302] = "Found";
+    HttpStatus[HttpStatus["SeeOther"] = 303] = "SeeOther";
+    HttpStatus[HttpStatus["NotModified"] = 304] = "NotModified";
+    HttpStatus[HttpStatus["TemporaryRedirect"] = 307] = "TemporaryRedirect";
+    HttpStatus[HttpStatus["PermanentRedirect"] = 308] = "PermanentRedirect";
+    HttpStatus[HttpStatus["BadRequest"] = 400] = "BadRequest";
+    HttpStatus[HttpStatus["Unauthorized"] = 401] = "Unauthorized";
+    HttpStatus[HttpStatus["Forbidden"] = 403] = "Forbidden";
+    HttpStatus[HttpStatus["NotFound"] = 404] = "NotFound";
+    HttpStatus[HttpStatus["InternalServerError"] = 500] = "InternalServerError";
+    HttpStatus[HttpStatus["NotImplemented"] = 501] = "NotImplemented";
+    HttpStatus[HttpStatus["BadGateway"] = 502] = "BadGateway";
+    HttpStatus[HttpStatus["ServiceUnavailable"] = 503] = "ServiceUnavailable";
+    HttpStatus[HttpStatus["GatewayTimeout"] = 504] = "GatewayTimeout";
+    HttpStatus[HttpStatus["HttpVersionNotSupported"] = 505] = "HttpVersionNotSupported";
+})(HttpStatus || (HttpStatus = {}));
+//# sourceMappingURL=HttpStatus.js.map

package/codes/Mimes.d.ts

@@ -0,0 +1,28 @@
+export declare enum Mimes {
+    ApplicationJson = "application/json",
+    ApplicationOctetStream = "application/octet-stream",
+    ApplicationXml = "application/xml",
+    ApplicationJsonPatch = "application/json-patch+json",
+    ApplicationXWwwFormUrlencoded = "application/x-www-form-urlencoded",
+    TextPlain = "text/plain",
+    TextHtml = "text/html",
+    All = "*/*",
+    TextCss = "text/css",
+    TextJavascript = "text/javascript",
+    TextXml = "text/xml",
+    TextXslt = "text/xslt",
+    TextXmlDtd = "text/xml-dtd",
+    TextPlainUtf8 = "text/plain; charset=utf-8",
+    ImagePng = "image/png",
+    ImageGif = "image/gif",
+    ImageJpeg = "image/jpeg",
+    ImageSvg = "image/svg+xml",
+    ImageBmp = "image/bmp",
+    ImageTiff = "image/tiff",
+    ImagePdf = "application/pdf",
+    ImageXBmp = "image/x-bmp",
+    ImageXpixmap = "image/x-xpixmap",
+    ImageXxbm = "image/x-xbm",
+    MultipartFormData = "multipart/form-data"
+}
+//# sourceMappingURL=Mimes.d.ts.map

package/codes/Mimes.js

@@ -0,0 +1,29 @@
+export var Mimes;
+(function (Mimes) {
+    Mimes["ApplicationJson"] = "application/json";
+    Mimes["ApplicationOctetStream"] = "application/octet-stream";
+    Mimes["ApplicationXml"] = "application/xml";
+    Mimes["ApplicationJsonPatch"] = "application/json-patch+json";
+    Mimes["ApplicationXWwwFormUrlencoded"] = "application/x-www-form-urlencoded";
+    Mimes["TextPlain"] = "text/plain";
+    Mimes["TextHtml"] = "text/html";
+    Mimes["All"] = "*/*";
+    Mimes["TextCss"] = "text/css";
+    Mimes["TextJavascript"] = "text/javascript";
+    Mimes["TextXml"] = "text/xml";
+    Mimes["TextXslt"] = "text/xslt";
+    Mimes["TextXmlDtd"] = "text/xml-dtd";
+    Mimes["TextPlainUtf8"] = "text/plain; charset=utf-8";
+    Mimes["ImagePng"] = "image/png";
+    Mimes["ImageGif"] = "image/gif";
+    Mimes["ImageJpeg"] = "image/jpeg";
+    Mimes["ImageSvg"] = "image/svg+xml";
+    Mimes["ImageBmp"] = "image/bmp";
+    Mimes["ImageTiff"] = "image/tiff";
+    Mimes["ImagePdf"] = "application/pdf";
+    Mimes["ImageXBmp"] = "image/x-bmp";
+    Mimes["ImageXpixmap"] = "image/x-xpixmap";
+    Mimes["ImageXxbm"] = "image/x-xbm";
+    Mimes["MultipartFormData"] = "multipart/form-data";
+})(Mimes || (Mimes = {}));
+//# sourceMappingURL=Mimes.js.map

package/decorators/MethodMapping.d.ts

@@ -0,0 +1,74 @@
+import 'reflect-metadata';
+import { ConstructorType } from '@dooboostore/core/types';
+import { ReflectMethod } from '@dooboostore/simple-boot/types/Types';
+import { Resolver } from '../resolvers/Resolver';
+import { Mimes } from '../codes/Mimes';
+import { HttpMethod } from '../codes/HttpMethod';
+export declare enum UrlMappingSituationType {
+    REQ_JSON_BODY = "SIMPLE_BOOT_HTTP_SERVER://URLMAPPING/REQ_JSON_BODY",
+    REQ_FORM_URL_BODY = "SIMPLE_BOOT_HTTP_SERVER://URLMAPPING/REQ_FORM_URL_BODY"
+}
+export type MappingConfig = {
+    method: HttpMethod | string;
+    description?: {
+        name?: string;
+        detail?: string;
+    };
+    req?: {
+        contentType?: (Mimes | string)[];
+        accept?: (Mimes | string)[];
+    };
+    res?: {
+        status?: number;
+        header?: {
+            [key: string]: string;
+        };
+        contentType?: Mimes | string;
+    };
+    resolver?: Resolver | ConstructorType<Resolver>;
+};
+export type SaveMappingConfig = {
+    propertyKey: string | symbol;
+    config: MappingConfig;
+};
+export declare function UrlMapping(config: MappingConfig): ReflectMethod;
+export declare function UrlMapping(target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor): void;
+export declare const getUrlMapping: (target: any, propertyKey: string | symbol) => MappingConfig | undefined;
+export declare const getUrlMappings: (target: any) => SaveMappingConfig[];
+export declare function GET(config: Omit<MappingConfig, 'method'>): ReflectMethod;
+export declare function GET(target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor): void;
+export declare const getGET: (target: any, propertyKey: string | symbol) => MappingConfig | undefined;
+export declare const getGETS: (target: any) => SaveMappingConfig[];
+export declare function POST(config: Omit<MappingConfig, 'method'>): ReflectMethod;
+export declare function POST(target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor): void;
+export declare const getPOST: (target: any, propertyKey: string | symbol) => MappingConfig | undefined;
+export declare const getPOSTS: (target: any) => SaveMappingConfig[];
+export declare function DELETE(config: Omit<MappingConfig, 'method'>): ReflectMethod;
+export declare function DELETE(target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor): void;
+export declare const getDELETE: (target: any, propertyKey: string | symbol) => MappingConfig | undefined;
+export declare const getDELETES: (target: any) => SaveMappingConfig[];
+export declare function PUT(config: Omit<MappingConfig, 'method'>): ReflectMethod;
+export declare function PUT(target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor): void;
+export declare const getPUT: (target: any, propertyKey: string | symbol) => MappingConfig | undefined;
+export declare const getPUTS: (target: any) => SaveMappingConfig[];
+export declare function PATCH(config: Omit<MappingConfig, 'method'>): ReflectMethod;
+export declare function PATCH(target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor): void;
+export declare const getPATCH: (target: any, propertyKey: string | symbol) => MappingConfig | undefined;
+export declare const getPATCHS: (target: any) => SaveMappingConfig[];
+export declare function OPTIONS(config: Omit<MappingConfig, 'method'>): ReflectMethod;
+export declare function OPTIONS(target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor): void;
+export declare const getOPTIONS: (target: any, propertyKey: string | symbol) => MappingConfig | undefined;
+export declare const getOPTIONSS: (target: any) => SaveMappingConfig[];
+export declare function HEAD(config: Omit<MappingConfig, 'method'>): ReflectMethod;
+export declare function HEAD(target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor): void;
+export declare const getHEAD: (target: any, propertyKey: string | symbol) => MappingConfig | undefined;
+export declare const getHEADS: (target: any) => SaveMappingConfig[];
+export declare function TRACE(config: Omit<MappingConfig, 'method'>): ReflectMethod;
+export declare function TRACE(target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor): void;
+export declare const getTRACE: (target: any, propertyKey: string | symbol) => MappingConfig | undefined;
+export declare const getTRACES: (target: any) => SaveMappingConfig[];
+export declare function CONNECT(config: Omit<MappingConfig, 'method'>): ReflectMethod;
+export declare function CONNECT(target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor): void;
+export declare const getCONNECT: (target: any, propertyKey: string | symbol) => MappingConfig | undefined;
+export declare const getCONNECTS: (target: any) => SaveMappingConfig[];
+//# sourceMappingURL=MethodMapping.d.ts.map

package/decorators/MethodMapping.js

@@ -0,0 +1,198 @@
+import 'reflect-metadata';
+import { ReflectUtils } from '@dooboostore/simple-boot/utils/reflect/ReflectUtils';
+import { HttpMethod } from '../codes/HttpMethod';
+export var UrlMappingSituationType;
+(function (UrlMappingSituationType) {
+    UrlMappingSituationType["REQ_JSON_BODY"] = "SIMPLE_BOOT_HTTP_SERVER://URLMAPPING/REQ_JSON_BODY";
+    UrlMappingSituationType["REQ_FORM_URL_BODY"] = "SIMPLE_BOOT_HTTP_SERVER://URLMAPPING/REQ_FORM_URL_BODY";
+})(UrlMappingSituationType || (UrlMappingSituationType = {}));
+const MappingMetadataKey = Symbol('MappingMetadataKey');
+const process = (config, target, propertyKey, descriptor) => {
+    var _a;
+    const saveMappingConfigs = ((_a = ReflectUtils.getMetadata(MappingMetadataKey, target.constructor)) !== null && _a !== void 0 ? _a : []);
+    saveMappingConfigs.push({ propertyKey, config });
+    ReflectUtils.defineMetadata(MappingMetadataKey, saveMappingConfigs, target.constructor);
+    ReflectUtils.defineMetadata(MappingMetadataKey, config, target, propertyKey);
+};
+export function UrlMapping(configOrtarget, propertyKey, descriptor) {
+    if (propertyKey && descriptor) {
+        process({ method: HttpMethod.GET }, configOrtarget, propertyKey, descriptor);
+    }
+    else {
+        return (target, propertyKey, descriptor) => {
+            process(configOrtarget, target, propertyKey, descriptor);
+        };
+    }
+}
+export const getUrlMapping = (target, propertyKey) => {
+    return ReflectUtils.getMetadata(MappingMetadataKey, target, propertyKey);
+};
+export const getUrlMappings = (target) => {
+    if (target !== null && undefined !== target && typeof target === 'object') {
+        target = target.constructor;
+    }
+    return ReflectUtils.getMetadata(MappingMetadataKey, target);
+};
+export function GET(configOrTarget, propertyKey, descriptor) {
+    if (propertyKey && descriptor) {
+        process({ method: HttpMethod.GET }, configOrTarget, propertyKey, descriptor);
+    }
+    else {
+        return (target, propertyKey, descriptor) => {
+            configOrTarget.method = HttpMethod.GET;
+            process(configOrTarget, target, propertyKey, descriptor);
+        };
+    }
+}
+export const getGET = (target, propertyKey) => {
+    return getUrlMapping(target, propertyKey);
+};
+export const getGETS = (target) => {
+    var _a;
+    return (_a = getUrlMappings(target)) === null || _a === void 0 ? void 0 : _a.filter(it => { var _a; return ((_a = it.config) === null || _a === void 0 ? void 0 : _a.method.toUpperCase()) === HttpMethod.GET; });
+};
+export function POST(configOrTarget, propertyKey, descriptor) {
+    if (propertyKey && descriptor) {
+        process({ method: HttpMethod.POST }, configOrTarget, propertyKey, descriptor);
+    }
+    else {
+        return (target, propertyKey, descriptor) => {
+            configOrTarget.method = HttpMethod.POST;
+            process(configOrTarget, target, propertyKey, descriptor);
+        };
+    }
+}
+export const getPOST = (target, propertyKey) => {
+    return getUrlMapping(target, propertyKey);
+};
+export const getPOSTS = (target) => {
+    var _a;
+    return (_a = getUrlMappings(target)) === null || _a === void 0 ? void 0 : _a.filter(it => { var _a; return ((_a = it.config) === null || _a === void 0 ? void 0 : _a.method.toUpperCase()) === HttpMethod.POST; });
+};
+export function DELETE(configOrTarget, propertyKey, descriptor) {
+    if (propertyKey && descriptor) {
+        process({ method: HttpMethod.DELETE }, configOrTarget, propertyKey, descriptor);
+    }
+    else {
+        return (target, propertyKey, descriptor) => {
+            configOrTarget.method = HttpMethod.DELETE;
+            process(configOrTarget, target, propertyKey, descriptor);
+        };
+    }
+}
+export const getDELETE = (target, propertyKey) => {
+    return getUrlMapping(target, propertyKey);
+};
+export const getDELETES = (target) => {
+    var _a;
+    return (_a = getUrlMappings(target)) === null || _a === void 0 ? void 0 : _a.filter(it => { var _a; return ((_a = it.config) === null || _a === void 0 ? void 0 : _a.method.toUpperCase()) === HttpMethod.DELETE; });
+};
+export function PUT(configOrTarget, propertyKey, descriptor) {
+    if (propertyKey && descriptor) {
+        process({ method: HttpMethod.PUT }, configOrTarget, propertyKey, descriptor);
+    }
+    else {
+        return (target, propertyKey, descriptor) => {
+            configOrTarget.method = HttpMethod.PUT;
+            process(configOrTarget, target, propertyKey, descriptor);
+        };
+    }
+}
+export const getPUT = (target, propertyKey) => {
+    return getUrlMapping(target, propertyKey);
+};
+export const getPUTS = (target) => {
+    var _a;
+    return (_a = getUrlMappings(target)) === null || _a === void 0 ? void 0 : _a.filter(it => { var _a; return ((_a = it.config) === null || _a === void 0 ? void 0 : _a.method.toUpperCase()) === HttpMethod.PUT; });
+};
+export function PATCH(configOrTarget, propertyKey, descriptor) {
+    if (propertyKey && descriptor) {
+        process({ method: HttpMethod.PATCH }, configOrTarget, propertyKey, descriptor);
+    }
+    else {
+        return (target, propertyKey, descriptor) => {
+            configOrTarget.method = HttpMethod.PATCH;
+            process(configOrTarget, target, propertyKey, descriptor);
+        };
+    }
+}
+export const getPATCH = (target, propertyKey) => {
+    return getUrlMapping(target, propertyKey);
+};
+export const getPATCHS = (target) => {
+    var _a;
+    return (_a = getUrlMappings(target)) === null || _a === void 0 ? void 0 : _a.filter(it => { var _a; return ((_a = it.config) === null || _a === void 0 ? void 0 : _a.method.toUpperCase()) === HttpMethod.GET; });
+};
+export function OPTIONS(configOrTarget, propertyKey, descriptor) {
+    if (propertyKey && descriptor) {
+        process({ method: HttpMethod.OPTIONS }, configOrTarget, propertyKey, descriptor);
+    }
+    else {
+        return (target, propertyKey, descriptor) => {
+            configOrTarget.method = HttpMethod.OPTIONS;
+            process(configOrTarget, target, propertyKey, descriptor);
+        };
+    }
+}
+export const getOPTIONS = (target, propertyKey) => {
+    return getUrlMapping(target, propertyKey);
+};
+export const getOPTIONSS = (target) => {
+    var _a;
+    return (_a = getUrlMappings(target)) === null || _a === void 0 ? void 0 : _a.filter(it => { var _a; return ((_a = it.config) === null || _a === void 0 ? void 0 : _a.method.toUpperCase()) === HttpMethod.OPTIONS; });
+};
+export function HEAD(configOrTarget, propertyKey, descriptor) {
+    if (propertyKey && descriptor) {
+        process({ method: HttpMethod.HEAD }, configOrTarget, propertyKey, descriptor);
+    }
+    else {
+        return (target, propertyKey, descriptor) => {
+            configOrTarget.method = HttpMethod.HEAD;
+            process(configOrTarget, target, propertyKey, descriptor);
+        };
+    }
+}
+export const getHEAD = (target, propertyKey) => {
+    return getUrlMapping(target, propertyKey);
+};
+export const getHEADS = (target) => {
+    var _a;
+    return (_a = getUrlMappings(target)) === null || _a === void 0 ? void 0 : _a.filter(it => { var _a; return ((_a = it.config) === null || _a === void 0 ? void 0 : _a.method.toUpperCase()) === HttpMethod.GET; });
+};
+export function TRACE(configOrTarget, propertyKey, descriptor) {
+    if (propertyKey && descriptor) {
+        process({ method: HttpMethod.TRACE }, configOrTarget, propertyKey, descriptor);
+    }
+    else {
+        return (target, propertyKey, descriptor) => {
+            configOrTarget.method = HttpMethod.TRACE;
+            process(configOrTarget, target, propertyKey, descriptor);
+        };
+    }
+}
+export const getTRACE = (target, propertyKey) => {
+    return getUrlMapping(target, propertyKey);
+};
+export const getTRACES = (target) => {
+    var _a;
+    return (_a = getUrlMappings(target)) === null || _a === void 0 ? void 0 : _a.filter(it => { var _a; return ((_a = it.config) === null || _a === void 0 ? void 0 : _a.method.toUpperCase()) === HttpMethod.TRACE; });
+};
+export function CONNECT(configOrTarget, propertyKey, descriptor) {
+    if (propertyKey && descriptor) {
+        process({ method: HttpMethod.CONNECT }, configOrTarget, propertyKey, descriptor);
+    }
+    else {
+        return (target, propertyKey, descriptor) => {
+            configOrTarget.method = HttpMethod.CONNECT;
+            process(configOrTarget, target, propertyKey, descriptor);
+        };
+    }
+}
+export const getCONNECT = (target, propertyKey) => {
+    return getUrlMapping(target, propertyKey);
+};
+export const getCONNECTS = (target) => {
+    var _a;
+    return (_a = getUrlMappings(target)) === null || _a === void 0 ? void 0 : _a.filter(it => { var _a; return ((_a = it.config) === null || _a === void 0 ? void 0 : _a.method.toUpperCase()) === HttpMethod.CONNECT; });
+};
+//# sourceMappingURL=MethodMapping.js.map

package/endpoints/CrossDomainHeaderEndPoint.d.ts

@@ -0,0 +1,16 @@
+import { EndPoint } from './EndPoint';
+import { SimpleBootHttpServer } from '../SimpleBootHttpServer';
+import { RequestResponse } from '../models/RequestResponse';
+export type CrossDomainHeaderEndPointConfig = {
+    accessControlAllowOrigin?: string | string[];
+    accessControlAllowMethods?: string | string[];
+    accessControlAllowHeaders?: string | string[];
+    accessControlExposeHeaders?: string | string[];
+};
+export declare class CrossDomainHeaderEndPoint implements EndPoint {
+    private config?;
+    constructor(config?: CrossDomainHeaderEndPointConfig);
+    endPoint(rr: RequestResponse, app: SimpleBootHttpServer): Promise<void>;
+    onInit(app: SimpleBootHttpServer): Promise<void>;
+}
+//# sourceMappingURL=CrossDomainHeaderEndPoint.d.ts.map

package/endpoints/CrossDomainHeaderEndPoint.js

@@ -0,0 +1,37 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { HttpHeaders } from '../codes/HttpHeaders';
+export class CrossDomainHeaderEndPoint {
+    constructor(config) {
+        this.config = config;
+    }
+    endPoint(rr, app) {
+        var _a, _b, _c, _d;
+        return __awaiter(this, void 0, void 0, function* () {
+            if ((_a = this.config) === null || _a === void 0 ? void 0 : _a.accessControlAllowOrigin) {
+                rr.resSetHeader(HttpHeaders.AccessControlAllowOrigin, Array.isArray(this.config.accessControlAllowOrigin) ? this.config.accessControlAllowOrigin.join(', ') : this.config.accessControlAllowOrigin);
+            }
+            if ((_b = this.config) === null || _b === void 0 ? void 0 : _b.accessControlAllowMethods) {
+                rr.resSetHeader(HttpHeaders.AccessControlAllowMethods, Array.isArray(this.config.accessControlAllowMethods) ? this.config.accessControlAllowMethods.join(', ') : this.config.accessControlAllowMethods);
+            }
+            if ((_c = this.config) === null || _c === void 0 ? void 0 : _c.accessControlAllowHeaders) {
+                rr.resSetHeader(HttpHeaders.AccessControlAllowHeaders, Array.isArray(this.config.accessControlAllowHeaders) ? this.config.accessControlAllowHeaders.join(', ') : this.config.accessControlAllowHeaders);
+            }
+            if ((_d = this.config) === null || _d === void 0 ? void 0 : _d.accessControlExposeHeaders) {
+                rr.resSetHeader(HttpHeaders.AccessControlExposeHeaders, Array.isArray(this.config.accessControlExposeHeaders) ? this.config.accessControlExposeHeaders.join(', ') : this.config.accessControlExposeHeaders);
+            }
+        });
+    }
+    onInit(app) {
+        return __awaiter(this, void 0, void 0, function* () {
+        });
+    }
+}
+//# sourceMappingURL=CrossDomainHeaderEndPoint.js.map

package/endpoints/EndPoint.d.ts

@@ -0,0 +1,7 @@
+import { RequestResponse } from '../models/RequestResponse';
+import { SimpleBootHttpServer } from '../SimpleBootHttpServer';
+import { OnInit } from '../lifecycle/OnInit';
+export interface EndPoint extends OnInit {
+    endPoint(rr: RequestResponse, app: SimpleBootHttpServer): Promise<any>;
+}
+//# sourceMappingURL=EndPoint.d.ts.map

package/endpoints/EndPoint.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=EndPoint.js.map

package/endpoints/HeaderEndPoint.d.ts

@@ -0,0 +1,12 @@
+import { EndPoint } from './EndPoint';
+import { SimpleBootHttpServer } from '../SimpleBootHttpServer';
+import { RequestResponse } from '../models/RequestResponse';
+export declare class HeaderEndPoint implements EndPoint {
+    private headers?;
+    constructor(headers?: {
+        [key: string]: string | string[];
+    });
+    endPoint(rr: RequestResponse, app: SimpleBootHttpServer): Promise<void>;
+    onInit(app: SimpleBootHttpServer): Promise<void>;
+}
+//# sourceMappingURL=HeaderEndPoint.d.ts.map

package/endpoints/HeaderEndPoint.js

@@ -0,0 +1,26 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+export class HeaderEndPoint {
+    constructor(headers) {
+        this.headers = headers;
+    }
+    endPoint(rr, app) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.headers) {
+                rr.resSetHeaders(this.headers);
+            }
+        });
+    }
+    onInit(app) {
+        return __awaiter(this, void 0, void 0, function* () {
+        });
+    }
+}
+//# sourceMappingURL=HeaderEndPoint.js.map

package/errors/BadRequestError.d.ts

@@ -0,0 +1,8 @@
+import { HttpError } from './HttpError';
+export declare class BadRequestError extends HttpError {
+    constructor({ status, message }?: {
+        status?: number;
+        message?: string;
+    });
+}
+//# sourceMappingURL=BadRequestError.d.ts.map

package/errors/BadRequestError.js

@@ -0,0 +1,8 @@
+import { HttpError } from './HttpError';
+import { HttpStatus } from '../codes/HttpStatus';
+export class BadRequestError extends HttpError {
+    constructor({ status = HttpStatus.BadRequest, message = 'Bad Request' } = {}) {
+        super({ status, message });
+    }
+}
+//# sourceMappingURL=BadRequestError.js.map

package/errors/ForbiddenError.d.ts

@@ -0,0 +1,8 @@
+import { HttpError } from './HttpError';
+export declare class ForbiddenError extends HttpError {
+    constructor({ status, message }?: {
+        status?: number;
+        message?: string;
+    });
+}
+//# sourceMappingURL=ForbiddenError.d.ts.map

package/errors/ForbiddenError.js

@@ -0,0 +1,8 @@
+import { HttpError } from './HttpError';
+import { HttpStatus } from '../codes/HttpStatus';
+export class ForbiddenError extends HttpError {
+    constructor({ status = HttpStatus.Forbidden, message = 'Forbidden' } = {}) {
+        super({ status, message });
+    }
+}
+//# sourceMappingURL=ForbiddenError.js.map

package/errors/HttpError.d.ts

@@ -0,0 +1,12 @@
+export declare class HttpError {
+    name: string;
+    message: string;
+    stack?: string;
+    data?: any;
+    status: number;
+    constructor({ status, message }: {
+        status: number;
+        message?: string;
+    });
+}
+//# sourceMappingURL=HttpError.d.ts.map

package/errors/HttpError.js

@@ -0,0 +1,8 @@
+export class HttpError {
+    constructor({ status, message = 'HttpError' }) {
+        this.name = 'Error';
+        this.message = message;
+        this.status = status;
+    }
+}
+//# sourceMappingURL=HttpError.js.map

package/errors/InternalServerError.d.ts

@@ -0,0 +1,8 @@
+import { HttpError } from './HttpError';
+export declare class InternalServerError extends HttpError {
+    constructor({ status, message }?: {
+        status?: number;
+        message?: string;
+    });
+}
+//# sourceMappingURL=InternalServerError.d.ts.map

package/errors/InternalServerError.js

@@ -0,0 +1,8 @@
+import { HttpError } from './HttpError';
+import { HttpStatus } from '../codes/HttpStatus';
+export class InternalServerError extends HttpError {
+    constructor({ status = HttpStatus.InternalServerError, message = 'Internal Server Error' } = {}) {
+        super({ status, message });
+    }
+}
+//# sourceMappingURL=InternalServerError.js.map

package/errors/NotFoundError.d.ts

@@ -0,0 +1,8 @@
+import { HttpError } from './HttpError';
+export declare class NotFoundError extends HttpError {
+    constructor({ status, message }?: {
+        status?: number;
+        message?: string;
+    });
+}
+//# sourceMappingURL=NotFoundError.d.ts.map