@duplojs/http 0.2.0 → 0.4.0

package/dist/core/response/index.mjs

@@ -1,39 +1,4 @@
-import { kindHeritage, O } from '@duplojs/utils';
-import { createCoreLibKind } from '../kind.mjs';
+export { Response } from './base.mjs';
 export { ResponseContract } from './contract.mjs';
-
-class Response extends kindHeritage("response", createCoreLibKind("response")) {
-    code;
-    information;
-    body;
-    headers = undefined;
-    constructor(code, information, body) {
-        super();
-        this.code = code;
-        this.information = information;
-        this.body = body;
-    }
-    setHeaders(headers) {
-        this.headers = O.override(this.headers ?? {}, headers);
-        return this;
-    }
-    setHeader(key, header) {
-        if (!this.headers) {
-            this.headers = {};
-        }
-        if (typeof header !== "undefined") {
-            this.headers[key] = header;
-        }
-        return this;
-    }
-    deleteHeader(key) {
-        if (!this.headers) {
-            return this;
-        }
-        const { [key]: deleteHeader, ...rest } = this.headers;
-        this.headers = rest;
-        return this;
-    }
-}
-
-export { Response };
+export { HookResponse } from './hook.mjs';
+export { PredictedResponse } from './predicted.mjs';

package/dist/core/response/predicted.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+var kind = require('../kind.cjs');
+require('./index.cjs');
+var utils = require('@duplojs/utils');
+var base = require('./base.cjs');
+
+const defaultParamsParent = [undefined, undefined, undefined];
+const defaultParams = {};
+class PredictedResponse extends utils.kindHeritage("predicted-response", kind.createCoreLibKind("predicted-response"), base.Response) {
+    code;
+    information;
+    body;
+    constructor(code, information, body) {
+        super(defaultParams, defaultParamsParent);
+        this.code = code;
+        this.information = information;
+        this.body = body;
+    }
+}
+
+exports.PredictedResponse = PredictedResponse;

package/dist/core/response/predicted.d.ts

@@ -0,0 +1,11 @@
+import { type ResponseCode, Response } from "../response";
+declare const PredictedResponse_base: new (params: {
+    "@DuplojsHttpCore/predicted-response"?: unknown;
+}, parentParams: [code: any, information: any, body: any]) => Response<any, any, any> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/predicted-response", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"predicted-response", unknown>, unknown>;
+export declare class PredictedResponse<GenericCode extends ResponseCode = ResponseCode, GenericInformation extends string = string, GenericBody extends unknown = unknown> extends PredictedResponse_base {
+    code: GenericCode;
+    information: GenericInformation;
+    body: GenericBody;
+    constructor(code: GenericCode, information: GenericInformation, body: GenericBody);
+}
+export {};

package/dist/core/response/predicted.mjs

@@ -0,0 +1,20 @@
+import { createCoreLibKind } from '../kind.mjs';
+import './index.mjs';
+import { kindHeritage } from '@duplojs/utils';
+import { Response } from './base.mjs';
+
+const defaultParamsParent = [undefined, undefined, undefined];
+const defaultParams = {};
+class PredictedResponse extends kindHeritage("predicted-response", createCoreLibKind("predicted-response"), Response) {
+    code;
+    information;
+    body;
+    constructor(code, information, body) {
+        super(defaultParams, defaultParamsParent);
+        this.code = code;
+        this.information = information;
+        this.body = body;
+    }
+}
+
+export { PredictedResponse };

package/dist/core/route/{hooks/index.cjs → hooks.cjs}

@@ -1,7 +1,7 @@
 'use strict';
 
-var kind = require('../../kind.cjs');
-var response = require('./response.cjs');
+var kind = require('../kind.cjs');
+require('../response/index.cjs');
 
 const hookRouteExitKind = kind.createCoreLibKind("route-hook-exit");
 const hookRouteNextKind = kind.createCoreLibKind("route-hook-next");
@@ -15,7 +15,6 @@ function createHookRouteLifeCycle(...args) {
     };
 }
 
-exports.HookResponse = response.HookResponse;
 exports.createHookRouteLifeCycle = createHookRouteLifeCycle;
 exports.hookRouteExitKind = hookRouteExitKind;
 exports.hookRouteNextKind = hookRouteNextKind;

package/dist/core/route/{hooks/index.d.ts → hooks.d.ts}

@@ -1,8 +1,8 @@
-import { type Request } from "../../request";
+import { type Request } from "../request";
 import { type UnionToIntersection, type AnyFunction, type Kind, type MaybePromise, type SimplifyTopLevel, type IsEqual } from "@duplojs/utils";
-import { type HookResponse } from "./response";
-import { type ResponseCode, type Response } from "../../response";
-export * from "./response";
+import { type HookResponse } from "../response";
+import { type ResponseCode, type Response } from "../response";
+export * from "../response";
 export interface HookParamsOnConstructRequest {
     request: Request;
     addRequestProperties<GenericNewProperties extends Record<string, unknown>>(newProperties: GenericNewProperties): Request & GenericNewProperties;

package/dist/core/route/{hooks/index.mjs → hooks.mjs}

@@ -1,5 +1,5 @@
-import { createCoreLibKind } from '../../kind.mjs';
-export { HookResponse } from './response.mjs';
+import { createCoreLibKind } from '../kind.mjs';
+import '../response/index.mjs';
 
 const hookRouteExitKind = createCoreLibKind("route-hook-exit");
 const hookRouteNextKind = createCoreLibKind("route-hook-next");

package/dist/core/route/index.cjs

@@ -3,15 +3,15 @@
 var utils = require('@duplojs/utils');
 var kind = require('../kind.cjs');
 require('./types/index.cjs');
-var index = require('./hooks/index.cjs');
+var hooks = require('./hooks.cjs');
 
 const routeKind = kind.createCoreLibKind("route");
 function createRoute(definition) {
     return utils.pipe({ definition }, routeKind.setTo);
 }
 
-exports.createHookRouteLifeCycle = index.createHookRouteLifeCycle;
-exports.hookRouteExitKind = index.hookRouteExitKind;
-exports.hookRouteNextKind = index.hookRouteNextKind;
+exports.createHookRouteLifeCycle = hooks.createHookRouteLifeCycle;
+exports.hookRouteExitKind = hooks.hookRouteExitKind;
+exports.hookRouteNextKind = hooks.hookRouteNextKind;
 exports.createRoute = createRoute;
 exports.routeKind = routeKind;

package/dist/core/route/index.mjs

@@ -1,7 +1,7 @@
 import { pipe } from '@duplojs/utils';
 import { createCoreLibKind } from '../kind.mjs';
 import './types/index.mjs';
-export { createHookRouteLifeCycle, hookRouteExitKind, hookRouteNextKind } from './hooks/index.mjs';
+export { createHookRouteLifeCycle, hookRouteExitKind, hookRouteNextKind } from './hooks.mjs';
 
 const routeKind = createCoreLibKind("route");
 function createRoute(definition) {

package/dist/core/steps/cut.d.ts

@@ -2,16 +2,16 @@ import { type WrappedValue, type Kind, type MaybePromise, type NeverCoalescing }
 import { type StepKind } from "./kind";
 import { type Floor } from "../floor";
 import { type StepFunctionParams } from "./types";
-import { type Response, type ResponseContract } from "../response";
+import { type PredictedResponse, type ResponseContract } from "../response";
 import { type Request } from "../request";
 export declare const cutStepOutputKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/cut-output", unknown>>;
 export interface CutStepFunctionOutput<GenericData extends Record<string, unknown> = Record<string, unknown>> extends Kind<typeof cutStepOutputKind.definition>, WrappedValue<GenericData> {
 }
-export interface CutStepFunctionParams<GenericRequest extends Request = Request, GenericResponse extends Response = Response> extends StepFunctionParams<GenericRequest, GenericResponse> {
+export interface CutStepFunctionParams<GenericRequest extends Request = Request, GenericResponse extends PredictedResponse = PredictedResponse> extends StepFunctionParams<GenericRequest, GenericResponse> {
     output<GenericData extends Record<string, unknown> = never>(data?: GenericData): CutStepFunctionOutput<NeverCoalescing<GenericData, {}>>;
 }
 export interface CutStepDefinition {
-    theFunction(floor: Floor, params: CutStepFunctionParams): MaybePromise<CutStepFunctionOutput | Response>;
+    theFunction(floor: Floor, params: CutStepFunctionParams): MaybePromise<CutStepFunctionOutput | PredictedResponse>;
     readonly responseContract: ResponseContract.Contract | readonly ResponseContract.Contract[];
 }
 export declare const cutStepKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/cut-step", unknown>>;

package/dist/core/steps/handler.d.ts

@@ -1,13 +1,13 @@
 import { type MaybePromise, type Kind } from "@duplojs/utils";
 import { type StepKind } from "./kind";
 import { type Floor } from "../floor";
-import { type Response, type ResponseContract } from "../response";
+import { type PredictedResponse, type ResponseContract } from "../response";
 import { type Request } from "../request";
 import { type StepFunctionParams } from "./types";
-export interface HandlerStepFunctionParams<GenericRequest extends Request = Request, GenericResponse extends Response = Response> extends StepFunctionParams<GenericRequest, GenericResponse> {
+export interface HandlerStepFunctionParams<GenericRequest extends Request = Request, GenericResponse extends PredictedResponse = PredictedResponse> extends StepFunctionParams<GenericRequest, GenericResponse> {
 }
 export interface HandlerStepDefinition {
-    theFunction(floor: Floor, params: HandlerStepFunctionParams): MaybePromise<Response>;
+    theFunction(floor: Floor, params: HandlerStepFunctionParams): MaybePromise<PredictedResponse>;
     readonly responseContract: ResponseContract.Contract | readonly ResponseContract.Contract[];
 }
 export declare const handlerStepKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/handler-step", unknown>>;

package/dist/core/steps/identifier.d.ts

@@ -1,5 +1,5 @@
 import { type Kind } from "@duplojs/utils";
 export declare const stepIdentifier: {
-    <GenericKindHandler extends import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/checker-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/cut-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/extract-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/handler-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/presetChecker-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/process-step", unknown>>, GenericInput extends Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/step", unknown>, unknown>, GenericGroupedKind extends import("@duplojs/utils").UnionToIntersection<GenericKindHandler extends import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<string, unknown>> ? Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>>(kind: GenericKindHandler | GenericKindHandler[]): (input: GenericInput) => input is (import("@duplojs/utils").IsEqual<import("@duplojs/utils").IsEqual<false | (GenericInput extends any ? import("@duplojs/utils").IsEqual<GenericInput, Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/step", unknown>, unknown>> : never), boolean>, true> extends true ? Extract<import("./checker").CheckerStep<import("./checker").CheckerStepDefinition>, GenericGroupedKind> | Extract<import("./cut").CutStep<import("./cut").CutStepDefinition>, GenericGroupedKind> | Extract<import("./extract").ExtractStep<import("./extract").ExtractStepDefinition>, GenericGroupedKind> | Extract<import("./handler").HandlerStep<import("./handler").HandlerStepDefinition>, GenericGroupedKind> | Extract<import("./presetChecker").PresetCheckerStep<import("./presetChecker").PresetCheckerStepDefinition>, GenericGroupedKind> | Extract<import("./process").ProcessStep<import("./process").ProcessStepDefinition>, GenericGroupedKind> : never) | Extract<GenericInput, GenericGroupedKind>;
-    <GenericKindHandler extends import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/checker-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/cut-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/extract-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/handler-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/presetChecker-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/process-step", unknown>>, GenericInput extends Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/step", unknown>, unknown>, GenericGroupedKind extends import("@duplojs/utils").UnionToIntersection<GenericKindHandler extends import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<string, unknown>> ? Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>>(input: GenericInput, kind: GenericKindHandler | GenericKindHandler[]): input is (import("@duplojs/utils").IsEqual<import("@duplojs/utils").IsEqual<false | (GenericInput extends any ? import("@duplojs/utils").IsEqual<GenericInput, Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/step", unknown>, unknown>> : never), boolean>, true> extends true ? Extract<import("./checker").CheckerStep<import("./checker").CheckerStepDefinition>, GenericGroupedKind> | Extract<import("./cut").CutStep<import("./cut").CutStepDefinition>, GenericGroupedKind> | Extract<import("./extract").ExtractStep<import("./extract").ExtractStepDefinition>, GenericGroupedKind> | Extract<import("./handler").HandlerStep<import("./handler").HandlerStepDefinition>, GenericGroupedKind> | Extract<import("./presetChecker").PresetCheckerStep<import("./presetChecker").PresetCheckerStepDefinition>, GenericGroupedKind> | Extract<import("./process").ProcessStep<import("./process").ProcessStepDefinition>, GenericGroupedKind> : never) | Extract<GenericInput, GenericGroupedKind>;
+    <GenericKindHandler extends import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/checker-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/cut-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/extract-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/handler-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/presetChecker-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/process-step", unknown>>, GenericInput extends unknown, GenericGroupedKind extends import("@duplojs/utils").UnionToIntersection<GenericKindHandler extends import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<string, unknown>> ? Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>>(kind: GenericKindHandler | GenericKindHandler[]): (input: GenericInput) => input is (import("@duplojs/utils").IsEqual<import("@duplojs/utils").IsEqual<false | (GenericInput extends any ? import("@duplojs/utils").IsEqual<GenericInput, Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/step", unknown>, unknown>> : never), boolean>, true> extends true ? Extract<import("./checker").CheckerStep<import("./checker").CheckerStepDefinition>, GenericGroupedKind> | Extract<import("./cut").CutStep<import("./cut").CutStepDefinition>, GenericGroupedKind> | Extract<import("./extract").ExtractStep<import("./extract").ExtractStepDefinition>, GenericGroupedKind> | Extract<import("./handler").HandlerStep<import("./handler").HandlerStepDefinition>, GenericGroupedKind> | Extract<import("./presetChecker").PresetCheckerStep<import("./presetChecker").PresetCheckerStepDefinition>, GenericGroupedKind> | Extract<import("./process").ProcessStep<import("./process").ProcessStepDefinition>, GenericGroupedKind> : never) | Extract<GenericInput, GenericGroupedKind>;
+    <GenericKindHandler extends import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/checker-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/cut-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/extract-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/handler-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/presetChecker-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/process-step", unknown>>, GenericInput extends unknown, GenericGroupedKind extends import("@duplojs/utils").UnionToIntersection<GenericKindHandler extends import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<string, unknown>> ? Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>>(input: GenericInput, kind: GenericKindHandler | GenericKindHandler[]): input is (import("@duplojs/utils").IsEqual<import("@duplojs/utils").IsEqual<false | (GenericInput extends any ? import("@duplojs/utils").IsEqual<GenericInput, Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/step", unknown>, unknown>> : never), boolean>, true> extends true ? Extract<import("./checker").CheckerStep<import("./checker").CheckerStepDefinition>, GenericGroupedKind> | Extract<import("./cut").CutStep<import("./cut").CutStepDefinition>, GenericGroupedKind> | Extract<import("./extract").ExtractStep<import("./extract").ExtractStepDefinition>, GenericGroupedKind> | Extract<import("./handler").HandlerStep<import("./handler").HandlerStepDefinition>, GenericGroupedKind> | Extract<import("./presetChecker").PresetCheckerStep<import("./presetChecker").PresetCheckerStepDefinition>, GenericGroupedKind> | Extract<import("./process").ProcessStep<import("./process").ProcessStepDefinition>, GenericGroupedKind> : never) | Extract<GenericInput, GenericGroupedKind>;
 };

package/dist/core/steps/types/stepFunctionParams.d.ts

@@ -1,7 +1,7 @@
 import { type Request } from "../../request";
-import { type Response } from "../../response";
+import { type PredictedResponse } from "../../response";
 import { type IsEqual, type Or } from "@duplojs/utils";
-export interface StepFunctionParams<GenericRequest extends Request = Request, GenericResponse extends Response = Response> {
+export interface StepFunctionParams<GenericRequest extends Request = Request, GenericResponse extends PredictedResponse = PredictedResponse> {
     request: GenericRequest;
     response<GenericInformation extends GenericResponse["information"], GenericFilteredResponse extends Extract<GenericResponse, {
         information: GenericInformation;

package/dist/core/types/forbiddenBigintDataParser.cjs

@@ -0,0 +1,2 @@
+'use strict';
+

package/dist/core/types/forbiddenBigintDataParser.d.ts

@@ -0,0 +1,6 @@
+import { type DP } from "@duplojs/utils";
+declare const SymbolForbiddenBigintDataParser: unique symbol;
+export type ForbiddenBigintDataParser<GenericDataParser extends DP.DataParser> = DP.Contain<GenericDataParser, DP.DataParserBigInt<any>> extends true ? {
+    [SymbolForbiddenBigintDataParser]: "Bigint dataParser is not supported.";
+} : unknown;
+export {};

package/dist/core/types/forbiddenBigintDataParser.mjs

@@ -0,0 +1 @@
+

package/dist/core/types/index.cjs

@@ -1,4 +1,5 @@
 'use strict';
 
 require('./environment.cjs');
+require('./forbiddenBigintDataParser.cjs');
 

package/dist/core/types/index.d.ts

@@ -1 +1,2 @@
 export * from "./environment";
+export * from "./forbiddenBigintDataParser";

package/dist/core/types/index.mjs

@@ -1 +1,2 @@
 import './environment.mjs';
+import './forbiddenBigintDataParser.mjs';

package/dist/interfaces/node/createHttpServer.cjs

@@ -13,6 +13,7 @@ async function createHttpServer(inputHub, params) {
         ...params,
         maxBodySize: "50mb",
         informationHeaderKey: "information",
+        predictedHeaderKey: "predicted",
         fromHookHeaderKey: "from-hook",
         interface: "node",
     };

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

@@ -10,6 +10,7 @@ declare module "../../core/hub" {
         readonly port: number;
         readonly maxBodySize: BytesInString | number;
         readonly informationHeaderKey: string;
+        readonly predictedHeaderKey: string;
         readonly fromHookHeaderKey: string;
         readonly http?: http.ServerOptions;
         readonly https?: https.ServerOptions;
@@ -19,5 +20,5 @@ declare module "../../core/hub" {
         readonly serverResponse: http.ServerResponse;
     }
 }
-export type CreateHttpServerParams = O.PartialKeys<Omit<HttpServerParams, "interface">, "maxBodySize" | "informationHeaderKey" | "fromHookHeaderKey">;
+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>>;

package/dist/interfaces/node/createHttpServer.mjs

@@ -11,6 +11,7 @@ async function createHttpServer(inputHub, params) {
         ...params,
         maxBodySize: "50mb",
         informationHeaderKey: "information",
+        predictedHeaderKey: "predicted",
         fromHookHeaderKey: "from-hook",
         interface: "node",
     };

package/dist/interfaces/node/hooks.cjs

@@ -3,18 +3,20 @@
 require('../../core/route/index.cjs');
 var utils = require('@duplojs/utils');
 require('./error/index.cjs');
-var index = require('../../core/route/hooks/index.cjs');
-var response = require('../../core/route/hooks/response.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 index.createHookRouteLifeCycle({
+    return hooks.createHookRouteLifeCycle({
         async parseBody({ request, exit }) {
             const contentType = request.headers["content-type"] instanceof Array
                 ? request.headers["content-type"].join(", ")
@@ -79,17 +81,20 @@ function makeNodeHook(hub, serverParams) {
         },
         beforeSendResponse({ request, currentResponse, exit }) {
             const body = currentResponse.body;
-            if (typeof body === "number"
-                || typeof body === "string"
-                || body === null
+            if (typeof body === "string"
                 || body instanceof Error) {
                 currentResponse.setHeader("content-type", "text/plain; charset=utf-8");
             }
-            else if (typeof body === "object") {
+            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 response.HookResponse) {
+            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);
@@ -101,16 +106,14 @@ function makeNodeHook(hub, serverParams) {
             if (body instanceof Error) {
                 rawResponse.write(body.toString());
             }
-            else if (typeof body === "object") {
+            else if (typeof body === "object"
+                || typeof body === "number"
+                || typeof body === "boolean") {
                 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();
         },

package/dist/interfaces/node/hooks.mjs

@@ -1,14 +1,16 @@
 import '../../core/route/index.mjs';
 import { stringToBytes } from '@duplojs/utils';
 import './error/index.mjs';
-import { createHookRouteLifeCycle } from '../../core/route/hooks/index.mjs';
-import { HookResponse } from '../../core/route/hooks/response.mjs';
+import { createHookRouteLifeCycle } from '../../core/route/hooks.mjs';
+import { PredictedResponse } from '../../core/response/predicted.mjs';
+import { HookResponse } from '../../core/response/hook.mjs';
 import { BodySizeExceedsLimitError } from './error/bodySizeExceedsLimitError.mjs';
 import { BodyParseWrongChunkReceived } from './error/bodyParseWrongChunkReceived.mjs';
 import { BodyParseUnknownError } from './error/bodyParseUnknownError.mjs';
 
 function makeNodeHook(hub, serverParams) {
     const informationHeaderKey = serverParams.informationHeaderKey;
+    const predictedHeaderKey = serverParams.predictedHeaderKey;
     const fromHookHeaderKey = serverParams.fromHookHeaderKey;
     const isDev = hub.config.environment === "DEV";
     const maxBodySize = stringToBytes(serverParams.maxBodySize);
@@ -77,17 +79,20 @@ function makeNodeHook(hub, serverParams) {
         },
         beforeSendResponse({ request, currentResponse, exit }) {
             const body = currentResponse.body;
-            if (typeof body === "number"
-                || typeof body === "string"
-                || body === null
+            if (typeof body === "string"
                 || body instanceof Error) {
                 currentResponse.setHeader("content-type", "text/plain; charset=utf-8");
             }
-            else if (typeof body === "object") {
+            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 HookResponse) {
+            if (currentResponse instanceof PredictedResponse) {
+                currentResponse.setHeader(predictedHeaderKey, "1");
+            }
+            else if (currentResponse instanceof HookResponse) {
                 currentResponse.setHeader(fromHookHeaderKey, currentResponse.fromHook);
             }
             request.raw.response.writeHead(Number(currentResponse.code), currentResponse.headers);
@@ -99,16 +104,14 @@ function makeNodeHook(hub, serverParams) {
             if (body instanceof Error) {
                 rawResponse.write(body.toString());
             }
-            else if (typeof body === "object") {
+            else if (typeof body === "object"
+                || typeof body === "number"
+                || typeof body === "boolean") {
                 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();
         },

package/dist/plugins/codeGenerator/index.cjs

@@ -9,8 +9,5 @@ var stepsToDataParser = require('./stepsToDataParser.cjs');
 
 
 exports.codeGeneratorPlugin = plugin.codeGeneratorPlugin;
-exports.digitDataParser = routeToDataParser.digitDataParser;
-exports.responseCodeDataParser = routeToDataParser.responseCodeDataParser;
-exports.responseCodeDataParsers = routeToDataParser.responseCodeDataParsers;
 exports.routeToDataParser = routeToDataParser.routeToDataParser;
 exports.stepsToDataParser = stepsToDataParser.stepsToDataParser;

package/dist/plugins/codeGenerator/index.mjs

@@ -1,5 +1,5 @@
 import '@duplojs/data-parser-tools/toTypescript';
 import './types/index.mjs';
 export { codeGeneratorPlugin } from './plugin.mjs';
-export { digitDataParser, responseCodeDataParser, responseCodeDataParsers, routeToDataParser } from './routeToDataParser.mjs';
+export { routeToDataParser } from './routeToDataParser.mjs';
 export { stepsToDataParser } from './stepsToDataParser.mjs';

package/dist/plugins/codeGenerator/plugin.cjs

@@ -31,7 +31,7 @@ function codeGeneratorPlugin(pluginParams) {
             {
                 beforeStartServer: async (hub) => {
                     const routes = hub.aggregatesRoutes();
-                    const dataParserRoutes = utils.A.map(routes, (route) => routeToDataParser.routeToDataParser(route, {
+                    const dataParserRoutes = utils.A.flatMap(routes, (route) => routeToDataParser.routeToDataParser(route, {
                         defaultExtractContract: hub.defaultExtractContract,
                     }));
                     if (!utils.A.minElements(dataParserRoutes, 1)) {

package/dist/plugins/codeGenerator/plugin.mjs

@@ -10,7 +10,7 @@ function codeGeneratorPlugin(pluginParams) {
             {
                 beforeStartServer: async (hub) => {
                     const routes = hub.aggregatesRoutes();
-                    const dataParserRoutes = A.map(routes, (route) => routeToDataParser(route, {
+                    const dataParserRoutes = A.flatMap(routes, (route) => routeToDataParser(route, {
                         defaultExtractContract: hub.defaultExtractContract,
                     }));
                     if (!A.minElements(dataParserRoutes, 1)) {

package/dist/plugins/codeGenerator/routeToDataParser.cjs

@@ -3,41 +3,6 @@
 var stepsToDataParser = require('./stepsToDataParser.cjs');
 var utils = require('@duplojs/utils');
 
-const digitDataParser = utils.DP.literal(["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"]).setIdentifier("Digit");
-const responseCodeDataParsers = {
-    information: utils.DP.templateLiteral([
-        "1",
-        digitDataParser,
-        digitDataParser,
-    ]),
-    success: utils.DP.templateLiteral([
-        "2",
-        digitDataParser,
-        digitDataParser,
-    ]),
-    redirection: utils.DP.templateLiteral([
-        "3",
-        digitDataParser,
-        digitDataParser,
-    ]),
-    clientError: utils.DP.templateLiteral([
-        "4",
-        digitDataParser,
-        digitDataParser,
-    ]),
-    serverError: utils.DP.templateLiteral([
-        "5",
-        digitDataParser,
-        digitDataParser,
-    ]),
-};
-const responseCodeDataParser = utils.DP.union([
-    responseCodeDataParsers.information,
-    responseCodeDataParsers.success,
-    responseCodeDataParsers.redirection,
-    responseCodeDataParsers.clientError,
-    responseCodeDataParsers.serverError,
-]).setIdentifier("ResponseCode");
 function routeToDataParser(route, params) {
     return utils.pipe([
         ...route.definition.preflightSteps,
@@ -52,28 +17,12 @@ function routeToDataParser(route, params) {
             return select(utils.O.entry(key, utils.DP.object(value)));
         }
         return skip();
-    }), utils.O.fromEntries)), ({ endpointContract, entrypointContract }) => utils.DP.object({
+    }), utils.O.fromEntries)), ({ endpointContract, entrypointContract }) => utils.A.map(route.definition.paths, (path) => utils.DP.object({
         method: utils.DP.literal(route.definition.method),
-        path: utils.DP.literal(route.definition.paths),
+        path: utils.DP.literal(path),
         ...entrypointContract,
-        responses: utils.DP.union([
-            utils.DP.object({
-                code: responseCodeDataParser,
-                information: utils.DP.string(),
-                body: utils.DP.unknown(),
-                fromHook: utils.DP.literal(true),
-            }),
-            utils.DP.object({
-                code: responseCodeDataParsers.serverError,
-                information: utils.DP.string(),
-                body: utils.DP.unknown(),
-            }),
-            ...endpointContract,
-        ]),
-    }));
+        responses: utils.DP.union(endpointContract),
+    })));
 }
 
-exports.digitDataParser = digitDataParser;
-exports.responseCodeDataParser = responseCodeDataParser;
-exports.responseCodeDataParsers = responseCodeDataParsers;
 exports.routeToDataParser = routeToDataParser;