@duplojs/http 0.7.4 → 0.8.5

package/dist/core/request/bodyController/base.mjs

@@ -1,24 +1,41 @@
 import { createCoreLibKind } from '../../kind.mjs';
-import { E } from '@duplojs/utils';
+import { kindHeritage, E, unwrap } from '@duplojs/utils';
 
 const bodyReaderKind = createCoreLibKind("body-reader");
 const bodyReaderImplementationKind = createCoreLibKind("body-reader-implementation");
 const bodyControllerKind = createCoreLibKind("body-controller");
 const bodyControllerHandlerKind = createCoreLibKind("body-controller-handler");
+class WrongBodyReaderImplementationError extends kindHeritage("wrong-body-reader-implementation", createCoreLibKind("wrong-body-reader-implementation"), Error) {
+    controllerName;
+    bodyReaderImplementation;
+    constructor(controllerName, bodyReaderImplementation) {
+        super({}, ["Received wrong body reader implementation."]);
+        this.controllerName = controllerName;
+        this.bodyReaderImplementation = bodyReaderImplementation;
+    }
+}
 function createBodyController(name) {
     return bodyControllerHandlerKind.setTo({
         name,
         create(params) {
+            function tryToCreateReader(readerImplementation) {
+                if (bodyReaderImplementationKind.getValue(readerImplementation) !== name) {
+                    return E.fail();
+                }
+                return E.success(bodyReaderKind.setTo({
+                    read: (request) => readerImplementation.read(request, params),
+                }, name));
+            }
             return bodyControllerKind.setTo({
                 name,
                 params,
-                tryToCreateReader(readerImplementation) {
-                    if (bodyReaderImplementationKind.getValue(readerImplementation) !== name) {
-                        return E.fail();
+                tryToCreateReader,
+                createReaderOrThrow(readerImplementation) {
+                    const result = tryToCreateReader(readerImplementation);
+                    if (E.isLeft(result)) {
+                        throw new WrongBodyReaderImplementationError(name, readerImplementation);
                     }
-                    return E.success(bodyReaderKind.setTo({
-                        read: (request) => readerImplementation.read(request, params),
-                    }, name));
+                    return unwrap(result);
                 },
             }, name);
         },
@@ -31,4 +48,4 @@ function createBodyController(name) {
     });
 }
 
-export { createBodyController };
+export { WrongBodyReaderImplementationError, createBodyController };

package/dist/core/request/bodyController/empty.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var base = require('./base.cjs');
+
+const EmptyBodyController = base.createBodyController("empty");
+function controlBodyAsEmpty() {
+    return EmptyBodyController.create({});
+}
+
+exports.EmptyBodyController = EmptyBodyController;
+exports.controlBodyAsEmpty = controlBodyAsEmpty;

package/dist/core/request/bodyController/empty.d.ts

@@ -0,0 +1,3 @@
+export declare const EmptyBodyController: import("./base").BodyControllerHandler<"empty", {}>;
+export type EmptyBodyController = typeof EmptyBodyController;
+export declare function controlBodyAsEmpty(): import("./base").BodyController<"empty", {}>;

package/dist/core/request/bodyController/empty.mjs

@@ -0,0 +1,8 @@
+import { createBodyController } from './base.mjs';
+
+const EmptyBodyController = createBodyController("empty");
+function controlBodyAsEmpty() {
+    return EmptyBodyController.create({});
+}
+
+export { EmptyBodyController, controlBodyAsEmpty };

package/dist/core/request/bodyController/formData.cjs

@@ -9,6 +9,7 @@ function controlBodyAsFormData(params) {
         maxFileQuantity: params.maxFileQuantity,
         bodyMaxSize: params.bodyMaxSize && utils.stringToBytes(params.bodyMaxSize),
         fileMaxSize: params.fileMaxSize && utils.stringToBytes(params.fileMaxSize),
+        textFieldMaxSize: params.textFieldMaxSize && utils.stringToBytes(params.textFieldMaxSize),
         mimeType: params.mimeType !== undefined
             ? utils.toRegExp(params.mimeType)
             : undefined,

package/dist/core/request/bodyController/formData.d.ts

@@ -1,9 +1,10 @@
-import { type BytesInString } from "@duplojs/utils";
+import { type AnyTuple, type BytesInString } from "@duplojs/utils";
 import { type BodyControllerParams } from "./base";
 export interface FormDataBodyReaderParams extends BodyControllerParams {
     maxFileQuantity: number;
     mimeType?: RegExp;
     fileMaxSize?: number;
+    textFieldMaxSize?: number;
     maxBufferSize: number;
     maxIndexArray: number;
     maxKeyLength: number;
@@ -12,9 +13,10 @@ export declare const FormDataBodyController: import("./base").BodyControllerHand
 export type FormDataBodyController = typeof FormDataBodyController;
 export interface ControlBodyAsFormDataParams {
     maxFileQuantity: number;
-    mimeType?: string | string[] | RegExp;
+    mimeType?: string | AnyTuple<string> | RegExp;
     bodyMaxSize?: number | BytesInString;
     fileMaxSize?: number | BytesInString;
+    textFieldMaxSize?: number | BytesInString;
     maxBufferSize?: number | BytesInString;
     maxIndexArray?: number;
     maxKeyLength?: number;

package/dist/core/request/bodyController/formData.mjs

@@ -7,6 +7,7 @@ function controlBodyAsFormData(params) {
         maxFileQuantity: params.maxFileQuantity,
         bodyMaxSize: params.bodyMaxSize && stringToBytes(params.bodyMaxSize),
         fileMaxSize: params.fileMaxSize && stringToBytes(params.fileMaxSize),
+        textFieldMaxSize: params.textFieldMaxSize && stringToBytes(params.textFieldMaxSize),
         mimeType: params.mimeType !== undefined
             ? toRegExp(params.mimeType)
             : undefined,

package/dist/core/request/bodyController/index.cjs

@@ -3,11 +3,15 @@
 var base = require('./base.cjs');
 var formData = require('./formData.cjs');
 var text = require('./text.cjs');
+var empty = require('./empty.cjs');
 
 
 
+exports.WrongBodyReaderImplementationError = base.WrongBodyReaderImplementationError;
 exports.createBodyController = base.createBodyController;
 exports.FormDataBodyController = formData.FormDataBodyController;
 exports.controlBodyAsFormData = formData.controlBodyAsFormData;
 exports.TextBodyController = text.TextBodyController;
 exports.controlBodyAsText = text.controlBodyAsText;
+exports.EmptyBodyController = empty.EmptyBodyController;
+exports.controlBodyAsEmpty = empty.controlBodyAsEmpty;

package/dist/core/request/bodyController/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./base";
 export * from "./formData";
 export * from "./text";
+export * from "./empty";

package/dist/core/request/bodyController/index.mjs

@@ -1,3 +1,4 @@
-export { createBodyController } from './base.mjs';
+export { WrongBodyReaderImplementationError, createBodyController } from './base.mjs';
 export { FormDataBodyController, controlBodyAsFormData } from './formData.mjs';
 export { TextBodyController, controlBodyAsText } from './text.mjs';
+export { EmptyBodyController, controlBodyAsEmpty } from './empty.mjs';

package/dist/core/request/index.cjs

@@ -45,6 +45,11 @@ class Request extends utils.kindHeritage("request", kind.createCoreLibKind("requ
             externalPromise.resolve(result);
             this.bodyResult = result;
             return result;
+        })
+            .catch((error) => {
+            const result = utils.E.error(error);
+            externalPromise.resolve(result);
+            return result;
         });
     }
 }

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

@@ -1,4 +1,4 @@
-import { type E, type MaybePromise } from "@duplojs/utils";
+import { E, type MaybePromise } from "@duplojs/utils";
 import { type GetPropsWithValue } from "@duplojs/utils/object";
 import { type BodyReader } from "./bodyController";
 export * from "./bodyController";

package/dist/core/request/index.mjs

@@ -1,4 +1,4 @@
-import { kindHeritage, createExternalPromise } from '@duplojs/utils';
+import { kindHeritage, createExternalPromise, E } from '@duplojs/utils';
 import { createCoreLibKind } from '../kind.mjs';
 import './bodyController/index.mjs';
 
@@ -43,6 +43,11 @@ class Request extends kindHeritage("request", createCoreLibKind("request")) {
             externalPromise.resolve(result);
             this.bodyResult = result;
             return result;
+        })
+            .catch((error) => {
+            const result = E.error(error);
+            externalPromise.resolve(result);
+            return result;
         });
     }
 }

package/dist/core/response/contract.cjs

@@ -78,13 +78,26 @@ exports.ResponseContract = void 0;
     ResponseContract.loopDetected = createContractBuilder("508", { defaultSchema });
     ResponseContract.notExtended = createContractBuilder("510", { defaultSchema });
     ResponseContract.networkAuthenticationRequired = createContractBuilder("511", { defaultSchema });
+    ResponseContract.serverSentEventsContractKind = kind.createCoreLibKind("server-sent-events-response-contract");
+    function serverSentEvents(information, mainEventSchema, events = {}) {
+        return ResponseContract.serverSentEventsContractKind.setTo({
+            code: "200",
+            information,
+            events: {
+                ...events,
+                message: mainEventSchema,
+            },
+            body: defaultSchema,
+        });
+    }
+    ResponseContract.serverSentEvents = serverSentEvents;
     class Error extends utils.kindHeritage("contract-error", kind.createCoreLibKind("contract-error"), ErrorClass) {
         information;
-        dataParserError;
-        constructor(information, dataParserError) {
-            super({}, [`Error executing the response contract with the information: "${information}".`]);
+        detail;
+        constructor(information, detail) {
+            super({}, [`Error executing the response contract with the information: "${information}"`]);
             this.information = information;
-            this.dataParserError = dataParserError;
+            this.detail = detail;
         }
     }
     ResponseContract.Error = Error;

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

@@ -1,5 +1,5 @@
 import { DP, type Kind, type NeverCoalescing } from "@duplojs/utils";
-import { type ResponseCode, type PredictedResponse } from ".";
+import { type ResponseCode, type PredictedResponse, type ServerSentEventsPredictedResponse, type SuccessResponseCode } from ".";
 import { type ForbiddenBigintDataParser } from "../types";
 export declare namespace ResponseContract {
     type SupportedDataParser = DP.DataParser;
@@ -9,7 +9,6 @@ export declare namespace ResponseContract {
         information: GenericInformation;
         body: GenericSchema;
     }
-    export type Convert<GenericContract extends Contract> = GenericContract extends Contract ? PredictedResponse<GenericContract["code"], GenericContract["information"], DP.Input<GenericContract["body"]>> : never;
     export const http100Continue: <GenericInformation extends string, GenericSchema extends SupportedDataParser = DP.DataParserEmpty<{
         readonly errorMessage?: string | undefined;
         readonly coerce: boolean;
@@ -281,13 +280,29 @@ export declare namespace ResponseContract {
         readonly coerce: boolean;
         readonly checkers: readonly [];
     }>>(information: GenericInformation, schema?: (GenericSchema & ForbiddenBigintDataParser<GenericSchema>) | undefined) => NoInfer<Contract<"511", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
+    export const serverSentEventsContractKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/server-sent-events-response-contract", unknown>>;
+    export interface ServerSentEventsContract<GenericCode extends SuccessResponseCode = SuccessResponseCode, GenericInformation extends string = string, GenericEvents extends Record<string, SupportedDataParser> = Record<string, SupportedDataParser>, GenericSchema extends SupportedDataParser = SupportedDataParser> extends Kind<typeof serverSentEventsContractKind.definition> {
+        code: GenericCode;
+        information: GenericInformation;
+        events: GenericEvents;
+        body: GenericSchema;
+    }
+    export function serverSentEvents<GenericInformation extends string, GenericMainEventSchema extends SupportedDataParser, GenericEvents extends Record<string, SupportedDataParser> = {}>(information: GenericInformation, mainEventSchema: GenericMainEventSchema, events?: GenericEvents): ServerSentEventsContract<"200", GenericInformation, GenericEvents & {
+        message: GenericMainEventSchema;
+    }>;
+    export type Convert<GenericContract extends Contract | ServerSentEventsContract> = GenericContract extends Contract ? PredictedResponse<GenericContract["code"], GenericContract["information"], DP.Input<GenericContract["body"]>> : GenericContract extends ServerSentEventsContract ? ServerSentEventsPredictedResponse<GenericContract["code"], GenericContract["information"], {
+        [Prop in keyof GenericContract["events"]]: [
+            Extract<Prop, string>,
+            DP.Output<GenericContract["events"][Prop]>
+        ];
+    }[keyof GenericContract["events"]]> : never;
     const Error_base: new (params: {
         "@DuplojsHttpCore/contract-error"?: unknown;
     }, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => globalThis.Error & Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/contract-error", unknown>, unknown> & Kind<import("@duplojs/utils").KindDefinition<"contract-error", unknown>, unknown>;
     export class Error extends Error_base {
         information: string;
-        dataParserError?: DP.DataParserError | undefined;
-        constructor(information: string, dataParserError?: DP.DataParserError | undefined);
+        detail: DP.DataParserError | string;
+        constructor(information: string, detail: DP.DataParserError | string);
     }
     export {};
 }

package/dist/core/response/contract.mjs

@@ -76,13 +76,26 @@ var ResponseContract;
     ResponseContract.loopDetected = createContractBuilder("508", { defaultSchema });
     ResponseContract.notExtended = createContractBuilder("510", { defaultSchema });
     ResponseContract.networkAuthenticationRequired = createContractBuilder("511", { defaultSchema });
+    ResponseContract.serverSentEventsContractKind = createCoreLibKind("server-sent-events-response-contract");
+    function serverSentEvents(information, mainEventSchema, events = {}) {
+        return ResponseContract.serverSentEventsContractKind.setTo({
+            code: "200",
+            information,
+            events: {
+                ...events,
+                message: mainEventSchema,
+            },
+            body: defaultSchema,
+        });
+    }
+    ResponseContract.serverSentEvents = serverSentEvents;
     class Error extends kindHeritage("contract-error", createCoreLibKind("contract-error"), ErrorClass) {
         information;
-        dataParserError;
-        constructor(information, dataParserError) {
-            super({}, [`Error executing the response contract with the information: "${information}".`]);
+        detail;
+        constructor(information, detail) {
+            super({}, [`Error executing the response contract with the information: "${information}"`]);
             this.information = information;
-            this.dataParserError = dataParserError;
+            this.detail = detail;
         }
     }
     ResponseContract.Error = Error;

package/dist/core/response/index.cjs

@@ -4,6 +4,7 @@ var base = require('./base.cjs');
 var contract = require('./contract.cjs');
 var hook = require('./hook.cjs');
 var predicted = require('./predicted.cjs');
+var serverSentEventsPredicted = require('./serverSentEventsPredicted.cjs');
 
 
 
@@ -14,3 +15,4 @@ Object.defineProperty(exports, "ResponseContract", {
 });
 exports.HookResponse = hook.HookResponse;
 exports.PredictedResponse = predicted.PredictedResponse;
+exports.ServerSentEventsPredictedResponse = serverSentEventsPredicted.ServerSentEventsPredictedResponse;

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

@@ -2,3 +2,4 @@ export * from "./base";
 export * from "./contract";
 export * from "./hook";
 export * from "./predicted";
+export * from "./serverSentEventsPredicted";

package/dist/core/response/index.mjs

@@ -2,3 +2,4 @@ export { Response } from './base.mjs';
 export { ResponseContract } from './contract.mjs';
 export { HookResponse } from './hook.mjs';
 export { PredictedResponse } from './predicted.mjs';
+export { ServerSentEventsPredictedResponse } from './serverSentEventsPredicted.mjs';

package/dist/core/response/serverSentEventsPredicted.cjs

@@ -0,0 +1,23 @@
+'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 ServerSentEventsPredictedResponse extends utils.kindHeritage("server-sent-events-predicted-response", kind.createCoreLibKind("server-sent-events-predicted-response"), base.Response) {
+    startSendingEvents;
+    code;
+    information;
+    body = undefined;
+    constructor(code, information, startSendingEvents) {
+        super(defaultParams, defaultParamsParent);
+        this.startSendingEvents = startSendingEvents;
+        this.code = code;
+        this.information = information;
+    }
+}
+
+exports.ServerSentEventsPredictedResponse = ServerSentEventsPredictedResponse;

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

@@ -0,0 +1,14 @@
+import { Response, type SuccessResponseCode } from "../response";
+import { type ServerSentEvents } from "../serverSentEvents";
+import { type MaybePromise } from "@duplojs/utils";
+declare const ServerSentEventsPredictedResponse_base: new (params: {
+    "@DuplojsHttpCore/server-sent-events-predicted-response"?: unknown;
+}, parentParams: readonly [code: any, information: any, body: any]) => Response<any, any, any> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/server-sent-events-predicted-response", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"server-sent-events-predicted-response", unknown>, unknown>;
+export declare class ServerSentEventsPredictedResponse<GenericCode extends SuccessResponseCode = SuccessResponseCode, GenericInformation extends string = string, GenericEvents extends ServerSentEvents.DefinitionShape = ServerSentEvents.DefinitionShape> extends ServerSentEventsPredictedResponse_base {
+    startSendingEvents: (params: ServerSentEvents.StartSendingParams<GenericEvents>) => MaybePromise<void>;
+    code: GenericCode;
+    information: GenericInformation;
+    body: undefined;
+    constructor(code: GenericCode, information: GenericInformation, startSendingEvents: (params: ServerSentEvents.StartSendingParams<GenericEvents>) => MaybePromise<void>);
+}
+export {};

package/dist/core/response/serverSentEventsPredicted.mjs

@@ -0,0 +1,21 @@
+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 ServerSentEventsPredictedResponse extends kindHeritage("server-sent-events-predicted-response", createCoreLibKind("server-sent-events-predicted-response"), Response) {
+    startSendingEvents;
+    code;
+    information;
+    body = undefined;
+    constructor(code, information, startSendingEvents) {
+        super(defaultParams, defaultParamsParent);
+        this.startSendingEvents = startSendingEvents;
+        this.code = code;
+        this.information = information;
+    }
+}
+
+export { ServerSentEventsPredictedResponse };

package/dist/core/route/hooks.cjs

@@ -13,7 +13,16 @@ function createHookRouteLifeCycle(...args) {
         onConstructRequest: args[0],
     };
 }
+function hookRouteLifeCycleAddRequestProperties(request) {
+    return (newProperties) => {
+        for (const key in newProperties) {
+            request[key] = newProperties[key];
+        }
+        return request;
+    };
+}
 
 exports.createHookRouteLifeCycle = createHookRouteLifeCycle;
 exports.hookRouteExitKind = hookRouteExitKind;
+exports.hookRouteLifeCycleAddRequestProperties = hookRouteLifeCycleAddRequestProperties;
 exports.hookRouteNextKind = hookRouteNextKind;

package/dist/core/route/hooks.d.ts

@@ -1,5 +1,5 @@
 import { type Request } from "../request";
-import { type UnionToIntersection, type AnyFunction, type Kind, type MaybePromise, type SimplifyTopLevel, type IsEqual } from "@duplojs/utils";
+import { type UnionToIntersection, type AnyFunction, type Kind, type MaybePromise, type SimplifyTopLevel, type IsEqual, type BivariantFunction } from "@duplojs/utils";
 import { type HookResponse } from "../response";
 import { type ResponseCode, type Response } from "../response";
 export interface HookParamsOnConstructRequest {
@@ -38,17 +38,18 @@ export type HookBeforeSendResponse<GenericRequest extends Request = Request> = (
 export type HookSendResponse<GenericRequest extends Request = Request> = (params: RouteHookParamsAfter<GenericRequest>) => MaybePromise<RouteHookExit | RouteHookNext>;
 export type HookAfterSendResponse<GenericRequest extends Request = Request> = (params: RouteHookParamsAfter<GenericRequest>) => MaybePromise<RouteHookExit | RouteHookNext>;
 export interface HookRouteLifeCycle<GenericRequest extends Request = Request> {
-    onConstructRequest?: HookOnConstructRequest<GenericRequest>;
-    beforeRouteExecution?: HookBeforeRouteExecution<GenericRequest>;
+    onConstructRequest?: BivariantFunction<HookOnConstructRequest<GenericRequest>>;
+    beforeRouteExecution?: BivariantFunction<HookBeforeRouteExecution<GenericRequest>>;
     error?: HookError;
-    beforeSendResponse?: HookBeforeSendResponse<GenericRequest>;
-    sendResponse?: HookSendResponse<GenericRequest>;
-    afterSendResponse?: HookAfterSendResponse<GenericRequest>;
+    beforeSendResponse?: BivariantFunction<HookBeforeSendResponse<GenericRequest>>;
+    sendResponse?: BivariantFunction<HookSendResponse<GenericRequest>>;
+    afterSendResponse?: BivariantFunction<HookAfterSendResponse<GenericRequest>>;
 }
-export declare function createHookRouteLifeCycle<GenericHookLiveCycle extends Omit<HookRouteLifeCycle, "onConstructRequest">>(hookRouteLifeCycle: GenericHookLiveCycle): GenericHookLiveCycle;
-export declare function createHookRouteLifeCycle<GenericOnConstructRequest extends HookOnConstructRequest, GenericHookLiveCycle extends Omit<HookRouteLifeCycle<Awaited<ReturnType<GenericOnConstructRequest>>>, "onConstructRequest">>(onConstructRequest: GenericOnConstructRequest, hookRouteLifeCycle: GenericHookLiveCycle): SimplifyTopLevel<{
-    onConstructRequest: GenericOnConstructRequest;
+export declare function createHookRouteLifeCycle<const GenericHookLiveCycle extends Omit<HookRouteLifeCycle, "onConstructRequest">>(hookRouteLifeCycle: GenericHookLiveCycle): GenericHookLiveCycle;
+export declare function createHookRouteLifeCycle<GenericOnConstructRequest extends HookOnConstructRequest, const GenericHookLiveCycle extends Omit<HookRouteLifeCycle<Awaited<ReturnType<GenericOnConstructRequest>>>, "onConstructRequest">>(onConstructRequest: GenericOnConstructRequest, hookRouteLifeCycle: GenericHookLiveCycle): SimplifyTopLevel<{
+    readonly onConstructRequest: GenericOnConstructRequest;
 } & GenericHookLiveCycle>;
+export declare function hookRouteLifeCycleAddRequestProperties<GenericRequest extends Request = Request>(request: GenericRequest): <GenericNewProperties extends Record<string, unknown> = Record<string, unknown>>(newProperties: GenericNewProperties) => never;
 export type ExtractRequestFromHooks<GenericHooks extends readonly HookRouteLifeCycle[]> = GenericHooks extends readonly [
     infer InferredFirst,
     ...infer InferredRest extends HookRouteLifeCycle[]

package/dist/core/route/hooks.mjs

@@ -11,5 +11,13 @@ function createHookRouteLifeCycle(...args) {
         onConstructRequest: args[0],
     };
 }
+function hookRouteLifeCycleAddRequestProperties(request) {
+    return (newProperties) => {
+        for (const key in newProperties) {
+            request[key] = newProperties[key];
+        }
+        return request;
+    };
+}
 
-export { createHookRouteLifeCycle, hookRouteExitKind, hookRouteNextKind };
+export { createHookRouteLifeCycle, hookRouteExitKind, hookRouteLifeCycleAddRequestProperties, hookRouteNextKind };

package/dist/core/route/index.cjs

@@ -12,6 +12,7 @@ function createRoute(definition) {
 
 exports.createHookRouteLifeCycle = hooks.createHookRouteLifeCycle;
 exports.hookRouteExitKind = hooks.hookRouteExitKind;
+exports.hookRouteLifeCycleAddRequestProperties = hooks.hookRouteLifeCycleAddRequestProperties;
 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.mjs';
+export { createHookRouteLifeCycle, hookRouteExitKind, hookRouteLifeCycleAddRequestProperties, hookRouteNextKind } from './hooks.mjs';
 
 const routeKind = createCoreLibKind("route");
 function createRoute(definition) {

package/dist/core/router/buildSystemRoute.cjs

@@ -0,0 +1,33 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+require('../functionsBuilders/index.cjs');
+require('../request/index.cjs');
+var index = require('../route/index.cjs');
+var buildError = require('./buildError.cjs');
+var defaultEmptyReaderImplementation = require('../hub/defaultEmptyReaderImplementation.cjs');
+var empty = require('../request/bodyController/empty.cjs');
+var build = require('../functionsBuilders/route/build.cjs');
+
+async function buildSystemRoute(params) {
+    const bodyController = empty.controlBodyAsEmpty();
+    const bodyReader = bodyController.createReaderOrThrow(defaultEmptyReaderImplementation.defaultEmptyReaderImplementation);
+    const route = index.createRoute({
+        method: "GET",
+        paths: ["/"],
+        hooks: [],
+        preflightSteps: [],
+        steps: [params.handlerStep],
+        metadata: [],
+        bodyController,
+    });
+    const buildedRoute = await utils.asyncPipe(build.buildRouteFunction(route, params.buildParams), utils.E.whenIsLeft((element) => {
+        throw new buildError.RouterBuildError(route, element);
+    }), utils.unwrap);
+    return {
+        bodyReader,
+        buildedRoute,
+    };
+}
+
+exports.buildSystemRoute = buildSystemRoute;

package/dist/core/router/buildSystemRoute.d.ts

@@ -0,0 +1,11 @@
+import { type BuildRouteFunctionParams } from "../functionsBuilders";
+import { type HandlerStep } from "../steps";
+interface BuildSystemRouteParams {
+    handlerStep: HandlerStep;
+    buildParams: BuildRouteFunctionParams;
+}
+export declare function buildSystemRoute(params: BuildSystemRouteParams): Promise<{
+    bodyReader: import("../request").BodyReader<"empty">;
+    buildedRoute: import("../functionsBuilders").BuildedRouteFunction;
+}>;
+export {};

package/dist/core/router/buildSystemRoute.mjs

@@ -0,0 +1,31 @@
+import { asyncPipe, E, unwrap } from '@duplojs/utils';
+import '../functionsBuilders/index.mjs';
+import '../request/index.mjs';
+import { createRoute } from '../route/index.mjs';
+import { RouterBuildError } from './buildError.mjs';
+import { defaultEmptyReaderImplementation } from '../hub/defaultEmptyReaderImplementation.mjs';
+import { controlBodyAsEmpty } from '../request/bodyController/empty.mjs';
+import { buildRouteFunction } from '../functionsBuilders/route/build.mjs';
+
+async function buildSystemRoute(params) {
+    const bodyController = controlBodyAsEmpty();
+    const bodyReader = bodyController.createReaderOrThrow(defaultEmptyReaderImplementation);
+    const route = createRoute({
+        method: "GET",
+        paths: ["/"],
+        hooks: [],
+        preflightSteps: [],
+        steps: [params.handlerStep],
+        metadata: [],
+        bodyController,
+    });
+    const buildedRoute = await asyncPipe(buildRouteFunction(route, params.buildParams), E.whenIsLeft((element) => {
+        throw new RouterBuildError(route, element);
+    }), unwrap);
+    return {
+        bodyReader,
+        buildedRoute,
+    };
+}
+
+export { buildSystemRoute };

package/dist/core/router/decodeUrl.cjs

@@ -2,6 +2,7 @@
 
 const regexUrlAnalyser = /^(?<path>[^?]*)(?:\?(?<query>[^#]*))?(?:#(?<fragment>[^]*))?$/;
 const regexQueryAnalyser = /(?<key>[^=&]+)=(?<value>[^&]*)/g;
+const invalidEntryRegex = /__proto__|constructor|prototype/;
 function decodeUrl(url) {
     try {
         const groups = regexUrlAnalyser.exec(url).groups;
@@ -17,6 +18,9 @@ function decodeUrl(url) {
         for (const result of queryString.matchAll(regexQueryAnalyser)) {
             const groups = result.groups;
             const key = decodeURIComponent(groups.key);
+            if (invalidEntryRegex.test(key)) {
+                continue;
+            }
             const value = decodeURIComponent(groups.value);
             const currentValue = query[key];
             if (typeof currentValue === "undefined") {
@@ -35,10 +39,7 @@ function decodeUrl(url) {
         };
     }
     catch {
-        return {
-            path: "/",
-            query: {},
-        };
+        return null;
     }
 }
 

package/dist/core/router/decodeUrl.d.ts

@@ -4,4 +4,4 @@ export interface DecodedUrl {
     path: string;
     query: Record<string, string | string[]>;
 }
-export declare function decodeUrl(url: string): DecodedUrl;
+export declare function decodeUrl(url: string): DecodedUrl | null;

package/dist/core/router/decodeUrl.mjs

@@ -1,5 +1,6 @@
 const regexUrlAnalyser = /^(?<path>[^?]*)(?:\?(?<query>[^#]*))?(?:#(?<fragment>[^]*))?$/;
 const regexQueryAnalyser = /(?<key>[^=&]+)=(?<value>[^&]*)/g;
+const invalidEntryRegex = /__proto__|constructor|prototype/;
 function decodeUrl(url) {
     try {
         const groups = regexUrlAnalyser.exec(url).groups;
@@ -15,6 +16,9 @@ function decodeUrl(url) {
         for (const result of queryString.matchAll(regexQueryAnalyser)) {
             const groups = result.groups;
             const key = decodeURIComponent(groups.key);
+            if (invalidEntryRegex.test(key)) {
+                continue;
+            }
             const value = decodeURIComponent(groups.value);
             const currentValue = query[key];
             if (typeof currentValue === "undefined") {
@@ -33,10 +37,7 @@ function decodeUrl(url) {
         };
     }
     catch {
-        return {
-            path: "/",
-            query: {},
-        };
+        return null;
     }
 }