@duplojs/http 0.6.1 → 0.7.0

package/dist/interfaces/node/bodyReaders/formData/readRequestFormData.cjs

@@ -0,0 +1,175 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var error = require('./error.cjs');
+require('../../../../core/errors/index.cjs');
+var bodySizeExceedsLimitError = require('../../../../core/errors/bodySizeExceedsLimitError.cjs');
+var bodyParseWrongChunkReceived = require('../../../../core/errors/bodyParseWrongChunkReceived.cjs');
+
+const endHeaderPart = Buffer.from("\r\n\r\n");
+const bufferStart = Buffer.from("\r\n");
+const regexBoundary = /boundary=(?<boundary>[^; ]+)/i;
+const regexHeaderPart = /name="(?<name>(?:\\"|[^"])+)"(?:; filename="(?<filename>(?:\\"|[^"])+)")?(?:;\s+filename\*=[^']+'[^']*'(?<encodedFilename>[^;\r\n\s]+))?/i;
+function safeDecode(value) {
+    try {
+        return decodeURIComponent(value);
+    }
+    catch {
+        return value;
+    }
+}
+async function readRequestFormData(request, firstValueAccumulator, params, onReceiveHeader) {
+    const boundary = utils.S.extract(request.headers["content-type"] ?? "", regexBoundary)?.namedGroups?.boundary;
+    if (!boundary) {
+        return utils.E.error(new error.BodyParseFormDataError("Wrong boundary."));
+    }
+    let valueAccumulator = firstValueAccumulator;
+    const startPart = Buffer.from(`\r\n--${boundary}`);
+    const endMultiPart = Buffer.from(`\r\n--${boundary}--`);
+    let currentBuffer = bufferStart;
+    let size = 0;
+    const keep = endMultiPart.length - 1;
+    let currentStream = undefined;
+    let fileQuantity = 0;
+    let currentFileSize = undefined;
+    const checkSize = (receivedChunk) => {
+        size += receivedChunk.length;
+        return size > params.maxBodySize
+            ? new bodySizeExceedsLimitError.BodySizeExceedsLimitError(params.maxBodySize)
+            : true;
+    };
+    const flushReceiveHeader = async (headerPart) => {
+        valueAccumulator = await currentStream?.onEndPart(valueAccumulator) ?? valueAccumulator;
+        const sizeResult = checkSize(headerPart);
+        if (sizeResult !== true) {
+            return sizeResult;
+        }
+        const extract = utils.S.extract(headerPart.toString("utf-8"), regexHeaderPart)?.namedGroups;
+        const header = extract?.name
+            ? {
+                name: extract.name.trim(),
+                filename: (extract.encodedFilename !== undefined
+                    ? safeDecode(extract.encodedFilename)
+                    : extract.filename)?.trim(),
+            }
+            : null;
+        if (!header) {
+            return new error.BodyParseFormDataError("Bad content header part.");
+        }
+        if (header.name.length > params.maxKeyLength) {
+            return new error.BodyParseFormDataError("key length exceeds limit.");
+        }
+        if (header.filename !== undefined) {
+            currentFileSize = 0;
+            fileQuantity++;
+            if (fileQuantity > params.maxFileQuantity) {
+                return new error.BodyParseFormDataError("File quantity exceeds limit.");
+            }
+            else if (params.mimeType !== undefined
+                && !params.mimeType.test(utils.Path.getExtensionName(header.filename) ?? "")) {
+                return new error.BodyParseFormDataError("File have wrong mimeType.");
+            }
+        }
+        else {
+            currentFileSize = undefined;
+        }
+        const newStream = await onReceiveHeader(header);
+        if (newStream instanceof Error) {
+            return newStream;
+        }
+        currentStream = newStream;
+        return true;
+    };
+    const flushReceiveChunk = async (chunk) => {
+        if (chunk.length === 0) {
+            return true;
+        }
+        const sizeResult = checkSize(chunk);
+        if (sizeResult !== true) {
+            return sizeResult;
+        }
+        if (!currentStream) {
+            return new error.BodyParseFormDataError("Receive chunk before header part.");
+        }
+        if (typeof currentFileSize === "number") {
+            currentFileSize += chunk.length;
+            if (params.fileMaxSize !== undefined && currentFileSize > params.fileMaxSize) {
+                return new error.BodyParseFormDataError("File size exceeds limit.");
+            }
+        }
+        await currentStream.onReceiveChunk(chunk);
+        return true;
+    };
+    const treatError = async (error) => {
+        await currentStream?.onError?.(error, valueAccumulator);
+        return utils.E.error(error);
+    };
+    try {
+        for await (const chunk of request) {
+            if (!(chunk instanceof Buffer)) {
+                return await treatError(new bodyParseWrongChunkReceived.BodyParseWrongChunkReceived("Buffer.", chunk));
+            }
+            currentBuffer = Buffer.concat([currentBuffer, chunk]);
+            if (currentBuffer.length > params.maxBufferSize) {
+                return await treatError(new error.BodyParseFormDataError("Buffer size exceeds limit."));
+            }
+            while (true) {
+                const endMultiPartIndex = currentBuffer.indexOf(endMultiPart);
+                if (endMultiPartIndex !== -1) {
+                    // check if buffer contain end of transmissions
+                    currentBuffer = currentBuffer.subarray(0, endMultiPartIndex);
+                }
+                const startPartIndex = currentBuffer.indexOf(startPart);
+                const endHeaderPartIndex = currentBuffer.indexOf(endHeaderPart);
+                if (startPartIndex !== -1 && endHeaderPartIndex !== -1) {
+                    // check if buffer contain an entire header of part
+                    const resultChunk = await flushReceiveChunk(currentBuffer.subarray(0, startPartIndex));
+                    if (resultChunk !== true) {
+                        return await treatError(resultChunk);
+                    }
+                    const endIndex = endHeaderPartIndex + endHeaderPart.length;
+                    const resultHeader = await flushReceiveHeader(currentBuffer.subarray(startPartIndex, endIndex));
+                    if (resultHeader !== true) {
+                        return await treatError(resultHeader);
+                    }
+                    currentBuffer = currentBuffer.subarray(endIndex);
+                }
+                else if (startPartIndex === -1 && endHeaderPartIndex === -1) {
+                    // check if buffer contain only data
+                    if (currentBuffer.length > keep) {
+                        const bufferRestIndex = currentBuffer.length - keep;
+                        const resultChunk = await flushReceiveChunk(currentBuffer.subarray(0, bufferRestIndex));
+                        if (resultChunk !== true) {
+                            return await treatError(resultChunk);
+                        }
+                        currentBuffer = currentBuffer.subarray(bufferRestIndex);
+                    }
+                    break;
+                }
+                else if (startPartIndex !== -1 && endHeaderPartIndex === -1) {
+                    // check if buffer contain start of header but not contain end
+                    break;
+                }
+                else {
+                    // check if buffer contain only end of header part
+                    return await treatError(new error.BodyParseFormDataError("Wrong content."));
+                }
+            }
+        }
+        const resultChunk = await flushReceiveChunk(currentBuffer);
+        if (resultChunk !== true) {
+            return await treatError(resultChunk);
+        }
+        valueAccumulator = await currentStream?.onEndPart(valueAccumulator) ?? valueAccumulator;
+        return valueAccumulator;
+    }
+    catch (error) {
+        await currentStream?.onError?.(error, valueAccumulator);
+        return utils.E.left("server-error", error);
+    }
+    finally {
+        request.destroy();
+    }
+}
+
+exports.readRequestFormData = readRequestFormData;

package/dist/interfaces/node/bodyReaders/formData/readRequestFormData.d.ts

@@ -0,0 +1,21 @@
+import { E, type MaybePromise } from "@duplojs/utils";
+import type http from "http";
+interface HeaderPartInformation {
+    name: string;
+    filename?: string;
+}
+export interface ReadRequestFormDataStreamChunkEvent<GenericValueAccumulator extends unknown = unknown> {
+    onReceiveChunk(chunk: Buffer): MaybePromise<void>;
+    onEndPart(valueAccumulator: GenericValueAccumulator): MaybePromise<GenericValueAccumulator>;
+    onError: ((error: unknown, valueAccumulator: GenericValueAccumulator) => MaybePromise<void>) | null;
+}
+export interface ReadRequestFormDataParams {
+    maxBodySize: number;
+    maxFileQuantity: number;
+    maxBufferSize: number;
+    maxKeyLength: number;
+    fileMaxSize?: number;
+    mimeType?: RegExp;
+}
+export declare function readRequestFormData<GenericValueAccumulator extends unknown, GenericOutputHeader extends E.Left = never>(request: http.IncomingMessage, firstValueAccumulator: GenericValueAccumulator, params: ReadRequestFormDataParams, onReceiveHeader: (header: HeaderPartInformation) => MaybePromise<ReadRequestFormDataStreamChunkEvent<GenericValueAccumulator> | Error>): Promise<E.Left<"server-error", unknown> | GenericOutputHeader | E.Error<Error> | GenericValueAccumulator>;
+export {};

package/dist/interfaces/node/bodyReaders/formData/readRequestFormData.mjs

@@ -0,0 +1,173 @@
+import { S, E, Path } from '@duplojs/utils';
+import { BodyParseFormDataError } from './error.mjs';
+import '../../../../core/errors/index.mjs';
+import { BodySizeExceedsLimitError } from '../../../../core/errors/bodySizeExceedsLimitError.mjs';
+import { BodyParseWrongChunkReceived } from '../../../../core/errors/bodyParseWrongChunkReceived.mjs';
+
+const endHeaderPart = Buffer.from("\r\n\r\n");
+const bufferStart = Buffer.from("\r\n");
+const regexBoundary = /boundary=(?<boundary>[^; ]+)/i;
+const regexHeaderPart = /name="(?<name>(?:\\"|[^"])+)"(?:; filename="(?<filename>(?:\\"|[^"])+)")?(?:;\s+filename\*=[^']+'[^']*'(?<encodedFilename>[^;\r\n\s]+))?/i;
+function safeDecode(value) {
+    try {
+        return decodeURIComponent(value);
+    }
+    catch {
+        return value;
+    }
+}
+async function readRequestFormData(request, firstValueAccumulator, params, onReceiveHeader) {
+    const boundary = S.extract(request.headers["content-type"] ?? "", regexBoundary)?.namedGroups?.boundary;
+    if (!boundary) {
+        return E.error(new BodyParseFormDataError("Wrong boundary."));
+    }
+    let valueAccumulator = firstValueAccumulator;
+    const startPart = Buffer.from(`\r\n--${boundary}`);
+    const endMultiPart = Buffer.from(`\r\n--${boundary}--`);
+    let currentBuffer = bufferStart;
+    let size = 0;
+    const keep = endMultiPart.length - 1;
+    let currentStream = undefined;
+    let fileQuantity = 0;
+    let currentFileSize = undefined;
+    const checkSize = (receivedChunk) => {
+        size += receivedChunk.length;
+        return size > params.maxBodySize
+            ? new BodySizeExceedsLimitError(params.maxBodySize)
+            : true;
+    };
+    const flushReceiveHeader = async (headerPart) => {
+        valueAccumulator = await currentStream?.onEndPart(valueAccumulator) ?? valueAccumulator;
+        const sizeResult = checkSize(headerPart);
+        if (sizeResult !== true) {
+            return sizeResult;
+        }
+        const extract = S.extract(headerPart.toString("utf-8"), regexHeaderPart)?.namedGroups;
+        const header = extract?.name
+            ? {
+                name: extract.name.trim(),
+                filename: (extract.encodedFilename !== undefined
+                    ? safeDecode(extract.encodedFilename)
+                    : extract.filename)?.trim(),
+            }
+            : null;
+        if (!header) {
+            return new BodyParseFormDataError("Bad content header part.");
+        }
+        if (header.name.length > params.maxKeyLength) {
+            return new BodyParseFormDataError("key length exceeds limit.");
+        }
+        if (header.filename !== undefined) {
+            currentFileSize = 0;
+            fileQuantity++;
+            if (fileQuantity > params.maxFileQuantity) {
+                return new BodyParseFormDataError("File quantity exceeds limit.");
+            }
+            else if (params.mimeType !== undefined
+                && !params.mimeType.test(Path.getExtensionName(header.filename) ?? "")) {
+                return new BodyParseFormDataError("File have wrong mimeType.");
+            }
+        }
+        else {
+            currentFileSize = undefined;
+        }
+        const newStream = await onReceiveHeader(header);
+        if (newStream instanceof Error) {
+            return newStream;
+        }
+        currentStream = newStream;
+        return true;
+    };
+    const flushReceiveChunk = async (chunk) => {
+        if (chunk.length === 0) {
+            return true;
+        }
+        const sizeResult = checkSize(chunk);
+        if (sizeResult !== true) {
+            return sizeResult;
+        }
+        if (!currentStream) {
+            return new BodyParseFormDataError("Receive chunk before header part.");
+        }
+        if (typeof currentFileSize === "number") {
+            currentFileSize += chunk.length;
+            if (params.fileMaxSize !== undefined && currentFileSize > params.fileMaxSize) {
+                return new BodyParseFormDataError("File size exceeds limit.");
+            }
+        }
+        await currentStream.onReceiveChunk(chunk);
+        return true;
+    };
+    const treatError = async (error) => {
+        await currentStream?.onError?.(error, valueAccumulator);
+        return E.error(error);
+    };
+    try {
+        for await (const chunk of request) {
+            if (!(chunk instanceof Buffer)) {
+                return await treatError(new BodyParseWrongChunkReceived("Buffer.", chunk));
+            }
+            currentBuffer = Buffer.concat([currentBuffer, chunk]);
+            if (currentBuffer.length > params.maxBufferSize) {
+                return await treatError(new BodyParseFormDataError("Buffer size exceeds limit."));
+            }
+            while (true) {
+                const endMultiPartIndex = currentBuffer.indexOf(endMultiPart);
+                if (endMultiPartIndex !== -1) {
+                    // check if buffer contain end of transmissions
+                    currentBuffer = currentBuffer.subarray(0, endMultiPartIndex);
+                }
+                const startPartIndex = currentBuffer.indexOf(startPart);
+                const endHeaderPartIndex = currentBuffer.indexOf(endHeaderPart);
+                if (startPartIndex !== -1 && endHeaderPartIndex !== -1) {
+                    // check if buffer contain an entire header of part
+                    const resultChunk = await flushReceiveChunk(currentBuffer.subarray(0, startPartIndex));
+                    if (resultChunk !== true) {
+                        return await treatError(resultChunk);
+                    }
+                    const endIndex = endHeaderPartIndex + endHeaderPart.length;
+                    const resultHeader = await flushReceiveHeader(currentBuffer.subarray(startPartIndex, endIndex));
+                    if (resultHeader !== true) {
+                        return await treatError(resultHeader);
+                    }
+                    currentBuffer = currentBuffer.subarray(endIndex);
+                }
+                else if (startPartIndex === -1 && endHeaderPartIndex === -1) {
+                    // check if buffer contain only data
+                    if (currentBuffer.length > keep) {
+                        const bufferRestIndex = currentBuffer.length - keep;
+                        const resultChunk = await flushReceiveChunk(currentBuffer.subarray(0, bufferRestIndex));
+                        if (resultChunk !== true) {
+                            return await treatError(resultChunk);
+                        }
+                        currentBuffer = currentBuffer.subarray(bufferRestIndex);
+                    }
+                    break;
+                }
+                else if (startPartIndex !== -1 && endHeaderPartIndex === -1) {
+                    // check if buffer contain start of header but not contain end
+                    break;
+                }
+                else {
+                    // check if buffer contain only end of header part
+                    return await treatError(new BodyParseFormDataError("Wrong content."));
+                }
+            }
+        }
+        const resultChunk = await flushReceiveChunk(currentBuffer);
+        if (resultChunk !== true) {
+            return await treatError(resultChunk);
+        }
+        valueAccumulator = await currentStream?.onEndPart(valueAccumulator) ?? valueAccumulator;
+        return valueAccumulator;
+    }
+    catch (error) {
+        await currentStream?.onError?.(error, valueAccumulator);
+        return E.left("server-error", error);
+    }
+    finally {
+        request.destroy();
+    }
+}
+
+export { readRequestFormData };

package/dist/interfaces/node/bodyReaders/index.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+var index = require('./formData/index.cjs');
+var index$1 = require('./text/index.cjs');
+
+
+
+exports.createFormDataBodyReaderImplementation = index.createFormDataBodyReaderImplementation;
+exports.createTextBodyReaderImplementation = index$1.createTextBodyReaderImplementation;

package/dist/interfaces/node/bodyReaders/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./formData";
+export * from "./text";

package/dist/interfaces/node/bodyReaders/index.mjs

@@ -0,0 +1,2 @@
+export { createFormDataBodyReaderImplementation } from './formData/index.mjs';
+export { createTextBodyReaderImplementation } from './text/index.mjs';

package/dist/interfaces/node/bodyReaders/text/index.cjs

@@ -0,0 +1,41 @@
+'use strict';
+
+require('../../../../core/request/index.cjs');
+var readRequestText = require('./readRequestText.cjs');
+var utils = require('@duplojs/utils');
+require('../../../../core/errors/index.cjs');
+var text = require('../../../../core/request/bodyController/text.cjs');
+var wrongContentTypeError = require('../../../../core/errors/wrongContentTypeError.cjs');
+var parseJsonError = require('../../../../core/errors/parseJsonError.cjs');
+
+function createTextBodyReaderImplementation(serverParams) {
+    const serverMaxBodySize = utils.stringToBytes(serverParams.maxBodySize);
+    return text.TextBodyController.createReaderImplementation(async (request, params) => {
+        if (!request.headers["content-type"]?.includes("application/json")
+            && !request.headers["content-type"]?.includes("text/plain")) {
+            return utils.E.error(new wrongContentTypeError.WrongContentTypeError("application/json or text/plain", utils.A.join(utils.A.coalescing(request.headers["content-type"] ?? ""), " ")));
+        }
+        const result = await readRequestText.readRequestText(request.raw.request, { maxBodySize: params.bodyMaxSize ?? serverMaxBodySize }, (result) => {
+            if (request.headers["content-type"]?.includes("application/json")) {
+                try {
+                    return utils.E.success(JSON.parse(result));
+                }
+                catch (error) {
+                    return utils.E.error(new parseJsonError.ParseJsonError(result, error));
+                }
+            }
+            return utils.E.success(result);
+        });
+        if (utils.E.isLeft(result)) {
+            // mandatory in case of error to avoid monopolizing the client connection if a stream is not finished.
+            request.raw.response.setHeader("Connection", "close");
+        }
+        if (utils.E.hasInformation(result, "server-error")) {
+            throw utils.unwrap(result);
+        }
+        return result;
+    });
+}
+
+exports.readRequestText = readRequestText.readRequestText;
+exports.createTextBodyReaderImplementation = createTextBodyReaderImplementation;

package/dist/interfaces/node/bodyReaders/text/index.d.ts

@@ -0,0 +1,3 @@
+import { type HttpServerParams } from "../../../../core/types";
+export * from "./readRequestText";
+export declare function createTextBodyReaderImplementation(serverParams: HttpServerParams): import("../../../../core/request").BodyReaderImplementation<"text", import("../../../../core/request").TextBodyReaderParams>;

package/dist/interfaces/node/bodyReaders/text/index.mjs

@@ -0,0 +1,38 @@
+import '../../../../core/request/index.mjs';
+import { readRequestText } from './readRequestText.mjs';
+import { stringToBytes, E, A, unwrap } from '@duplojs/utils';
+import '../../../../core/errors/index.mjs';
+import { TextBodyController } from '../../../../core/request/bodyController/text.mjs';
+import { WrongContentTypeError } from '../../../../core/errors/wrongContentTypeError.mjs';
+import { ParseJsonError } from '../../../../core/errors/parseJsonError.mjs';
+
+function createTextBodyReaderImplementation(serverParams) {
+    const serverMaxBodySize = stringToBytes(serverParams.maxBodySize);
+    return TextBodyController.createReaderImplementation(async (request, params) => {
+        if (!request.headers["content-type"]?.includes("application/json")
+            && !request.headers["content-type"]?.includes("text/plain")) {
+            return E.error(new WrongContentTypeError("application/json or text/plain", A.join(A.coalescing(request.headers["content-type"] ?? ""), " ")));
+        }
+        const result = await readRequestText(request.raw.request, { maxBodySize: params.bodyMaxSize ?? serverMaxBodySize }, (result) => {
+            if (request.headers["content-type"]?.includes("application/json")) {
+                try {
+                    return E.success(JSON.parse(result));
+                }
+                catch (error) {
+                    return E.error(new ParseJsonError(result, error));
+                }
+            }
+            return E.success(result);
+        });
+        if (E.isLeft(result)) {
+            // mandatory in case of error to avoid monopolizing the client connection if a stream is not finished.
+            request.raw.response.setHeader("Connection", "close");
+        }
+        if (E.hasInformation(result, "server-error")) {
+            throw unwrap(result);
+        }
+        return result;
+    });
+}
+
+export { createTextBodyReaderImplementation, readRequestText };

package/dist/interfaces/node/bodyReaders/text/readRequestText.cjs

@@ -0,0 +1,37 @@
+'use strict';
+
+require('../../../../core/errors/index.cjs');
+var utils = require('@duplojs/utils');
+var bodyParseWrongChunkReceived = require('../../../../core/errors/bodyParseWrongChunkReceived.cjs');
+var bodySizeExceedsLimitError = require('../../../../core/errors/bodySizeExceedsLimitError.cjs');
+
+async function readRequestText(request, params, onEnd) {
+    let result = "";
+    let size = 0;
+    try {
+        for await (const chunk of request) {
+            if (!(chunk instanceof Buffer) && typeof chunk !== "string") {
+                return utils.E.error(new bodyParseWrongChunkReceived.BodyParseWrongChunkReceived("Buffer or String.", chunk));
+            }
+            size += chunk instanceof Buffer
+                ? chunk.byteLength
+                : Buffer.byteLength(chunk);
+            if (size > params.maxBodySize) {
+                return utils.E.error(new bodySizeExceedsLimitError.BodySizeExceedsLimitError(params.maxBodySize));
+            }
+            result += chunk.toString();
+        }
+        if (onEnd) {
+            return await onEnd(result);
+        }
+        return result;
+    }
+    catch (error) {
+        return utils.E.left("server-error", error);
+    }
+    finally {
+        request.destroy();
+    }
+}
+
+exports.readRequestText = readRequestText;

package/dist/interfaces/node/bodyReaders/text/readRequestText.d.ts

@@ -0,0 +1,6 @@
+import { E } from "@duplojs/utils";
+import type http from "http";
+export interface ReadRequestTextParams {
+    maxBodySize: number;
+}
+export declare function readRequestText<GenericOutputValue extends unknown = string>(request: http.IncomingMessage, params: ReadRequestTextParams, onEnd?: (result: string) => GenericOutputValue): Promise<E.Left<"server-error", unknown> | E.Error<Error> | GenericOutputValue>;

package/dist/interfaces/node/bodyReaders/text/readRequestText.mjs

@@ -0,0 +1,35 @@
+import '../../../../core/errors/index.mjs';
+import { E } from '@duplojs/utils';
+import { BodyParseWrongChunkReceived } from '../../../../core/errors/bodyParseWrongChunkReceived.mjs';
+import { BodySizeExceedsLimitError } from '../../../../core/errors/bodySizeExceedsLimitError.mjs';
+
+async function readRequestText(request, params, onEnd) {
+    let result = "";
+    let size = 0;
+    try {
+        for await (const chunk of request) {
+            if (!(chunk instanceof Buffer) && typeof chunk !== "string") {
+                return E.error(new BodyParseWrongChunkReceived("Buffer or String.", chunk));
+            }
+            size += chunk instanceof Buffer
+                ? chunk.byteLength
+                : Buffer.byteLength(chunk);
+            if (size > params.maxBodySize) {
+                return E.error(new BodySizeExceedsLimitError(params.maxBodySize));
+            }
+            result += chunk.toString();
+        }
+        if (onEnd) {
+            return await onEnd(result);
+        }
+        return result;
+    }
+    catch (error) {
+        return E.left("server-error", error);
+    }
+    finally {
+        request.destroy();
+    }
+}
+
+export { readRequestText };

package/dist/interfaces/node/createHttpServer.cjs

@@ -1,12 +1,16 @@
 'use strict';
 
-var utils = require('@duplojs/utils');
 var http = require('http');
 var https = require('https');
-var hooks = require('./hooks.cjs');
+var index$3 = require('./hooks/index.cjs');
 var implementHttpServer = require('../../core/implementHttpServer.cjs');
+var utils = require('@duplojs/utils');
+var index$2 = require('../../core/defaultHooks/index.cjs');
+require('./bodyReaders/index.cjs');
+var index = require('./bodyReaders/text/index.cjs');
+var index$1 = require('./bodyReaders/formData/index.cjs');
 
-function createHttpServer(inputHub, params) {
+function createHttpServer(hub, params) {
     const httpServerParams = utils.O.override({
         host: "localhost",
         port: 80,
@@ -15,9 +19,13 @@ function createHttpServer(inputHub, params) {
         predictedHeaderKey: "predicted",
         fromHookHeaderKey: "from-hook",
         interface: "node",
+        uploadFolder: "./upload",
     }, params);
-    const hooks$1 = hooks.makeNodeHook(inputHub, httpServerParams);
-    const hub = inputHub.addRouteHooks(hooks$1);
+    hub.addBodyReaderImplementation([
+        index.createTextBodyReaderImplementation(httpServerParams),
+        index$1.createFormDataBodyReaderImplementation(httpServerParams),
+    ]);
+    hub.addRouteHooks([index$2.initDefaultHook(hub, httpServerParams), index$3.nodeHook]);
     function whenUncaughtError(error, routerInitializationData) {
         const serverResponse = routerInitializationData.raw.response;
         if (!serverResponse.headersSent && !serverResponse.writableEnded) {

package/dist/interfaces/node/createHttpServer.d.ts

@@ -1,20 +1,21 @@
-import { type HttpServerParams, type Hub } from "../../core/hub";
-import { type Hosts } from "./types/host";
-import { type BytesInString, O } from "@duplojs/utils";
+import { type Hub } from "../../core/hub";
 import http from "http";
 import https from "https";
-declare module "../../core/hub" {
+import { O } from "@duplojs/utils";
+import { type HttpServerParams } from "../../core/types";
+declare module "../../core/types" {
     interface HttpServerParams {
         readonly interface: "node";
-        readonly host: Hosts;
-        readonly port: number;
-        readonly maxBodySize: BytesInString | number;
-        readonly informationHeaderKey: string;
-        readonly predictedHeaderKey: string;
-        readonly fromHookHeaderKey: string;
         readonly http?: http.ServerOptions;
         readonly https?: https.ServerOptions;
     }
+    interface HostCustom {
+        "::": true;
+        "0.0.0.0": true;
+        localhost: true;
+        "127.0.0.1": true;
+        "::1": true;
+    }
 }
-export type CreateHttpServerParams = O.PartialKeys<Omit<HttpServerParams, "interface">, "maxBodySize" | "informationHeaderKey" | "predictedHeaderKey" | "fromHookHeaderKey">;
-export declare function createHttpServer(inputHub: Hub, params: CreateHttpServerParams): Promise<https.Server<typeof http.IncomingMessage, typeof http.ServerResponse> | http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>>;
+export type CreateHttpServerParams = O.PartialKeys<Omit<HttpServerParams, "interface">, "maxBodySize" | "informationHeaderKey" | "predictedHeaderKey" | "fromHookHeaderKey" | "uploadFolder">;
+export declare function createHttpServer(hub: Hub, params: CreateHttpServerParams): Promise<https.Server<typeof http.IncomingMessage, typeof http.ServerResponse> | http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>>;

package/dist/interfaces/node/createHttpServer.mjs

@@ -1,10 +1,14 @@
-import { O } from '@duplojs/utils';
 import http from 'http';
 import https from 'https';
-import { makeNodeHook } from './hooks.mjs';
+import { nodeHook } from './hooks/index.mjs';
 import { implementHttpServer } from '../../core/implementHttpServer.mjs';
+import { O } from '@duplojs/utils';
+import { initDefaultHook } from '../../core/defaultHooks/index.mjs';
+import './bodyReaders/index.mjs';
+import { createTextBodyReaderImplementation } from './bodyReaders/text/index.mjs';
+import { createFormDataBodyReaderImplementation } from './bodyReaders/formData/index.mjs';
 
-function createHttpServer(inputHub, params) {
+function createHttpServer(hub, params) {
     const httpServerParams = O.override({
         host: "localhost",
         port: 80,
@@ -13,9 +17,13 @@ function createHttpServer(inputHub, params) {
         predictedHeaderKey: "predicted",
         fromHookHeaderKey: "from-hook",
         interface: "node",
+        uploadFolder: "./upload",
     }, params);
-    const hooks = makeNodeHook(inputHub, httpServerParams);
-    const hub = inputHub.addRouteHooks(hooks);
+    hub.addBodyReaderImplementation([
+        createTextBodyReaderImplementation(httpServerParams),
+        createFormDataBodyReaderImplementation(httpServerParams),
+    ]);
+    hub.addRouteHooks([initDefaultHook(hub, httpServerParams), nodeHook]);
     function whenUncaughtError(error, routerInitializationData) {
         const serverResponse = routerInitializationData.raw.response;
         if (!serverResponse.headersSent && !serverResponse.writableEnded) {