@duplojs/http 0.7.4 → 0.8.4

package/dist/core/functionsBuilders/steps/defaults/handlerStep.mjs

@@ -5,6 +5,7 @@ import '../../../response/index.mjs';
 import { handlerStepKind } from '../../../steps/handler.mjs';
 import { ResponseContract } from '../../../response/contract.mjs';
 import { PredictedResponse } from '../../../response/predicted.mjs';
+import { ServerSentEventsPredictedResponse } from '../../../response/serverSentEventsPredicted.mjs';
 
 const defaultHandlerStepFunctionBuilder = createStepFunctionBuilder(handlerStepKind.has, (step, { success }) => {
     const { responseContract, theFunction: handlerFunction, } = step.definition;
@@ -13,26 +14,45 @@ const defaultHandlerStepFunctionBuilder = createStepFunctionBuilder(handlerStepK
     }));
     const response = (information, body) => {
         const currentContract = preparedContractResponse[information];
-        if (!currentContract) {
-            throw new ResponseContract.Error(information);
+        if (!currentContract
+            || !ResponseContract.contractKind.has(currentContract)) {
+            throw new ResponseContract.Error(information, "Contract not found.");
         }
-        return new PredictedResponse(currentContract.code, currentContract.information, body);
+        const result = currentContract.body.parse(body);
+        if (E.isLeft(result)) {
+            throw new ResponseContract.Error(information, unwrap(result));
+        }
+        return new PredictedResponse(currentContract.code, information, body);
+    };
+    const serverSentEventsResponse = (information, startSendingEvents) => {
+        const currentContract = preparedContractResponse[information];
+        if (!currentContract
+            || !ResponseContract.serverSentEventsContractKind.has(currentContract)) {
+            throw new ResponseContract.Error(information, "Contract not found.");
+        }
+        return new ServerSentEventsPredictedResponse(currentContract.code, information, (params) => startSendingEvents({
+            ...params,
+            send: (event, data, sendParams) => {
+                const dataParser = currentContract.events[event];
+                if (!dataParser) {
+                    console.error(new ResponseContract.Error(information, `Event '${event}' not found.`));
+                    return Promise.resolve();
+                }
+                const result = dataParser.parse(data);
+                if (E.isLeft(result)) {
+                    console.error(new ResponseContract.Error(information, unwrap(result)));
+                    return Promise.resolve();
+                }
+                return params.send(event, data, sendParams);
+            },
+        }));
     };
     return success({
-        buildedFunction: async (request, floor) => {
-            const predictedResponse = await handlerFunction(floor, {
-                request,
-                response,
-            });
-            const currentContract = preparedContractResponse[predictedResponse.information];
-            const result = currentContract.body.isAsynchronous()
-                ? await currentContract.body.asyncParse(predictedResponse.body)
-                : currentContract.body.parse(predictedResponse.body);
-            if (E.isLeft(result)) {
-                throw new ResponseContract.Error(predictedResponse.information, unwrap(result));
-            }
-            return predictedResponse;
-        },
+        buildedFunction: async (request, floor) => handlerFunction(floor, {
+            request,
+            response,
+            serverSentEventsResponse,
+        }),
         hooksRouteLifeCycle: [],
     });
 });

package/dist/core/functionsBuilders/steps/defaults/processStep.cjs

@@ -5,7 +5,7 @@ require('../../../response/index.cjs');
 var create = require('../create.cjs');
 var utils = require('@duplojs/utils');
 var process = require('../../../steps/process.cjs');
-var predicted = require('../../../response/predicted.cjs');
+var base = require('../../../response/base.cjs');
 
 function buildStepsFunction(steps, buildStep) {
     return utils.G.asyncReduce(steps, utils.G.reduceFrom([]), async ({ lastValue, element: step, next, exit }) => {
@@ -33,8 +33,8 @@ const defaultProcessStepFunctionBuilder = create.createStepFunctionBuilder(proce
             let processFloor = { options: getOptions(floor) };
             // eslint-disable-next-line @typescript-eslint/prefer-for-of
             for (let index = 0; index < buildedSteps.length; index++) {
-                const result = await buildedSteps[index].buildedFunction(request, floor);
-                if (result instanceof predicted.PredictedResponse) {
+                const result = await buildedSteps[index].buildedFunction(request, processFloor);
+                if (result instanceof base.Response) {
                     return result;
                 }
                 processFloor = result;

package/dist/core/functionsBuilders/steps/defaults/processStep.mjs

@@ -3,7 +3,7 @@ import '../../../response/index.mjs';
 import { createStepFunctionBuilder } from '../create.mjs';
 import { G, E, A, unwrap, pipe, P, or, isType, forward } from '@duplojs/utils';
 import { processStepKind } from '../../../steps/process.mjs';
-import { PredictedResponse } from '../../../response/predicted.mjs';
+import { Response } from '../../../response/base.mjs';
 
 function buildStepsFunction(steps, buildStep) {
     return G.asyncReduce(steps, G.reduceFrom([]), async ({ lastValue, element: step, next, exit }) => {
@@ -31,8 +31,8 @@ const defaultProcessStepFunctionBuilder = createStepFunctionBuilder(processStepK
             let processFloor = { options: getOptions(floor) };
             // eslint-disable-next-line @typescript-eslint/prefer-for-of
             for (let index = 0; index < buildedSteps.length; index++) {
-                const result = await buildedSteps[index].buildedFunction(request, floor);
-                if (result instanceof PredictedResponse) {
+                const result = await buildedSteps[index].buildedFunction(request, processFloor);
+                if (result instanceof Response) {
                     return result;
                 }
                 processFloor = result;

package/dist/core/hub/defaultEmptyReaderImplementation.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+require('../request/index.cjs');
+var empty = require('../request/bodyController/empty.cjs');
+
+const defaultEmptyReaderImplementation = empty.EmptyBodyController.createReaderImplementation(() => Promise.resolve(utils.E.success(undefined)));
+
+exports.defaultEmptyReaderImplementation = defaultEmptyReaderImplementation;

package/dist/core/hub/defaultEmptyReaderImplementation.d.ts

@@ -0,0 +1 @@
+export declare const defaultEmptyReaderImplementation: import("../request").BodyReaderImplementation<"empty", {}>;

package/dist/core/hub/defaultEmptyReaderImplementation.mjs

@@ -0,0 +1,7 @@
+import { E } from '@duplojs/utils';
+import '../request/index.mjs';
+import { EmptyBodyController } from '../request/bodyController/empty.mjs';
+
+const defaultEmptyReaderImplementation = EmptyBodyController.createReaderImplementation(() => Promise.resolve(E.success(undefined)));
+
+export { defaultEmptyReaderImplementation };

package/dist/core/hub/defaultMalformedUrlHandler.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+require('../response/index.cjs');
+require('../steps/index.cjs');
+var handler = require('../steps/handler.cjs');
+var contract = require('../response/contract.cjs');
+
+const defaultMalformedUrlHandler = handler.createHandlerStep({
+    responseContract: contract.ResponseContract.badRequest("malformed-url"),
+    theFunction: (__, { response }) => response("malformed-url", undefined),
+    metadata: [],
+});
+
+exports.defaultMalformedUrlHandler = defaultMalformedUrlHandler;

package/dist/core/hub/defaultMalformedUrlHandler.d.ts

@@ -0,0 +1,10 @@
+import { ResponseContract } from "../response";
+export declare const defaultMalformedUrlHandler: import("../steps").HandlerStep<{
+    responseContract: NoInfer<ResponseContract.Contract<"400", "malformed-url", import("@duplojs/utils/dataParser").DataParserEmpty<{
+        readonly errorMessage?: string | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
+    }>>>;
+    theFunction: (__: import("..").Floor, { response }: import("../steps").HandlerStepFunctionParams<import("..").Request, import("../response").ServerSentEventsPredictedResponse<"200" | "201" | "202" | "203" | "204" | "205" | "206" | "207" | "208" | "209" | "210" | "211" | "212" | "213" | "214" | "215" | "216" | "217" | "218" | "219" | "220" | "221" | "222" | "223" | "224" | "225" | "226" | "227" | "228" | "229" | "230" | "231" | "232" | "233" | "234" | "235" | "236" | "237" | "238" | "239" | "240" | "241" | "242" | "243" | "244" | "245" | "246" | "247" | "248" | "249" | "250" | "251" | "252" | "253" | "254" | "255" | "256" | "257" | "258" | "259" | "260" | "261" | "262" | "263" | "264" | "265" | "266" | "267" | "268" | "269" | "270" | "271" | "272" | "273" | "274" | "275" | "276" | "277" | "278" | "279" | "280" | "281" | "282" | "283" | "284" | "285" | "286" | "287" | "288" | "289" | "290" | "291" | "292" | "293" | "294" | "295" | "296" | "297" | "298" | "299", string, import("..").ServerSentEvents.DefinitionShape> | import("../response").PredictedResponse<import("../response").ResponseCode, string, unknown>>) => never;
+    metadata: never[];
+}>;

package/dist/core/hub/defaultMalformedUrlHandler.mjs

@@ -0,0 +1,12 @@
+import '../response/index.mjs';
+import '../steps/index.mjs';
+import { createHandlerStep } from '../steps/handler.mjs';
+import { ResponseContract } from '../response/contract.mjs';
+
+const defaultMalformedUrlHandler = createHandlerStep({
+    responseContract: ResponseContract.badRequest("malformed-url"),
+    theFunction: (__, { response }) => response("malformed-url", undefined),
+    metadata: [],
+});
+
+export { defaultMalformedUrlHandler };

package/dist/core/hub/defaultNotfoundHandler.d.ts

@@ -6,6 +6,6 @@ export declare const defaultNotfoundHandler: import("../steps").HandlerStep<{
         readonly coerce: boolean;
         readonly checkers: readonly [];
     }>>>;
-    theFunction: (floor: import("..").Floor, { request, response }: import("../steps").HandlerStepFunctionParams<import("..").Request, import("../response").PredictedResponse<import("../response").ResponseCode, string, unknown>>) => never;
+    theFunction: (floor: import("..").Floor, { request, response }: import("../steps").HandlerStepFunctionParams<import("..").Request, import("../response").ServerSentEventsPredictedResponse<"200" | "201" | "202" | "203" | "204" | "205" | "206" | "207" | "208" | "209" | "210" | "211" | "212" | "213" | "214" | "215" | "216" | "217" | "218" | "219" | "220" | "221" | "222" | "223" | "224" | "225" | "226" | "227" | "228" | "229" | "230" | "231" | "232" | "233" | "234" | "235" | "236" | "237" | "238" | "239" | "240" | "241" | "242" | "243" | "244" | "245" | "246" | "247" | "248" | "249" | "250" | "251" | "252" | "253" | "254" | "255" | "256" | "257" | "258" | "259" | "260" | "261" | "262" | "263" | "264" | "265" | "266" | "267" | "268" | "269" | "270" | "271" | "272" | "273" | "274" | "275" | "276" | "277" | "278" | "279" | "280" | "281" | "282" | "283" | "284" | "285" | "286" | "287" | "288" | "289" | "290" | "291" | "292" | "293" | "294" | "295" | "296" | "297" | "298" | "299", string, import("..").ServerSentEvents.DefinitionShape> | import("../response").PredictedResponse<import("../response").ResponseCode, string, unknown>>) => never;
     metadata: never[];
 }>;

package/dist/core/hub/index.cjs

@@ -8,6 +8,8 @@ var index = require('../request/index.cjs');
 var defaultNotfoundHandler = require('./defaultNotfoundHandler.cjs');
 var defaultExtractContract = require('./defaultExtractContract.cjs');
 var defaultBodyController = require('./defaultBodyController.cjs');
+var defaultMalformedUrlHandler = require('./defaultMalformedUrlHandler.cjs');
+var defaultEmptyReaderImplementation = require('./defaultEmptyReaderImplementation.cjs');
 var hooks = require('./hooks.cjs');
 var handler = require('../steps/handler.cjs');
 
@@ -20,11 +22,12 @@ class Hub extends utils.kindHeritage("hub", kind.createCoreLibKind("hub")) {
     routes = new Set();
     routeFunctionBuilders = [];
     stepFunctionBuilders = [];
-    bodyReaderImplementations = [];
+    bodyReaderImplementations = [defaultEmptyReaderImplementation.defaultEmptyReaderImplementation];
     classRequest = index.Request;
     notfoundHandler = defaultNotfoundHandler.defaultNotfoundHandler;
     defaultExtractContract = defaultExtractContract.defaultExtractContract;
     defaultBodyController = defaultBodyController.defaultBodyController;
+    malformedUrlHandler = defaultMalformedUrlHandler.defaultMalformedUrlHandler;
     constructor(config) {
         super({});
         this.config = config;
@@ -100,6 +103,14 @@ class Hub extends utils.kindHeritage("hub", kind.createCoreLibKind("hub")) {
     aggregatesHooksRouteLifeCycle(hookName) {
         return utils.A.flatMap(this.hooksRouteLifeCycle, (hooks) => hooks[hookName] ?? []);
     }
+    setMalformedUrlHandler(responseContract, theFunction) {
+        this.malformedUrlHandler = handler.createHandlerStep({
+            responseContract,
+            theFunction: (__, params) => theFunction(params),
+            metadata: [],
+        });
+        return this;
+    }
     /**
      * @internal
      */
@@ -114,6 +125,8 @@ function createHub(config) {
 exports.defaultNotfoundHandler = defaultNotfoundHandler.defaultNotfoundHandler;
 exports.defaultExtractContract = defaultExtractContract.defaultExtractContract;
 exports.defaultBodyController = defaultBodyController.defaultBodyController;
+exports.defaultMalformedUrlHandler = defaultMalformedUrlHandler.defaultMalformedUrlHandler;
+exports.defaultEmptyReaderImplementation = defaultEmptyReaderImplementation.defaultEmptyReaderImplementation;
 exports.createHookHubLifeCycle = hooks.createHookHubLifeCycle;
 exports.hookServerExitKind = hooks.hookServerExitKind;
 exports.hookServerNextKind = hooks.hookServerNextKind;

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

@@ -11,6 +11,8 @@ export * from "./hooks";
 export * from "./defaultNotfoundHandler";
 export * from "./defaultExtractContract";
 export * from "./defaultBodyController";
+export * from "./defaultMalformedUrlHandler";
+export * from "./defaultEmptyReaderImplementation";
 export declare const hubKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/hub", unknown>>;
 export interface HubConfig {
     readonly environment: Environment;
@@ -40,6 +42,7 @@ export declare class Hub<GenericConfig extends HubConfig = HubConfig> extends Hu
     notfoundHandler: HandlerStep;
     defaultExtractContract: ResponseContract.Contract<ClientErrorResponseCode, string, DP.DataParserEmpty>;
     defaultBodyController: BodyController;
+    malformedUrlHandler: HandlerStep;
     private constructor();
     register(routes: Route | Iterable<Route> | Record<string, Route>): this;
     addRouteFunctionBuilder(functionBuilder: MaybeArray<ReturnType<typeof createRouteFunctionBuilder>>): this;
@@ -53,5 +56,6 @@ export declare class Hub<GenericConfig extends HubConfig = HubConfig> extends Hu
     aggregatesHooksHubLifeCycle<GenericHookName extends keyof HookHubLifeCycle>(hookName: GenericHookName): (NonNullable<HookHubLifeCycle[GenericHookName]> extends infer T ? T extends NonNullable<HookHubLifeCycle[GenericHookName]> ? T extends readonly (infer InnerArr)[] ? InnerArr extends readonly (infer InnerArr)[] ? InnerArr : InnerArr : T : never : never)[];
     setDefaultBodyController(bodyController: BodyController): this;
     aggregatesHooksRouteLifeCycle<GenericHookName extends keyof HookRouteLifeCycle>(hookName: GenericHookName): (NonNullable<HookRouteLifeCycle<Request>[GenericHookName]> extends infer T ? T extends NonNullable<HookRouteLifeCycle<Request>[GenericHookName]> ? T extends readonly (infer InnerArr)[] ? InnerArr extends readonly (infer InnerArr)[] ? InnerArr : InnerArr : T : never : never)[];
+    setMalformedUrlHandler<GenericResponseContract extends ResponseContract.Contract, GenericResponse extends ResponseContract.Convert<GenericResponseContract>>(responseContract: GenericResponseContract, theFunction: (param: HandlerStepFunctionParams<Request, GenericResponse>) => MaybePromise<GenericResponse>): this;
 }
 export declare function createHub<const GenericConfig extends HubConfig>(config: GenericConfig): Hub<GenericConfig>;

package/dist/core/hub/index.mjs

@@ -6,6 +6,8 @@ import { Request } from '../request/index.mjs';
 import { defaultNotfoundHandler } from './defaultNotfoundHandler.mjs';
 import { defaultExtractContract } from './defaultExtractContract.mjs';
 import { defaultBodyController } from './defaultBodyController.mjs';
+import { defaultMalformedUrlHandler } from './defaultMalformedUrlHandler.mjs';
+import { defaultEmptyReaderImplementation } from './defaultEmptyReaderImplementation.mjs';
 export { createHookHubLifeCycle, hookServerExitKind, hookServerNextKind, launchHookBeforeBuildRoute, launchHookServer, launchHookServerError, serverErrorExitHookFunction, serverErrorNextHookFunction } from './hooks.mjs';
 import { createHandlerStep } from '../steps/handler.mjs';
 
@@ -18,11 +20,12 @@ class Hub extends kindHeritage("hub", createCoreLibKind("hub")) {
     routes = new Set();
     routeFunctionBuilders = [];
     stepFunctionBuilders = [];
-    bodyReaderImplementations = [];
+    bodyReaderImplementations = [defaultEmptyReaderImplementation];
     classRequest = Request;
     notfoundHandler = defaultNotfoundHandler;
     defaultExtractContract = defaultExtractContract;
     defaultBodyController = defaultBodyController;
+    malformedUrlHandler = defaultMalformedUrlHandler;
     constructor(config) {
         super({});
         this.config = config;
@@ -98,6 +101,14 @@ class Hub extends kindHeritage("hub", createCoreLibKind("hub")) {
     aggregatesHooksRouteLifeCycle(hookName) {
         return A.flatMap(this.hooksRouteLifeCycle, (hooks) => hooks[hookName] ?? []);
     }
+    setMalformedUrlHandler(responseContract, theFunction) {
+        this.malformedUrlHandler = createHandlerStep({
+            responseContract,
+            theFunction: (__, params) => theFunction(params),
+            metadata: [],
+        });
+        return this;
+    }
     /**
      * @internal
      */
@@ -109,4 +120,4 @@ function createHub(config) {
     return Hub.new(config);
 }
 
-export { Hub, createHub, defaultBodyController, defaultExtractContract, defaultNotfoundHandler, hubKind };
+export { Hub, createHub, defaultBodyController, defaultEmptyReaderImplementation, defaultExtractContract, defaultMalformedUrlHandler, defaultNotfoundHandler, hubKind };

package/dist/core/implementHttpServer.cjs

@@ -1,13 +1,18 @@
 'use strict';
 
 require('./hub/index.cjs');
-var index = require('./router/index.cjs');
+var index$1 = require('./router/index.cjs');
 var utils = require('@duplojs/utils');
+var index = require('./defaultHooks/index.cjs');
 var hooks = require('./hub/hooks.cjs');
 
 async function implementHttpServer(params, initHttpServer) {
     await hooks.launchHookServer(params.hub.aggregatesHooksHubLifeCycle("beforeServerBuildRoutes"), params.hub, params.httpServerParams);
-    const router = await index.buildRouter(params.hub);
+    params.hub.addRouteHooks([
+        index.initDefaultHook(params.hub, params.httpServerParams),
+        ...params.getInterfaceHooks(params),
+    ]);
+    const router = await index$1.buildRouter(params.hub);
     await hooks.launchHookServer(params.hub.aggregatesHooksHubLifeCycle("beforeStartServer"), params.hub, params.httpServerParams);
     const serverErrorHooks = params.hub.aggregatesHooksHubLifeCycle("serverError");
     function catchCriticalError(error) {

package/dist/core/implementHttpServer.d.ts

@@ -1,10 +1,16 @@
 import { type Hub } from "./hub";
 import { type RouterInitializationData } from "./router";
-import { type MaybePromise } from "@duplojs/utils";
+import { type AnyTuple, type MaybePromise } from "@duplojs/utils";
 import { type HttpServerParams } from "./types";
+import { type HookRouteLifeCycle } from "./route";
+export interface GetInterfaceHooksParams {
+    readonly hub: Hub;
+    readonly httpServerParams: HttpServerParams;
+}
 export interface ImplementHttpServerParams {
     readonly hub: Hub;
     readonly httpServerParams: HttpServerParams;
+    getInterfaceHooks(params: GetInterfaceHooksParams): AnyTuple<HookRouteLifeCycle>;
 }
 export type ExecRouteSystem = (routerInitializationData: RouterInitializationData, whenUncaughtError: (error: unknown, routerInitializationData: RouterInitializationData) => MaybePromise<void>) => Promise<void>;
 export interface InitHttpServerParams {

package/dist/core/implementHttpServer.mjs

@@ -1,10 +1,15 @@
 import './hub/index.mjs';
 import { buildRouter } from './router/index.mjs';
 import { forward } from '@duplojs/utils';
+import { initDefaultHook } from './defaultHooks/index.mjs';
 import { launchHookServer, launchHookServerError, serverErrorNextHookFunction, serverErrorExitHookFunction } from './hub/hooks.mjs';
 
 async function implementHttpServer(params, initHttpServer) {
     await launchHookServer(params.hub.aggregatesHooksHubLifeCycle("beforeServerBuildRoutes"), params.hub, params.httpServerParams);
+    params.hub.addRouteHooks([
+        initDefaultHook(params.hub, params.httpServerParams),
+        ...params.getInterfaceHooks(params),
+    ]);
     const router = await buildRouter(params.hub);
     await launchHookServer(params.hub.aggregatesHooksHubLifeCycle("beforeStartServer"), params.hub, params.httpServerParams);
     const serverErrorHooks = params.hub.aggregatesHooksHubLifeCycle("serverError");

package/dist/core/index.cjs

@@ -21,6 +21,7 @@ var narrowingInput = require('./narrowingInput.cjs');
 require('./clean/index.cjs');
 var index$5 = require('./defaultHooks/index.cjs');
 require('./errors/index.cjs');
+var serverSentEvents = require('./serverSentEvents.cjs');
 var checker = require('./builders/checker.cjs');
 var builder = require('./builders/route/builder.cjs');
 var store = require('./builders/route/store.cjs');
@@ -30,6 +31,7 @@ var base = require('./response/base.cjs');
 var contract = require('./response/contract.cjs');
 var hook = require('./response/hook.cjs');
 var predicted = require('./response/predicted.cjs');
+var serverSentEventsPredicted = require('./response/serverSentEventsPredicted.cjs');
 var hooks = require('./route/hooks.cjs');
 var kind = require('./steps/kind.cjs');
 var identifier = require('./steps/identifier.cjs');
@@ -42,10 +44,13 @@ var presetChecker = require('./steps/presetChecker.cjs');
 var base$1 = require('./request/bodyController/base.cjs');
 var formData = require('./request/bodyController/formData.cjs');
 var text = require('./request/bodyController/text.cjs');
+var empty = require('./request/bodyController/empty.cjs');
 var hooks$1 = require('./hub/hooks.cjs');
 var defaultNotfoundHandler = require('./hub/defaultNotfoundHandler.cjs');
 var defaultExtractContract = require('./hub/defaultExtractContract.cjs');
 var defaultBodyController = require('./hub/defaultBodyController.cjs');
+var defaultMalformedUrlHandler = require('./hub/defaultMalformedUrlHandler.cjs');
+var defaultEmptyReaderImplementation = require('./hub/defaultEmptyReaderImplementation.cjs');
 var build = require('./functionsBuilders/route/build.cjs');
 var create = require('./functionsBuilders/route/create.cjs');
 var _default = require('./functionsBuilders/route/default.cjs');
@@ -61,6 +66,7 @@ var pathToRegExp = require('./router/pathToRegExp.cjs');
 var buildError = require('./router/buildError.cjs');
 var decodeUrl = require('./router/decodeUrl.cjs');
 var notFoundBodyReaderImplementationError = require('./router/notFoundBodyReaderImplementationError.cjs');
+var buildSystemRoute = require('./router/buildSystemRoute.cjs');
 var base$2 = require('./metadata/base.cjs');
 var ignoreByRouteStore = require('./metadata/ignoreByRouteStore.cjs');
 var wrongContentTypeError = require('./errors/wrongContentTypeError.cjs');
@@ -89,6 +95,10 @@ exports.createCoreLibStringIdentifier = stringIdentifier.createCoreLibStringIden
 exports.implementHttpServer = implementHttpServer.implementHttpServer;
 exports.createNarrowingInput = narrowingInput.createNarrowingInput;
 exports.initDefaultHook = index$5.initDefaultHook;
+Object.defineProperty(exports, "ServerSentEvents", {
+	enumerable: true,
+	get: function () { return serverSentEvents.ServerSentEvents; }
+});
 exports.checkerBuilder = checker.checkerBuilder;
 exports.useCheckerBuilder = checker.useCheckerBuilder;
 exports.routeBuilderHandler = builder.routeBuilderHandler;
@@ -105,8 +115,10 @@ Object.defineProperty(exports, "ResponseContract", {
 });
 exports.HookResponse = hook.HookResponse;
 exports.PredictedResponse = predicted.PredictedResponse;
+exports.ServerSentEventsPredictedResponse = serverSentEventsPredicted.ServerSentEventsPredictedResponse;
 exports.createHookRouteLifeCycle = hooks.createHookRouteLifeCycle;
 exports.hookRouteExitKind = hooks.hookRouteExitKind;
+exports.hookRouteLifeCycleAddRequestProperties = hooks.hookRouteLifeCycleAddRequestProperties;
 exports.hookRouteNextKind = hooks.hookRouteNextKind;
 exports.stepKind = kind.stepKind;
 exports.stepIdentifier = identifier.stepIdentifier;
@@ -123,11 +135,14 @@ exports.createProcessStep = process.createProcessStep;
 exports.processStepKind = process.processStepKind;
 exports.createPresetCheckerStep = presetChecker.createPresetCheckerStep;
 exports.presetCheckerStepKind = presetChecker.presetCheckerStepKind;
+exports.WrongBodyReaderImplementationError = base$1.WrongBodyReaderImplementationError;
 exports.createBodyController = base$1.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;
 exports.createHookHubLifeCycle = hooks$1.createHookHubLifeCycle;
 exports.hookServerExitKind = hooks$1.hookServerExitKind;
 exports.hookServerNextKind = hooks$1.hookServerNextKind;
@@ -139,6 +154,8 @@ exports.serverErrorNextHookFunction = hooks$1.serverErrorNextHookFunction;
 exports.defaultNotfoundHandler = defaultNotfoundHandler.defaultNotfoundHandler;
 exports.defaultExtractContract = defaultExtractContract.defaultExtractContract;
 exports.defaultBodyController = defaultBodyController.defaultBodyController;
+exports.defaultMalformedUrlHandler = defaultMalformedUrlHandler.defaultMalformedUrlHandler;
+exports.defaultEmptyReaderImplementation = defaultEmptyReaderImplementation.defaultEmptyReaderImplementation;
 exports.buildRouteFunction = build.buildRouteFunction;
 exports.createRouteFunctionBuilder = create.createRouteFunctionBuilder;
 exports.defaultRouteFunctionBuilder = _default.defaultRouteFunctionBuilder;
@@ -162,6 +179,7 @@ exports.decodeUrl = decodeUrl.decodeUrl;
 exports.regexQueryAnalyser = decodeUrl.regexQueryAnalyser;
 exports.regexUrlAnalyser = decodeUrl.regexUrlAnalyser;
 exports.NotFoundBodyReaderImplementationError = notFoundBodyReaderImplementationError.NotFoundBodyReaderImplementationError;
+exports.buildSystemRoute = buildSystemRoute.buildSystemRoute;
 exports.createMetadata = base$2.createMetadata;
 exports.metadataKind = base$2.metadataKind;
 exports.IgnoreByRouteStoreMetadata = ignoreByRouteStore.IgnoreByRouteStoreMetadata;

package/dist/core/index.d.ts

@@ -19,3 +19,4 @@ export * from "./narrowingInput";
 export * from "./clean";
 export * from "./defaultHooks";
 export * from "./errors";
+export * from "./serverSentEvents";

package/dist/core/index.mjs

@@ -19,6 +19,7 @@ export { createNarrowingInput } from './narrowingInput.mjs';
 import './clean/index.mjs';
 export { initDefaultHook } from './defaultHooks/index.mjs';
 import './errors/index.mjs';
+export { ServerSentEvents } from './serverSentEvents.mjs';
 export { checkerBuilder, useCheckerBuilder } from './builders/checker.mjs';
 export { routeBuilderHandler, useRouteBuilder } from './builders/route/builder.mjs';
 export { routeStore } from './builders/route/store.mjs';
@@ -28,7 +29,8 @@ export { Response } from './response/base.mjs';
 export { ResponseContract } from './response/contract.mjs';
 export { HookResponse } from './response/hook.mjs';
 export { PredictedResponse } from './response/predicted.mjs';
-export { createHookRouteLifeCycle, hookRouteExitKind, hookRouteNextKind } from './route/hooks.mjs';
+export { ServerSentEventsPredictedResponse } from './response/serverSentEventsPredicted.mjs';
+export { createHookRouteLifeCycle, hookRouteExitKind, hookRouteLifeCycleAddRequestProperties, hookRouteNextKind } from './route/hooks.mjs';
 export { stepKind } from './steps/kind.mjs';
 export { stepIdentifier } from './steps/identifier.mjs';
 export { checkerStepKind, createCheckerStep } from './steps/checker.mjs';
@@ -37,13 +39,16 @@ export { createCutStep, cutStepKind, cutStepOutputKind } from './steps/cut.mjs';
 export { createHandlerStep, handlerStepKind } from './steps/handler.mjs';
 export { createProcessStep, processStepKind } from './steps/process.mjs';
 export { createPresetCheckerStep, presetCheckerStepKind } from './steps/presetChecker.mjs';
-export { createBodyController } from './request/bodyController/base.mjs';
+export { WrongBodyReaderImplementationError, createBodyController } from './request/bodyController/base.mjs';
 export { FormDataBodyController, controlBodyAsFormData } from './request/bodyController/formData.mjs';
 export { TextBodyController, controlBodyAsText } from './request/bodyController/text.mjs';
+export { EmptyBodyController, controlBodyAsEmpty } from './request/bodyController/empty.mjs';
 export { createHookHubLifeCycle, hookServerExitKind, hookServerNextKind, launchHookBeforeBuildRoute, launchHookServer, launchHookServerError, serverErrorExitHookFunction, serverErrorNextHookFunction } from './hub/hooks.mjs';
 export { defaultNotfoundHandler } from './hub/defaultNotfoundHandler.mjs';
 export { defaultExtractContract } from './hub/defaultExtractContract.mjs';
 export { defaultBodyController } from './hub/defaultBodyController.mjs';
+export { defaultMalformedUrlHandler } from './hub/defaultMalformedUrlHandler.mjs';
+export { defaultEmptyReaderImplementation } from './hub/defaultEmptyReaderImplementation.mjs';
 export { buildRouteFunction } from './functionsBuilders/route/build.mjs';
 export { createRouteFunctionBuilder } from './functionsBuilders/route/create.mjs';
 export { defaultRouteFunctionBuilder } from './functionsBuilders/route/default.mjs';
@@ -59,6 +64,7 @@ export { pathToRegExp } from './router/pathToRegExp.mjs';
 export { RouterBuildError } from './router/buildError.mjs';
 export { decodeUrl, regexQueryAnalyser, regexUrlAnalyser } from './router/decodeUrl.mjs';
 export { NotFoundBodyReaderImplementationError } from './router/notFoundBodyReaderImplementationError.mjs';
+export { buildSystemRoute } from './router/buildSystemRoute.mjs';
 export { createMetadata, metadataKind } from './metadata/base.mjs';
 export { IgnoreByRouteStoreMetadata } from './metadata/ignoreByRouteStore.mjs';
 export { WrongContentTypeError } from './errors/wrongContentTypeError.mjs';

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

@@ -7,20 +7,37 @@ const bodyReaderKind = kind.createCoreLibKind("body-reader");
 const bodyReaderImplementationKind = kind.createCoreLibKind("body-reader-implementation");
 const bodyControllerKind = kind.createCoreLibKind("body-controller");
 const bodyControllerHandlerKind = kind.createCoreLibKind("body-controller-handler");
+class WrongBodyReaderImplementationError extends utils.kindHeritage("wrong-body-reader-implementation", kind.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 utils.E.fail();
+                }
+                return utils.E.success(bodyReaderKind.setTo({
+                    read: (request) => readerImplementation.read(request, params),
+                }, name));
+            }
             return bodyControllerKind.setTo({
                 name,
                 params,
-                tryToCreateReader(readerImplementation) {
-                    if (bodyReaderImplementationKind.getValue(readerImplementation) !== name) {
-                        return utils.E.fail();
+                tryToCreateReader,
+                createReaderOrThrow(readerImplementation) {
+                    const result = tryToCreateReader(readerImplementation);
+                    if (utils.E.isLeft(result)) {
+                        throw new WrongBodyReaderImplementationError(name, readerImplementation);
                     }
-                    return utils.E.success(bodyReaderKind.setTo({
-                        read: (request) => readerImplementation.read(request, params),
-                    }, name));
+                    return utils.unwrap(result);
                 },
             }, name);
         },
@@ -33,4 +50,5 @@ function createBodyController(name) {
     });
 }
 
+exports.WrongBodyReaderImplementationError = WrongBodyReaderImplementationError;
 exports.createBodyController = createBodyController;

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

@@ -16,6 +16,7 @@ export interface BodyController<GenericName extends string = string, GenericPara
     readonly name: GenericName;
     readonly params: GenericParams;
     tryToCreateReader(readerImplementation: BodyReaderImplementation): E.Success<BodyReader<GenericName>> | E.Fail;
+    createReaderOrThrow(readerImplementation: BodyReaderImplementation): BodyReader<GenericName>;
 }
 declare const bodyControllerHandlerKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/body-controller-handler", unknown>>;
 export interface BodyControllerHandler<GenericName extends string = string, GenericParams extends BodyControllerParams = BodyControllerParams> extends Kind<typeof bodyControllerHandlerKind.definition> {
@@ -24,5 +25,13 @@ export interface BodyControllerHandler<GenericName extends string = string, Gene
     createReaderImplementation(read: BodyReaderImplementation<GenericName, GenericParams>["read"]): BodyReaderImplementation<GenericName, GenericParams>;
     is(input: unknown): input is BodyController<GenericName, GenericParams>;
 }
+declare const WrongBodyReaderImplementationError_base: new (params: {
+    "@DuplojsHttpCore/wrong-body-reader-implementation"?: unknown;
+}, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/wrong-body-reader-implementation", unknown>, unknown> & Kind<import("@duplojs/utils").KindDefinition<"wrong-body-reader-implementation", unknown>, unknown>;
+export declare class WrongBodyReaderImplementationError extends WrongBodyReaderImplementationError_base {
+    controllerName: string;
+    bodyReaderImplementation: BodyReaderImplementation;
+    constructor(controllerName: string, bodyReaderImplementation: BodyReaderImplementation);
+}
 export declare function createBodyController<GenericName extends string, GenericParams extends BodyControllerParams>(name: GenericName): BodyControllerHandler<GenericName, GenericParams>;
 export {};