@duplojs/http 0.9.5 → 0.11.0

package/dist/client/clientCache.cjs

@@ -0,0 +1,84 @@
+'use strict';
+
+var insertParamsInPath = require('./insertParamsInPath.cjs');
+
+function autoCreateCacheKey(params) {
+    try {
+        return JSON.stringify({
+            method: params.method,
+            path: insertParamsInPath.insertParamsInPath(params.path, params.params),
+            query: params.query
+                ? Object.entries(params.query).sort((entryA, entryB) => entryA[0].localeCompare(entryB[0]))
+                : undefined,
+            body: params.body,
+        });
+    }
+    catch {
+        return null;
+    }
+}
+function findResponseFromCacheStore(requestParams) {
+    if (!requestParams.clientCache
+        || requestParams.bypassClientCache === true
+        || requestParams.refreshClientCache === true) {
+        return null;
+    }
+    const key = requestParams.clientCache({
+        method: requestParams.method,
+        path: requestParams.path,
+        body: requestParams.body,
+        headers: requestParams.headers,
+        hookParams: requestParams.hookParams,
+        params: requestParams.params,
+        query: requestParams.query,
+    });
+    if (key === null) {
+        return null;
+    }
+    const cachedResponse = requestParams.cacheStore.get(key);
+    if (!cachedResponse) {
+        return null;
+    }
+    const rawResponse = new Response(undefined, { headers: cachedResponse.headers });
+    return {
+        ...cachedResponse,
+        information: cachedResponse.information,
+        headers: rawResponse.headers,
+        raw: rawResponse,
+        requestParams,
+        fromCache: true,
+    };
+}
+function saveResponseInCacheStore(requestParams, clientResponse) {
+    if (!requestParams.clientCache
+        || requestParams.bypassClientCache === true) {
+        return;
+    }
+    const key = requestParams.clientCache({
+        method: requestParams.method,
+        path: requestParams.path,
+        body: requestParams.body,
+        headers: requestParams.headers,
+        hookParams: requestParams.hookParams,
+        params: requestParams.params,
+        query: requestParams.query,
+    });
+    if (key === null) {
+        return;
+    }
+    requestParams.cacheStore.set(key, {
+        body: clientResponse.body,
+        code: clientResponse.code,
+        headers: Object.fromEntries(clientResponse.headers.entries()),
+        information: clientResponse.information,
+        ok: clientResponse.ok,
+        predicted: clientResponse.predicted,
+        redirected: clientResponse.redirected,
+        type: clientResponse.type,
+        url: clientResponse.url,
+    });
+}
+
+exports.autoCreateCacheKey = autoCreateCacheKey;
+exports.findResponseFromCacheStore = findResponseFromCacheStore;
+exports.saveResponseInCacheStore = saveResponseInCacheStore;

package/dist/client/clientCache.d.ts

@@ -0,0 +1,4 @@
+import { type PromiseRequestParams, type ClientResponse, type CreateClientCacheKeyParams } from "./types";
+export declare function autoCreateCacheKey(params: CreateClientCacheKeyParams): string | null;
+export declare function findResponseFromCacheStore(requestParams: PromiseRequestParams): null | ClientResponse;
+export declare function saveResponseInCacheStore(requestParams: PromiseRequestParams, clientResponse: ClientResponse): void;

package/dist/client/clientCache.mjs

@@ -0,0 +1,80 @@
+import { insertParamsInPath } from './insertParamsInPath.mjs';
+
+function autoCreateCacheKey(params) {
+    try {
+        return JSON.stringify({
+            method: params.method,
+            path: insertParamsInPath(params.path, params.params),
+            query: params.query
+                ? Object.entries(params.query).sort((entryA, entryB) => entryA[0].localeCompare(entryB[0]))
+                : undefined,
+            body: params.body,
+        });
+    }
+    catch {
+        return null;
+    }
+}
+function findResponseFromCacheStore(requestParams) {
+    if (!requestParams.clientCache
+        || requestParams.bypassClientCache === true
+        || requestParams.refreshClientCache === true) {
+        return null;
+    }
+    const key = requestParams.clientCache({
+        method: requestParams.method,
+        path: requestParams.path,
+        body: requestParams.body,
+        headers: requestParams.headers,
+        hookParams: requestParams.hookParams,
+        params: requestParams.params,
+        query: requestParams.query,
+    });
+    if (key === null) {
+        return null;
+    }
+    const cachedResponse = requestParams.cacheStore.get(key);
+    if (!cachedResponse) {
+        return null;
+    }
+    const rawResponse = new Response(undefined, { headers: cachedResponse.headers });
+    return {
+        ...cachedResponse,
+        information: cachedResponse.information,
+        headers: rawResponse.headers,
+        raw: rawResponse,
+        requestParams,
+        fromCache: true,
+    };
+}
+function saveResponseInCacheStore(requestParams, clientResponse) {
+    if (!requestParams.clientCache
+        || requestParams.bypassClientCache === true) {
+        return;
+    }
+    const key = requestParams.clientCache({
+        method: requestParams.method,
+        path: requestParams.path,
+        body: requestParams.body,
+        headers: requestParams.headers,
+        hookParams: requestParams.hookParams,
+        params: requestParams.params,
+        query: requestParams.query,
+    });
+    if (key === null) {
+        return;
+    }
+    requestParams.cacheStore.set(key, {
+        body: clientResponse.body,
+        code: clientResponse.code,
+        headers: Object.fromEntries(clientResponse.headers.entries()),
+        information: clientResponse.information,
+        ok: clientResponse.ok,
+        predicted: clientResponse.predicted,
+        redirected: clientResponse.redirected,
+        type: clientResponse.type,
+        url: clientResponse.url,
+    });
+}
+
+export { autoCreateCacheKey, findResponseFromCacheStore, saveResponseInCacheStore };

package/dist/client/getBody.cjs

@@ -5,9 +5,6 @@ function getBody(response) {
     if (!responseContentType) {
         return Promise.resolve(undefined);
     }
-    else if (responseContentType.includes("text/event-stream")) {
-        return Promise.resolve(undefined);
-    }
     else if (responseContentType.includes("json")) {
         return response.json();
     }

package/dist/client/getBody.mjs

@@ -3,9 +3,6 @@ function getBody(response) {
     if (!responseContentType) {
         return Promise.resolve(undefined);
     }
-    else if (responseContentType.includes("text/event-stream")) {
-        return Promise.resolve(undefined);
-    }
     else if (responseContentType.includes("json")) {
         return response.json();
     }

package/dist/client/hooks.cjs

@@ -108,17 +108,53 @@ async function launchReceiveEventServerEventHook(clientHook, promiseRequestHook,
         await clientHook[index](event, response);
     }
 }
+async function launchCloseStreamHook(clientHook, promiseRequestHook, response) {
+    for (let index = 0; index < promiseRequestHook.length; index++) {
+        await promiseRequestHook[index](response);
+    }
+    for (let index = 0; index < clientHook.length; index++) {
+        await clientHook[index](response);
+    }
+}
+async function launchReceiveDataStreamHook(clientHook, promiseRequestHook, data, response) {
+    for (let index = 0; index < promiseRequestHook.length; index++) {
+        await promiseRequestHook[index](data, response);
+    }
+    for (let index = 0; index < clientHook.length; index++) {
+        await clientHook[index](data, response);
+    }
+}
+async function launchErrorStreamHook(clientHook, promiseRequestHook, error, response) {
+    for (let index = 0; index < promiseRequestHook.length; index++) {
+        await promiseRequestHook[index](error, response);
+    }
+    for (let index = 0; index < clientHook.length; index++) {
+        await clientHook[index](error, response);
+    }
+}
+async function launchStartStreamHook(clientHook, promiseRequestHook, response) {
+    for (let index = 0; index < promiseRequestHook.length; index++) {
+        await promiseRequestHook[index](response);
+    }
+    for (let index = 0; index < clientHook.length; index++) {
+        await clientHook[index](response);
+    }
+}
 
 exports.launchBeforeRetryServerEventHook = launchBeforeRetryServerEventHook;
 exports.launchCloseServerEventHook = launchCloseServerEventHook;
+exports.launchCloseStreamHook = launchCloseStreamHook;
 exports.launchCodeHook = launchCodeHook;
 exports.launchErrorHook = launchErrorHook;
 exports.launchErrorServerEventHook = launchErrorServerEventHook;
+exports.launchErrorStreamHook = launchErrorStreamHook;
 exports.launchExpectedResponseHook = launchExpectedResponseHook;
 exports.launchInformationHook = launchInformationHook;
 exports.launchNotPredictedHook = launchNotPredictedHook;
+exports.launchReceiveDataStreamHook = launchReceiveDataStreamHook;
 exports.launchReceiveEventServerEventHook = launchReceiveEventServerEventHook;
 exports.launchRequestHook = launchRequestHook;
 exports.launchResponseHook = launchResponseHook;
 exports.launchResponseTypeHook = launchResponseTypeHook;
 exports.launchStartServerEventHook = launchStartServerEventHook;
+exports.launchStartStreamHook = launchStartStreamHook;

package/dist/client/hooks.d.ts

@@ -1,4 +1,4 @@
-import { type CodeHook, type ErrorHook, type InformationHook, type NotPredictedResponseHook, type RequestHook, type ResponseHook, type ResponseTypeHook, type PromiseRequestParams, type NotPredictedClientResponse, type ClientResponse, type CloseServerEventHook, type ClientEventsResponse, type BeforeRetryServerEventHook, type ErrorServerEventHook, type StartServerEventHook, type ServerEvent, type ReceiveEventServerEventHook } from "./types";
+import { type CodeHook, type ErrorHook, type InformationHook, type NotPredictedResponseHook, type RequestHook, type ResponseHook, type ResponseTypeHook, type PromiseRequestParams, type NotPredictedClientResponse, type ClientResponse, type CloseServerEventHook, type ClientEventsResponse, type BeforeRetryServerEventHook, type ErrorServerEventHook, type StartServerEventHook, type ServerEvent, type ReceiveEventServerEventHook, type CloseStreamHook, type ClientStreamResponse, type ReceiveDataStreamHook, type ErrorStreamHook, type StartStreamHook, type ServerRouteResponseFlux } from "./types";
 export declare function launchRequestHook(clientHook: readonly RequestHook[], promiseRequestHook: readonly RequestHook[], requestParams: PromiseRequestParams): Promise<PromiseRequestParams>;
 export declare function launchResponseHook(clientHook: readonly ResponseHook[], promiseRequestHook: readonly ResponseHook[], response: ClientResponse): Promise<ClientResponse>;
 export declare function launchInformationHook(clientHook: readonly InformationHook[], promiseRequestHook: readonly InformationHook[], response: ClientResponse): Promise<void>;
@@ -12,3 +12,7 @@ export declare function launchBeforeRetryServerEventHook(clientHook: readonly Be
 export declare function launchErrorServerEventHook(clientHook: readonly ErrorServerEventHook[], promiseRequestHook: readonly ErrorServerEventHook[], error: unknown, response: ClientEventsResponse): Promise<void>;
 export declare function launchStartServerEventHook(clientHook: readonly StartServerEventHook[], promiseRequestHook: readonly StartServerEventHook[], response: ClientEventsResponse): Promise<void>;
 export declare function launchReceiveEventServerEventHook(clientHook: readonly ReceiveEventServerEventHook[], promiseRequestHook: readonly ReceiveEventServerEventHook[], event: ServerEvent, response: ClientEventsResponse): Promise<void>;
+export declare function launchCloseStreamHook(clientHook: readonly CloseStreamHook[], promiseRequestHook: readonly CloseStreamHook[], response: ClientStreamResponse): Promise<void>;
+export declare function launchReceiveDataStreamHook(clientHook: readonly ReceiveDataStreamHook[], promiseRequestHook: readonly ReceiveDataStreamHook[], data: ServerRouteResponseFlux, response: ClientStreamResponse): Promise<void>;
+export declare function launchErrorStreamHook(clientHook: readonly ErrorStreamHook[], promiseRequestHook: readonly ErrorStreamHook[], error: unknown, response: ClientStreamResponse): Promise<void>;
+export declare function launchStartStreamHook(clientHook: readonly StartStreamHook[], promiseRequestHook: readonly StartStreamHook[], response: ClientStreamResponse): Promise<void>;

package/dist/client/hooks.mjs

@@ -106,5 +106,37 @@ async function launchReceiveEventServerEventHook(clientHook, promiseRequestHook,
         await clientHook[index](event, response);
     }
 }
+async function launchCloseStreamHook(clientHook, promiseRequestHook, response) {
+    for (let index = 0; index < promiseRequestHook.length; index++) {
+        await promiseRequestHook[index](response);
+    }
+    for (let index = 0; index < clientHook.length; index++) {
+        await clientHook[index](response);
+    }
+}
+async function launchReceiveDataStreamHook(clientHook, promiseRequestHook, data, response) {
+    for (let index = 0; index < promiseRequestHook.length; index++) {
+        await promiseRequestHook[index](data, response);
+    }
+    for (let index = 0; index < clientHook.length; index++) {
+        await clientHook[index](data, response);
+    }
+}
+async function launchErrorStreamHook(clientHook, promiseRequestHook, error, response) {
+    for (let index = 0; index < promiseRequestHook.length; index++) {
+        await promiseRequestHook[index](error, response);
+    }
+    for (let index = 0; index < clientHook.length; index++) {
+        await clientHook[index](error, response);
+    }
+}
+async function launchStartStreamHook(clientHook, promiseRequestHook, response) {
+    for (let index = 0; index < promiseRequestHook.length; index++) {
+        await promiseRequestHook[index](response);
+    }
+    for (let index = 0; index < clientHook.length; index++) {
+        await clientHook[index](response);
+    }
+}
 
-export { launchBeforeRetryServerEventHook, launchCloseServerEventHook, launchCodeHook, launchErrorHook, launchErrorServerEventHook, launchExpectedResponseHook, launchInformationHook, launchNotPredictedHook, launchReceiveEventServerEventHook, launchRequestHook, launchResponseHook, launchResponseTypeHook, launchStartServerEventHook };
+export { launchBeforeRetryServerEventHook, launchCloseServerEventHook, launchCloseStreamHook, launchCodeHook, launchErrorHook, launchErrorServerEventHook, launchErrorStreamHook, launchExpectedResponseHook, launchInformationHook, launchNotPredictedHook, launchReceiveDataStreamHook, launchReceiveEventServerEventHook, launchRequestHook, launchResponseHook, launchResponseTypeHook, launchStartServerEventHook, launchStartStreamHook };

package/dist/client/httpClient.cjs

@@ -4,6 +4,7 @@ var OO = require('@duplojs/utils/object');
 var GG = require('@duplojs/utils/generator');
 var kind = require('./kind.cjs');
 var promiseRequest = require('./promiseRequest.cjs');
+var clientCache = require('./clientCache.cjs');
 
 function _interopNamespaceDefault(e) {
     var n = Object.create(null);
@@ -27,6 +28,9 @@ var GG__namespace = /*#__PURE__*/_interopNamespaceDefault(GG);
 
 const httpClientKind = kind.createClientKind("http-client");
 function createHttpClient(clientParams) {
+    const cacheStore = new Map(clientParams.clientCacheInitialValues
+        ? OO__namespace.entries(clientParams.clientCacheInitialValues)
+        : []);
     const hooks = OO__namespace.override({
         request: [],
         response: [],
@@ -45,6 +49,10 @@ function createHttpClient(clientParams) {
         errorServerEvent: [],
         receiveEventServerEvent: [],
         startServerEvent: [],
+        closeStream: [],
+        errorStream: [],
+        receiveDataStream: [],
+        startStream: [],
     }, clientParams.hooks ?? {});
     const config = {
         baseUrl: clientParams.baseUrl,
@@ -59,6 +67,7 @@ function createHttpClient(clientParams) {
         config,
         hooks,
         defaultHeaders,
+        cacheStore,
         addDefaultHeader(headerName, headerValue) {
             defaultHeaders.set(headerName, typeof headerValue === "function"
                 ? headerValue
@@ -122,6 +131,18 @@ function createHttpClient(clientParams) {
         addStartServerEventHook(hook) {
             hooks.startServerEvent.push(hook);
         },
+        addCloseStreamHook(hook) {
+            hooks.closeStream.push(hook);
+        },
+        addReceiveDataStreamHook(hook) {
+            hooks.receiveDataStream.push(hook);
+        },
+        addErrorStreamHook(hook) {
+            hooks.errorStream.push(hook);
+        },
+        addStartStreamHook(hook) {
+            hooks.startStream.push(hook);
+        },
         request(params) {
             const headers = GG__namespace.reduce(defaultHeaders.entries(), GG__namespace.reduceFrom({}), ({ element, lastValue, next }) => {
                 const value = element[1]();
@@ -135,8 +156,8 @@ function createHttpClient(clientParams) {
                 baseUrl: config.baseUrl,
                 ...params,
                 headers: {
-                    ...params.headers,
                     ...headers,
+                    ...params.headers,
                 },
                 initParams: {
                     ...params.initParams,
@@ -147,6 +168,10 @@ function createHttpClient(clientParams) {
                 informationHeaderKey: config.informationHeaderKey,
                 disabledPredicateMode: config.disabledPredictedMode,
                 abortController: params.abortController ?? new AbortController(),
+                cacheStore: cacheStore,
+                clientCache: params.clientCache === "auto"
+                    ? clientCache.autoCreateCacheKey
+                    : params.clientCache,
             });
         },
         get: ((path, params) => self.request({

package/dist/client/httpClient.d.ts

@@ -1,5 +1,5 @@
 import { type Kind, type MayBeGetter, type SimplifyTopLevel, type IsEqual } from "@duplojs/utils";
-import { type ClientRequestInitParams, type ServerRoute, type ServerRouteToClientRequestParams, type ServerRouteToClientResponse, type ClientRequestParams, type Hooks, type RequestHook, type ResponseHook, type InformationHook, type CodeHook, type ResponseTypeHook, type ExpectedResponseHook, type NotPredictedResponseHook, type ErrorHook, type GetServerRoutePath, type AllClientResponse, type BeforeRetryServerEventHook, type CloseServerEventHook, type ErrorServerEventHook, type StartServerEventHook, type ReceiveEventServerEventHook } from "./types";
+import { type ClientRequestInitParams, type ServerRoute, type ServerRouteToClientRequestParams, type ServerRouteToClientResponse, type ClientRequestParams, type Hooks, type RequestHook, type ResponseHook, type InformationHook, type CodeHook, type ResponseTypeHook, type ExpectedResponseHook, type NotPredictedResponseHook, type ErrorHook, type GetServerRoutePath, type AllClientResponse, type BeforeRetryServerEventHook, type CloseServerEventHook, type ErrorServerEventHook, type StartServerEventHook, type ReceiveEventServerEventHook, type ClientCacheInitialValues, type ClientCacheStore, type CloseStreamHook, type ReceiveDataStreamHook, type ErrorStreamHook, type StartStreamHook } from "./types";
 import { PromiseRequest } from "./promiseRequest";
 export declare const httpClientKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpClient/http-client", unknown>>;
 type MaybeRequestParams<GenericRequestParams extends object> = {} extends GenericRequestParams ? [params?: GenericRequestParams] : [params: GenericRequestParams];
@@ -21,11 +21,13 @@ export interface HttpClientConfig {
     readonly disabledPredictedMode: boolean;
     readonly credentials?: ClientRequestInitParams["credentials"];
     readonly cache?: ClientRequestInitParams["cache"];
+    readonly clientCacheInitialValues?: ClientCacheInitialValues;
 }
 export interface HttpClient<GenericServerRoute extends ServerRoute = ServerRoute, GenericHookParams extends Record<string, unknown> = Record<string, unknown>> extends Kind<typeof httpClientKind.definition> {
     readonly config: HttpClientConfig;
     readonly hooks: Hooks;
     readonly defaultHeaders: Map<string, () => (string | undefined | null)>;
+    readonly cacheStore: ClientCacheStore;
     addDefaultHeader(headerName: string, headerValue: MayBeGetter<string | undefined | null>): void;
     addDefaultHeaders(headers: Record<string, MayBeGetter<string | undefined | null>>): void;
     addRequestHook(hook: RequestHook<GenericHookParams>): void;
@@ -45,6 +47,10 @@ export interface HttpClient<GenericServerRoute extends ServerRoute = ServerRoute
     addErrorServerEventHook(hook: ErrorServerEventHook<GenericHookParams>): void;
     addStartServerEventHook(hook: StartServerEventHook<GenericHookParams>): void;
     addReceiveEventServerEventHook(hook: ReceiveEventServerEventHook<GenericHookParams>): void;
+    addCloseStreamHook(hook: CloseStreamHook<GenericHookParams>): void;
+    addReceiveDataStreamHook(hook: ReceiveDataStreamHook<GenericHookParams>): void;
+    addErrorStreamHook(hook: ErrorStreamHook<GenericHookParams>): void;
+    addStartStreamHook(hook: StartStreamHook<GenericHookParams>): void;
     request<GenericClientRequestParams extends ServerRouteToClientRequestParams<GenericServerRoute, GenericHookParams>, GenericMatchedPath extends GetServerRoutePath<Extract<GenericServerRoute, {
         method: GenericClientRequestParams["method"];
     }>, GenericClientRequestParams["path"]>>(params: GenericClientRequestParams): PromiseRequest<GenericHookParams, IsEqual<GenericServerRoute, ServerRoute> extends true ? AllClientResponse<GenericHookParams> : ServerRouteToClientResponse<Extract<GenericServerRoute, {
@@ -65,6 +71,7 @@ export interface CreateHttpClientParams {
     readonly informationHeaderKey?: string;
     readonly predictedHeaderKey?: string;
     readonly disabledPredictedMode?: boolean;
+    readonly clientCacheInitialValues?: ClientCacheInitialValues;
 }
 export declare function createHttpClient<GenericServerRoute extends ServerRoute = ServerRoute, GenericHookParams extends Record<string, unknown> = Record<string, unknown>>(clientParams: CreateHttpClientParams): HttpClient<GenericServerRoute, GenericHookParams>;
 export {};

package/dist/client/httpClient.mjs

@@ -2,9 +2,13 @@ import * as OO from '@duplojs/utils/object';
 import * as GG from '@duplojs/utils/generator';
 import { createClientKind } from './kind.mjs';
 import { PromiseRequest } from './promiseRequest.mjs';
+import { autoCreateCacheKey } from './clientCache.mjs';
 
 const httpClientKind = createClientKind("http-client");
 function createHttpClient(clientParams) {
+    const cacheStore = new Map(clientParams.clientCacheInitialValues
+        ? OO.entries(clientParams.clientCacheInitialValues)
+        : []);
     const hooks = OO.override({
         request: [],
         response: [],
@@ -23,6 +27,10 @@ function createHttpClient(clientParams) {
         errorServerEvent: [],
         receiveEventServerEvent: [],
         startServerEvent: [],
+        closeStream: [],
+        errorStream: [],
+        receiveDataStream: [],
+        startStream: [],
     }, clientParams.hooks ?? {});
     const config = {
         baseUrl: clientParams.baseUrl,
@@ -37,6 +45,7 @@ function createHttpClient(clientParams) {
         config,
         hooks,
         defaultHeaders,
+        cacheStore,
         addDefaultHeader(headerName, headerValue) {
             defaultHeaders.set(headerName, typeof headerValue === "function"
                 ? headerValue
@@ -100,6 +109,18 @@ function createHttpClient(clientParams) {
         addStartServerEventHook(hook) {
             hooks.startServerEvent.push(hook);
         },
+        addCloseStreamHook(hook) {
+            hooks.closeStream.push(hook);
+        },
+        addReceiveDataStreamHook(hook) {
+            hooks.receiveDataStream.push(hook);
+        },
+        addErrorStreamHook(hook) {
+            hooks.errorStream.push(hook);
+        },
+        addStartStreamHook(hook) {
+            hooks.startStream.push(hook);
+        },
         request(params) {
             const headers = GG.reduce(defaultHeaders.entries(), GG.reduceFrom({}), ({ element, lastValue, next }) => {
                 const value = element[1]();
@@ -113,8 +134,8 @@ function createHttpClient(clientParams) {
                 baseUrl: config.baseUrl,
                 ...params,
                 headers: {
-                    ...params.headers,
                     ...headers,
+                    ...params.headers,
                 },
                 initParams: {
                     ...params.initParams,
@@ -125,6 +146,10 @@ function createHttpClient(clientParams) {
                 informationHeaderKey: config.informationHeaderKey,
                 disabledPredicateMode: config.disabledPredictedMode,
                 abortController: params.abortController ?? new AbortController(),
+                cacheStore: cacheStore,
+                clientCache: params.clientCache === "auto"
+                    ? autoCreateCacheKey
+                    : params.clientCache,
             });
         },
         get: ((path, params) => self.request({

package/dist/client/index.cjs

@@ -10,6 +10,8 @@ var queryToString = require('./queryToString.cjs');
 var promiseRequest = require('./promiseRequest.cjs');
 var unexpectedResponseError = require('./unexpectedResponseError.cjs');
 var serverSentEvents = require('./serverSentEvents.cjs');
+var stream = require('./stream.cjs');
+var clientCache = require('./clientCache.cjs');
 
 
 
@@ -18,17 +20,21 @@ exports.createHttpClient = httpClient.createHttpClient;
 exports.httpClientKind = httpClient.httpClientKind;
 exports.launchBeforeRetryServerEventHook = hooks.launchBeforeRetryServerEventHook;
 exports.launchCloseServerEventHook = hooks.launchCloseServerEventHook;
+exports.launchCloseStreamHook = hooks.launchCloseStreamHook;
 exports.launchCodeHook = hooks.launchCodeHook;
 exports.launchErrorHook = hooks.launchErrorHook;
 exports.launchErrorServerEventHook = hooks.launchErrorServerEventHook;
+exports.launchErrorStreamHook = hooks.launchErrorStreamHook;
 exports.launchExpectedResponseHook = hooks.launchExpectedResponseHook;
 exports.launchInformationHook = hooks.launchInformationHook;
 exports.launchNotPredictedHook = hooks.launchNotPredictedHook;
+exports.launchReceiveDataStreamHook = hooks.launchReceiveDataStreamHook;
 exports.launchReceiveEventServerEventHook = hooks.launchReceiveEventServerEventHook;
 exports.launchRequestHook = hooks.launchRequestHook;
 exports.launchResponseHook = hooks.launchResponseHook;
 exports.launchResponseTypeHook = hooks.launchResponseTypeHook;
 exports.launchStartServerEventHook = hooks.launchStartServerEventHook;
+exports.launchStartStreamHook = hooks.launchStartStreamHook;
 exports.getBody = getBody.getBody;
 exports.insertParamsInPath = insertParamsInPath.insertParamsInPath;
 exports.queryToString = queryToString.queryToString;
@@ -37,4 +43,10 @@ exports.UnexpectedCodeResponseError = unexpectedResponseError.UnexpectedCodeResp
 exports.UnexpectedInformationResponseError = unexpectedResponseError.UnexpectedInformationResponseError;
 exports.UnexpectedResponseError = unexpectedResponseError.UnexpectedResponseError;
 exports.UnexpectedResponseTypeError = unexpectedResponseError.UnexpectedResponseTypeError;
+exports.isClientEventsResponse = serverSentEvents.isClientEventsResponse;
 exports.makeClientEventsResponse = serverSentEvents.makeClientEventsResponse;
+exports.isClientStreamResponse = stream.isClientStreamResponse;
+exports.makeClientStreamResponse = stream.makeClientStreamResponse;
+exports.autoCreateCacheKey = clientCache.autoCreateCacheKey;
+exports.findResponseFromCacheStore = clientCache.findResponseFromCacheStore;
+exports.saveResponseInCacheStore = clientCache.saveResponseInCacheStore;

package/dist/client/index.d.ts

@@ -8,3 +8,5 @@ export * from "./queryToString";
 export * from "./promiseRequest";
 export * from "./unexpectedResponseError";
 export * from "./serverSentEvents";
+export * from "./stream";
+export * from "./clientCache";

package/dist/client/index.mjs

@@ -1,10 +1,12 @@
 import './types/index.mjs';
 export { createClientKind } from './kind.mjs';
 export { createHttpClient, httpClientKind } from './httpClient.mjs';
-export { launchBeforeRetryServerEventHook, launchCloseServerEventHook, launchCodeHook, launchErrorHook, launchErrorServerEventHook, launchExpectedResponseHook, launchInformationHook, launchNotPredictedHook, launchReceiveEventServerEventHook, launchRequestHook, launchResponseHook, launchResponseTypeHook, launchStartServerEventHook } from './hooks.mjs';
+export { launchBeforeRetryServerEventHook, launchCloseServerEventHook, launchCloseStreamHook, launchCodeHook, launchErrorHook, launchErrorServerEventHook, launchErrorStreamHook, launchExpectedResponseHook, launchInformationHook, launchNotPredictedHook, launchReceiveDataStreamHook, launchReceiveEventServerEventHook, launchRequestHook, launchResponseHook, launchResponseTypeHook, launchStartServerEventHook, launchStartStreamHook } from './hooks.mjs';
 export { getBody } from './getBody.mjs';
 export { insertParamsInPath } from './insertParamsInPath.mjs';
 export { queryToString } from './queryToString.mjs';
 export { PromiseRequest } from './promiseRequest.mjs';
 export { UnexpectedCodeResponseError, UnexpectedInformationResponseError, UnexpectedResponseError, UnexpectedResponseTypeError } from './unexpectedResponseError.mjs';
-export { makeClientEventsResponse } from './serverSentEvents.mjs';
+export { isClientEventsResponse, makeClientEventsResponse } from './serverSentEvents.mjs';
+export { isClientStreamResponse, makeClientStreamResponse } from './stream.mjs';
+export { autoCreateCacheKey, findResponseFromCacheStore, saveResponseInCacheStore } from './clientCache.mjs';

package/dist/client/promiseRequest.cjs

@@ -10,6 +10,8 @@ var SS = require('@duplojs/utils/string');
 var AA = require('@duplojs/utils/array');
 var unexpectedResponseError = require('./unexpectedResponseError.cjs');
 var serverSentEvents = require('./serverSentEvents.cjs');
+var clientCache = require('./clientCache.cjs');
+var stream = require('./stream.cjs');
 
 function _interopNamespaceDefault(e) {
     var n = Object.create(null);
@@ -151,12 +153,22 @@ class PromiseRequest extends Promise {
         void this.then(EE__namespace.whenIsRight((response) => {
             if ((response.predicted === true
                 || response.requestParams.disabledPredicateMode === true)
-                && Symbol.asyncIterator in response) {
+                && serverSentEvents.isClientEventsResponse(response)) {
                 response.onReceiveEvent(eventName, callback);
             }
         }));
         return this;
     }
+    whenReceiveDataStream(callback) {
+        void this.then(EE__namespace.whenIsRight((response) => {
+            if ((response.predicted === true
+                || response.requestParams.disabledPredicateMode === true)
+                && stream.isClientStreamResponse(response)) {
+                response.onStream("receiveData", callback);
+            }
+        }));
+        return this;
+    }
     iWantInformation(information) {
         const formattedInformation = AA__namespace.coalescing(information);
         return this.then(EE__namespace.whenIsRight((response) => {
@@ -318,7 +330,7 @@ class PromiseRequest extends Promise {
             if (EE__namespace.isRight(maybeResponse)) {
                 return utils.unwrap(maybeResponse);
             }
-            throw new unexpectedResponseError.UnexpectedResponseTypeError("informational", utils.unwrap(maybeResponse));
+            throw new unexpectedResponseError.UnexpectedResponseTypeError("serverError", utils.unwrap(maybeResponse));
         });
     }
     iWantExpectedResponseOrThrow() {
@@ -345,6 +357,10 @@ class PromiseRequest extends Promise {
         return Promise;
     }
     static fetch(requestParams) {
+        const cachedResponse = clientCache.findResponseFromCacheStore(requestParams);
+        if (cachedResponse) {
+            return Promise.resolve(EE__namespace.right("response", cachedResponse));
+        }
         const path = insertParamsInPath.insertParamsInPath(requestParams.path, requestParams.params);
         const query = queryToString.queryToString(requestParams.query);
         const url = query
@@ -359,7 +375,7 @@ class PromiseRequest extends Promise {
                     body = body.toString();
                 }
                 else if (body instanceof utils.TheFormData) {
-                    headers["content-type-options"] = "advanced";
+                    headers["x-duplojs-body-options"] = "advanced";
                 }
                 else if ((body
                     && typeof body === "object"
@@ -383,10 +399,9 @@ class PromiseRequest extends Promise {
             signal: requestParams.abortController.signal,
         };
         return fetch(fetchUrl, fetchInitParams)
-            .then((response) => getBody.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)
@@ -403,8 +418,18 @@ class PromiseRequest extends Promise {
             if (response.headers.get("content-type")?.includes("text/event-stream")) {
                 return EE__namespace.right("response", serverSentEvents.makeClientEventsResponse(clientResponse, fetchUrl, fetchInitParams));
             }
-            return EE__namespace.right("response", clientResponse);
-        }))
+            if (response.headers.get("x-duplojs-body-options")?.includes("stream")) {
+                return EE__namespace.right("response", stream.makeClientStreamResponse(clientResponse));
+            }
+            return getBody.getBody(response)
+                .then((body) => {
+                clientResponse.body = body;
+                if (clientResponse.code.startsWith("2")) {
+                    clientCache.saveResponseInCacheStore(requestParams, clientResponse);
+                }
+                return EE__namespace.right("response", clientResponse);
+            });
+        })
             .catch((error) => EE__namespace.left("request-error", {
             error,
             requestParams,