@hapaul/api 0.1.2 → 0.1.4

package/dist/index.d.ts

@@ -1,5 +1,4 @@
-import { MaybeOptionalInit, ParseAsResponse } from "openapi-fetch";
-import { PathsWithMethod, ResponseObjectMap, SuccessResponse } from "openapi-typescript-helpers";
+import { ErrorResponse, FilterKeys, IsOperationRequestBodyOptional, OperationRequestBodyContent, PathsWithMethod, ResponseObjectMap, SuccessResponse } from "openapi-typescript-helpers";
 
 //#region schema.d.ts
 
@@ -2192,6 +2191,43 @@ interface operations {
 }
 //#endregion
 //#region index.d.ts
+interface DefaultParamsOption {
+  params?: {
+    query?: Record<string, unknown>;
+  };
+}
+type BodyType<T = unknown> = {
+  json: T;
+  text: Awaited<ReturnType<Response['text']>>;
+  blob: Awaited<ReturnType<Response['blob']>>;
+  arrayBuffer: Awaited<ReturnType<Response['arrayBuffer']>>;
+  stream: Response['body'];
+};
+type ParseAs = keyof BodyType;
+type ParseAsResponse<T, Options> = Options extends {
+  parseAs: ParseAs;
+} ? BodyType<T>[Options['parseAs']] : T;
+type ParamsOption<T> = T extends {
+  parameters: any;
+} ? RequiredKeysOf<T['parameters']> extends never ? {
+  params?: T['parameters'];
+} : {
+  params: T['parameters'];
+} : DefaultParamsOption;
+type RequestBodyOption<T> = OperationRequestBodyContent<T> extends never ? {
+  body?: never;
+} : IsOperationRequestBodyOptional<T> extends true ? {
+  body?: OperationRequestBodyContent<T>;
+} : {
+  body: OperationRequestBodyContent<T>;
+};
+type HeadersOptions = Required<RequestInit>['headers'] | Record<string, string | number | boolean | (string | number | boolean)[] | null | undefined>;
+type RequestOptions<T> = ParamsOption<T> & RequestBodyOption<T> & {
+  baseUrl?: string;
+  headers?: HeadersOptions;
+};
+type FetchOptions<T> = RequestOptions<T> & Omit<RequestInit, 'body' | 'headers'>;
+type MaybeOptionalInit<Params, Location extends keyof Params> = RequiredKeysOf<FetchOptions<FilterKeys<Params, Location>>> extends never ? FetchOptions<FilterKeys<Params, Location>> | undefined : FetchOptions<FilterKeys<Params, Location>>;
 type RequiredKeysOfHelper<T> = { [K in keyof T]: {} extends Pick<T, K> ? never : K }[keyof T];
 type RequiredKeysOf<T> = RequiredKeysOfHelper<T> extends undefined ? never : RequiredKeysOfHelper<T>;
 type InitParam<Init> = RequiredKeysOf<Init> extends never ? [(Init & {
@@ -2199,47 +2235,55 @@ type InitParam<Init> = RequiredKeysOf<Init> extends never ? [(Init & {
 })?] : [Init & {
   [key: string]: unknown;
 }];
-type GetPaths = PathsWithMethod<paths, 'get'>;
-type PostPaths = PathsWithMethod<paths, 'post'>;
-type PutPaths = PathsWithMethod<paths, 'put'>;
-type PatchPaths = PathsWithMethod<paths, 'patch'>;
-type DeletePaths = PathsWithMethod<paths, 'delete'>;
-type GetParams<T extends GetPaths> = InitParam<MaybeOptionalInit<paths[T], 'get'>>;
-type PostParams<T extends PostPaths> = InitParam<MaybeOptionalInit<paths[T], 'post'>>;
-type PutParams<T extends PutPaths> = InitParam<MaybeOptionalInit<paths[T], 'put'>>;
-type PatchParams<T extends PatchPaths> = InitParam<MaybeOptionalInit<paths[T], 'patch'>>;
-type DeleteParams<T extends DeletePaths> = InitParam<MaybeOptionalInit<paths[T], 'delete'>>;
-type ResponseData<T extends keyof paths, M extends 'get' | 'post' | 'put' | 'patch' | 'delete'> = ParseAsResponse<SuccessResponse<ResponseObjectMap<paths[T][M]>, `${string}/${string}`>, MaybeOptionalInit<paths[T], M>>;
-interface ApiError {
-  status: number;
-  code: string;
-  message: string;
-}
-interface IClientConfig {
+type Methods = 'get' | 'post' | 'put' | 'patch' | 'delete';
+type RequestParams<T extends PathsWithMethod<paths, M>, M extends Methods> = InitParam<MaybeOptionalInit<paths[T], M>>;
+type ResponseData<T extends PathsWithMethod<paths, M>, M extends Methods> = ParseAsResponse<SuccessResponse<ResponseObjectMap<paths[T][M]>, `${string}/${string}`>, MaybeOptionalInit<paths[T], M>>;
+type ResponseError<T extends PathsWithMethod<paths, M>, M extends Methods> = ErrorResponse<ResponseObjectMap<paths[T][M]>, `${string}/${string}`>;
+interface ClientConfig<C = {}> {
   baseUrl?: string;
-  showLoading?: boolean;
-  showMessage?: boolean;
-  handleMessage?: (error: ApiError) => string;
+  custom?: C;
+}
+interface RequestConfig<C> extends ClientConfig<C> {}
+type RequestResponse<T extends PathsWithMethod<paths, M>, M extends Methods> = Promise<{
+  data: ResponseData<T, M>;
+  error: ResponseError<T, M>;
+  response: Response;
+}>;
+interface Middleware<C> {
+  onRequest?: (config: RequestConfig<C>) => RequestConfig<C> | Promise<RequestConfig<C>>;
+  onResponse?: (config: RequestConfig<C>, response: Response) => Response | Promise<Response>;
 }
-declare class ApiClient {
-  private client;
+declare class Client<C = {}> {
+  private middlewares;
   private baseUrl;
-  private showLoading;
-  private showMessage;
-  private handleMessage;
-  constructor(config?: IClientConfig);
-  config(config: IClientConfig): ApiClient;
-  get<T extends GetPaths>(path: T, ...params: GetParams<T>): Promise<ResponseData<T, 'get'>>;
-  post<T extends PostPaths>(path: T, ...params: PostParams<T>): Promise<ResponseData<T, 'post'>>;
-  put<T extends PutPaths>(path: T, ...params: PutParams<T>): Promise<ResponseData<T, 'put'>>;
-  patch<T extends PatchPaths>(path: T, ...params: PatchParams<T>): Promise<ResponseData<T, 'patch'>>;
-  delete<T extends DeletePaths>(path: T, ...params: DeleteParams<T>): Promise<ResponseData<T, 'delete'>>;
-  handleResponse<D extends {
-    data: unknown;
-  } | {
-    code: string;
-    message: string;
-  } | any, U>(data: D, error: U): Promise<D>;
+  constructor(config?: ClientConfig);
+  use(middleware: Middleware<C>): void;
+  request<T extends PathsWithMethod<paths, M>, M extends Methods>(params: {
+    method: M;
+    path: T;
+  } & RequestParams<T, M>, config?: RequestConfig<C>): RequestResponse<T, M>;
+  get<T extends PathsWithMethod<paths, 'get'>>(params: {
+    path: T;
+  } & RequestParams<T, 'get'>, config?: RequestConfig<C>): RequestResponse<T, 'get'>;
+  post<T extends PathsWithMethod<paths, 'post'>>(params: {
+    path: T;
+  } & RequestParams<T, 'post'>, config?: RequestConfig<C>): RequestResponse<T, 'post'>;
+  put<T extends PathsWithMethod<paths, 'put'>>(params: {
+    path: T;
+  } & RequestParams<T, 'put'>, config?: RequestConfig<C>): RequestResponse<T, 'put'>;
+  patch<T extends PathsWithMethod<paths, 'patch'>>(params: {
+    path: T;
+  } & RequestParams<T, 'patch'>, config?: RequestConfig<C>): RequestResponse<T, 'patch'>;
+  delete<T extends PathsWithMethod<paths, 'delete'>>(params: {
+    path: T;
+  } & RequestParams<T, 'delete'>, config?: RequestConfig<C>): RequestResponse<T, 'delete'>;
+  beforeRequest(params: {
+    config: RequestConfig<C>;
+  }): Promise<RequestConfig<C>>;
+  afterResponse(params: {
+    config: ClientConfig<C>;
+    response: Response;
+  }): Promise<Response>;
 }
 //#endregion
-export { ApiClient, ApiError, IClientConfig };
+export { Client, ClientConfig, Middleware, RequestConfig, RequestResponse };

package/dist/index.js

@@ -1,422 +1,97 @@
-//#region node_modules/.pnpm/openapi-fetch@0.14.0/node_modules/openapi-fetch/dist/index.mjs
-const PATH_PARAM_RE = /\{[^{}]+\}/g;
-const supportsRequestInitExt = () => {
-	return typeof process === "object" && Number.parseInt(process?.versions?.node?.substring(0, 2)) >= 18 && process.versions.undici;
-};
-function randomID() {
-	return Math.random().toString(36).slice(2, 11);
-}
-function createClient(clientOptions) {
-	let { baseUrl = "", Request: CustomRequest = globalThis.Request, fetch: baseFetch = globalThis.fetch, querySerializer: globalQuerySerializer, bodySerializer: globalBodySerializer, headers: baseHeaders, requestInitExt = void 0,...baseOptions } = { ...clientOptions };
-	requestInitExt = supportsRequestInitExt() ? requestInitExt : void 0;
-	baseUrl = removeTrailingSlash(baseUrl);
-	const middlewares = [];
-	async function coreFetch(schemaPath, fetchOptions) {
-		const { baseUrl: localBaseUrl, fetch = baseFetch, Request = CustomRequest, headers, params = {}, parseAs = "json", querySerializer: requestQuerySerializer, bodySerializer = globalBodySerializer ?? defaultBodySerializer, body,...init } = fetchOptions || {};
-		let finalBaseUrl = baseUrl;
-		if (localBaseUrl) finalBaseUrl = removeTrailingSlash(localBaseUrl) ?? baseUrl;
-		let querySerializer = typeof globalQuerySerializer === "function" ? globalQuerySerializer : createQuerySerializer(globalQuerySerializer);
-		if (requestQuerySerializer) querySerializer = typeof requestQuerySerializer === "function" ? requestQuerySerializer : createQuerySerializer({
-			...typeof globalQuerySerializer === "object" ? globalQuerySerializer : {},
-			...requestQuerySerializer
-		});
-		const serializedBody = body === void 0 ? void 0 : bodySerializer(body, mergeHeaders(baseHeaders, headers, params.header));
-		const finalHeaders = mergeHeaders(serializedBody === void 0 || serializedBody instanceof FormData ? {} : { "Content-Type": "application/json" }, baseHeaders, headers, params.header);
-		const requestInit = {
-			redirect: "follow",
-			...baseOptions,
-			...init,
-			body: serializedBody,
-			headers: finalHeaders
-		};
-		let id;
-		let options;
-		let request = new CustomRequest(createFinalURL(schemaPath, {
-			baseUrl: finalBaseUrl,
-			params,
-			querySerializer
-		}), requestInit);
-		let response;
-		for (const key in init) if (!(key in request)) request[key] = init[key];
-		if (middlewares.length) {
-			id = randomID();
-			options = Object.freeze({
-				baseUrl: finalBaseUrl,
-				fetch,
-				parseAs,
-				querySerializer,
-				bodySerializer
+//#region index.ts
+var Client = class {
+	middlewares;
+	baseUrl;
+	constructor(config) {
+		this.middlewares = [];
+		this.baseUrl = config?.baseUrl ?? "";
+	}
+	use(middleware) {
+		this.middlewares.push(middleware);
+	}
+	async request(params, config) {
+		config = await this.beforeRequest({ config });
+		const baseUrl = config.baseUrl ?? this.baseUrl;
+		const url = baseUrl + params.path;
+		try {
+			let response = await fetch(url);
+			response = await this.afterResponse({
+				config,
+				response
 			});
-			for (const m of middlewares) if (m && typeof m === "object" && typeof m.onRequest === "function") {
-				const result = await m.onRequest({
-					request,
-					schemaPath,
-					params,
-					options,
-					id
-				});
-				if (result) if (result instanceof CustomRequest) request = result;
-				else if (result instanceof Response) {
-					response = result;
+			const { status } = response;
+			let data;
+			let error;
+			let isOk = true;
+			const assign = (value) => {
+				if (isOk) data = value;
+				else error = value;
+			};
+			if (status >= 200 && status < 300) isOk = true;
+			else if (status >= 400) isOk = false;
+			const contentType = response.headers.get("Content-Type") || "application/json";
+			switch (contentType) {
+				case "application/json":
+					assign(await response.json());
 					break;
-				} else throw new Error("onRequest: must return new Request() or Response() when modifying the request");
-			}
-		}
-		if (!response) {
-			try {
-				response = await fetch(request, requestInitExt);
-			} catch (error2) {
-				let errorAfterMiddleware = error2;
-				if (middlewares.length) for (let i = middlewares.length - 1; i >= 0; i--) {
-					const m = middlewares[i];
-					if (m && typeof m === "object" && typeof m.onError === "function") {
-						const result = await m.onError({
-							request,
-							error: errorAfterMiddleware,
-							schemaPath,
-							params,
-							options,
-							id
-						});
-						if (result) {
-							if (result instanceof Response) {
-								errorAfterMiddleware = void 0;
-								response = result;
-								break;
-							}
-							if (result instanceof Error) {
-								errorAfterMiddleware = result;
-								continue;
-							}
-							throw new Error("onError: must return new Response() or instance of Error");
-						}
-					}
-				}
-				if (errorAfterMiddleware) throw errorAfterMiddleware;
-			}
-			if (middlewares.length) for (let i = middlewares.length - 1; i >= 0; i--) {
-				const m = middlewares[i];
-				if (m && typeof m === "object" && typeof m.onResponse === "function") {
-					const result = await m.onResponse({
-						request,
-						response,
-						schemaPath,
-						params,
-						options,
-						id
-					});
-					if (result) {
-						if (!(result instanceof Response)) throw new Error("onResponse: must return new Response() when modifying the response");
-						response = result;
-					}
-				}
+				case "text":
+					assign(await response.text());
+					break;
+				case "arrayBuffer":
+					assign(await response.arrayBuffer());
+					break;
+				default: assign(await response.bytes());
 			}
-		}
-		if (response.status === 204 || request.method === "HEAD" || response.headers.get("Content-Length") === "0") return response.ok ? {
-			data: void 0,
-			response
-		} : {
-			error: void 0,
-			response
-		};
-		if (response.ok) {
-			if (parseAs === "stream") return {
-				data: response.body,
-				response
-			};
 			return {
-				data: await response[parseAs](),
+				data,
+				error,
 				response
 			};
+		} catch (error) {
+			throw error;
 		}
-		let error = await response.text();
-		try {
-			error = JSON.parse(error);
-		} catch {}
-		return {
-			error,
-			response
-		};
-	}
-	return {
-		request(method, url, init) {
-			return coreFetch(url, {
-				...init,
-				method: method.toUpperCase()
-			});
-		},
-		GET(url, init) {
-			return coreFetch(url, {
-				...init,
-				method: "GET"
-			});
-		},
-		PUT(url, init) {
-			return coreFetch(url, {
-				...init,
-				method: "PUT"
-			});
-		},
-		POST(url, init) {
-			return coreFetch(url, {
-				...init,
-				method: "POST"
-			});
-		},
-		DELETE(url, init) {
-			return coreFetch(url, {
-				...init,
-				method: "DELETE"
-			});
-		},
-		OPTIONS(url, init) {
-			return coreFetch(url, {
-				...init,
-				method: "OPTIONS"
-			});
-		},
-		HEAD(url, init) {
-			return coreFetch(url, {
-				...init,
-				method: "HEAD"
-			});
-		},
-		PATCH(url, init) {
-			return coreFetch(url, {
-				...init,
-				method: "PATCH"
-			});
-		},
-		TRACE(url, init) {
-			return coreFetch(url, {
-				...init,
-				method: "TRACE"
-			});
-		},
-		use(...middleware) {
-			for (const m of middleware) {
-				if (!m) continue;
-				if (typeof m !== "object" || !("onRequest" in m || "onResponse" in m || "onError" in m)) throw new Error("Middleware must be an object with one of `onRequest()`, `onResponse() or `onError()`");
-				middlewares.push(m);
-			}
-		},
-		eject(...middleware) {
-			for (const m of middleware) {
-				const i = middlewares.indexOf(m);
-				if (i !== -1) middlewares.splice(i, 1);
-			}
-		}
-	};
-}
-function serializePrimitiveParam(name, value, options) {
-	if (value === void 0 || value === null) return "";
-	if (typeof value === "object") throw new Error("Deeply-nested arrays/objects aren’t supported. Provide your own `querySerializer()` to handle these.");
-	return `${name}=${options?.allowReserved === true ? value : encodeURIComponent(value)}`;
-}
-function serializeObjectParam(name, value, options) {
-	if (!value || typeof value !== "object") return "";
-	const values = [];
-	const joiner = {
-		simple: ",",
-		label: ".",
-		matrix: ";"
-	}[options.style] || "&";
-	if (options.style !== "deepObject" && options.explode === false) {
-		for (const k in value) values.push(k, options.allowReserved === true ? value[k] : encodeURIComponent(value[k]));
-		const final2 = values.join(",");
-		switch (options.style) {
-			case "form": return `${name}=${final2}`;
-			case "label": return `.${final2}`;
-			case "matrix": return `;${name}=${final2}`;
-			default: return final2;
-		}
-	}
-	for (const k in value) {
-		const finalName = options.style === "deepObject" ? `${name}[${k}]` : k;
-		values.push(serializePrimitiveParam(finalName, value[k], options));
-	}
-	const final = values.join(joiner);
-	return options.style === "label" || options.style === "matrix" ? `${joiner}${final}` : final;
-}
-function serializeArrayParam(name, value, options) {
-	if (!Array.isArray(value)) return "";
-	if (options.explode === false) {
-		const joiner2 = {
-			form: ",",
-			spaceDelimited: "%20",
-			pipeDelimited: "|"
-		}[options.style] || ",";
-		const final = (options.allowReserved === true ? value : value.map((v) => encodeURIComponent(v))).join(joiner2);
-		switch (options.style) {
-			case "simple": return final;
-			case "label": return `.${final}`;
-			case "matrix": return `;${name}=${final}`;
-			default: return `${name}=${final}`;
-		}
-	}
-	const joiner = {
-		simple: ",",
-		label: ".",
-		matrix: ";"
-	}[options.style] || "&";
-	const values = [];
-	for (const v of value) if (options.style === "simple" || options.style === "label") values.push(options.allowReserved === true ? v : encodeURIComponent(v));
-	else values.push(serializePrimitiveParam(name, v, options));
-	return options.style === "label" || options.style === "matrix" ? `${joiner}${values.join(joiner)}` : values.join(joiner);
-}
-function createQuerySerializer(options) {
-	return function querySerializer(queryParams) {
-		const search = [];
-		if (queryParams && typeof queryParams === "object") for (const name in queryParams) {
-			const value = queryParams[name];
-			if (value === void 0 || value === null) continue;
-			if (Array.isArray(value)) {
-				if (value.length === 0) continue;
-				search.push(serializeArrayParam(name, value, {
-					style: "form",
-					explode: true,
-					...options?.array,
-					allowReserved: options?.allowReserved || false
-				}));
-				continue;
-			}
-			if (typeof value === "object") {
-				search.push(serializeObjectParam(name, value, {
-					style: "deepObject",
-					explode: true,
-					...options?.object,
-					allowReserved: options?.allowReserved || false
-				}));
-				continue;
-			}
-			search.push(serializePrimitiveParam(name, value, options));
-		}
-		return search.join("&");
-	};
-}
-function defaultPathSerializer(pathname, pathParams) {
-	let nextURL = pathname;
-	for (const match of pathname.match(PATH_PARAM_RE) ?? []) {
-		let name = match.substring(1, match.length - 1);
-		let explode = false;
-		let style = "simple";
-		if (name.endsWith("*")) {
-			explode = true;
-			name = name.substring(0, name.length - 1);
-		}
-		if (name.startsWith(".")) {
-			style = "label";
-			name = name.substring(1);
-		} else if (name.startsWith(";")) {
-			style = "matrix";
-			name = name.substring(1);
-		}
-		if (!pathParams || pathParams[name] === void 0 || pathParams[name] === null) continue;
-		const value = pathParams[name];
-		if (Array.isArray(value)) {
-			nextURL = nextURL.replace(match, serializeArrayParam(name, value, {
-				style,
-				explode
-			}));
-			continue;
-		}
-		if (typeof value === "object") {
-			nextURL = nextURL.replace(match, serializeObjectParam(name, value, {
-				style,
-				explode
-			}));
-			continue;
-		}
-		if (style === "matrix") {
-			nextURL = nextURL.replace(match, `;${serializePrimitiveParam(name, value)}`);
-			continue;
-		}
-		nextURL = nextURL.replace(match, style === "label" ? `.${encodeURIComponent(value)}` : encodeURIComponent(value));
-	}
-	return nextURL;
-}
-function defaultBodySerializer(body, headers) {
-	if (body instanceof FormData) return body;
-	if (headers) {
-		const contentType = headers.get instanceof Function ? headers.get("Content-Type") ?? headers.get("content-type") : headers["Content-Type"] ?? headers["content-type"];
-		if (contentType === "application/x-www-form-urlencoded") return new URLSearchParams(body).toString();
-	}
-	return JSON.stringify(body);
-}
-function createFinalURL(pathname, options) {
-	let finalURL = `${options.baseUrl}${pathname}`;
-	if (options.params?.path) finalURL = defaultPathSerializer(finalURL, options.params.path);
-	let search = options.querySerializer(options.params.query ?? {});
-	if (search.startsWith("?")) search = search.substring(1);
-	if (search) finalURL += `?${search}`;
-	return finalURL;
-}
-function mergeHeaders(...allHeaders) {
-	const finalHeaders = new Headers();
-	for (const h of allHeaders) {
-		if (!h || typeof h !== "object") continue;
-		const iterator = h instanceof Headers ? h.entries() : Object.entries(h);
-		for (const [k, v] of iterator) if (v === null) finalHeaders.delete(k);
-		else if (Array.isArray(v)) for (const v2 of v) finalHeaders.append(k, v2);
-		else if (v !== void 0) finalHeaders.set(k, v);
-	}
-	return finalHeaders;
-}
-function removeTrailingSlash(url) {
-	if (url.endsWith("/")) return url.substring(0, url.length - 1);
-	return url;
-}
-
-//#endregion
-//#region index.ts
-var ApiClient = class ApiClient {
-	client;
-	baseUrl;
-	showLoading;
-	showMessage;
-	handleMessage;
-	constructor(config) {
-		this.baseUrl = config?.baseUrl ?? "";
-		this.showLoading = config?.showLoading ?? true;
-		this.showMessage = config?.showMessage ?? true;
-		this.handleMessage = config?.handleMessage ?? ((error) => error.message);
-		this.client = createClient({ baseUrl: this.baseUrl });
 	}
-	config(config) {
-		const newConfig = {
-			...this.config,
-			...config
-		};
-		return new ApiClient(newConfig);
+	get(params, config) {
+		return this.request({
+			method: "get",
+			...params
+		}, config);
 	}
-	async get(path, ...params) {
-		const { data, error } = await this.client.GET(path, ...params);
-		return this.handleResponse(data, error);
+	post(params, config) {
+		return this.request({
+			method: "post",
+			...params
+		}, config);
 	}
-	async post(path, ...params) {
-		const { data, error } = await this.client.POST(path, ...params);
-		return this.handleResponse(data, error);
+	put(params, config) {
+		return this.request({
+			method: "put",
+			...params
+		}, config);
 	}
-	async put(path, ...params) {
-		const { data, error } = await this.client.PUT(path, ...params);
-		return this.handleResponse(data, error);
+	patch(params, config) {
+		return this.request({
+			method: "patch",
+			...params
+		}, config);
 	}
-	async patch(path, ...params) {
-		const { data, error } = await this.client.PATCH(path, ...params);
-		return this.handleResponse(data, error);
+	delete(params, config) {
+		return this.request({
+			method: "delete",
+			...params
+		}, config);
 	}
-	async delete(path, ...params) {
-		const { data, error } = await this.client.DELETE(path, ...params);
-		return this.handleResponse(data, error);
+	async beforeRequest(params) {
+		let config = params.config;
+		for (const middleware of this.middlewares) config = await middleware.onRequest?.(config);
+		return config;
 	}
-	async handleResponse(data, error) {
-		if (error) return Promise.reject(error);
-		if (typeof data === "object") if (data) if ("code" in data) return Promise.reject(data);
-		else return Promise.resolve(data);
-		else return Promise.reject(error);
-		else return Promise.resolve(data);
+	async afterResponse(params) {
+		let response = params.response;
+		for (const middleware of this.middlewares) response = await middleware.onResponse?.(params.config, response);
+		return response;
 	}
 };
 
 //#endregion
-export { ApiClient };
+export { Client };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hapaul/api",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "",
   "type": "module",
   "files": [