@duplojs/http 0.7.1 → 0.8.4

package/dist/client/serverSentEvents.mjs

@@ -0,0 +1,208 @@
+import { pipe, sleep } from '@duplojs/utils';
+import * as GG from '@duplojs/utils/generator';
+import * as SS from '@duplojs/utils/string';
+import * as AA from '@duplojs/utils/array';
+import { launchStartServerEventHook, launchErrorServerEventHook, launchBeforeRetryServerEventHook, launchReceiveEventServerEventHook, launchCloseServerEventHook } from './hooks.mjs';
+
+const closeReason = Symbol("CloseReason");
+const endMessageRegexp = /\n\n|\r\r|\r\n\r\n/;
+const eventPayloadRegexp = /^(?<field>event|data|id|retry|content-type): ?(?<value>.*)$/gm;
+const validRetryRegexp = /^[0-9]+$/;
+const nullIdRegexp = /\0|\n|\r/;
+function makeClientEventsResponse(response, fetchUrl, fetchInitParams) {
+    let reader = response.raw.body?.getReader();
+    let abortController = response.requestParams.abortController;
+    const createEventResponse = (eventsReaderGenerator) => {
+        let closeServerEvent = undefined;
+        let beforeRetryServerEvent = undefined;
+        let errorServerEvent = undefined;
+        let startServerEvent = undefined;
+        let receiveEventServerEvent = undefined;
+        const eventResponse = {
+            ...response,
+            closeEventStream: () => void abortController.abort(closeReason),
+            onReceiveEvent: (eventName, callback) => {
+                receiveEventServerEvent ??= [];
+                receiveEventServerEvent.push((receiveEvent) => receiveEvent.event === eventName
+                    ? callback(receiveEvent, eventResponse)
+                    : undefined);
+                return eventResponse;
+            },
+            onStreamEvent: (event, callback) => {
+                if (event === "receiveServerEvents") {
+                    receiveEventServerEvent ??= [];
+                    receiveEventServerEvent.push(callback);
+                }
+                else if (event === "beforeRetry") {
+                    beforeRetryServerEvent ??= [];
+                    beforeRetryServerEvent.push(callback);
+                }
+                else if (event === "close") {
+                    closeServerEvent ??= [];
+                    closeServerEvent.push(callback);
+                }
+                else if (event === "start") {
+                    startServerEvent ??= [];
+                    startServerEvent.push(callback);
+                }
+                else if (event === "error") {
+                    errorServerEvent ??= [];
+                    errorServerEvent.push(callback);
+                }
+                return eventResponse;
+            },
+            async consumeEventStream() {
+                for await (const __ of eventResponse) { }
+            },
+            [Symbol.asyncIterator]: async function* () {
+                await launchStartServerEventHook(response.requestParams.hooks.startServerEvent, startServerEvent ?? [], eventResponse).catch(console.error);
+                const onError = (error) => launchErrorServerEventHook(response.requestParams.hooks.errorServerEvent, errorServerEvent ?? [], error, eventResponse).catch(console.error);
+                const generator = eventsReaderGenerator(onError, () => launchBeforeRetryServerEventHook(response.requestParams.hooks.beforeRetryServerEvent, beforeRetryServerEvent ?? [], eventResponse).catch(console.error));
+                try {
+                    for await (const event of generator) {
+                        await launchReceiveEventServerEventHook(response.requestParams.hooks.receiveEventServerEvent, receiveEventServerEvent ?? [], event, eventResponse).catch(console.error);
+                        yield event;
+                    }
+                }
+                finally {
+                    await launchCloseServerEventHook(response.requestParams.hooks.closeServerEvent, closeServerEvent ?? [], eventResponse).catch(console.error);
+                }
+            },
+        };
+        return eventResponse;
+    };
+    if (!reader
+        || response.code === "204"
+        || !response.headers.get("content-type")?.includes("text/event-stream")) {
+        return createEventResponse(async function* () { });
+    }
+    return createEventResponse((emitError, emitBeforeRetry) => {
+        let lastId = response.requestParams.headers?.["last-event-id"];
+        let retry = 3000;
+        return pipe(GG.asyncLoop(async ({ next, exit }) => {
+            try {
+                if (abortController.signal.aborted) {
+                    return exit();
+                }
+                else if (reader) {
+                    const chunk = await reader.read();
+                    if (chunk.done) {
+                        reader = undefined;
+                    }
+                    return next(chunk);
+                }
+                else {
+                    abortController = new AbortController();
+                    await sleep(retry);
+                    await emitBeforeRetry();
+                    const fetchResponse = await fetch(fetchUrl, {
+                        ...fetchInitParams,
+                        headers: {
+                            ...fetchInitParams.headers,
+                            ...(typeof lastId === "string"
+                                ? { "last-event-id": lastId }
+                                : undefined),
+                        },
+                        signal: abortController.signal,
+                    });
+                    const fetchInformation = fetchResponse.headers.get(response.requestParams.informationHeaderKey);
+                    if (fetchResponse.status !== 204
+                        && fetchResponse.headers.get("content-type")?.includes("text/event-stream")
+                        && fetchResponse.body
+                        && ((fetchInformation === null
+                            && response.information === undefined)
+                            || fetchInformation === response.information)) {
+                        reader = fetchResponse.body.getReader();
+                        return next();
+                    }
+                    return exit();
+                }
+            }
+            catch (error) {
+                if (error !== closeReason) {
+                    await emitError(error);
+                }
+                reader = undefined;
+                return next();
+            }
+        }), async function* (chunkGenerator) {
+            const decoder = new TextDecoder("utf-8");
+            let buffer = "";
+            for await (const chunk of chunkGenerator) {
+                buffer += decoder.decode(chunk.value, { stream: true });
+                if (SS.test(buffer, endMessageRegexp)) {
+                    const events = SS.split(buffer, endMessageRegexp);
+                    buffer = AA.last(events);
+                    const restEvents = AA.pop(events);
+                    for (const event of restEvents) {
+                        yield event;
+                    }
+                }
+                if (chunk.done) {
+                    buffer = "";
+                }
+            }
+        }, async function* (chunkStringGenerator) {
+            for await (const stringChunk of chunkStringGenerator) {
+                const eventContent = GG.reduce(SS.extractAll(stringChunk, eventPayloadRegexp), GG.reduceFrom({}), ({ lastValue, element, next }) => {
+                    const { field, value } = element.namedGroups;
+                    if (field === "data") {
+                        return next({
+                            ...lastValue,
+                            data: lastValue.data === undefined
+                                ? value
+                                : `${lastValue.data}\n${value}`,
+                        });
+                    }
+                    else if (field === "retry") {
+                        const retry = SS.test(value, validRetryRegexp)
+                            ? parseInt(value, 10)
+                            : undefined;
+                        return next({
+                            ...lastValue,
+                            retry: typeof retry === "number" && !isNaN(retry)
+                                ? retry
+                                : undefined,
+                        });
+                    }
+                    else if (field === "id") {
+                        return next({
+                            ...lastValue,
+                            id: !SS.test(value, nullIdRegexp)
+                                ? value
+                                : undefined,
+                        });
+                    }
+                    return next({
+                        ...lastValue,
+                        [field]: value,
+                    });
+                });
+                if (typeof eventContent.id === "string") {
+                    lastId = eventContent.id;
+                }
+                if (typeof eventContent.retry === "number") {
+                    retry = eventContent.retry;
+                }
+                if (eventContent.data === undefined) {
+                    continue;
+                }
+                try {
+                    yield {
+                        event: eventContent.event || "message",
+                        data: eventContent["content-type"]?.includes("application/json")
+                            ? JSON.parse(eventContent.data)
+                            : eventContent.data,
+                        id: eventContent.id,
+                        retry: eventContent.retry,
+                    };
+                }
+                catch (error) {
+                    await emitError(error);
+                }
+            }
+        });
+    });
+}
+
+export { makeClientEventsResponse };

package/dist/client/types/clientRequestParams.d.ts

@@ -21,6 +21,7 @@ export interface ClientRequestParams<GenericHookParams extends Record<string, un
     params?: ClientRequestParamsParams;
     query?: ClientRequestParamsQuery;
     body?: ClientRequestParamsBody;
+    abortController?: AbortController;
     initParams?: ClientRequestInitParams;
     hookParams?: GenericHookParams;
 }
@@ -43,6 +44,7 @@ type MaybeParams<GenericParams extends object> = {
 export type ServerRouteToClientRequestParams<GenericServerRoute extends ServerRoute = ServerRoute, GenericHookParams extends Record<string, unknown> = Record<string, unknown>> = GenericServerRoute extends any ? SimplifyTopLevel<({
     method: GenericServerRoute["method"];
     path: GenericServerRoute["path"];
+    abortController?: AbortController;
     initParams?: ClientRequestInitParams;
     hookParams?: GenericHookParams;
 } & MaybeParams<(IsEqual<GenericServerRoute["headers"], unknown> extends true ? {} : {

package/dist/client/types/clientResponse.d.ts

@@ -1,6 +1,6 @@
 import type * as SS from "@duplojs/utils/string";
 import { type ServerRouteResponse, type ServerRoute } from "./serverRoute";
-import { type IsEqual, type SimplifyTopLevel } from "@duplojs/utils";
+import { type MaybePromise, type IsEqual, type SimplifyTopLevel, type NeverCoalescing } from "@duplojs/utils";
 import { type PromiseRequestParams } from "./promiseRequestParams";
 export type ClientResponseBody = unknown;
 export interface ClientResponse<GenericHookParams extends Record<string, unknown> = Record<string, unknown>> {
@@ -16,10 +16,34 @@ export interface ClientResponse<GenericHookParams extends Record<string, unknown
     requestParams: PromiseRequestParams<GenericHookParams>;
     predicted: boolean;
 }
+export interface ServerEvent {
+    data: unknown;
+    event: string;
+    id?: string;
+    retry?: number;
+}
+export interface ClientEventsResponseHandler<GenericServerEvent extends ServerEvent = ServerEvent> extends AsyncIterable<GenericServerEvent, void> {
+    closeEventStream(): void;
+    onReceiveEvent<GenericEventName extends GenericServerEvent["event"]>(name: GenericEventName, callback: (event: NeverCoalescing<Extract<GenericServerEvent, {
+        event: GenericEventName;
+    }>, ServerEvent>, response: this) => MaybePromise<void>): this;
+    onStreamEvent(event: "close", callback: (response: this) => MaybePromise<void>): this;
+    onStreamEvent(event: "beforeRetry", callback: (response: this) => MaybePromise<void>): this;
+    onStreamEvent(event: "error", callback: (error: unknown, response: this) => MaybePromise<void>): this;
+    onStreamEvent(event: "start", callback: (response: this) => MaybePromise<void>): this;
+    onStreamEvent(event: "receiveServerEvents", callback: (event: GenericServerEvent, response: this) => MaybePromise<void>): this;
+    consumeEventStream(): Promise<void>;
+}
+export interface ClientEventsResponse<GenericHookParams extends Record<string, unknown> = Record<string, unknown>> extends ClientResponse<GenericHookParams>, ClientEventsResponseHandler {
+}
+export type AllClientResponse<GenericHookParams extends Record<string, unknown> = Record<string, unknown>> = (ClientResponse<GenericHookParams> | ClientEventsResponse<GenericHookParams>);
 export interface NotPredictedClientResponse<GenericHookParams extends Record<string, unknown> = Record<string, unknown>> extends ClientResponse<GenericHookParams> {
     predicted: false;
 }
-export type ServerRouteToClientResponse<GenericServerRoute extends ServerRoute = ServerRoute, GenericHookParams extends Record<string, unknown> = Record<string, unknown>> = GenericServerRoute extends any ? GenericServerRoute["responses"] extends infer InferredResponse ? InferredResponse extends ServerRouteResponse ? SimplifyTopLevel<{
+export interface NotPredictedClientEventsResponse<GenericHookParams extends Record<string, unknown> = Record<string, unknown>> extends NotPredictedClientResponse<GenericHookParams>, ClientEventsResponseHandler {
+}
+export type AllNotPredictedClientResponse<GenericHookParams extends Record<string, unknown> = Record<string, unknown>> = (NotPredictedClientResponse<GenericHookParams> | NotPredictedClientEventsResponse<GenericHookParams>);
+export type ServerRouteToClientResponse<GenericServerRoute extends ServerRoute = ServerRoute, GenericHookParams extends Record<string, unknown> = Record<string, unknown>> = GenericServerRoute extends any ? GenericServerRoute["responses"] extends infer InferredResponse ? InferredResponse extends ServerRouteResponse ? (SimplifyTopLevel<{
     code: InferredResponse["code"];
     information: InferredResponse["information"];
     body: IsEqual<InferredResponse["body"], File> extends true ? undefined : InferredResponse["body"];
@@ -31,4 +55,11 @@ export type ServerRouteToClientResponse<GenericServerRoute extends ServerRoute =
     raw: globalThis.Response;
     requestParams: PromiseRequestParams<GenericHookParams>;
     predicted: boolean;
-}> extends infer InferredResult extends ClientResponse ? InferredResult : never : never : never : never;
+}> & (IsEqual<InferredResponse["events"], unknown> extends true ? unknown : InferredResponse["events"] extends object ? ClientEventsResponseHandler<{
+    [EventName in keyof InferredResponse["events"]]: EventName extends string ? {
+        event: EventName;
+        data: InferredResponse["events"][EventName];
+        id?: string;
+        retry?: number;
+    } : never;
+}[keyof InferredResponse["events"]]> : unknown)) extends infer InferredResult extends ClientResponse ? InferredResult : never : never : never : never;

package/dist/client/types/hooks.d.ts

@@ -1,14 +1,19 @@
 import { type MaybePromise } from "@duplojs/utils";
-import { type NotPredictedClientResponse, type ClientResponse } from "./clientResponse";
+import { type ClientEventsResponse, type ServerEvent, type AllClientResponse, type AllNotPredictedClientResponse } from "./clientResponse";
 import { type PromiseRequestParams } from "./promiseRequestParams";
 export type RequestHook<GenericHookParams extends Record<string, unknown> = Record<string, unknown>> = (requestParams: PromiseRequestParams<GenericHookParams>) => MaybePromise<PromiseRequestParams<GenericHookParams>>;
-export type ResponseHook<GenericHookParams extends Record<string, unknown> = Record<string, unknown>> = (response: ClientResponse<GenericHookParams>) => MaybePromise<ClientResponse<GenericHookParams>>;
-export type InformationHook<GenericHookParams extends Record<string, unknown> = Record<string, unknown>> = (response: ClientResponse<GenericHookParams>) => MaybePromise<void>;
-export type ResponseTypeHook<GenericHookParams extends Record<string, unknown> = Record<string, unknown>> = (response: ClientResponse<GenericHookParams>) => MaybePromise<void>;
-export type ExpectedResponseHook<GenericHookParams extends Record<string, unknown> = Record<string, unknown>> = (response: ClientResponse<GenericHookParams>) => MaybePromise<void>;
-export type CodeHook<GenericHookParams extends Record<string, unknown> = Record<string, unknown>> = (response: ClientResponse<GenericHookParams>) => MaybePromise<void>;
-export type NotPredictedResponseHook<GenericHookParams extends Record<string, unknown> = Record<string, unknown>> = (response: NotPredictedClientResponse<GenericHookParams>) => MaybePromise<void>;
+export type ResponseHook<GenericHookParams extends Record<string, unknown> = Record<string, unknown>> = (response: AllClientResponse<GenericHookParams>) => MaybePromise<AllClientResponse<GenericHookParams>>;
+export type InformationHook<GenericHookParams extends Record<string, unknown> = Record<string, unknown>> = (response: AllClientResponse<GenericHookParams>) => MaybePromise<void>;
+export type ResponseTypeHook<GenericHookParams extends Record<string, unknown> = Record<string, unknown>> = (response: AllClientResponse<GenericHookParams>) => MaybePromise<void>;
+export type ExpectedResponseHook<GenericHookParams extends Record<string, unknown> = Record<string, unknown>> = (response: AllClientResponse<GenericHookParams>) => MaybePromise<void>;
+export type CodeHook<GenericHookParams extends Record<string, unknown> = Record<string, unknown>> = (response: AllClientResponse<GenericHookParams>) => MaybePromise<void>;
+export type NotPredictedResponseHook<GenericHookParams extends Record<string, unknown> = Record<string, unknown>> = (response: AllNotPredictedClientResponse<GenericHookParams>) => MaybePromise<void>;
 export type ErrorHook<GenericHookParams extends Record<string, unknown> = Record<string, unknown>> = (error: unknown, requestParams: PromiseRequestParams<GenericHookParams>) => MaybePromise<void>;
+export type CloseServerEventHook<GenericHookParams extends Record<string, unknown> = Record<string, unknown>> = (response: ClientEventsResponse<GenericHookParams>) => MaybePromise<void>;
+export type BeforeRetryServerEventHook<GenericHookParams extends Record<string, unknown> = Record<string, unknown>> = (response: ClientEventsResponse<GenericHookParams>) => MaybePromise<void>;
+export type ErrorServerEventHook<GenericHookParams extends Record<string, unknown> = Record<string, unknown>> = (error: unknown, response: ClientEventsResponse<GenericHookParams>) => MaybePromise<void>;
+export type StartServerEventHook<GenericHookParams extends Record<string, unknown> = Record<string, unknown>> = (response: ClientEventsResponse<GenericHookParams>) => MaybePromise<void>;
+export type ReceiveEventServerEventHook<GenericHookParams extends Record<string, unknown> = Record<string, unknown>> = (event: ServerEvent, response: ClientEventsResponse<GenericHookParams>) => MaybePromise<void>;
 export interface Hooks {
     request: RequestHook[];
     response: ResponseHook[];
@@ -22,4 +27,9 @@ export interface Hooks {
     expectedResponse: ExpectedResponseHook[];
     notPredictedResponse: NotPredictedResponseHook[];
     error: ErrorHook[];
+    closeServerEvent: CloseServerEventHook[];
+    beforeRetryServerEvent: BeforeRetryServerEventHook[];
+    errorServerEvent: ErrorServerEventHook[];
+    startServerEvent: StartServerEventHook[];
+    receiveEventServerEvent: ReceiveEventServerEventHook[];
 }

package/dist/client/types/promiseRequestParams.d.ts

@@ -6,4 +6,5 @@ export interface PromiseRequestParams<GenericHookParams extends Record<string, u
     informationHeaderKey: string;
     predictedHeaderKey: string;
     disabledPredicateMode: boolean;
+    abortController: AbortController;
 }

package/dist/client/types/serverRoute.d.ts

@@ -12,10 +12,12 @@ export type ServerRouteQuery = Record<string, MaybeArray<ServerPrimitiveData | {
 }>>;
 export type ServerRouteBody = unknown;
 export type ServerRouteResponseBody = unknown;
+export type ServerRouteResponseEvents = Record<string, unknown>;
 export interface ServerRouteResponse {
     code: SS.Number;
     information?: string;
     body?: ServerRouteResponseBody;
+    events?: ServerRouteResponseEvents;
 }
 export interface ServerRoute {
     path: string;

package/dist/core/builders/route/handler.d.ts

@@ -2,12 +2,15 @@ import { type Floor } from "../../floor";
 import { type ResponseContract } from "../../response";
 import { type Route, type RouteDefinition } from "../../route";
 import { type HandlerStep, type HandlerStepFunctionParams } from "../../steps";
-import { type MaybePromise, type AnyTuple, type O } from "@duplojs/utils";
+import { type MaybePromise, type O } from "@duplojs/utils";
 import { type Request } from "../../request";
 import { type Metadata } from "../../metadata";
 declare module "./builder" {
     interface RouteBuilder<GenericDefinition extends RouteDefinition = RouteDefinition, GenericFloor extends Floor = {}, GenericRequest extends Request = Request> {
-        handler<GenericResponseContract extends (ResponseContract.Contract | readonly [ResponseContract.Contract, ...ResponseContract.Contract[]]), GenericResponse extends ResponseContract.Convert<GenericResponseContract extends AnyTuple ? GenericResponseContract[number] : GenericResponseContract>, const GenericMetadata extends readonly Metadata[] = readonly []>(responseContract: GenericResponseContract, theFunction: (floor: GenericFloor, param: HandlerStepFunctionParams<GenericRequest, GenericResponse>) => MaybePromise<GenericResponse>, ...metadata: GenericMetadata): Route<O.AssignObjects<GenericDefinition, {
+        handler<GenericResponseContract extends (ResponseContract.Contract | ResponseContract.ServerSentEventsContract | readonly [
+            (ResponseContract.Contract | ResponseContract.ServerSentEventsContract),
+            ...(ResponseContract.Contract | ResponseContract.ServerSentEventsContract)[]
+        ]), GenericResponse extends ResponseContract.Convert<GenericResponseContract extends readonly any[] ? GenericResponseContract[number] : GenericResponseContract>, const GenericMetadata extends readonly Metadata[] = readonly []>(responseContract: GenericResponseContract, theFunction: (floor: GenericFloor, param: HandlerStepFunctionParams<GenericRequest, GenericResponse>) => MaybePromise<GenericResponse>, ...metadata: GenericMetadata): Route<O.AssignObjects<GenericDefinition, {
             readonly steps: readonly [
                 ...GenericDefinition["steps"],
                 HandlerStep<{

package/dist/core/clean/entity.cjs

@@ -1,33 +1,24 @@
 'use strict';
 
 var utils = require('@duplojs/utils');
-var clean = require('@duplojs/utils/clean');
+require('@duplojs/utils/clean');
 
-function propertiesDefinitionToSchema(definition, method) {
-    return utils.pipe(definition, utils.P.when(clean.newTypeHandlerKind.has, (value) => value[method]()), utils.P.when(utils.isType("array"), utils.innerPipe(utils.A.map((element) => element[method]()), (options) => {
-        utils.asserts(options, utils.A.minElements(1));
-        return utils.DP.union(options);
-    })), utils.P.otherwise((definition) => utils.pipe(definition.type, (subDefinition) => propertiesDefinitionToSchema(subDefinition, method), (dataParser) => {
-        if (definition.inArray) {
-            return utils.pipe(dataParser, utils.DP.array, (dataParser) => typeof definition.inArray === "object"
-                && typeof definition.inArray.min === "number"
-                ? dataParser.addChecker(utils.DP.checkerArrayMin(definition.inArray.min))
-                : dataParser, (dataParser) => typeof definition.inArray === "object"
-                && typeof definition.inArray.max === "number"
-                ? dataParser.addChecker(utils.DP.checkerArrayMax(definition.inArray.max))
-                : dataParser);
-        }
-        return dataParser;
-    }, (dataParser) => definition.nullable === true
-        ? utils.DP.nullable(dataParser)
-        : dataParser)));
-}
-clean.createEntity.overrideHandler.setMethod("toExtractParser", (self, keys) => utils.pipe(self.propertiesDefinition, utils.O.entries, utils.A.filter(([key]) => keys === undefined || utils.A.includes(keys, key)), utils.A.map(([key, value]) => utils.O.entry(key, propertiesDefinitionToSchema(value, "toExtractParser"))), utils.O.fromEntries, utils.DPE.object));
-clean.createEntity.overrideHandler.setMethod("toEndpointSchema", (self, keys, params) => utils.pipe(self.propertiesDefinition, utils.O.entries, utils.A.filter(([key]) => keys === undefined || utils.A.includes(keys, key)), utils.A.map(([key, value]) => utils.O.entry(key, propertiesDefinitionToSchema(value, "toEndpointSchema"))), utils.O.fromEntries, (shape) => typeof params?.addEntityName !== "undefined"
-    ? {
-        ...shape,
-        _entityName: typeof params.addEntityName === "string"
-            ? utils.DP.literal(`${self.name}/${params.addEntityName}`)
-            : utils.DP.literal(self.name),
+utils.C.createEntity.overrideHandler.setMethod("toExtractParser", (self, keys) => {
+    if (typeof keys === "string") {
+        return utils.C.entityPropertyDefinitionToDataParser(self.propertiesDefinition[keys], (newTypeHandler) => newTypeHandler.toExtractParser());
+    }
+    return utils.pipe(self.propertiesDefinition, utils.O.entries, utils.A.filter(([key]) => keys === undefined || utils.A.includes(keys, key)), utils.A.map(([key, value]) => utils.O.entry(key, utils.C.entityPropertyDefinitionToDataParser(value, (newTypeHandler) => newTypeHandler.toExtractParser()))), utils.O.fromEntries, utils.DPE.object);
+});
+utils.C.createEntity.overrideHandler.setMethod("toEndpointSchema", (self, keys, params) => {
+    if (typeof keys === "string") {
+        return utils.C.entityPropertyDefinitionToDataParser(self.propertiesDefinition[keys], (newTypeHandler) => newTypeHandler.toEndpointSchema());
     }
-    : shape, utils.DPE.object));
+    return utils.pipe(self.propertiesDefinition, utils.O.entries, utils.A.filter(([key]) => keys === undefined || utils.A.includes(keys, key)), utils.A.map(([key, value]) => utils.O.entry(key, utils.C.entityPropertyDefinitionToDataParser(value, (newTypeHandler) => newTypeHandler.toEndpointSchema()))), utils.O.fromEntries, (shape) => typeof params?.addEntityName !== "undefined"
+        ? {
+            ...shape,
+            _entityName: typeof params.addEntityName === "string"
+                ? utils.DP.literal(`${self.name}/${params.addEntityName}`)
+                : utils.DP.literal(self.name),
+        }
+        : shape, utils.DPE.object);
+});

package/dist/core/clean/entity.d.ts

@@ -1,20 +1,20 @@
-import { DP, DPE, type IsEqual, type SimplifyTopLevel, type IsExtends } from "@duplojs/utils";
-import { type EntityRawProperties, type EntityProperties, type EntityPropertiesDefinition } from "@duplojs/utils/clean";
+import { DP, DPE, type IsEqual, type SimplifyTopLevel, type IsExtends, C, type MaybeArray } from "@duplojs/utils";
+import "@duplojs/utils/clean";
 interface ToEndpointSchemaParams {
     addEntityName?: boolean | string;
 }
 declare module "@duplojs/utils/clean" {
-    interface EntityHandler<GenericName extends string = string, GenericPropertiesDefinition extends EntityPropertiesDefinition = EntityPropertiesDefinition> {
-        toExtractParser<GenericEntityProperties extends EntityProperties<GenericPropertiesDefinition>, const GenericKey extends keyof GenericEntityProperties = keyof GenericEntityProperties>(keys?: GenericKey[]): ReturnType<typeof DPE.object<{
-            [Prop in GenericKey]: DP.Contract<GenericEntityProperties[Prop], unknown>;
-        }>>;
-        toEndpointSchema<GenericEntityRawProperties extends EntityRawProperties<GenericPropertiesDefinition>, const GenericKey extends keyof GenericEntityRawProperties = keyof GenericEntityRawProperties, const GenericParams extends ToEndpointSchemaParams = {}>(keys?: GenericKey[], params?: GenericParams | ToEndpointSchemaParams): ReturnType<typeof DPE.object<SimplifyTopLevel<{
-            [Prop in GenericKey]: DP.Contract<GenericEntityRawProperties[Prop], unknown>;
+    interface EntityHandler<GenericName extends string = string, GenericPropertiesDefinition extends C.EntityPropertiesDefinition = C.EntityPropertiesDefinition> {
+        toExtractParser<GenericEntityProperties extends C.EntityProperties<GenericPropertiesDefinition>, const GenericKey extends MaybeArray<keyof GenericEntityProperties> = readonly (keyof GenericEntityProperties)[]>(keys?: GenericKey): GenericKey extends readonly any[] ? ReturnType<typeof DPE.object<SimplifyTopLevel<{
+            [Prop in GenericKey[number]]: DP.Contract<GenericEntityProperties[Prop], unknown>;
+        }>>> : DP.Contract<GenericEntityProperties[Extract<GenericKey, string>], unknown>;
+        toEndpointSchema<GenericEntityRawProperties extends C.EntityRawProperties<GenericPropertiesDefinition>, const GenericKey extends MaybeArray<keyof GenericEntityRawProperties> = readonly (keyof GenericEntityRawProperties)[], const GenericParams extends (ToEndpointSchemaParams) = {}>(keys?: GenericKey, params?: (GenericParams | ToEndpointSchemaParams) & (GenericKey extends string ? never : unknown)): GenericKey extends readonly any[] ? ReturnType<typeof DPE.object<SimplifyTopLevel<{
+            [Prop in GenericKey[number]]: DP.Contract<GenericEntityRawProperties[Prop], unknown>;
         } & (IsEqual<GenericParams["addEntityName"], true> extends true ? {
             [Prop in "_entityName"]: DP.Contract<GenericName, unknown>;
         } : {}) & (IsExtends<GenericParams["addEntityName"], string> extends true ? {
             [Prop in "_entityName"]: DP.Contract<`${GenericName}/${GenericParams["addEntityName"]}`, unknown>;
-        } : {})>>>;
+        } : {})>>> : DP.Contract<GenericEntityRawProperties[Extract<GenericKey, string>], unknown>;
     }
 }
 export {};

package/dist/core/clean/entity.mjs

@@ -1,31 +1,22 @@
-import { pipe, P, isType, innerPipe, A, asserts, DP, O, DPE } from '@duplojs/utils';
-import { newTypeHandlerKind, createEntity } from '@duplojs/utils/clean';
+import { C, pipe, O, A, DPE, DP } from '@duplojs/utils';
+import '@duplojs/utils/clean';
 
-function propertiesDefinitionToSchema(definition, method) {
-    return pipe(definition, P.when(newTypeHandlerKind.has, (value) => value[method]()), P.when(isType("array"), innerPipe(A.map((element) => element[method]()), (options) => {
-        asserts(options, A.minElements(1));
-        return DP.union(options);
-    })), P.otherwise((definition) => pipe(definition.type, (subDefinition) => propertiesDefinitionToSchema(subDefinition, method), (dataParser) => {
-        if (definition.inArray) {
-            return pipe(dataParser, DP.array, (dataParser) => typeof definition.inArray === "object"
-                && typeof definition.inArray.min === "number"
-                ? dataParser.addChecker(DP.checkerArrayMin(definition.inArray.min))
-                : dataParser, (dataParser) => typeof definition.inArray === "object"
-                && typeof definition.inArray.max === "number"
-                ? dataParser.addChecker(DP.checkerArrayMax(definition.inArray.max))
-                : dataParser);
-        }
-        return dataParser;
-    }, (dataParser) => definition.nullable === true
-        ? DP.nullable(dataParser)
-        : dataParser)));
-}
-createEntity.overrideHandler.setMethod("toExtractParser", (self, keys) => pipe(self.propertiesDefinition, O.entries, A.filter(([key]) => keys === undefined || A.includes(keys, key)), A.map(([key, value]) => O.entry(key, propertiesDefinitionToSchema(value, "toExtractParser"))), O.fromEntries, DPE.object));
-createEntity.overrideHandler.setMethod("toEndpointSchema", (self, keys, params) => pipe(self.propertiesDefinition, O.entries, A.filter(([key]) => keys === undefined || A.includes(keys, key)), A.map(([key, value]) => O.entry(key, propertiesDefinitionToSchema(value, "toEndpointSchema"))), O.fromEntries, (shape) => typeof params?.addEntityName !== "undefined"
-    ? {
-        ...shape,
-        _entityName: typeof params.addEntityName === "string"
-            ? DP.literal(`${self.name}/${params.addEntityName}`)
-            : DP.literal(self.name),
+C.createEntity.overrideHandler.setMethod("toExtractParser", (self, keys) => {
+    if (typeof keys === "string") {
+        return C.entityPropertyDefinitionToDataParser(self.propertiesDefinition[keys], (newTypeHandler) => newTypeHandler.toExtractParser());
+    }
+    return pipe(self.propertiesDefinition, O.entries, A.filter(([key]) => keys === undefined || A.includes(keys, key)), A.map(([key, value]) => O.entry(key, C.entityPropertyDefinitionToDataParser(value, (newTypeHandler) => newTypeHandler.toExtractParser()))), O.fromEntries, DPE.object);
+});
+C.createEntity.overrideHandler.setMethod("toEndpointSchema", (self, keys, params) => {
+    if (typeof keys === "string") {
+        return C.entityPropertyDefinitionToDataParser(self.propertiesDefinition[keys], (newTypeHandler) => newTypeHandler.toEndpointSchema());
     }
-    : shape, DPE.object));
+    return pipe(self.propertiesDefinition, O.entries, A.filter(([key]) => keys === undefined || A.includes(keys, key)), A.map(([key, value]) => O.entry(key, C.entityPropertyDefinitionToDataParser(value, (newTypeHandler) => newTypeHandler.toEndpointSchema()))), O.fromEntries, (shape) => typeof params?.addEntityName !== "undefined"
+        ? {
+            ...shape,
+            _entityName: typeof params.addEntityName === "string"
+                ? DP.literal(`${self.name}/${params.addEntityName}`)
+                : DP.literal(self.name),
+        }
+        : shape, DPE.object);
+});

package/dist/core/defaultHooks/index.cjs

@@ -5,6 +5,7 @@ require('../route/index.cjs');
 var serverUtils = require('@duplojs/server-utils');
 var hooks = require('../route/hooks.cjs');
 var predicted = require('../response/predicted.cjs');
+var serverSentEventsPredicted = require('../response/serverSentEventsPredicted.cjs');
 var hook = require('../response/hook.cjs');
 
 function initDefaultHook(hub, serverParams) {
@@ -39,6 +40,13 @@ function initDefaultHook(hub, serverParams) {
             if (currentResponse instanceof predicted.PredictedResponse) {
                 currentResponse.setHeader(predictedHeaderKey, "1");
             }
+            else if (currentResponse instanceof serverSentEventsPredicted.ServerSentEventsPredictedResponse) {
+                currentResponse.setHeader(predictedHeaderKey, "1");
+                currentResponse.setHeader("transfer-encoding", "chunked");
+                currentResponse.setHeader("content-type", "text/event-stream");
+                currentResponse.setHeader("cache-control", "no-cache");
+                currentResponse.setHeader("connection", "keep-alive");
+            }
             else if (currentResponse instanceof hook.HookResponse) {
                 currentResponse.setHeader(fromHookHeaderKey, currentResponse.fromHook);
             }

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

@@ -1,5 +1,5 @@
 import { type Hub } from "../hub";
 import { type HttpServerParams } from "../types";
 export declare function initDefaultHook(hub: Hub, serverParams: HttpServerParams): {
-    beforeSendResponse({ currentResponse, next }: import("../route").RouteHookParamsAfter<import("..").Request>): import("../route").RouteHookNext;
+    readonly beforeSendResponse: ({ currentResponse, next }: import("../route").RouteHookParamsAfter<import("..").Request>) => import("../route").RouteHookNext;
 };

package/dist/core/defaultHooks/index.mjs

@@ -3,6 +3,7 @@ import '../route/index.mjs';
 import { SF } from '@duplojs/server-utils';
 import { createHookRouteLifeCycle } from '../route/hooks.mjs';
 import { PredictedResponse } from '../response/predicted.mjs';
+import { ServerSentEventsPredictedResponse } from '../response/serverSentEventsPredicted.mjs';
 import { HookResponse } from '../response/hook.mjs';
 
 function initDefaultHook(hub, serverParams) {
@@ -37,6 +38,13 @@ function initDefaultHook(hub, serverParams) {
             if (currentResponse instanceof PredictedResponse) {
                 currentResponse.setHeader(predictedHeaderKey, "1");
             }
+            else if (currentResponse instanceof ServerSentEventsPredictedResponse) {
+                currentResponse.setHeader(predictedHeaderKey, "1");
+                currentResponse.setHeader("transfer-encoding", "chunked");
+                currentResponse.setHeader("content-type", "text/event-stream");
+                currentResponse.setHeader("cache-control", "no-cache");
+                currentResponse.setHeader("connection", "keep-alive");
+            }
             else if (currentResponse instanceof HookResponse) {
                 currentResponse.setHeader(fromHookHeaderKey, currentResponse.fromHook);
             }

package/dist/core/functionsBuilders/route/default.cjs

@@ -9,6 +9,7 @@ require('../steps/index.cjs');
 var processStep = require('../steps/defaults/processStep.cjs');
 var base = require('../../response/base.cjs');
 var hook$1 = require('../../response/hook.cjs');
+var hooks = require('../../route/hooks.cjs');
 
 /* eslint-disable @typescript-eslint/prefer-for-of */
 const defaultRouteFunctionBuilder = create.createRouteFunctionBuilder(index.routeKind.has, async (route, { success, buildStep, globalHooksRouteLifeCycle, }) => {
@@ -35,7 +36,7 @@ const defaultRouteFunctionBuilder = create.createRouteFunctionBuilder(index.rout
     const hookOnConstructRequest = utils.pipe(allHooks, utils.A.map(({ onConstructRequest }) => onConstructRequest), utils.A.filter(utils.isType("function")), utils.forward);
     const hookError = utils.pipe(allHooks, utils.A.map(({ error }) => error), utils.A.filter(utils.isType("function")), utils.forward);
     const hookSendResponse = utils.pipe(allHooks, utils.A.map(({ sendResponse }) => sendResponse), utils.A.filter(utils.isType("function")), utils.forward);
-    const hooks = {
+    const hooks$1 = {
         afterSendResponse: hook.buildHookAfter(hookAfterSendResponse),
         beforeRouteExecution: hook.buildHookBefore(hookBeforeRouteExecution),
         beforeSendResponse: hook.buildHookAfter(hookBeforeSendResponse),
@@ -56,7 +57,7 @@ const defaultRouteFunctionBuilder = create.createRouteFunctionBuilder(index.rout
     };
     async function routeExecution(request) {
         try {
-            const beforeRouteExecutionResult = await hooks.beforeRouteExecution({
+            const beforeRouteExecutionResult = await hooks$1.beforeRouteExecution({
                 request,
                 exit: hook.exitHookFunction,
                 next: hook.nextHookFunction,
@@ -83,7 +84,7 @@ const defaultRouteFunctionBuilder = create.createRouteFunctionBuilder(index.rout
             return new base.Response("500", "missing-response", undefined);
         }
         catch (error) {
-            const errorResult = await hooks.error({
+            const errorResult = await hooks$1.error({
                 request,
                 error,
                 exit: hook.exitHookFunction,
@@ -97,14 +98,9 @@ const defaultRouteFunctionBuilder = create.createRouteFunctionBuilder(index.rout
         }
     }
     return success(async (request) => {
-        const currentRequest = await hooks.onConstructRequest({
+        const currentRequest = await hooks$1.onConstructRequest({
             request,
-            addRequestProperties: (newProperties) => {
-                for (const key in newProperties) {
-                    request[key] = newProperties[key];
-                }
-                return request;
-            },
+            addRequestProperties: hooks.hookRouteLifeCycleAddRequestProperties(request),
         });
         const currentResponse = await routeExecution(currentRequest);
         const afterHookParams = {
@@ -113,9 +109,9 @@ const defaultRouteFunctionBuilder = create.createRouteFunctionBuilder(index.rout
             exit: hook.exitHookFunction,
             next: hook.nextHookFunction,
         };
-        await hooks.beforeSendResponse(afterHookParams);
-        await hooks.sendResponse(afterHookParams);
-        await hooks.afterSendResponse(afterHookParams);
+        await hooks$1.beforeSendResponse(afterHookParams);
+        await hooks$1.sendResponse(afterHookParams);
+        await hooks$1.afterSendResponse(afterHookParams);
     });
 });