feat: set modifiedResponse in response middleware

src/applyMiddleware/applyMiddleware.ts

@@ -1,9 +1,9 @@
-import { MiddlewareHandlers } from '../types';
+import type { MiddlewareHandlers, MiddlewareMeta } from '../types';
 import { is } from '../utils';
 
 export function applyMiddleware(
   options: unknown,
-  meta: Partial<Response>,
+  meta: MiddlewareMeta,
   middleware?: MiddlewareHandlers,
 ) {
   const isValidMiddleware = Array.isArray(middleware) && middleware.length > 0;
@@ -14,7 +14,7 @@ export function applyMiddleware(
 
 function apply(
   options: unknown,
-  meta: Partial<Response>,
+  meta: MiddlewareMeta,
   middleware: MiddlewareHandlers,
 ) {
   const isValidProcessor = (processor: unknown) => ['Function', 'AsyncFunction', 'Promise'].some((accessor) => is[accessor](processor));

src/createHttpClient/createHttpClient.spec.ts

@@ -118,4 +118,24 @@ clientSuite('should apply middleware', async () => {
 
 });
 
+clientSuite.only('should modify response in middleware', async () => {
+  const { post } = createHttpClient({
+    middleware: {
+      response: [
+        (options) => {
+          return Promise.resolve({ ...(options ?? {}), modifiedResponse: 'MODIFIED_RESPONSE', ok: true });
+        },
+      ],
+    },
+  });
+  const params: CreateMethod = {
+    url: endpoint,
+    query: mockQuery,
+  };
+  const response = await post<string>(params);
+
+  assert.match(response, 'MODIFIED_RESPONSE');
+
+});
+
 clientSuite.run();

src/createHttpClient/createMethod.ts

@@ -1,5 +1,9 @@
 import { applyMiddleware } from '../applyMiddleware';
-import { CreateMethod, FormattedResponse } from '../types';
+import type {
+  CreateMethod,
+  FormattedResponse,
+  MiddlewareMeta
+} from '../types';
 import { getBody,is } from '../utils';
 
 /**
@@ -64,7 +68,7 @@ export async function createMethod<Result = undefined>({
 
   return fetch(formattedUrl, requestOptions)
     .then(async (response: Response & { formattedResponse?: unknown }) => {
-      const meta = {
+      const meta: MiddlewareMeta = {
         ok: response.ok,
         headers: response.headers,
         status: response.status,
@@ -82,13 +86,17 @@ export async function createMethod<Result = undefined>({
         is.Object(processedOptions) &&
         'ok' in processedOptions &&
         processedOptions.ok;
+      const modifiedResponse =
+        isProcessed && processedOptions?.modifiedResponse ?
+          processedOptions.modifiedResponse :
+          formattedResponse;
 
       if (!(isProcessed || response.ok)) {
         response.formattedResponse = formattedResponse;
 
         throw response;
       }
 
-      return formattedResponse as (Result extends undefined ? typeof formattedResponse : Result);
+      return modifiedResponse as (Result extends undefined ? typeof formattedResponse : Result);
     });
 }

src/types.d.ts

@@ -4,8 +4,13 @@ export type BasicObject = Record<string, unknown>;
 
 export type Method = keyof typeof Methods;
 
+export interface MiddlewareMeta extends Partial<Response> {
+  request?: Omit<Partial<Request>, 'signal'>;
+  signal?: Request['signal'];
+}
+
 export type MiddlewareType = 'request' | 'response';
-export type MiddlewareHandler = (params: unknown, meta: Partial<Response>) => Promise<typeof params>;
+export type MiddlewareHandler = (params: unknown, meta: MiddlewareMeta) => Promise<typeof params>;
 export type MiddlewareHandlers = Array<MiddlewareHandler>;
 export type Middleware = {
   [key in MiddlewareType]?: MiddlewareHandlers
@@ -14,10 +19,10 @@ export type Middleware = {
 export type CreateMethod = {
   query?: unknown,
   url?: string,
-  baseUrl?: string;
+  baseUrl?: string,
   timeout?: number,
   middleware?: Middleware,
-  params?: RequestInit,
+  params?: Partial<RequestInit>,
   method?: Uppercase<`${Methods}`>,
   format?: keyof Omit<Body, 'body' | 'bodyUsed'>,
 };