Replace axios with fetch

Author: pdziewa

package.json

@@ -18,8 +18,7 @@
     "prepublishOnly": "npm run lint && npm run test"
   },
   "dependencies": {
-    "axios": "^1.6.1",
-    "form-data": "^4.0.0"
+    "form-data": "^4.0.4"
   },
   "devDependencies": {
     "@babel/preset-env": "^7.23.3",
@@ -40,7 +39,7 @@
     "eslint-plugin-standard": "^5.0.0",
     "jest": "^29.7.0",
     "lodash": "^4.17.21",
-    "nock": "^13.3.8",
+    "nock": "^14.0.6",
     "prettier": "^3.0.3",
     "rimraf": "^5.0.5",
     "terser": "^5.24.0",
@@ -50,6 +49,6 @@
     "uuid": "^9.0.1"
   },
   "engines": {
-    "node": ">=10"
+    "node": ">=18"
   }
 }

src/helpers/mapKeys/index.ts

@@ -3,7 +3,7 @@ import { isObject } from '../isObject';
 export const mapKeys = (
   value: Record<string, unknown>,
   callback: (key: string) => string,
-): Record<string, string | boolean | number> => {
+): Record<string, unknown> => {
   if (value === undefined || !isObject(value)) {
     return value;
   }

src/modules/baseMessageModule/index.ts

@@ -88,7 +88,6 @@ export class BaseMessageModule extends BaseModule {
       const formData = this.getFormDataForVmsLocalFile(body, content);
 
       const data = await this.httpClient.post<
-        ApiMessageResponse | MessageErrorResponse,
         ApiMessageResponse | MessageErrorResponse
       >(this.endpoint, formData.getBuffer(), {
         headers: formData.getHeaders(),
@@ -102,7 +101,6 @@ export class BaseMessageModule extends BaseModule {
     }
 
     const data = await this.httpClient.post<
-      ApiMessageResponse | MessageErrorResponse,
       ApiMessageResponse | MessageErrorResponse
     >(this.endpoint, body);
 

src/modules/baseModule/index.ts

@@ -1,9 +1,9 @@
-import { AxiosInstance } from 'axios';
+import { HttpClient } from '../../smsapi/httpClient';
 
 export class BaseModule {
-  protected httpClient: AxiosInstance;
+  protected httpClient: HttpClient;
 
-  constructor(httpClient: AxiosInstance) {
+  constructor(httpClient: HttpClient) {
     this.httpClient = httpClient;
   }
 }

src/modules/contacts/httpClient/formatResponseDates/index.spec.ts

@@ -1,19 +1,19 @@
-import { createAxiosResponse } from '../../../../testHelpers/createAxiosResponse';
-
 import { formatResponseDates } from '.';
 
 describe('formatResponseDates', () => {
   it('should format dates for ApiCollection<Group>', () => {
     // given
-    const response = createAxiosResponse({
-      collection: [
-        {
-          date_created: '2020-09-01T14:49:00+02:00',
-          date_updated: '2020-09-01T14:49:00+02:00',
-        },
-      ],
-      size: 1,
-    });
+    const response = {
+      data: {
+        collection: [
+          {
+            date_created: '2020-09-01T14:49:00+02:00',
+            date_updated: '2020-09-01T14:49:00+02:00',
+          },
+        ],
+        size: 1,
+      },
+    };
 
     // when
     const formattedResponse = formatResponseDates(response);
@@ -31,10 +31,12 @@ describe('formatResponseDates', () => {
 
   it('should format dates for Group', () => {
     // given
-    const response = createAxiosResponse({
-      date_created: '2020-09-01T14:49:00+02:00',
-      date_updated: '2020-09-01T14:49:00+02:00',
-    });
+    const response = {
+      data: {
+        date_created: '2020-09-01T14:49:00+02:00',
+        date_updated: '2020-09-01T14:49:00+02:00',
+      },
+    };
 
     // when
     const formattedResponse = formatResponseDates(response);
@@ -48,9 +50,11 @@ describe('formatResponseDates', () => {
 
   it('should not format dates when date_created or date_updated are not present', () => {
     // given
-    const response = createAxiosResponse({
-      name: 'someName',
-    });
+    const response = {
+      data: {
+        name: 'someName',
+      },
+    };
 
     // when
     const formattedResponse = formatResponseDates(response);

src/modules/contacts/httpClient/formatResponseDates/index.ts

@@ -1,5 +1,3 @@
-import { AxiosResponse } from 'axios';
-
 import { ApiCollection } from '../../../../types/ApiCollection';
 
 interface ApiGroup {
@@ -30,7 +28,7 @@ const formatDates = (group: ApiGroup): Record<string, Date | string> => {
   };
 };
 
-export const formatResponseDates = (response: AxiosResponse): AxiosResponse => {
+export const formatResponseDates = (response) => {
   const { data } = response;
 
   if (isApiCollection(data)) {

src/modules/contacts/httpClient/prepareParamsForRequest/index.ts

@@ -1,22 +1,17 @@
-import { stringify } from 'querystring';
-
-import { InternalAxiosRequestConfig } from 'axios';
-
 import { formatDate } from '../../helpers/formatDate';
 import { mapKeys } from '../../../../helpers/mapKeys';
 import { mapValues } from '../../../../helpers/mapValues';
 import { snakeCase } from '../../../../helpers/snakeCase';
+import { RequestInterceptor } from '../../../../smsapi/httpClient';
 
-const formatKeys = (data: Record<string, string | boolean | number>) => {
+const formatKeys = (data: Record<string, unknown>) => {
   return mapKeys(data, snakeCase);
 };
 
-export const prepareParamsForRequest = (
-  config: InternalAxiosRequestConfig,
-): InternalAxiosRequestConfig => {
-  const { data, method, params } = config;
+export const prepareParamsForRequest: RequestInterceptor = (config) => {
+  const { body, method, params } = config;
 
-  if (['get', 'delete'].includes((method as string).toLowerCase())) {
+  if (params && ['get', 'delete'].includes((method as string).toLowerCase())) {
     let formattedParams = mapValues(params, (value, key) => {
       if (key === 'birthdayDate') {
         if (Array.isArray(value)) {
@@ -38,14 +33,13 @@ export const prepareParamsForRequest = (
     return {
       ...config,
       params: formattedParams,
-      paramsSerializer: (params) => stringify(params),
     };
   }
 
-  if (data) {
+  if (body && typeof body === 'object' && !Buffer.isBuffer(body)) {
     return {
       ...config,
-      data: stringify(formatKeys(data)),
+      body: formatKeys(body) as Record<string, string | number | boolean>,
     };
   }
 

src/modules/contacts/index.ts

@@ -1,10 +1,8 @@
-import axios, { AxiosInstance } from 'axios';
-
-import { extractDataFromResponse } from '../../smsapi/httpClient/extractDataFromResponse';
 import { BaseModule } from '../baseModule';
 import { ApiCollection } from '../../types/ApiCollection';
 import { mapKeys } from '../../helpers/mapKeys';
 import { snakeCase } from '../../helpers/snakeCase';
+import { HttpClient } from '../../smsapi/httpClient';
 
 import { Contact } from './types/Contact';
 import { NewContact } from './types/NewContact';
@@ -18,45 +16,31 @@ import { UpdateContact } from './types/UpdateContact';
 import { Fields } from './modules/fields';
 
 export class Contacts extends BaseModule {
-  private contactHttpClient: AxiosInstance;
-
   public fields: Fields;
   public groups: Groups;
 
-  constructor(httpClient: AxiosInstance) {
+  constructor(httpClient: HttpClient) {
     super(httpClient);
 
-    this.contactHttpClient = axios.create({
-      adapter: httpClient.defaults.adapter,
-      baseURL: httpClient.defaults.baseURL,
-      headers: httpClient.defaults.headers,
-    });
-
-    this.contactHttpClient.interceptors.request.use(prepareParamsForRequest);
-    this.contactHttpClient.interceptors.response.use(formatResponseDates);
-    this.contactHttpClient.interceptors.response.use(extractDataFromResponse);
+    this.httpClient.addRequestInterceptor(prepareParamsForRequest);
+    this.httpClient.addResponseInterceptor(formatResponseDates);
 
-    this.fields = new Fields(this.contactHttpClient);
-    this.groups = new Groups(this.contactHttpClient);
+    this.fields = new Fields(this.httpClient);
+    this.groups = new Groups(this.httpClient);
   }
 
   async get(params?: GetContactsQueryParams): Promise<ApiCollection<Contact>> {
-    return await this.contactHttpClient.get<
-      ApiCollection<Contact>,
-      ApiCollection<Contact>
-    >('/contacts', {
+    return await this.httpClient.get<ApiCollection<Contact>>('/contacts', {
       params,
     });
   }
 
   async getById(contactId: string): Promise<Contact> {
-    return await this.contactHttpClient.get<Contact, Contact>(
-      `/contacts/${contactId}`,
-    );
+    return await this.httpClient.get<Contact>(`/contacts/${contactId}`);
   }
 
   async create(phoneNumber: string, details?: NewContact): Promise<Contact> {
-    return await this.contactHttpClient.post<Contact, Contact>('/contacts', {
+    return await this.httpClient.post<Contact>('/contacts', {
       phone_number: phoneNumber,
       ...this.formatContactDetails(details || {}),
     });
@@ -66,27 +50,23 @@ export class Contacts extends BaseModule {
     contactId: string,
     updateContact: UpdateContact,
   ): Promise<Contact> {
-    return await this.contactHttpClient.put<Contact, Contact>(
-      `/contacts/${contactId}`,
-      {
-        ...this.formatContactDetails(updateContact || {}),
-      },
-    );
+    return await this.httpClient.put<Contact>(`/contacts/${contactId}`, {
+      ...this.formatContactDetails(updateContact || {}),
+    });
   }
 
   async remove(contactId: string): Promise<void> {
-    await this.contactHttpClient.delete(`/contacts/${contactId}`);
+    await this.httpClient.delete(`/contacts/${contactId}`);
   }
 
   async getGroups(contactId: string): Promise<ApiCollection<Group>> {
-    return await this.contactHttpClient.get<
-      ApiCollection<Group>,
-      ApiCollection<Group>
-    >(`/contacts/${contactId}/groups`);
+    return await this.httpClient.get<ApiCollection<Group>>(
+      `/contacts/${contactId}/groups`,
+    );
   }
 
   async getGroupById(contactId: string, groupId: string): Promise<Group> {
-    return await this.contactHttpClient.get<Group, Group>(
+    return await this.httpClient.get<Group>(
       `/contacts/${contactId}/groups/${groupId}`,
     );
   }
@@ -95,19 +75,16 @@ export class Contacts extends BaseModule {
     contactId: string,
     groupId: string,
   ): Promise<ApiCollection<Group>> {
-    return await this.contactHttpClient.put<
-      ApiCollection<Group>,
-      ApiCollection<Group>
-    >(`/contacts/${contactId}/groups/${groupId}`);
+    return await this.httpClient.put<ApiCollection<Group>>(
+      `/contacts/${contactId}/groups/${groupId}`,
+    );
   }
 
   async unpinContactFromGroup(
     contactId: string,
     groupId: string,
   ): Promise<void> {
-    await this.contactHttpClient.delete(
-      `/contacts/${contactId}/groups/${groupId}`,
-    );
+    await this.httpClient.delete(`/contacts/${contactId}/groups/${groupId}`);
   }
 
   private formatContactDetails(details: NewContact): Record<string, unknown> {

src/modules/contacts/modules/fields/index.ts

@@ -6,29 +6,23 @@ import { FieldType } from './types/FieldType';
 
 export class Fields extends BaseModule {
   async get(): Promise<ApiCollection<Field>> {
-    return await this.httpClient.get<
-      ApiCollection<Field>,
-      ApiCollection<Field>
-    >('/contacts/fields');
+    return await this.httpClient.get<ApiCollection<Field>>('/contacts/fields');
   }
 
   async create(
     fieldName: string,
     fieldType: FieldType = 'text',
   ): Promise<Field> {
-    return await this.httpClient.post<Field, Field>('/contacts/fields', {
+    return await this.httpClient.post<Field>('/contacts/fields', {
       name: fieldName,
       type: fieldType,
     });
   }
 
   async update(fieldId: string, newName: string): Promise<Field> {
-    return await this.httpClient.put<Field, Field>(
-      `/contacts/fields/${fieldId}`,
-      {
-        name: newName,
-      },
-    );
+    return await this.httpClient.put<Field>(`/contacts/fields/${fieldId}`, {
+      name: newName,
+    });
   }
 
   async remove(fieldId: string): Promise<void> {

src/modules/contacts/modules/groups/index.ts

@@ -1,35 +1,31 @@
 import { BaseModule } from '../../../baseModule';
 import { ApiCollection } from '../../../../types/ApiCollection';
+import { RequestConfig } from '../../../../smsapi/httpClient';
 
 import { CreateGroupDetails } from './types/CreateGroupDetails';
 import { Group } from './types/Group';
 import { UpdateGroup } from './types/UpdateGroup';
 
 export class Groups extends BaseModule {
   async get(): Promise<ApiCollection<Group>> {
-    return await this.httpClient.get<
-      ApiCollection<Group>,
-      ApiCollection<Group>
-    >('/contacts/groups');
+    return await this.httpClient.get<ApiCollection<Group>>('/contacts/groups');
   }
 
   async getById(groupId: string): Promise<Group> {
-    return await this.httpClient.get<Group, Group>(
-      `/contacts/groups/${groupId}`,
-    );
+    return await this.httpClient.get<Group>(`/contacts/groups/${groupId}`);
   }
 
   async create(name: string, details?: CreateGroupDetails): Promise<Group> {
-    return await this.httpClient.post<Group, Group>('/contacts/groups', {
+    return await this.httpClient.post<Group>('/contacts/groups', {
       name,
       ...details,
     });
   }
 
   async update(groupId: string, updateGroup: UpdateGroup): Promise<Group> {
-    return await this.httpClient.put<Group, Group>(
+    return await this.httpClient.put<Group>(
       `/contacts/groups/${groupId}`,
-      updateGroup,
+      updateGroup as RequestConfig['body'],
     );
   }