@duplojs/http 0.1.0

package/dist/interfaces/node/error/bodyParseWrongChunkReceived.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var kind = require('../kind.cjs');
+
+class BodyParseWrongChunkReceived extends utils.kindHeritage("body-parse-wrong-chunk-received", kind.createInterfacesNodeLibKind("body-parse-wrong-chunk-received"), Error) {
+    wrongChunk;
+    constructor(wrongChunk) {
+        super({}, ["Received chunk is not buffer or string."]);
+        this.wrongChunk = wrongChunk;
+    }
+}
+
+exports.BodyParseWrongChunkReceived = BodyParseWrongChunkReceived;

package/dist/interfaces/node/error/bodyParseWrongChunkReceived.d.ts

@@ -0,0 +1,8 @@
+declare const BodyParseWrongChunkReceived_base: new (params: {
+    "@DuplojsHttpInterfacesNode/body-parse-wrong-chunk-received"?: unknown;
+}, parentParams: [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpInterfacesNode/body-parse-wrong-chunk-received", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"body-parse-wrong-chunk-received", unknown>, unknown>;
+export declare class BodyParseWrongChunkReceived extends BodyParseWrongChunkReceived_base {
+    wrongChunk: unknown;
+    constructor(wrongChunk: unknown);
+}
+export {};

package/dist/interfaces/node/error/bodyParseWrongChunkReceived.mjs

@@ -0,0 +1,12 @@
+import { kindHeritage } from '@duplojs/utils';
+import { createInterfacesNodeLibKind } from '../kind.mjs';
+
+class BodyParseWrongChunkReceived extends kindHeritage("body-parse-wrong-chunk-received", createInterfacesNodeLibKind("body-parse-wrong-chunk-received"), Error) {
+    wrongChunk;
+    constructor(wrongChunk) {
+        super({}, ["Received chunk is not buffer or string."]);
+        this.wrongChunk = wrongChunk;
+    }
+}
+
+export { BodyParseWrongChunkReceived };

package/dist/interfaces/node/error/bodySizeExceedsLimitError.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var kind = require('../kind.cjs');
+
+class BodySizeExceedsLimitError extends utils.kindHeritage("body-size-exceeds-limit-error", kind.createInterfacesNodeLibKind("body-size-exceeds-limit-error"), Error) {
+    bytesInString;
+    constructor(bytesInString) {
+        super({}, [`Body size is bigger than ${bytesInString}.`]);
+        this.bytesInString = bytesInString;
+    }
+}
+
+exports.BodySizeExceedsLimitError = BodySizeExceedsLimitError;

package/dist/interfaces/node/error/bodySizeExceedsLimitError.d.ts

@@ -0,0 +1,9 @@
+import { type BytesInString } from "@duplojs/utils";
+declare const BodySizeExceedsLimitError_base: new (params: {
+    "@DuplojsHttpInterfacesNode/body-size-exceeds-limit-error"?: unknown;
+}, parentParams: [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpInterfacesNode/body-size-exceeds-limit-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"body-size-exceeds-limit-error", unknown>, unknown>;
+export declare class BodySizeExceedsLimitError extends BodySizeExceedsLimitError_base {
+    bytesInString: BytesInString | number;
+    constructor(bytesInString: BytesInString | number);
+}
+export {};

package/dist/interfaces/node/error/bodySizeExceedsLimitError.mjs

@@ -0,0 +1,12 @@
+import { kindHeritage } from '@duplojs/utils';
+import { createInterfacesNodeLibKind } from '../kind.mjs';
+
+class BodySizeExceedsLimitError extends kindHeritage("body-size-exceeds-limit-error", createInterfacesNodeLibKind("body-size-exceeds-limit-error"), Error) {
+    bytesInString;
+    constructor(bytesInString) {
+        super({}, [`Body size is bigger than ${bytesInString}.`]);
+        this.bytesInString = bytesInString;
+    }
+}
+
+export { BodySizeExceedsLimitError };

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

@@ -0,0 +1,3 @@
+export * from "./bodySizeExceedsLimitError";
+export * from "./bodyParseWrongChunkReceived";
+export * from "./bodyParseUnknownError";

package/dist/interfaces/node/hooks.cjs

@@ -0,0 +1,119 @@
+'use strict';
+
+require('../../core/route/index.cjs');
+var utils = require('@duplojs/utils');
+var bodySizeExceedsLimitError = require('./error/bodySizeExceedsLimitError.cjs');
+var bodyParseWrongChunkReceived = require('./error/bodyParseWrongChunkReceived.cjs');
+var bodyParseUnknownError = require('./error/bodyParseUnknownError.cjs');
+var index = require('../../core/route/hooks/index.cjs');
+var response = require('../../core/route/hooks/response.cjs');
+
+function makeNodeHook(hub, serverParams) {
+    const informationHeaderKey = serverParams.informationHeaderKey;
+    const fromHookHeaderKey = serverParams.fromHookHeaderKey;
+    const isDev = hub.config.environment === "DEV";
+    const maxBodySize = utils.stringToBytes(serverParams.maxBodySize);
+    return index.createHookRouteLifeCycle({
+        async parseBody({ request, exit }) {
+            const contentType = request.headers["content-type"] instanceof Array
+                ? request.headers["content-type"].join(", ")
+                : request.headers["content-type"] ?? "";
+            const isText = contentType.includes("text/plain");
+            const isJson = contentType.includes("application/json");
+            if (!isText && !isJson) {
+                return exit();
+            }
+            const { request: rawRequest } = request.raw;
+            request.body = await new Promise((resolve, reject) => {
+                function errorCallback(error) {
+                    if (error instanceof bodySizeExceedsLimitError.BodySizeExceedsLimitError
+                        || error instanceof bodyParseWrongChunkReceived.BodyParseWrongChunkReceived) {
+                        reject(error);
+                        return;
+                    }
+                    reject(new bodyParseUnknownError.BodyParseUnknownError(contentType, error));
+                }
+                let stringBody = "";
+                let byteLengthBody = 0;
+                rawRequest.on("error", errorCallback);
+                rawRequest.on("data", (chunk) => {
+                    if (!(chunk instanceof Buffer) && typeof chunk !== "string") {
+                        rawRequest.emit("error", new bodyParseWrongChunkReceived.BodyParseWrongChunkReceived(chunk));
+                        return;
+                    }
+                    byteLengthBody += chunk instanceof Buffer
+                        ? chunk.byteLength
+                        : Buffer.byteLength(chunk);
+                    if (byteLengthBody > maxBodySize) {
+                        rawRequest.emit("error", new bodySizeExceedsLimitError.BodySizeExceedsLimitError(serverParams.maxBodySize));
+                        return;
+                    }
+                    stringBody += chunk.toString();
+                });
+                rawRequest.on("end", () => {
+                    try {
+                        resolve(isText
+                            ? stringBody
+                            : JSON.parse(stringBody));
+                    }
+                    catch (error) {
+                        errorCallback(error);
+                    }
+                });
+            });
+            return exit();
+        },
+        error({ error, response, exit }) {
+            const displayedError = isDev ? error : undefined;
+            if (error instanceof bodySizeExceedsLimitError.BodySizeExceedsLimitError) {
+                return response("400", "body-size-exceeds-limit-error", displayedError);
+            }
+            else if (error instanceof bodyParseWrongChunkReceived.BodyParseWrongChunkReceived) {
+                return response("400", "body-parse-wrong-chunk-received", displayedError);
+            }
+            else if (error instanceof bodyParseUnknownError.BodyParseUnknownError) {
+                return response("400", "body-parse-unknown-error", displayedError);
+            }
+            return exit();
+        },
+        beforeSendResponse({ request, currentResponse, exit }) {
+            const body = currentResponse.body;
+            if (typeof body === "number"
+                || typeof body === "string"
+                || body === null
+                || body instanceof Error) {
+                currentResponse.setHeader("content-type", "text/plain; charset=utf-8");
+            }
+            else if (typeof body === "object") {
+                currentResponse.setHeader("content-type", "application/json; charset=utf-8");
+            }
+            currentResponse.setHeader(informationHeaderKey, currentResponse.information);
+            if (currentResponse instanceof response.HookResponse) {
+                currentResponse.setHeader(fromHookHeaderKey, currentResponse.fromHook);
+            }
+            request.raw.response.writeHead(Number(currentResponse.code), currentResponse.headers);
+            return exit();
+        },
+        sendResponse({ request, currentResponse, exit }) {
+            const { response: rawResponse } = request.raw;
+            const body = currentResponse.body;
+            if (body instanceof Error) {
+                rawResponse.write(body.toString());
+            }
+            else if (typeof body === "object") {
+                rawResponse.write(JSON.stringify(body));
+            }
+            else if (typeof body === "string") {
+                rawResponse.write(body);
+            }
+            else if (typeof body === "number"
+                || typeof body === "bigint") {
+                rawResponse.write(body.toString());
+            }
+            rawResponse.end();
+            return exit();
+        },
+    });
+}
+
+exports.makeNodeHook = makeNodeHook;

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

@@ -0,0 +1,8 @@
+import { type HttpServerParams, type Hub } from "../../core/hub";
+import { HookResponse } from "../../core/route";
+export declare function makeNodeHook(hub: Hub, serverParams: HttpServerParams): {
+    parseBody({ request, exit }: import("../../core/route").RouteHookParams<import("../../core/request").Request>): Promise<import("../../core/route").RouteHookExit>;
+    error({ error, response, exit }: import("../../core/route").RouteHookErrorParams<import("../../core/request").Request>): import("../../core/route").RouteHookExit | HookResponse<"400", "body-size-exceeds-limit-error", unknown> | HookResponse<"400", "body-parse-wrong-chunk-received", unknown> | HookResponse<"400", "body-parse-unknown-error", unknown>;
+    beforeSendResponse({ request, currentResponse, exit }: import("../../core/route").RouteHookParamsAfter<import("../../core/request").Request>): import("../../core/route").RouteHookExit;
+    sendResponse({ request, currentResponse, exit }: import("../../core/route").RouteHookParamsAfter<import("../../core/request").Request>): import("../../core/route").RouteHookExit;
+};

package/dist/interfaces/node/hooks.mjs

@@ -0,0 +1,117 @@
+import '../../core/route/index.mjs';
+import { stringToBytes } from '@duplojs/utils';
+import { BodySizeExceedsLimitError } from './error/bodySizeExceedsLimitError.mjs';
+import { BodyParseWrongChunkReceived } from './error/bodyParseWrongChunkReceived.mjs';
+import { BodyParseUnknownError } from './error/bodyParseUnknownError.mjs';
+import { createHookRouteLifeCycle } from '../../core/route/hooks/index.mjs';
+import { HookResponse } from '../../core/route/hooks/response.mjs';
+
+function makeNodeHook(hub, serverParams) {
+    const informationHeaderKey = serverParams.informationHeaderKey;
+    const fromHookHeaderKey = serverParams.fromHookHeaderKey;
+    const isDev = hub.config.environment === "DEV";
+    const maxBodySize = stringToBytes(serverParams.maxBodySize);
+    return createHookRouteLifeCycle({
+        async parseBody({ request, exit }) {
+            const contentType = request.headers["content-type"] instanceof Array
+                ? request.headers["content-type"].join(", ")
+                : request.headers["content-type"] ?? "";
+            const isText = contentType.includes("text/plain");
+            const isJson = contentType.includes("application/json");
+            if (!isText && !isJson) {
+                return exit();
+            }
+            const { request: rawRequest } = request.raw;
+            request.body = await new Promise((resolve, reject) => {
+                function errorCallback(error) {
+                    if (error instanceof BodySizeExceedsLimitError
+                        || error instanceof BodyParseWrongChunkReceived) {
+                        reject(error);
+                        return;
+                    }
+                    reject(new BodyParseUnknownError(contentType, error));
+                }
+                let stringBody = "";
+                let byteLengthBody = 0;
+                rawRequest.on("error", errorCallback);
+                rawRequest.on("data", (chunk) => {
+                    if (!(chunk instanceof Buffer) && typeof chunk !== "string") {
+                        rawRequest.emit("error", new BodyParseWrongChunkReceived(chunk));
+                        return;
+                    }
+                    byteLengthBody += chunk instanceof Buffer
+                        ? chunk.byteLength
+                        : Buffer.byteLength(chunk);
+                    if (byteLengthBody > maxBodySize) {
+                        rawRequest.emit("error", new BodySizeExceedsLimitError(serverParams.maxBodySize));
+                        return;
+                    }
+                    stringBody += chunk.toString();
+                });
+                rawRequest.on("end", () => {
+                    try {
+                        resolve(isText
+                            ? stringBody
+                            : JSON.parse(stringBody));
+                    }
+                    catch (error) {
+                        errorCallback(error);
+                    }
+                });
+            });
+            return exit();
+        },
+        error({ error, response, exit }) {
+            const displayedError = isDev ? error : undefined;
+            if (error instanceof BodySizeExceedsLimitError) {
+                return response("400", "body-size-exceeds-limit-error", displayedError);
+            }
+            else if (error instanceof BodyParseWrongChunkReceived) {
+                return response("400", "body-parse-wrong-chunk-received", displayedError);
+            }
+            else if (error instanceof BodyParseUnknownError) {
+                return response("400", "body-parse-unknown-error", displayedError);
+            }
+            return exit();
+        },
+        beforeSendResponse({ request, currentResponse, exit }) {
+            const body = currentResponse.body;
+            if (typeof body === "number"
+                || typeof body === "string"
+                || body === null
+                || body instanceof Error) {
+                currentResponse.setHeader("content-type", "text/plain; charset=utf-8");
+            }
+            else if (typeof body === "object") {
+                currentResponse.setHeader("content-type", "application/json; charset=utf-8");
+            }
+            currentResponse.setHeader(informationHeaderKey, currentResponse.information);
+            if (currentResponse instanceof HookResponse) {
+                currentResponse.setHeader(fromHookHeaderKey, currentResponse.fromHook);
+            }
+            request.raw.response.writeHead(Number(currentResponse.code), currentResponse.headers);
+            return exit();
+        },
+        sendResponse({ request, currentResponse, exit }) {
+            const { response: rawResponse } = request.raw;
+            const body = currentResponse.body;
+            if (body instanceof Error) {
+                rawResponse.write(body.toString());
+            }
+            else if (typeof body === "object") {
+                rawResponse.write(JSON.stringify(body));
+            }
+            else if (typeof body === "string") {
+                rawResponse.write(body);
+            }
+            else if (typeof body === "number"
+                || typeof body === "bigint") {
+                rawResponse.write(body.toString());
+            }
+            rawResponse.end();
+            return exit();
+        },
+    });
+}
+
+export { makeNodeHook };

package/dist/interfaces/node/index.cjs

@@ -0,0 +1,26 @@
+'use strict';
+
+require('../../core/request.cjs');
+require('../../core/steps/kind.cjs');
+require('../../core/steps/identifier.cjs');
+require('../../core/steps/checker.cjs');
+require('../../core/steps/extract.cjs');
+require('../../core/steps/cut.cjs');
+require('../../core/steps/handler.cjs');
+require('../../core/steps/process.cjs');
+require('../../core/steps/presetChecker.cjs');
+var kind = require('./kind.cjs');
+var bodySizeExceedsLimitError = require('./error/bodySizeExceedsLimitError.cjs');
+var bodyParseWrongChunkReceived = require('./error/bodyParseWrongChunkReceived.cjs');
+var bodyParseUnknownError = require('./error/bodyParseUnknownError.cjs');
+var createHttpServer = require('./createHttpServer.cjs');
+var hooks = require('./hooks.cjs');
+
+
+
+exports.createInterfacesNodeLibKind = kind.createInterfacesNodeLibKind;
+exports.BodySizeExceedsLimitError = bodySizeExceedsLimitError.BodySizeExceedsLimitError;
+exports.BodyParseWrongChunkReceived = bodyParseWrongChunkReceived.BodyParseWrongChunkReceived;
+exports.BodyParseUnknownError = bodyParseUnknownError.BodyParseUnknownError;
+exports.createHttpServer = createHttpServer.createHttpServer;
+exports.makeNodeHook = hooks.makeNodeHook;

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

@@ -0,0 +1,5 @@
+export * from "./types";
+export * from "./kind";
+export * from "./error";
+export * from "./createHttpServer";
+export * from "./hooks";

package/dist/interfaces/node/index.mjs

@@ -0,0 +1,15 @@
+import '../../core/request.mjs';
+import '../../core/steps/kind.mjs';
+import '../../core/steps/identifier.mjs';
+import '../../core/steps/checker.mjs';
+import '../../core/steps/extract.mjs';
+import '../../core/steps/cut.mjs';
+import '../../core/steps/handler.mjs';
+import '../../core/steps/process.mjs';
+import '../../core/steps/presetChecker.mjs';
+export { createInterfacesNodeLibKind } from './kind.mjs';
+export { BodySizeExceedsLimitError } from './error/bodySizeExceedsLimitError.mjs';
+export { BodyParseWrongChunkReceived } from './error/bodyParseWrongChunkReceived.mjs';
+export { BodyParseUnknownError } from './error/bodyParseUnknownError.mjs';
+export { createHttpServer } from './createHttpServer.mjs';
+export { makeNodeHook } from './hooks.mjs';

package/dist/interfaces/node/kind.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+
+const createInterfacesNodeLibKind = utils.createKindNamespace(
+// @ts-expect-error reserved kind namespace
+"DuplojsHttpInterfacesNode");
+
+exports.createInterfacesNodeLibKind = createInterfacesNodeLibKind;

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

@@ -0,0 +1,6 @@
+declare module "@duplojs/utils" {
+    interface ReservedKindNamespace {
+        DuplojsHttpInterfacesNode: true;
+    }
+}
+export declare const createInterfacesNodeLibKind: <GenericName extends string, GenericKindValue extends unknown = unknown>(name: GenericName & import("@duplojs/utils/string").ForbiddenString<GenericName, "@" | "/">) => import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<`@DuplojsHttpInterfacesNode/${GenericName}`, GenericKindValue>>;

package/dist/interfaces/node/kind.mjs

@@ -0,0 +1,7 @@
+import { createKindNamespace } from '@duplojs/utils';
+
+const createInterfacesNodeLibKind = createKindNamespace(
+// @ts-expect-error reserved kind namespace
+"DuplojsHttpInterfacesNode");
+
+export { createInterfacesNodeLibKind };

package/dist/interfaces/node/types/host.d.ts

@@ -0,0 +1,4 @@
+import { type O } from "@duplojs/utils";
+export interface HostCustom {
+}
+export type Hosts = (HostCustom[O.GetPropsWithValue<HostCustom, true>] | "::" | "0.0.0.0" | "localhost" | "127.0.0.1" | "::1");

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

@@ -0,0 +1,2 @@
+export * from "./host";
+export * from "./request";

package/dist/interfaces/node/types/request.d.ts

@@ -0,0 +1,23 @@
+import "../../../core/request";
+import "../../../core/steps";
+import type http from "http";
+export interface RawRequest {
+    request: http.IncomingMessage;
+    response: http.ServerResponse;
+}
+declare module "../../../core/steps" {
+    interface DisabledExtractKeysCustom {
+        raw: true;
+    }
+}
+declare module "../../../core/request" {
+    interface RequestInitializationData {
+        raw: RawRequest;
+    }
+    interface Request {
+        /**
+         * @deprecated
+         */
+        raw: RawRequest;
+    }
+}

package/package.json

@@ -0,0 +1,82 @@
+{
+  "name": "@duplojs/http",
+  "version": "0.1.0",
+  "author": "mathcovax",
+  "license": "MIT",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/duplojs/http.git"
+  },
+  "scripts": {
+    "build": "rollup --config",
+    "test:tu": "vitest --coverage",
+    "test:tu:bench": "vitest bench",
+    "test:tu:watch": "vitest --coverage --watch",
+    "test:tu:update": "vitest --coverage --update",
+    "test:types": "tsc -p tests/core/tsconfig.json && tsc -p tests/interfaces/node/tsconfig.json && tsc -p tests/interfaces/bun/tsconfig.json && tsc -p tests/interfaces/deno/tsconfig.json",
+    "test:lint": "eslint",
+    "test:lint:fix": "eslint --fix",
+    "prepare": "husky"
+  },
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/core/index.mjs",
+      "require": "./dist/core/index.cjs",
+      "types": "./dist/core/index.d.ts"
+    },
+    "./node": {
+      "import": "./dist/interfaces/node/index.mjs",
+      "require": "./dist/interfaces/node/index.cjs",
+      "types": "./dist/interfaces/node/index.d.ts"
+    },
+    "./bun": {
+      "import": "./dist/interfaces/bun/index.mjs",
+      "require": "./dist/interfaces/bun/index.cjs",
+      "types": "./dist/interfaces/bun/index.d.ts"
+    },
+    "./deno": {
+      "import": "./dist/interfaces/deno/index.mjs",
+      "require": "./dist/interfaces/deno/index.cjs",
+      "types": "./dist/interfaces/deno/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "peerDependencies": {
+    "@duplojs/utils": ">=1.1.16 <2.0.0"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "19.8.1",
+    "@commitlint/config-conventional": "19.8.1",
+    "@duplojs/eslint": "0.5.0",
+    "@rollup/plugin-typescript": "12.1.4",
+    "@types/bun": "^1.3.3",
+    "@types/deno": "^2.5.0",
+    "@types/node": "24.3.0",
+    "@vitest/coverage-istanbul": "3.2.4",
+    "eslint": "9.34.0",
+    "form-data": "^4.0.5",
+    "husky": "9.1.7",
+    "node-mocks-http": "^1.17.2",
+    "rollup": "4.50.0",
+    "rollup-plugin-delete": "3.0.1",
+    "rollup-plugin-esbuild": "6.2.1",
+    "rollup-plugin-tsc-alias": "1.1.4",
+    "tslib": "2.8.1",
+    "tsx": "4.20.5",
+    "typescript": "5.9.2",
+    "vite-tsconfig-paths": "5.1.4",
+    "vitest": "3.2.4"
+  },
+  "workspaces": [
+    "integration"
+  ],
+  "keywords": [],
+  "engines": {
+    "node": ">=22.15.1"
+  }
+}