@ackee/antonio-core
Version:
A HTTP client built on fetch API with axios-like API.
100 lines (97 loc) • 10.1 kB
JavaScript
class RequestInterceptorManager {
id;
interceptors;
constructor() {
this.id = 0;
this.interceptors = new Map();
}
/**
* Intercept every request with attached methods:
* 1. onRequestParams - Customize `bodyData`, `config` or `url` before they're used for creating a `Request`
* - The `requestParams.config` is NOT yet merged with the defaults from Antonio's constructor.
* 2. onRequest - Customize `Request` object before passing it to the `fetch` method.
*
* _1. Example - Set the same `responseDataType` for each GET request_
* @example
* ```ts
* const api = new Antonio();
*
* const interceptorId = api.interceptors.request.use(({ url, bodyData, config }: RequestParams, method: RequestMethod) => {
* if (method === 'GET') {
* requestParams.config.responseDataType = 'iterableStream';
* }
*
* return { url, bodyData, config };
* })
* ```
*
* _2. Example - Custom `params` encoding_
*
* Note that if `params` are already an instace of `URLSearchParams`,
* Antonio will only stringify them as `url.search = searchParams.toString()`.
* That's all it does with it in that case.
* @example
* ```ts
* import { Antonio, RequestSearchParams } from `@ackee/antonio-core`;
* const api = new Antonio();
// For instance, some API might only accepts encoded arrays with key suffix `[]`:
const suffixSearchParamName = (name: string) => `${name}[]`;
function encodeSearchParams(params: RequestSearchParams) {
if (params instanceof URLSearchParams) {
return params;
}
const searchParams = new URLSearchParams();
for (const [name, value] of Object.entries(params)) {
if (Array.isArray(value)) {
const arrayMemberName = suffixSearchParamName(name);
value.forEach(item => searchParams.append(arrayMemberName, String(item)));
} else {
searchParams.append(name, String(value));
}
}
return searchParams;
}
*
* const interceptorId = api.interceptors.request.use(({ url, bodyData, config }: RequestParams, method: RequestMethod) => {
* if (config.params) {
* config.params = encodeSearchParams(config.params);
* }
*
* return { url, bodyData, config };
* })
* ```
*
* _3. Example - Set Authorization header_
* @example
* ```ts
* const api = new Antonio();
*
* function* getAccessToken() {
* // obtain access token
* return '...'
* }
*
* const interceptorId = api.interceptors.request.use(null, function*(request: Request) {
* const token = yield getAccessToken();
* request.headers.set('Authorization', token);
* return request;
* })
* ```
*/
use(onRequestParams, onRequest) {
const nextId = this.id++;
this.interceptors.set(nextId, {
onRequestParams,
onRequest
});
return nextId;
}
/**
* Remove an interceptor by passing here the id from `use` method.
*/
eject(id) {
return this.interceptors.delete(id);
}
}
export default RequestInterceptorManager;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,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