@duplojs/http 0.9.5 → 0.11.0

package/dist/client/promiseRequest.d.ts

@@ -1,7 +1,7 @@
 import { type NeverCoalescing, type MaybePromise, type O } from "@duplojs/utils";
 import * as EE from "@duplojs/utils/either";
 import { type RequestErrorContent } from "./unexpectedResponseError";
-import { type PromiseRequestParams, type Hooks, type NotPredictedResponseHook, type ErrorHook, type ClientEventsResponse, type AllClientResponse, type AllNotPredictedClientResponse, type ClientEventsResponseHandler, type ServerEvent } from "./types";
+import { type PromiseRequestParams, type Hooks, type NotPredictedResponseHook, type ErrorHook, type ClientEventsResponse, type AllClientResponse, type AllNotPredictedClientResponse, type ClientEventsResponseHandler, type ServerEvent, type ClientStreamResponseHandler, type ClientStreamResponse } from "./types";
 type MaybeResponse<GenericClientResponse extends AllClientResponse = AllClientResponse> = (EE.Right<"response", GenericClientResponse> | EE.Left<"request-error", RequestErrorContent>);
 type MaybeWantedResponse<GenericWantedClientResponse extends AllClientResponse = AllClientResponse, GenericUnexpectClientResponse extends AllClientResponse = AllClientResponse> = (EE.Right<"response", GenericWantedClientResponse> | EE.Left<"unexpect-response", GenericUnexpectClientResponse> | EE.Left<"request-error", RequestErrorContent>);
 export declare class PromiseRequest<GenericHookParams extends Record<string, unknown> = Record<string, unknown>, GenericClientResponse extends AllClientResponse<GenericHookParams> = AllClientResponse<GenericHookParams>> extends Promise<MaybeResponse<GenericClientResponse | AllNotPredictedClientResponse<GenericHookParams>>> {
@@ -39,6 +39,7 @@ export declare class PromiseRequest<GenericHookParams extends Record<string, unk
     whenReceiveServerEvent<GenericEvent extends (GenericClientResponse extends ClientEventsResponseHandler<infer InferredEvent> ? InferredEvent : never), GenericEventName extends GenericEvent["event"]>(eventName: GenericEventName, callback: (event: NoInfer<NeverCoalescing<Extract<GenericEvent, {
         event: GenericEventName;
     }>, ServerEvent>>, response: NeverCoalescing<Extract<GenericClientResponse, ClientEventsResponseHandler<GenericEvent>>, ClientEventsResponse>) => MaybePromise<void>): this;
+    whenReceiveDataStream<GenericFlux extends (GenericClientResponse extends ClientStreamResponseHandler<infer InferredFlux> ? InferredFlux : never)>(callback: (data: GenericFlux, response: NeverCoalescing<Extract<GenericClientResponse, ClientStreamResponseHandler>, ClientStreamResponse>) => MaybePromise<void>): this;
     iWantInformation<GenericInformation extends Extract<GenericClientResponse["information"], string>, GenericResponse extends NeverCoalescing<Extract<GenericClientResponse, GenericInformation extends any ? {
         information: GenericInformation;
     } : never>, AllClientResponse<GenericHookParams>>>(information: GenericInformation | GenericInformation[]): Promise<MaybeWantedResponse<GenericResponse, NeverCoalescing<Exclude<GenericClientResponse, GenericResponse>, AllClientResponse<GenericHookParams>> | AllNotPredictedClientResponse<GenericHookParams>>>;

package/dist/client/promiseRequest.mjs

@@ -7,7 +7,9 @@ import * as EE from '@duplojs/utils/either';
 import * as SS from '@duplojs/utils/string';
 import * as AA from '@duplojs/utils/array';
 import { UnexpectedInformationResponseError, UnexpectedCodeResponseError, UnexpectedResponseTypeError, UnexpectedResponseError } from './unexpectedResponseError.mjs';
-import { makeClientEventsResponse } from './serverSentEvents.mjs';
+import { isClientEventsResponse, makeClientEventsResponse } from './serverSentEvents.mjs';
+import { findResponseFromCacheStore, saveResponseInCacheStore } from './clientCache.mjs';
+import { isClientStreamResponse, makeClientStreamResponse } from './stream.mjs';
 
 class PromiseRequest extends Promise {
     params;
@@ -128,12 +130,22 @@ class PromiseRequest extends Promise {
         void this.then(EE.whenIsRight((response) => {
             if ((response.predicted === true
                 || response.requestParams.disabledPredicateMode === true)
-                && Symbol.asyncIterator in response) {
+                && isClientEventsResponse(response)) {
                 response.onReceiveEvent(eventName, callback);
             }
         }));
         return this;
     }
+    whenReceiveDataStream(callback) {
+        void this.then(EE.whenIsRight((response) => {
+            if ((response.predicted === true
+                || response.requestParams.disabledPredicateMode === true)
+                && isClientStreamResponse(response)) {
+                response.onStream("receiveData", callback);
+            }
+        }));
+        return this;
+    }
     iWantInformation(information) {
         const formattedInformation = AA.coalescing(information);
         return this.then(EE.whenIsRight((response) => {
@@ -295,7 +307,7 @@ class PromiseRequest extends Promise {
             if (EE.isRight(maybeResponse)) {
                 return unwrap(maybeResponse);
             }
-            throw new UnexpectedResponseTypeError("informational", unwrap(maybeResponse));
+            throw new UnexpectedResponseTypeError("serverError", unwrap(maybeResponse));
         });
     }
     iWantExpectedResponseOrThrow() {
@@ -322,6 +334,10 @@ class PromiseRequest extends Promise {
         return Promise;
     }
     static fetch(requestParams) {
+        const cachedResponse = findResponseFromCacheStore(requestParams);
+        if (cachedResponse) {
+            return Promise.resolve(EE.right("response", cachedResponse));
+        }
         const path = insertParamsInPath(requestParams.path, requestParams.params);
         const query = queryToString(requestParams.query);
         const url = query
@@ -336,7 +352,7 @@ class PromiseRequest extends Promise {
                     body = body.toString();
                 }
                 else if (body instanceof TheFormData) {
-                    headers["content-type-options"] = "advanced";
+                    headers["x-duplojs-body-options"] = "advanced";
                 }
                 else if ((body
                     && typeof body === "object"
@@ -360,10 +376,9 @@ class PromiseRequest extends Promise {
             signal: requestParams.abortController.signal,
         };
         return fetch(fetchUrl, fetchInitParams)
-            .then((response) => getBody(response)
-            .then((body) => {
+            .then((response) => {
             const clientResponse = {
-                body,
+                body: undefined,
                 information: response.headers.get(requestParams.informationHeaderKey) ?? undefined,
                 code: response.status.toString(),
                 ok: (response.status < 500)
@@ -380,8 +395,18 @@ class PromiseRequest extends Promise {
             if (response.headers.get("content-type")?.includes("text/event-stream")) {
                 return EE.right("response", makeClientEventsResponse(clientResponse, fetchUrl, fetchInitParams));
             }
-            return EE.right("response", clientResponse);
-        }))
+            if (response.headers.get("x-duplojs-body-options")?.includes("stream")) {
+                return EE.right("response", makeClientStreamResponse(clientResponse));
+            }
+            return getBody(response)
+                .then((body) => {
+                clientResponse.body = body;
+                if (clientResponse.code.startsWith("2")) {
+                    saveResponseInCacheStore(requestParams, clientResponse);
+                }
+                return EE.right("response", clientResponse);
+            });
+        })
             .catch((error) => EE.left("request-error", {
             error,
             requestParams,

package/dist/client/serverSentEvents.cjs

@@ -43,14 +43,7 @@ function makeClientEventsResponse(response, fetchUrl, fetchInitParams) {
         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;
-            },
+            handlerType: "events",
             onStreamEvent: (event, callback) => {
                 if (event === "receiveServerEvents") {
                     receiveEventServerEvent ??= [];
@@ -74,7 +67,18 @@ function makeClientEventsResponse(response, fetchUrl, fetchInitParams) {
                 }
                 return eventResponse;
             },
-            async consumeEventStream() {
+            onReceiveEvent: (eventName, callback) => {
+                receiveEventServerEvent ??= [];
+                receiveEventServerEvent.push((receiveEvent) => receiveEvent.event === eventName
+                    ? callback(receiveEvent, eventResponse)
+                    : undefined);
+                return eventResponse;
+            },
+            closeEventStream: () => {
+                abortController.abort(closeReason);
+                void reader?.cancel(closeReason);
+            },
+            consumeEventStream: async () => {
                 for await (const __ of eventResponse) { }
             },
             [Symbol.asyncIterator]: async function* () {
@@ -94,9 +98,7 @@ function makeClientEventsResponse(response, fetchUrl, fetchInitParams) {
         };
         return eventResponse;
     };
-    if (!reader
-        || response.code === "204"
-        || !response.headers.get("content-type")?.includes("text/event-stream")) {
+    if (!reader || response.code === "204") {
         return createEventResponse(async function* () { });
     }
     return createEventResponse((emitError, emitBeforeRetry) => {
@@ -227,5 +229,9 @@ function makeClientEventsResponse(response, fetchUrl, fetchInitParams) {
         });
     });
 }
+function isClientEventsResponse(response) {
+    return Symbol.asyncIterator in response && response.handlerType === "events";
+}
 
+exports.isClientEventsResponse = isClientEventsResponse;
 exports.makeClientEventsResponse = makeClientEventsResponse;

package/dist/client/serverSentEvents.d.ts

@@ -1,2 +1,3 @@
-import { type ClientEventsResponse, type ClientResponse } from "./types";
+import { type ClientEventsResponse, type ClientResponse, type AllClientResponse } from "./types";
 export declare function makeClientEventsResponse(response: ClientResponse, fetchUrl: string, fetchInitParams: RequestInit): ClientEventsResponse;
+export declare function isClientEventsResponse<GenericResponse extends AllClientResponse>(response: GenericResponse): response is Extract<GenericResponse, ClientEventsResponse>;

package/dist/client/serverSentEvents.mjs

@@ -20,14 +20,7 @@ function makeClientEventsResponse(response, fetchUrl, fetchInitParams) {
         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;
-            },
+            handlerType: "events",
             onStreamEvent: (event, callback) => {
                 if (event === "receiveServerEvents") {
                     receiveEventServerEvent ??= [];
@@ -51,7 +44,18 @@ function makeClientEventsResponse(response, fetchUrl, fetchInitParams) {
                 }
                 return eventResponse;
             },
-            async consumeEventStream() {
+            onReceiveEvent: (eventName, callback) => {
+                receiveEventServerEvent ??= [];
+                receiveEventServerEvent.push((receiveEvent) => receiveEvent.event === eventName
+                    ? callback(receiveEvent, eventResponse)
+                    : undefined);
+                return eventResponse;
+            },
+            closeEventStream: () => {
+                abortController.abort(closeReason);
+                void reader?.cancel(closeReason);
+            },
+            consumeEventStream: async () => {
                 for await (const __ of eventResponse) { }
             },
             [Symbol.asyncIterator]: async function* () {
@@ -71,9 +75,7 @@ function makeClientEventsResponse(response, fetchUrl, fetchInitParams) {
         };
         return eventResponse;
     };
-    if (!reader
-        || response.code === "204"
-        || !response.headers.get("content-type")?.includes("text/event-stream")) {
+    if (!reader || response.code === "204") {
         return createEventResponse(async function* () { });
     }
     return createEventResponse((emitError, emitBeforeRetry) => {
@@ -204,5 +206,8 @@ function makeClientEventsResponse(response, fetchUrl, fetchInitParams) {
         });
     });
 }
+function isClientEventsResponse(response) {
+    return Symbol.asyncIterator in response && response.handlerType === "events";
+}
 
-export { makeClientEventsResponse };
+export { isClientEventsResponse, makeClientEventsResponse };

package/dist/client/stream.cjs

@@ -0,0 +1,117 @@
+'use strict';
+
+var GG = require('@duplojs/utils/generator');
+var hooks = require('./hooks.cjs');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var GG__namespace = /*#__PURE__*/_interopNamespaceDefault(GG);
+
+const closeReason = Symbol("CloseReason");
+function makeClientStreamResponse(response) {
+    const reader = response.raw.body?.getReader();
+    const abortController = response.requestParams.abortController;
+    const createStreamResponse = (streamReaderGenerator) => {
+        let closeStream = undefined;
+        let receiveDataStream = undefined;
+        let errorStream = undefined;
+        let startStream = undefined;
+        const streamResponse = {
+            ...response,
+            handlerType: "stream",
+            onStream: (event, callback) => {
+                if (event === "close") {
+                    closeStream ??= [];
+                    closeStream.push(callback);
+                }
+                else if (event === "receiveData") {
+                    receiveDataStream ??= [];
+                    receiveDataStream.push(callback);
+                }
+                else if (event === "error") {
+                    errorStream ??= [];
+                    errorStream.push(callback);
+                }
+                else if (event === "start") {
+                    startStream ??= [];
+                    startStream.push(callback);
+                }
+                return streamResponse;
+            },
+            closeStream: () => {
+                abortController.abort(closeReason);
+                void reader?.cancel(closeReason);
+            },
+            consumeStream: async () => {
+                for await (const __ of streamResponse) { }
+            },
+            [Symbol.asyncIterator]: async function* () {
+                await hooks.launchStartStreamHook(response.requestParams.hooks.startStream, startStream ?? [], streamResponse).catch(console.error);
+                const onError = (error) => hooks.launchErrorStreamHook(response.requestParams.hooks.errorStream, errorStream ?? [], error, streamResponse).catch(console.error);
+                const generator = streamReaderGenerator(onError);
+                try {
+                    for await (const event of generator) {
+                        await hooks.launchReceiveDataStreamHook(response.requestParams.hooks.receiveDataStream, receiveDataStream ?? [], event, streamResponse).catch(console.error);
+                        yield event;
+                    }
+                }
+                finally {
+                    await hooks.launchCloseStreamHook(response.requestParams.hooks.closeStream, closeStream ?? [], streamResponse).catch(console.error);
+                }
+            },
+        };
+        return streamResponse;
+    };
+    if (!reader || response.code === "204") {
+        return createStreamResponse(async function* () { });
+    }
+    const textDecoder = response.headers.get("content-type")?.includes("text") && new TextDecoder("utf-8");
+    return createStreamResponse((emitError) => GG__namespace.asyncLoop(async ({ next, exit }) => {
+        try {
+            if (abortController.signal.aborted) {
+                return exit();
+            }
+            const result = await reader.read();
+            if (textDecoder) {
+                const chunk = textDecoder.decode(result.value, { stream: true }) || undefined;
+                if (result.done) {
+                    return exit(`${chunk ?? ""}${textDecoder.decode()}` || undefined);
+                }
+                return next(chunk);
+            }
+            else if (result.done) {
+                return exit(result.value);
+            }
+            else {
+                return next(result.value);
+            }
+        }
+        catch (error) {
+            if (error !== closeReason) {
+                await emitError(error);
+            }
+            return exit();
+        }
+    }));
+}
+function isClientStreamResponse(response) {
+    return Symbol.asyncIterator in response && response.handlerType === "stream";
+}
+
+exports.isClientStreamResponse = isClientStreamResponse;
+exports.makeClientStreamResponse = makeClientStreamResponse;

package/dist/client/stream.d.ts

@@ -0,0 +1,3 @@
+import { type ClientResponse, type ClientStreamResponse, type AllClientResponse } from "./types";
+export declare function makeClientStreamResponse(response: ClientResponse): ClientStreamResponse;
+export declare function isClientStreamResponse<GenericResponse extends AllClientResponse>(response: GenericResponse): response is Extract<GenericResponse, ClientStreamResponse>;

package/dist/client/stream.mjs

@@ -0,0 +1,95 @@
+import * as GG from '@duplojs/utils/generator';
+import { launchStartStreamHook, launchErrorStreamHook, launchReceiveDataStreamHook, launchCloseStreamHook } from './hooks.mjs';
+
+const closeReason = Symbol("CloseReason");
+function makeClientStreamResponse(response) {
+    const reader = response.raw.body?.getReader();
+    const abortController = response.requestParams.abortController;
+    const createStreamResponse = (streamReaderGenerator) => {
+        let closeStream = undefined;
+        let receiveDataStream = undefined;
+        let errorStream = undefined;
+        let startStream = undefined;
+        const streamResponse = {
+            ...response,
+            handlerType: "stream",
+            onStream: (event, callback) => {
+                if (event === "close") {
+                    closeStream ??= [];
+                    closeStream.push(callback);
+                }
+                else if (event === "receiveData") {
+                    receiveDataStream ??= [];
+                    receiveDataStream.push(callback);
+                }
+                else if (event === "error") {
+                    errorStream ??= [];
+                    errorStream.push(callback);
+                }
+                else if (event === "start") {
+                    startStream ??= [];
+                    startStream.push(callback);
+                }
+                return streamResponse;
+            },
+            closeStream: () => {
+                abortController.abort(closeReason);
+                void reader?.cancel(closeReason);
+            },
+            consumeStream: async () => {
+                for await (const __ of streamResponse) { }
+            },
+            [Symbol.asyncIterator]: async function* () {
+                await launchStartStreamHook(response.requestParams.hooks.startStream, startStream ?? [], streamResponse).catch(console.error);
+                const onError = (error) => launchErrorStreamHook(response.requestParams.hooks.errorStream, errorStream ?? [], error, streamResponse).catch(console.error);
+                const generator = streamReaderGenerator(onError);
+                try {
+                    for await (const event of generator) {
+                        await launchReceiveDataStreamHook(response.requestParams.hooks.receiveDataStream, receiveDataStream ?? [], event, streamResponse).catch(console.error);
+                        yield event;
+                    }
+                }
+                finally {
+                    await launchCloseStreamHook(response.requestParams.hooks.closeStream, closeStream ?? [], streamResponse).catch(console.error);
+                }
+            },
+        };
+        return streamResponse;
+    };
+    if (!reader || response.code === "204") {
+        return createStreamResponse(async function* () { });
+    }
+    const textDecoder = response.headers.get("content-type")?.includes("text") && new TextDecoder("utf-8");
+    return createStreamResponse((emitError) => GG.asyncLoop(async ({ next, exit }) => {
+        try {
+            if (abortController.signal.aborted) {
+                return exit();
+            }
+            const result = await reader.read();
+            if (textDecoder) {
+                const chunk = textDecoder.decode(result.value, { stream: true }) || undefined;
+                if (result.done) {
+                    return exit(`${chunk ?? ""}${textDecoder.decode()}` || undefined);
+                }
+                return next(chunk);
+            }
+            else if (result.done) {
+                return exit(result.value);
+            }
+            else {
+                return next(result.value);
+            }
+        }
+        catch (error) {
+            if (error !== closeReason) {
+                await emitError(error);
+            }
+            return exit();
+        }
+    }));
+}
+function isClientStreamResponse(response) {
+    return Symbol.asyncIterator in response && response.handlerType === "stream";
+}
+
+export { isClientStreamResponse, makeClientStreamResponse };

package/dist/client/types/clientCache.cjs

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

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

@@ -0,0 +1,27 @@
+import type * as SS from "@duplojs/utils/string";
+import { type ClientRequestParamsBody, type ClientRequestParamsHeaders, type ClientRequestParamsParams, type ClientRequestParamsQuery } from "./clientRequestParams";
+import { type ClientResponseBody } from "./clientResponse";
+import { type BivariantFunction } from "@duplojs/utils";
+export interface ClientCacheValue {
+    information?: string;
+    body: ClientResponseBody;
+    headers: Record<string, string>;
+    ok: boolean | null;
+    type: ResponseType;
+    code: SS.Number;
+    url: string;
+    redirected: boolean;
+    predicted: boolean;
+}
+export type ClientCacheInitialValues = Record<string, ClientCacheValue>;
+export type ClientCacheStore = Map<string, ClientCacheValue>;
+export interface CreateClientCacheKeyParams<GenericHookParams extends Record<string, unknown> = Record<string, unknown>> {
+    method: string;
+    path: string;
+    headers: ClientRequestParamsHeaders | undefined;
+    params: ClientRequestParamsParams | undefined;
+    query: ClientRequestParamsQuery | undefined;
+    body: ClientRequestParamsBody;
+    hookParams: GenericHookParams | undefined;
+}
+export type CreateClientCacheKey<GenericHookParams extends Record<string, unknown> = Record<string, unknown>> = BivariantFunction<(params: CreateClientCacheKeyParams<GenericHookParams>) => string | null>;

package/dist/client/types/clientCache.mjs

@@ -0,0 +1 @@
+

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

@@ -2,6 +2,7 @@ import { type SimplifyTopLevel, type IsEqual, type MaybeArray, type AnyTuple } f
 import { type ServerRouteHeaders, type ServerRouteParams, type ServerRouteQuery, type ServerRoute, type ServerPrimitiveData } from "./serverRoute";
 import { type ObjectCanBeEmpty } from "./ObjectCanBeEmpty";
 import type * as OO from "@duplojs/utils/object";
+import { type CreateClientCacheKey } from "./clientCache";
 export interface ClientRequestInitParams extends Pick<RequestInit, "cache" | "credentials" | "integrity" | "keepalive" | "mode" | "redirect" | "referrer" | "referrerPolicy" | "signal"> {
 }
 export type ClientRequestParamsHeaders = Record<string, string | undefined | {
@@ -24,6 +25,9 @@ export interface ClientRequestParams<GenericHookParams extends Record<string, un
     abortController?: AbortController;
     initParams?: ClientRequestInitParams;
     hookParams?: GenericHookParams;
+    clientCache?: "auto" | CreateClientCacheKey<GenericHookParams>;
+    bypassClientCache?: boolean;
+    refreshClientCache?: boolean;
 }
 type StringifyTuple<GenericTuple extends AnyTuple<ServerPrimitiveData>> = GenericTuple extends [
     infer InferredFirst extends ServerPrimitiveData,
@@ -47,6 +51,9 @@ export type ServerRouteToClientRequestParams<GenericServerRoute extends ServerRo
     abortController?: AbortController;
     initParams?: ClientRequestInitParams;
     hookParams?: GenericHookParams;
+    bypassClientCache?: boolean;
+    refreshClientCache?: boolean;
+    clientCache?: "auto" | CreateClientCacheKey<GenericHookParams>;
 } & MaybeParams<(IsEqual<GenericServerRoute["headers"], unknown> extends true ? {} : {
     headers: ServerRouteToClientRequestParamsHeaders<GenericServerRoute["headers"]>;
 }) & (IsEqual<GenericServerRoute["params"], unknown> extends true ? {} : {
@@ -55,5 +62,5 @@ export type ServerRouteToClientRequestParams<GenericServerRoute extends ServerRo
     query: ServerRouteToClientRequestParamsQuery<GenericServerRoute["query"]>;
 }) & (IsEqual<GenericServerRoute["body"], unknown> extends true ? {} : {
     body: GenericServerRoute["body"];
-})>)> extends infer InferredResult extends ClientRequestParams ? InferredResult : never : never;
+})>)> extends infer InferredResult extends ClientRequestParams<GenericHookParams> ? InferredResult : never : never;
 export {};

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

@@ -1,7 +1,8 @@
 import type * as SS from "@duplojs/utils/string";
-import { type ServerRouteResponse, type ServerRoute } from "./serverRoute";
+import { type ServerRouteResponse, type ServerRoute, type ServerRouteResponseFlux } from "./serverRoute";
 import { type MaybePromise, type IsEqual, type SimplifyTopLevel, type NeverCoalescing } from "@duplojs/utils";
 import { type PromiseRequestParams } from "./promiseRequestParams";
+import { type ServerRouteToClientRequestParams } from "./clientRequestParams";
 export type ClientResponseBody = unknown;
 export interface ClientResponse<GenericHookParams extends Record<string, unknown> = Record<string, unknown>> {
     code: SS.Number;
@@ -15,6 +16,20 @@ export interface ClientResponse<GenericHookParams extends Record<string, unknown
     raw: globalThis.Response;
     requestParams: PromiseRequestParams<GenericHookParams>;
     predicted: boolean;
+    fromCache?: boolean;
+}
+export interface ClientResponseHandler<GenericType extends string> {
+    handlerType: GenericType;
+}
+export interface ClientStreamResponseHandler<GenericFlux extends ServerRouteResponseFlux = ServerRouteResponseFlux> extends AsyncIterable<GenericFlux, void>, ClientResponseHandler<"stream"> {
+    closeStream(): void;
+    onStream(event: "close", callback: (response: this) => MaybePromise<void>): this;
+    onStream(event: "error", callback: (error: unknown, response: this) => MaybePromise<void>): this;
+    onStream(event: "start", callback: (response: this) => MaybePromise<void>): this;
+    onStream(event: "receiveData", callback: (data: GenericFlux, response: this) => MaybePromise<void>): this;
+    consumeStream(): Promise<void>;
+}
+export interface ClientStreamResponse<GenericHookParams extends Record<string, unknown> = Record<string, unknown>> extends ClientResponse<GenericHookParams>, ClientStreamResponseHandler {
 }
 export interface ServerEvent {
     data: unknown;
@@ -22,7 +37,7 @@ export interface ServerEvent {
     id?: string;
     retry?: number;
 }
-export interface ClientEventsResponseHandler<GenericServerEvent extends ServerEvent = ServerEvent> extends AsyncIterable<GenericServerEvent, void> {
+export interface ClientEventsResponseHandler<GenericServerEvent extends ServerEvent = ServerEvent> extends AsyncIterable<GenericServerEvent, void>, ClientResponseHandler<"events"> {
     closeEventStream(): void;
     onReceiveEvent<GenericEventName extends GenericServerEvent["event"]>(name: GenericEventName, callback: (event: NeverCoalescing<Extract<GenericServerEvent, {
         event: GenericEventName;
@@ -36,13 +51,15 @@ export interface ClientEventsResponseHandler<GenericServerEvent extends ServerEv
 }
 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 type AllClientResponse<GenericHookParams extends Record<string, unknown> = Record<string, unknown>> = (ClientResponse<GenericHookParams> | ClientStreamResponse<GenericHookParams> | ClientEventsResponse<GenericHookParams>);
 export interface NotPredictedClientResponse<GenericHookParams extends Record<string, unknown> = Record<string, unknown>> extends ClientResponse<GenericHookParams> {
     predicted: false;
 }
+export interface NotPredictedClientStreamResponse<GenericHookParams extends Record<string, unknown> = Record<string, unknown>> extends NotPredictedClientResponse<GenericHookParams>, ClientStreamResponseHandler {
+}
 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 AllNotPredictedClientResponse<GenericHookParams extends Record<string, unknown> = Record<string, unknown>> = (NotPredictedClientResponse<GenericHookParams> | NotPredictedClientStreamResponse<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"];
@@ -53,8 +70,9 @@ export type ServerRouteToClientResponse<GenericServerRoute extends ServerRoute =
     url: string;
     redirected: boolean;
     raw: globalThis.Response;
-    requestParams: PromiseRequestParams<GenericHookParams>;
+    requestParams: SimplifyTopLevel<ServerRouteToClientRequestParams<GenericServerRoute, GenericHookParams> & PromiseRequestParams<GenericHookParams>>;
     predicted: boolean;
+    fromCache?: boolean;
 }> & (IsEqual<InferredResponse["events"], unknown> extends true ? unknown : InferredResponse["events"] extends object ? ClientEventsResponseHandler<{
     [EventName in keyof InferredResponse["events"]]: EventName extends string ? {
         event: EventName;
@@ -62,4 +80,4 @@ export type ServerRouteToClientResponse<GenericServerRoute extends ServerRoute =
         id?: string;
         retry?: number;
     } : never;
-}[keyof InferredResponse["events"]]> : unknown)) extends infer InferredResult extends ClientResponse ? InferredResult : never : never : never : never;
+}[keyof InferredResponse["events"]]> : unknown) & (IsEqual<InferredResponse["flux"], unknown> extends true ? unknown : InferredResponse["flux"] extends ServerRouteResponseFlux ? ClientStreamResponseHandler<InferredResponse["flux"]> : never)) extends infer InferredResult extends ClientResponse ? InferredResult : never : never : never : never;

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

@@ -1,6 +1,7 @@
 import { type MaybePromise } from "@duplojs/utils";
-import { type ClientEventsResponse, type ServerEvent, type AllClientResponse, type AllNotPredictedClientResponse } from "./clientResponse";
+import { type ClientEventsResponse, type ServerEvent, type AllClientResponse, type AllNotPredictedClientResponse, type ClientStreamResponse } from "./clientResponse";
 import { type PromiseRequestParams } from "./promiseRequestParams";
+import { type ServerRouteResponseFlux } from "./serverRoute";
 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: AllClientResponse<GenericHookParams>) => MaybePromise<AllClientResponse<GenericHookParams>>;
 export type InformationHook<GenericHookParams extends Record<string, unknown> = Record<string, unknown>> = (response: AllClientResponse<GenericHookParams>) => MaybePromise<void>;
@@ -14,6 +15,10 @@ export type BeforeRetryServerEventHook<GenericHookParams extends Record<string,
 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 type CloseStreamHook<GenericHookParams extends Record<string, unknown> = Record<string, unknown>> = (response: ClientStreamResponse<GenericHookParams>) => MaybePromise<void>;
+export type ReceiveDataStreamHook<GenericHookParams extends Record<string, unknown> = Record<string, unknown>> = (data: ServerRouteResponseFlux, response: ClientStreamResponse<GenericHookParams>) => MaybePromise<void>;
+export type ErrorStreamHook<GenericHookParams extends Record<string, unknown> = Record<string, unknown>> = (error: unknown, response: ClientStreamResponse<GenericHookParams>) => MaybePromise<void>;
+export type StartStreamHook<GenericHookParams extends Record<string, unknown> = Record<string, unknown>> = (response: ClientStreamResponse<GenericHookParams>) => MaybePromise<void>;
 export interface Hooks {
     request: RequestHook[];
     response: ResponseHook[];
@@ -32,4 +37,8 @@ export interface Hooks {
     errorServerEvent: ErrorServerEventHook[];
     startServerEvent: StartServerEventHook[];
     receiveEventServerEvent: ReceiveEventServerEventHook[];
+    closeStream: CloseStreamHook[];
+    receiveDataStream: ReceiveDataStreamHook[];
+    errorStream: ErrorStreamHook[];
+    startStream: StartStreamHook[];
 }

package/dist/client/types/index.cjs

@@ -6,4 +6,5 @@ require('./serverRoute.cjs');
 require('./ObjectCanBeEmpty.cjs');
 require('./promiseRequestParams.cjs');
 require('./hooks.cjs');
+require('./clientCache.cjs');
 

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

@@ -4,3 +4,4 @@ export * from "./serverRoute";
 export * from "./ObjectCanBeEmpty";
 export * from "./promiseRequestParams";
 export * from "./hooks";
+export * from "./clientCache";

package/dist/client/types/index.mjs

@@ -4,3 +4,4 @@ import './serverRoute.mjs';
 import './ObjectCanBeEmpty.mjs';
 import './promiseRequestParams.mjs';
 import './hooks.mjs';
+import './clientCache.mjs';