@dooboostore/simple-boot-http-server 1.0.14

package/models/RequestResponse.d.ts

@@ -0,0 +1,107 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { IncomingMessage, OutgoingHttpHeader, OutgoingHttpHeaders, ServerResponse } from 'http';
+import { HttpHeaders } from '../codes/HttpHeaders';
+import { Mimes } from '../codes/Mimes';
+import { Intent } from '@dooboostore/simple-boot/intent/Intent';
+import { URL, URLSearchParams } from 'url';
+import { Buffer } from 'buffer';
+import { MultipartData } from './datas/MultipartData';
+import { ReqFormUrlBody } from './datas/body/ReqFormUrlBody';
+import { ReqJsonBody } from './datas/body/ReqJsonBody';
+import { ReqHeader } from './datas/ReqHeader';
+import { HttpStatus } from '../codes/HttpStatus';
+import { SessionManager } from '../session/SessionManager';
+import { HttpServerOption } from '../option/HttpServerOption';
+type Config = {
+    sessionManager?: SessionManager;
+    option: HttpServerOption;
+};
+export declare class RequestResponse {
+    protected resWriteChunk: string | Buffer | undefined;
+    protected reqBodyChunk?: Buffer;
+    protected req: IncomingMessage;
+    protected res: ServerResponse;
+    protected config: Config;
+    constructor(req: IncomingMessage | RequestResponse, res: ServerResponse, config: Config);
+    get reqSocket(): import("net").Socket;
+    get reqCookieMap(): Map<string, string>;
+    reqCookieGet(key: string): string;
+    get reqRemoteAddress(): string | undefined;
+    get reqUrlObject(): URL;
+    get reqUrlPathName(): string;
+    get reqUrl(): string;
+    reqUrlObj(config?: {
+        scheme?: string;
+        host?: string;
+    }): URL;
+    get reqUrlSearchParamTuples(): [string, string][];
+    get reqUrlSearchParams(): URLSearchParams;
+    get reqUrlSearchParamsObj(): {
+        [p: string]: {
+            [p: string]: any;
+        };
+    };
+    get reqPathSearchParamUrl(): string;
+    get reqReadable(): boolean;
+    get reqIntent(): Intent<any, any>;
+    reqHasContentTypeHeader(mime: Mimes | string): boolean;
+    reqHasAcceptHeader(mime: Mimes | string): boolean;
+    reqBodyData(): Promise<Buffer>;
+    resBodyData(): string | Buffer | undefined;
+    reqBodyMultipartFormDataObject<T>(): Promise<T>;
+    reqBodyMultipartFormData(): Promise<MultipartData[]>;
+    reqBodyStringData(): Promise<string>;
+    reqBodyJsonData<T>(): Promise<T>;
+    reqBodyFormUrlData<T>(): Promise<T>;
+    reqBodyReqFormUrlBody(): Promise<ReqFormUrlBody>;
+    reqBodyReqJsonBody(): Promise<ReqJsonBody>;
+    resBodyJsonData<T>(): (T | null);
+    resBodyStringData(): string;
+    reqMethod(): string;
+    reqHeader(key: HttpHeaders | string): string | string[];
+    get reqHost(): string;
+    get reqHeaderObj(): ReqHeader;
+    reqHeaderFirst(key: HttpHeaders | string, defaultValue?: string): string;
+    reqAuthorizationHeader(): string;
+    reqRefreshTokenHeader(): string;
+    resStatusCode(code?: undefined): number;
+    resStatusCode(code: number | HttpStatus): RequestResponseChain<number>;
+    resHeader(key: HttpHeaders | string): string | number | string[];
+    resHeaderFirst(key: HttpHeaders | string, defaultValue?: string): string | number | string[];
+    reqSession(): Promise<{
+        [key: string]: any;
+    }>;
+    reqSessionSet(key: string, value: any): void;
+    reqSessionGet<T = any>(key: string): T | undefined;
+    resSetStatusCode(statusCode: number): RequestResponseChain<number>;
+    resWrite(chunk: string | Buffer | any, encoding?: BufferEncoding): RequestResponseChain<string | Buffer>;
+    resWriteJson(chunk: any, encoding?: BufferEncoding): RequestResponseChain<string | Buffer>;
+    resSetHeader(key: HttpHeaders | string, value: string | string[]): RequestResponseChain<ServerResponse<IncomingMessage>>;
+    resAddHeader(key: HttpHeaders | string, value: string | string[]): RequestResponseChain<ServerResponse<IncomingMessage>>;
+    resSetHeaders(headers: {
+        [key: string]: string | string[];
+    }): RequestResponseChain<any>;
+    resAddHeaders(headers: {
+        [key: string]: string | string[];
+    }): RequestResponseChain<any>;
+    private resEndChunk;
+    resEnd(chunk?: string | Buffer): Promise<void>;
+    resWriteHead(statusCode: number, headers?: OutgoingHttpHeaders | OutgoingHttpHeader[] | {
+        [key: string]: string | string[];
+    }): RequestResponseChain<ServerResponse<IncomingMessage>>;
+    resWriteHeadEnd(statusCode: number, headers?: OutgoingHttpHeaders | OutgoingHttpHeader[] | {
+        [key: string]: string | string[];
+    }): void;
+    resIsDone(): boolean;
+    createRequestResponseChain<T = any>(data?: T): RequestResponseChain<T>;
+}
+export declare class RequestResponseChain<T> extends RequestResponse {
+    result?: T;
+    constructor(req: IncomingMessage, res: ServerResponse, config: Config, result?: T);
+}
+export {};
+//# sourceMappingURL=RequestResponse.d.ts.map

package/models/RequestResponse.js

@@ -0,0 +1,467 @@
+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';
+import { Intent } from '@dooboostore/simple-boot/intent/Intent';
+import { URL, URLSearchParams } from 'url';
+import { Buffer } from 'buffer';
+import { ReqFormUrlBody } from './datas/body/ReqFormUrlBody';
+import { ReqJsonBody } from './datas/body/ReqJsonBody';
+import { ReqHeader } from './datas/ReqHeader';
+import { gzip } from 'node-gzip';
+import { FileUtils } from '@dooboostore/core-node/file/FileUtils';
+import { ConvertUtils } from '@dooboostore/core-node/convert/ConvertUtils';
+export class RequestResponse {
+    constructor(req, res, config) {
+        if (req instanceof RequestResponse) {
+            this.req = req.req;
+            this.res = req.res;
+            this.config = config;
+        }
+        else {
+            this.req = req;
+            this.res = res;
+            this.config = config;
+        }
+    }
+    get reqSocket() {
+        return this.req.socket;
+    }
+    get reqCookieMap() {
+        var _a;
+        let cookies = (_a = this.reqHeader(HttpHeaders.Cookie)) !== null && _a !== void 0 ? _a : '';
+        if (Array.isArray(cookies)) {
+            cookies = cookies.join(';');
+        }
+        const map = new Map();
+        cookies.split(';').map(it => it.trim().split('=')).forEach(it => {
+            map.set(it[0], it[1]);
+        });
+        return map;
+    }
+    reqCookieGet(key) {
+        return this.reqCookieMap.get(key);
+    }
+    get reqRemoteAddress() {
+        const ipHeader = this.req.headers['x-forwarded-for'];
+        let ip = this.req.socket.remoteAddress;
+        if (Array.isArray(ipHeader)) {
+            ip = ipHeader.join(',').split(',').shift();
+        }
+        else if (typeof ipHeader === 'string') {
+            ip = ipHeader.split(',').shift();
+        }
+        return ip;
+    }
+    get reqUrlObject() {
+        var _a;
+        return new URL(this.reqUrl, `${this.reqSocket ? 'https://' : 'http'}${(_a = this.reqHost) !== null && _a !== void 0 ? _a : 'localhost'}`);
+    }
+    get reqUrlPathName() {
+        var _a;
+        return (_a = this.reqUrlObj().pathname) !== null && _a !== void 0 ? _a : '';
+    }
+    get reqUrl() {
+        var _a;
+        return (_a = this.req.url) !== null && _a !== void 0 ? _a : '';
+    }
+    reqUrlObj(config) {
+        var _a, _b, _c;
+        return new URL(`${(_a = config === null || config === void 0 ? void 0 : config.scheme) !== null && _a !== void 0 ? _a : 'http'}://${(config === null || config === void 0 ? void 0 : config.host) ? config === null || config === void 0 ? void 0 : config.host : ((_b = this.reqHeaderFirst(HttpHeaders.Host)) !== null && _b !== void 0 ? _b : 'localhost')}${(_c = this.req.url) !== null && _c !== void 0 ? _c : ''}`);
+    }
+    get reqUrlSearchParamTuples() {
+        return Array.from(this.reqUrlObj().searchParams);
+    }
+    get reqUrlSearchParams() {
+        return this.reqUrlObj().searchParams;
+    }
+    get reqUrlSearchParamsObj() {
+        const entries = this.reqUrlObj().searchParams;
+        return Object.fromEntries(entries);
+    }
+    get reqPathSearchParamUrl() {
+        const reqUrlObj = this.reqUrlObj();
+        return reqUrlObj.pathname + (reqUrlObj.searchParams.toString() ? '?' + reqUrlObj.searchParams.toString() : '');
+    }
+    get reqReadable() {
+        return this.req.readable;
+    }
+    get reqIntent() {
+        return new Intent(this.reqPathSearchParamUrl);
+    }
+    reqHasContentTypeHeader(mime) {
+        var _a;
+        return ((_a = this.reqHeaderFirst(HttpHeaders.ContentType)) !== null && _a !== void 0 ? _a : '').toLowerCase().indexOf(mime.toLocaleLowerCase()) > -1;
+    }
+    reqHasAcceptHeader(mime) {
+        var _a;
+        return ((_a = this.reqHeaderFirst(HttpHeaders.Accept)) !== null && _a !== void 0 ? _a : '').toLowerCase().indexOf(mime.toLocaleLowerCase()) > -1;
+    }
+    reqBodyData() {
+        return new Promise((resolve, reject) => {
+            var _a;
+            if (this.reqReadable) {
+                const data = [];
+                this.req.on('data', (chunk) => data.push(chunk));
+                this.req.on('error', err => reject(err));
+                this.req.on('end', () => {
+                    this.reqBodyChunk = Buffer.concat(data);
+                    resolve(this.reqBodyChunk);
+                });
+            }
+            else {
+                resolve((_a = this.reqBodyChunk) !== null && _a !== void 0 ? _a : Buffer.alloc(0));
+            }
+        });
+    }
+    resBodyData() {
+        return this.resWriteChunk;
+    }
+    reqBodyMultipartFormDataObject() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const m = yield this.reqBodyMultipartFormData();
+            const formData = {};
+            for (const it of m) {
+                if (it.isFile) {
+                    formData[it.name] = yield FileUtils.writeFile(it.value, { originalName: it.filename });
+                }
+                else {
+                    const target = formData[it.name];
+                    if (Array.isArray(target)) {
+                        target.push(it.value);
+                    }
+                    else if (typeof target === 'string') {
+                        formData[it.name] = [target, it.value];
+                    }
+                    else {
+                        formData[it.name] = it.value;
+                    }
+                }
+            }
+            ;
+            return formData;
+        });
+    }
+    reqBodyMultipartFormData() {
+        return new Promise((resolve, reject) => {
+            const contentTypeHeader = this.req.headers['content-type'];
+            if (!contentTypeHeader || !contentTypeHeader.startsWith('multipart/form-data')) {
+                return reject(new Error('Invalid Content-Type. Expected multipart/form-data.'));
+            }
+            const boundaryMatch = contentTypeHeader.match(/boundary=(?:"([^"]+)"|([^;]+))/i);
+            if (!boundaryMatch) {
+                return reject(new Error('Boundary not found in Content-Type header.'));
+            }
+            const boundary = boundaryMatch[1] || boundaryMatch[2];
+            if (!boundary) {
+                return reject(new Error('Failed to extract boundary.'));
+            }
+            const boundaryBuffer = Buffer.from(`--${boundary}`);
+            const crlfBuffer = Buffer.from('\r\n');
+            const doubleCrlfBuffer = Buffer.from('\r\n\r\n');
+            const chunks = [];
+            let totalLength = 0;
+            this.req.on('data', (chunk) => {
+                chunks.push(chunk);
+                totalLength += chunk.length;
+            });
+            this.req.on('error', (err) => {
+                reject(err);
+            });
+            this.req.on('end', () => {
+                if (totalLength === 0) {
+                    return resolve([]);
+                }
+                const fullBuffer = Buffer.concat(chunks, totalLength);
+                const parsedParts = [];
+                let currentPosition = 0;
+                let boundaryStartIndex = fullBuffer.indexOf(boundaryBuffer, currentPosition);
+                if (boundaryStartIndex === -1) {
+                    return reject(new Error('Initial boundary not found.'));
+                }
+                currentPosition = boundaryStartIndex + boundaryBuffer.length;
+                if (fullBuffer.slice(currentPosition, currentPosition + crlfBuffer.length).equals(crlfBuffer)) {
+                    currentPosition += crlfBuffer.length;
+                }
+                while (currentPosition < fullBuffer.length) {
+                    const nextBoundaryIndex = fullBuffer.indexOf(boundaryBuffer, currentPosition);
+                    if (nextBoundaryIndex === -1) {
+                        break;
+                    }
+                    let partEndIndex = nextBoundaryIndex;
+                    if (partEndIndex > crlfBuffer.length && fullBuffer.slice(partEndIndex - crlfBuffer.length, partEndIndex).equals(crlfBuffer)) {
+                        partEndIndex -= crlfBuffer.length;
+                    }
+                    const partBuffer = fullBuffer.slice(currentPosition, partEndIndex);
+                    const headerBodySeparatorIndex = partBuffer.indexOf(doubleCrlfBuffer);
+                    if (headerBodySeparatorIndex === -1) {
+                        console.warn('Skipping malformed part: no header/body separator found.');
+                        currentPosition = nextBoundaryIndex + boundaryBuffer.length;
+                        if (fullBuffer.slice(currentPosition, currentPosition + crlfBuffer.length).equals(crlfBuffer)) {
+                            currentPosition += crlfBuffer.length;
+                        }
+                        if (fullBuffer.slice(currentPosition, currentPosition + 2).toString() === '--')
+                            break;
+                        continue;
+                    }
+                    const headerBuffer = partBuffer.slice(0, headerBodySeparatorIndex);
+                    const bodyBuffer = partBuffer.slice(headerBodySeparatorIndex + doubleCrlfBuffer.length);
+                    const headersStr = headerBuffer.toString('utf-8');
+                    const headers = {};
+                    headersStr.split('\r\n').forEach(line => {
+                        const colonIndex = line.indexOf(':');
+                        if (colonIndex > 0) {
+                            const key = line.substring(0, colonIndex).trim().toLowerCase();
+                            const value = line.substring(colonIndex + 1).trim();
+                            headers[key] = value;
+                        }
+                    });
+                    const contentDisposition = headers['content-disposition'];
+                    if (!contentDisposition) {
+                        console.warn('Skipping part: no Content-Disposition header.');
+                        currentPosition = nextBoundaryIndex + boundaryBuffer.length;
+                        if (fullBuffer.slice(currentPosition, currentPosition + crlfBuffer.length).equals(crlfBuffer)) {
+                            currentPosition += crlfBuffer.length;
+                        }
+                        if (fullBuffer.slice(currentPosition, currentPosition + 2).toString() === '--')
+                            break;
+                        continue;
+                    }
+                    const nameMatch = contentDisposition.match(/name="([^"]+)"/i);
+                    const filenameMatch = contentDisposition.match(/filename="([^"]+)"/i);
+                    const name = nameMatch ? nameMatch[1] : null;
+                    const filename = filenameMatch ? filenameMatch[1] : null;
+                    const contentType = headers['content-type'] || null;
+                    if (name) {
+                        const isFile = !!filename;
+                        const multipartData = {
+                            name: name,
+                            isFile: isFile,
+                            filename: filename,
+                            contentType: contentType,
+                            value: isFile ? bodyBuffer : bodyBuffer.toString('utf-8'),
+                        };
+                        parsedParts.push(multipartData);
+                    }
+                    else {
+                        console.warn("Skipping part: 'name' not found in Content-Disposition.");
+                    }
+                    currentPosition = nextBoundaryIndex + boundaryBuffer.length;
+                    if (fullBuffer.slice(currentPosition, currentPosition + crlfBuffer.length).equals(crlfBuffer)) {
+                        currentPosition += crlfBuffer.length;
+                    }
+                    if (fullBuffer.slice(currentPosition, currentPosition + 2).toString() === '--') {
+                        break;
+                    }
+                }
+                resolve(parsedParts);
+            });
+        });
+    }
+    reqBodyStringData() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = (yield this.reqBodyData()).toString();
+            return data;
+        });
+    }
+    reqBodyJsonData() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return JSON.parse(yield this.reqBodyStringData());
+        });
+    }
+    reqBodyFormUrlData() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = (yield this.reqBodyStringData());
+            const formData = {};
+            Array.from(new URLSearchParams(data).entries()).forEach(([k, v]) => {
+                const target = formData[k];
+                if (Array.isArray(target)) {
+                    target.push(v);
+                }
+                else if (typeof target === 'string') {
+                    formData[k] = [target, v];
+                }
+                else {
+                    formData[k] = v;
+                }
+            });
+            return formData;
+        });
+    }
+    reqBodyReqFormUrlBody() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = yield this.reqBodyFormUrlData();
+            return Object.assign(new ReqFormUrlBody(), data);
+        });
+    }
+    reqBodyReqJsonBody() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = (yield this.reqBodyStringData());
+            return Object.assign(new ReqJsonBody(), data ? JSON.parse(data) : {});
+        });
+    }
+    resBodyJsonData() {
+        const data = ConvertUtils.toString(this.resBodyData());
+        return data ? JSON.parse(data) : null;
+    }
+    resBodyStringData() {
+        return ConvertUtils.toString(this.resBodyData());
+    }
+    reqMethod() {
+        var _a;
+        return (_a = this.req.method) === null || _a === void 0 ? void 0 : _a.toUpperCase();
+    }
+    reqHeader(key) {
+        return this.req.headers[key.toLowerCase()];
+    }
+    get reqHost() {
+        return this.reqHeaderFirst(HttpHeaders.Host);
+    }
+    get reqHeaderObj() {
+        const h = new ReqHeader();
+        Object.entries(this.req.headers).forEach(([k, v]) => {
+            h[k] = v;
+        });
+        return h;
+    }
+    reqHeaderFirst(key, defaultValue) {
+        var _a, _b;
+        const header = this.req.headers[key.toLowerCase()];
+        if (header && Array.isArray(header)) {
+            return (_a = header[0]) !== null && _a !== void 0 ? _a : defaultValue;
+        }
+        else {
+            return (_b = header) !== null && _b !== void 0 ? _b : defaultValue;
+        }
+    }
+    reqAuthorizationHeader() {
+        return this.reqHeaderFirst(HttpHeaders.Authorization);
+    }
+    reqRefreshTokenHeader() {
+        return this.reqHeaderFirst(HttpHeaders.Authorization);
+    }
+    resStatusCode(code) {
+        if (code) {
+            this.res.statusCode = code;
+            return new RequestResponseChain(this.req, this.res, this.config, this.res.statusCode);
+        }
+        else {
+            return this.res.statusCode;
+        }
+    }
+    resHeader(key) {
+        return this.res.getHeader(key.toLowerCase());
+    }
+    resHeaderFirst(key, defaultValue) {
+        var _a;
+        const header = this.res.getHeader(key.toLowerCase());
+        if (header && Array.isArray(header)) {
+            return (_a = header[0]) !== null && _a !== void 0 ? _a : defaultValue;
+        }
+        else {
+            return header !== null && header !== void 0 ? header : defaultValue;
+        }
+    }
+    reqSession() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.config.sessionManager) {
+                return (yield this.config.sessionManager.session(this)).dataSet.data;
+            }
+            else {
+                return Promise.reject(new Error('Not SessionManager'));
+            }
+        });
+    }
+    reqSessionSet(key, value) {
+        this.reqSession[key] = value;
+    }
+    reqSessionGet(key) {
+        const session = this.reqSession;
+        if (session) {
+            return session[key];
+        }
+    }
+    resSetStatusCode(statusCode) {
+        this.res.statusCode = statusCode;
+        return this.createRequestResponseChain(this.res.statusCode);
+    }
+    resWrite(chunk, encoding = 'utf8') {
+        this.resWriteChunk = chunk;
+        return this.createRequestResponseChain(this.resWriteChunk);
+    }
+    resWriteJson(chunk, encoding = 'utf8') {
+        return this.resWrite(JSON.stringify(chunk), encoding);
+    }
+    resSetHeader(key, value) {
+        return this.createRequestResponseChain(this.res.setHeader(key.toLowerCase(), value));
+    }
+    resAddHeader(key, value) {
+        const existingValue = this.res.getHeader(key.toLowerCase());
+        const newValue = Array.isArray(existingValue)
+            ? existingValue.concat(value)
+            : existingValue
+                ? [existingValue.toString(), ...[].concat(value)]
+                : value;
+        return this.createRequestResponseChain(this.res.setHeader(key.toLowerCase(), newValue));
+    }
+    resSetHeaders(headers) {
+        Object.entries(headers).forEach(([key, value]) => this.resSetHeader(key, value));
+        return this.createRequestResponseChain();
+    }
+    resAddHeaders(headers) {
+        Object.entries(headers).forEach(([key, value]) => this.resAddHeader(key, value));
+        return this.createRequestResponseChain();
+    }
+    resEndChunk() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const encoding = this.reqHeaderFirst(HttpHeaders.AcceptEncoding);
+            let data = this.resWriteChunk;
+            if (encoding === null || encoding === void 0 ? void 0 : encoding.includes('gzip')) {
+                data = yield gzip(data);
+                this.resSetHeader(HttpHeaders.ContentEncoding, 'gzip');
+            }
+            this.res.end(data);
+        });
+    }
+    resEnd(chunk) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.resWriteChunk = chunk !== null && chunk !== void 0 ? chunk : this.resWriteChunk;
+            if (this.req.readable) {
+                yield this.reqBodyData();
+                yield this.resEndChunk();
+            }
+            else {
+                yield this.resEndChunk();
+            }
+        });
+    }
+    resWriteHead(statusCode, headers) {
+        return this.createRequestResponseChain(this.res.writeHead(statusCode, headers));
+    }
+    resWriteHeadEnd(statusCode, headers) {
+        this.createRequestResponseChain(this.res.writeHead(statusCode, headers));
+        this.res.end();
+    }
+    resIsDone() {
+        return this.res.finished || this.res.writableEnded || this.res.headersSent;
+    }
+    createRequestResponseChain(data) {
+        const requestResponseChain = new RequestResponseChain(this.req, this.res, this.config, data);
+        requestResponseChain.resWriteChunk = this.resWriteChunk;
+        requestResponseChain.reqBodyChunk = this.reqBodyChunk;
+        return requestResponseChain;
+    }
+}
+export class RequestResponseChain extends RequestResponse {
+    constructor(req, res, config, result) {
+        super(req, res, config);
+        this.result = result;
+    }
+}
+//# sourceMappingURL=RequestResponse.js.map

package/models/datas/HeaderData.d.ts

@@ -0,0 +1,10 @@
+export declare class HeaderData<T> {
+    header: {
+        [p: string]: [string];
+    };
+    data: T;
+    constructor(header: {
+        [p: string]: [string];
+    }, data: T);
+}
+//# sourceMappingURL=HeaderData.d.ts.map

package/models/datas/HeaderData.js

@@ -0,0 +1,7 @@
+export class HeaderData {
+    constructor(header, data) {
+        this.header = header;
+        this.data = data;
+    }
+}
+//# sourceMappingURL=HeaderData.js.map

package/models/datas/MultipartData.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="node" />
+/// <reference types="node" />
+export type MultipartData = {
+    isFile: true;
+    name: string;
+    filename: string;
+    contentType: string;
+    value: Buffer;
+} | {
+    isFile: false;
+    name: string;
+    value: string;
+};
+//# sourceMappingURL=MultipartData.d.ts.map

package/models/datas/MultipartData.js

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

package/models/datas/ReqHeader.d.ts

@@ -0,0 +1,69 @@
+/// <reference types="node" />
+import { IncomingHttpHeaders } from 'http';
+export declare class ReqHeader implements IncomingHttpHeaders {
+    [key: string]: string | string[] | undefined;
+    'accept-language': string | undefined;
+    'accept-patch': string | undefined;
+    'accept-ranges': string | undefined;
+    'access-control-allow-credentials': string | undefined;
+    'access-control-allow-headers': string | undefined;
+    'access-control-allow-methods': string | undefined;
+    'access-control-allow-origin': string | undefined;
+    'access-control-expose-headers': string | undefined;
+    'access-control-max-age': string | undefined;
+    'access-control-request-headers': string | undefined;
+    'access-control-request-method': string | undefined;
+    'alt-svc': string | undefined;
+    'cache-control': string | undefined;
+    'content-disposition': string | undefined;
+    'content-encoding': string | undefined;
+    'content-language': string | undefined;
+    'content-length': string | undefined;
+    'content-location': string | undefined;
+    'content-range': string | undefined;
+    'content-type': string | undefined;
+    'if-match': string | undefined;
+    'if-modified-since': string | undefined;
+    'if-none-match': string | undefined;
+    'if-unmodified-since': string | undefined;
+    'last-modified': string | undefined;
+    'proxy-authenticate': string | undefined;
+    'proxy-authorization': string | undefined;
+    'public-key-pins': string | undefined;
+    'retry-after': string | undefined;
+    'sec-websocket-accept': string | undefined;
+    'sec-websocket-extensions': string | undefined;
+    'sec-websocket-key': string | undefined;
+    'sec-websocket-protocol': string | undefined;
+    'sec-websocket-version': string | undefined;
+    'set-cookie': string[] | undefined;
+    'strict-transport-security': string | undefined;
+    'transfer-encoding': string | undefined;
+    'user-agent': string | undefined;
+    'www-authenticate': string | undefined;
+    accept: string | undefined;
+    age: string | undefined;
+    allow: string | undefined;
+    authorization: string | undefined;
+    connection: string | undefined;
+    cookie: string | undefined;
+    date: string | undefined;
+    etag: string | undefined;
+    expect: string | undefined;
+    expires: string | undefined;
+    forwarded: string | undefined;
+    from: string | undefined;
+    host: string | undefined;
+    location: string | undefined;
+    origin: string | undefined;
+    pragma: string | undefined;
+    range: string | undefined;
+    referer: string | undefined;
+    tk: string | undefined;
+    trailer: string | undefined;
+    upgrade: string | undefined;
+    vary: string | undefined;
+    via: string | undefined;
+    warning: string | undefined;
+}
+//# sourceMappingURL=ReqHeader.d.ts.map

package/models/datas/ReqHeader.js

@@ -0,0 +1,3 @@
+export class ReqHeader {
+}
+//# sourceMappingURL=ReqHeader.js.map