@duplojs/http 0.6.2 → 0.7.1

package/dist/plugins/codeGenerator/typescriptTransfomer.mjs

@@ -0,0 +1,24 @@
+import { createTransformer } from '@duplojs/data-parser-tools/toTypescript';
+import { SDP } from '@duplojs/server-utils';
+import { DP } from '@duplojs/utils';
+import { factory } from 'typescript';
+
+const fileTransformer = createTransformer(SDP.fileKind.has, (__, { success }) => success(factory.createTypeReferenceNode("File")));
+const dateTransformer = createTransformer(DP.dateKind.has, (__, { success, addImport }) => {
+    addImport("@duplojs/utils/date", "TheDate");
+    addImport("@duplojs/utils/date", "SerializedTheDate");
+    return success(factory.createUnionTypeNode([
+        factory.createTypeReferenceNode(factory.createIdentifier("SerializedTheDate")),
+        factory.createTypeReferenceNode(factory.createIdentifier("TheDate")),
+    ]));
+});
+const timeTransformer = createTransformer(DP.timeKind.has, (__, { success, addImport }) => {
+    addImport("@duplojs/utils/date", "TheTime");
+    addImport("@duplojs/utils/date", "SerializedTheTime");
+    return success(factory.createUnionTypeNode([
+        factory.createTypeReferenceNode(factory.createIdentifier("SerializedTheTime")),
+        factory.createTypeReferenceNode(factory.createIdentifier("TheTime")),
+    ]));
+});
+
+export { dateTransformer, fileTransformer, timeTransformer };

package/dist/plugins/openApiGenerator/makeOpenApiRoute.d.ts

@@ -7,10 +7,13 @@ export declare function makeOpenApiRoute(routePath: RoutePath, openApiPage: stri
     readonly hooks: readonly [];
     readonly preflightSteps: readonly [];
     readonly paths: readonly [`/${string}`];
+    readonly bodyController: null;
     readonly steps: readonly [import("../../core/steps").HandlerStep<{
         readonly responseContract: NoInfer<ResponseContract.Contract<"200", "swaggerUi", DP.DataParserString<{
             readonly errorMessage?: string | undefined;
             readonly identifier?: string | undefined;
+            readonly overrideJsonSchemaTransformer?: import("@duplojs/data-parser-tools/toJsonSchema").TransformerBuildFunction | undefined;
+            readonly overrideTypescriptTransformer?: import("@duplojs/data-parser-tools/toTypescript").TransformerBuildFunction | undefined;
             readonly coerce: boolean;
             readonly checkers: readonly [];
         }>>>;

package/dist/plugins/openApiGenerator/plugin.cjs

@@ -4,7 +4,7 @@ var routeToOpenApi = require('./routeToOpenApi.cjs');
 var utils = require('@duplojs/utils');
 var makeOpenApiPage = require('./makeOpenApiPage.cjs');
 var makeOpenApiRoute = require('./makeOpenApiRoute.cjs');
-var promises = require('fs/promises');
+var serverUtils = require('@duplojs/server-utils');
 
 function openApiGeneratorPlugin(pluginParams) {
     return () => ({
@@ -19,7 +19,7 @@ function openApiGeneratorPlugin(pluginParams) {
                     }
                     const contextToJsonSchemaFactory = new Map();
                     const resultSchemaContext = new Map();
-                    const routes = hub.aggregatesRoutes();
+                    const routes = utils.A.from(hub.routes);
                     const openApiRoutes = utils.pipe(routes, utils.A.filter((route) => route.definition.method !== "OPTIONS"), utils.A.flatMap((route) => routeToOpenApi.routeToOpenApi(route, {
                         defaultExtractContract: hub.defaultExtractContract,
                         resultSchemaContext,
@@ -77,7 +77,7 @@ function openApiGeneratorPlugin(pluginParams) {
                     };
                     const openApiDocumentString = JSON.stringify(openApiDocument, null, 2);
                     if (pluginParams.outputFile) {
-                        await promises.writeFile(pluginParams.outputFile, openApiDocumentString);
+                        utils.asserts(await serverUtils.SF.writeTextFile(pluginParams.outputFile, openApiDocumentString), utils.E.isRight);
                     }
                     if (pluginParams.routePath) {
                         const openApiPage = makeOpenApiPage.makeOpenApiPage({

package/dist/plugins/openApiGenerator/plugin.mjs

@@ -1,8 +1,8 @@
 import { routeToOpenApi } from './routeToOpenApi.mjs';
-import { equal, pipe, A, O, G, P, justReturn } from '@duplojs/utils';
+import { equal, A, pipe, O, G, P, justReturn, asserts, E } from '@duplojs/utils';
 import { makeOpenApiPage } from './makeOpenApiPage.mjs';
 import { makeOpenApiRoute } from './makeOpenApiRoute.mjs';
-import { writeFile } from 'fs/promises';
+import { SF } from '@duplojs/server-utils';
 
 function openApiGeneratorPlugin(pluginParams) {
     return () => ({
@@ -17,7 +17,7 @@ function openApiGeneratorPlugin(pluginParams) {
                     }
                     const contextToJsonSchemaFactory = new Map();
                     const resultSchemaContext = new Map();
-                    const routes = hub.aggregatesRoutes();
+                    const routes = A.from(hub.routes);
                     const openApiRoutes = pipe(routes, A.filter((route) => route.definition.method !== "OPTIONS"), A.flatMap((route) => routeToOpenApi(route, {
                         defaultExtractContract: hub.defaultExtractContract,
                         resultSchemaContext,
@@ -75,7 +75,7 @@ function openApiGeneratorPlugin(pluginParams) {
                     };
                     const openApiDocumentString = JSON.stringify(openApiDocument, null, 2);
                     if (pluginParams.outputFile) {
-                        await writeFile(pluginParams.outputFile, openApiDocumentString);
+                        asserts(await SF.writeTextFile(pluginParams.outputFile, openApiDocumentString), E.isRight);
                     }
                     if (pluginParams.routePath) {
                         const openApiPage = makeOpenApiPage({

package/dist/plugins/openApiGenerator/routeToOpenApi.cjs

@@ -3,14 +3,16 @@
 var aggregateStepContract = require('./aggregateStepContract.cjs');
 var utils = require('@duplojs/utils');
 var toJsonSchema = require('@duplojs/data-parser-tools/toJsonSchema');
+require('../../core/request/index.cjs');
 var metadata = require('./metadata.cjs');
+var formData = require('../../core/request/bodyController/formData.cjs');
 
 function factoryJsonSchema(params) {
     const identifier = params.schema.definition.identifier
         ?? `NotIdentified${params.resultSchemaContext.size}`;
     const renderResult = toJsonSchema.render(params.schema, {
         identifier,
-        mode: params.mode,
+        mode: "in",
         context: params.context,
         version: "openApi31",
         transformers: toJsonSchema.defaultTransformers,
@@ -32,6 +34,7 @@ const methodMapper = {
     TRACE: "trace",
     CONNECT: "connect",
     OPTIONS: "options",
+    PATCH: "patch",
 };
 function routeToOpenApi(route, params) {
     const isIgnore = utils.A.find(route.definition.metadata, metadata.IgnoreByOpenApiGeneratorMetadata.is);
@@ -54,18 +57,27 @@ function routeToOpenApi(route, params) {
         schema: factoryJsonSchema({
             context: params.contextToJsonSchemaFactory,
             resultSchemaContext: params.resultSchemaContext,
-            mode: "in",
             schema,
         }),
     }))));
-    const requestBody = utils.pipe(body, utils.when((value) => utils.O.countKeys(value) === 0, utils.justReturn(utils.DP.empty())), utils.whenNot(utils.DP.dataParserKind.has, utils.DP.object), utils.P.when(utils.DP.identifier(utils.DP.emptyKind), utils.justReturn(undefined)), utils.P.when(utils.DP.identifier(utils.DP.objectKind), (objectSchema) => ({
+    const requestBody = utils.pipe(body, utils.when((value) => utils.O.countKeys(value) === 0, utils.justReturn(utils.DP.empty())), utils.whenNot(utils.DP.dataParserKind.has, utils.DP.object), utils.P.when(utils.DP.identifier(utils.DP.emptyKind), utils.justReturn(undefined)), utils.P.when(() => formData.FormDataBodyController.is(route.definition.bodyController), (objectSchema) => ({
+        required: true,
+        content: {
+            "multipart/form-data": {
+                schema: factoryJsonSchema({
+                    context: params.contextToJsonSchemaFactory,
+                    resultSchemaContext: params.resultSchemaContext,
+                    schema: objectSchema,
+                }),
+            },
+        },
+    })), utils.P.when(utils.DP.identifier(utils.DP.objectKind), (objectSchema) => ({
         required: true,
         content: {
             "application/json": {
                 schema: factoryJsonSchema({
                     context: params.contextToJsonSchemaFactory,
                     resultSchemaContext: params.resultSchemaContext,
-                    mode: "in",
                     schema: objectSchema,
                 }),
             },
@@ -77,7 +89,6 @@ function routeToOpenApi(route, params) {
                 schema: factoryJsonSchema({
                     context: params.contextToJsonSchemaFactory,
                     resultSchemaContext: params.resultSchemaContext,
-                    mode: "in",
                     schema: primitiveSchema,
                 }),
             },
@@ -88,7 +99,6 @@ function routeToOpenApi(route, params) {
             ? factoryJsonSchema({
                 context: params.contextToJsonSchemaFactory,
                 resultSchemaContext: params.resultSchemaContext,
-                mode: "in",
                 schema: body,
             })
             : undefined;

package/dist/plugins/openApiGenerator/routeToOpenApi.d.ts

@@ -10,9 +10,18 @@ export interface RouteToOpenApiParams {
 }
 export declare function routeToOpenApi(route: Route, params: RouteToOpenApiParams): {
     path: `/${string}`;
-    method: "options" | "get" | "post" | "put" | "delete" | "head" | "trace" | "connect";
+    method: "options" | "get" | "post" | "put" | "patch" | "delete" | "head" | "trace" | "connect";
     parameters: EntrypointParameter[];
     requestBody: {
+        required: true;
+        content: {
+            "multipart/form-data": {
+                schema: {
+                    $ref: `#/components/schemas/${string}`;
+                };
+            };
+        };
+    } | {
         required: true;
         content: {
             "application/json": {

package/dist/plugins/openApiGenerator/routeToOpenApi.mjs

@@ -1,14 +1,16 @@
 import { aggregateStepContract } from './aggregateStepContract.mjs';
 import { O, A, pipe, DP, when, justReturn, whenNot, P, isType, S } from '@duplojs/utils';
 import { render, defaultTransformers } from '@duplojs/data-parser-tools/toJsonSchema';
+import '../../core/request/index.mjs';
 import { IgnoreByOpenApiGeneratorMetadata } from './metadata.mjs';
+import { FormDataBodyController } from '../../core/request/bodyController/formData.mjs';
 
 function factoryJsonSchema(params) {
     const identifier = params.schema.definition.identifier
         ?? `NotIdentified${params.resultSchemaContext.size}`;
     const renderResult = render(params.schema, {
         identifier,
-        mode: params.mode,
+        mode: "in",
         context: params.context,
         version: "openApi31",
         transformers: defaultTransformers,
@@ -30,6 +32,7 @@ const methodMapper = {
     TRACE: "trace",
     CONNECT: "connect",
     OPTIONS: "options",
+    PATCH: "patch",
 };
 function routeToOpenApi(route, params) {
     const isIgnore = A.find(route.definition.metadata, IgnoreByOpenApiGeneratorMetadata.is);
@@ -52,18 +55,27 @@ function routeToOpenApi(route, params) {
         schema: factoryJsonSchema({
             context: params.contextToJsonSchemaFactory,
             resultSchemaContext: params.resultSchemaContext,
-            mode: "in",
             schema,
         }),
     }))));
-    const requestBody = pipe(body, when((value) => O.countKeys(value) === 0, justReturn(DP.empty())), whenNot(DP.dataParserKind.has, DP.object), P.when(DP.identifier(DP.emptyKind), justReturn(undefined)), P.when(DP.identifier(DP.objectKind), (objectSchema) => ({
+    const requestBody = pipe(body, when((value) => O.countKeys(value) === 0, justReturn(DP.empty())), whenNot(DP.dataParserKind.has, DP.object), P.when(DP.identifier(DP.emptyKind), justReturn(undefined)), P.when(() => FormDataBodyController.is(route.definition.bodyController), (objectSchema) => ({
+        required: true,
+        content: {
+            "multipart/form-data": {
+                schema: factoryJsonSchema({
+                    context: params.contextToJsonSchemaFactory,
+                    resultSchemaContext: params.resultSchemaContext,
+                    schema: objectSchema,
+                }),
+            },
+        },
+    })), P.when(DP.identifier(DP.objectKind), (objectSchema) => ({
         required: true,
         content: {
             "application/json": {
                 schema: factoryJsonSchema({
                     context: params.contextToJsonSchemaFactory,
                     resultSchemaContext: params.resultSchemaContext,
-                    mode: "in",
                     schema: objectSchema,
                 }),
             },
@@ -75,7 +87,6 @@ function routeToOpenApi(route, params) {
                 schema: factoryJsonSchema({
                     context: params.contextToJsonSchemaFactory,
                     resultSchemaContext: params.resultSchemaContext,
-                    mode: "in",
                     schema: primitiveSchema,
                 }),
             },
@@ -86,7 +97,6 @@ function routeToOpenApi(route, params) {
             ? factoryJsonSchema({
                 context: params.contextToJsonSchemaFactory,
                 resultSchemaContext: params.resultSchemaContext,
-                mode: "in",
                 schema: body,
             })
             : undefined;

package/dist/plugins/openApiGenerator/types/entrypoint.d.ts

@@ -10,12 +10,17 @@ export interface EntrypointContentBodyApplicationJson {
         schema: JsonSchema;
     };
 }
+export interface EntrypointContentBodyFormData {
+    "multipart/form-data": {
+        schema: JsonSchema;
+    };
+}
 export interface EntrypointContentBodyTextPlain {
     "text/plain": {
         schema: JsonSchema;
     };
 }
-export type EntrypointContentBody = EntrypointContentBodyApplicationJson | EntrypointContentBodyTextPlain;
+export type EntrypointContentBody = (EntrypointContentBodyApplicationJson | EntrypointContentBodyTextPlain | EntrypointContentBodyFormData);
 export interface EntrypointRequestBody {
     required: true;
     content: EntrypointContentBody;

package/dist/plugins/openApiGenerator/types/openApiMethod.d.ts

@@ -1 +1 @@
-export type OpenApiMethod = "get" | "post" | "put" | "delete" | "head" | "trace" | "connect" | "options";
+export type OpenApiMethod = "get" | "post" | "put" | "patch" | "delete" | "head" | "trace" | "connect" | "options";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duplojs/http",
-  "version": "0.6.2",
+  "version": "0.7.1",
   "author": "mathcovax",
   "license": "MIT",
   "type": "module",
@@ -65,8 +65,9 @@
     "README.md"
   ],
   "peerDependencies": {
-    "@duplojs/data-parser-tools": ">=0.2.4 <1.0.0",
-    "@duplojs/utils": ">=1.4.57 <2.0.0"
+    "@duplojs/data-parser-tools": ">=0.2.8 <1.0.0",
+    "@duplojs/server-utils": ">=0.2.0 <1.0.0",
+    "@duplojs/utils": ">=1.5.6 <2.0.0"
   },
   "devDependencies": {
     "@commitlint/cli": "19.8.1",
@@ -76,6 +77,7 @@
     "@types/bun": "^1.3.3",
     "@types/deno": "^2.5.0",
     "@types/node": "24.3.0",
+    "@types/web": "^0.0.317",
     "@vitest/coverage-istanbul": "3.2.4",
     "eslint": "9.34.0",
     "form-data": "^4.0.5",
@@ -98,8 +100,5 @@
   "keywords": [],
   "engines": {
     "node": ">=22.15.1"
-  },
-  "dependencies": {
-    "@types/web": "^0.0.317"
   }
 }

package/dist/core/request.mjs

@@ -1,32 +0,0 @@
-import { kindHeritage } from '@duplojs/utils';
-import { createCoreLibKind } from './kind.mjs';
-
-class Request extends kindHeritage("request", createCoreLibKind("request")) {
-    method;
-    headers;
-    url;
-    host;
-    origin;
-    path;
-    params;
-    query;
-    matchedPath;
-    body = undefined;
-    constructor({ method, headers, url, host, origin, path, params, query, matchedPath, ...rest }) {
-        super();
-        this.method = method;
-        this.headers = headers;
-        this.url = url;
-        this.host = host;
-        this.origin = origin;
-        this.path = path;
-        this.params = params;
-        this.query = query;
-        this.matchedPath = matchedPath;
-        for (const key in rest) {
-            this[key] = rest[key];
-        }
-    }
-}
-
-export { Request };

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

@@ -1,16 +0,0 @@
-'use strict';
-
-var utils = require('@duplojs/utils');
-var kind = require('../kind.cjs');
-
-class BodyParseUnknownError extends utils.kindHeritage("body-parse-unknown-error", kind.createInterfacesNodeLibKind("body-parse-unknown-error"), Error) {
-    contentType;
-    unknownError;
-    constructor(contentType, unknownError) {
-        super({}, [`Error when parsing body with '${contentType}' content-type.`]);
-        this.contentType = contentType;
-        this.unknownError = unknownError;
-    }
-}
-
-exports.BodyParseUnknownError = BodyParseUnknownError;

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

@@ -1,9 +0,0 @@
-declare const BodyParseUnknownError_base: new (params: {
-    "@DuplojsHttpInterfacesNode/body-parse-unknown-error"?: unknown;
-}, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpInterfacesNode/body-parse-unknown-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"body-parse-unknown-error", unknown>, unknown>;
-export declare class BodyParseUnknownError extends BodyParseUnknownError_base {
-    contentType: string;
-    unknownError: unknown;
-    constructor(contentType: string, unknownError: unknown);
-}
-export {};

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

@@ -1,14 +0,0 @@
-import { kindHeritage } from '@duplojs/utils';
-import { createInterfacesNodeLibKind } from '../kind.mjs';
-
-class BodyParseUnknownError extends kindHeritage("body-parse-unknown-error", createInterfacesNodeLibKind("body-parse-unknown-error"), Error) {
-    contentType;
-    unknownError;
-    constructor(contentType, unknownError) {
-        super({}, [`Error when parsing body with '${contentType}' content-type.`]);
-        this.contentType = contentType;
-        this.unknownError = unknownError;
-    }
-}
-
-export { BodyParseUnknownError };

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

@@ -1,8 +0,0 @@
-declare const BodyParseWrongChunkReceived_base: new (params: {
-    "@DuplojsHttpInterfacesNode/body-parse-wrong-chunk-received"?: unknown;
-}, parentParams: readonly [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

@@ -1,12 +0,0 @@
-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/hooks.cjs

@@ -1,126 +0,0 @@
-'use strict';
-
-require('../../core/route/index.cjs');
-var utils = require('@duplojs/utils');
-require('./error/index.cjs');
-require('../../core/response/index.cjs');
-var hooks = require('../../core/route/hooks.cjs');
-var predicted = require('../../core/response/predicted.cjs');
-var hook = require('../../core/response/hook.cjs');
-var bodySizeExceedsLimitError = require('./error/bodySizeExceedsLimitError.cjs');
-var bodyParseWrongChunkReceived = require('./error/bodyParseWrongChunkReceived.cjs');
-var bodyParseUnknownError = require('./error/bodyParseUnknownError.cjs');
-
-function makeNodeHook(hub, serverParams) {
-    const informationHeaderKey = serverParams.informationHeaderKey;
-    const predictedHeaderKey = serverParams.predictedHeaderKey;
-    const fromHookHeaderKey = serverParams.fromHookHeaderKey;
-    const isDev = hub.config.environment === "DEV";
-    const maxBodySize = utils.stringToBytes(serverParams.maxBodySize);
-    return hooks.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 }) {
-            if (!currentResponse.headers?.["content-type"]) {
-                const body = currentResponse.body;
-                if (typeof body === "string"
-                    || body instanceof Error) {
-                    currentResponse.setHeader("content-type", "text/plain; charset=utf-8");
-                }
-                else if (typeof body === "object"
-                    || typeof body === "number"
-                    || typeof body === "boolean") {
-                    currentResponse.setHeader("content-type", "application/json; charset=utf-8");
-                }
-            }
-            currentResponse.setHeader(informationHeaderKey, currentResponse.information);
-            if (currentResponse instanceof predicted.PredictedResponse) {
-                currentResponse.setHeader(predictedHeaderKey, "1");
-            }
-            else if (currentResponse instanceof hook.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"
-                || typeof body === "number"
-                || typeof body === "boolean") {
-                rawResponse.write(JSON.stringify(body));
-            }
-            else if (typeof body === "string") {
-                rawResponse.write(body);
-            }
-            rawResponse.end();
-            return exit();
-        },
-    });
-}
-
-exports.makeNodeHook = makeNodeHook;

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

@@ -1,8 +0,0 @@
-import { type HttpServerParams, type Hub } from "../../core/hub";
-import { HookResponse } from "../../core/response";
-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;
-};