@rudderstack/integrations-lib 0.1.2 → 0.1.3

package/build/network/clients/axios_client.test.js

@@ -0,0 +1,231 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const axios_1 = __importDefault(require("axios"));
+const axios_mock_adapter_1 = __importDefault(require("axios-mock-adapter"));
+const axios_client_1 = require("./axios_client"); // Import the AxiosClient class
+// Mock Axios for testing
+jest.mock('axios', () => {
+    return {
+        ...jest.requireActual('axios'),
+        create: jest.fn().mockReturnValue(jest.requireActual('axios')),
+    };
+});
+// Test cases
+describe('AxiosClient', () => {
+    let axiosClient;
+    let mockAxios;
+    beforeEach(() => {
+        mockAxios = new axios_mock_adapter_1.default(axios_1.default); // Create a MockAdapter for Axios
+        axiosClient = new axios_client_1.AxiosClient(); // Create a new AxiosClient instance for each test
+    });
+    afterEach(() => {
+        mockAxios.restore();
+    });
+    describe('happy flow tests', () => {
+        // Scenario 1: GET request and receive a response
+        it('should make a GET request and receive a response', async () => {
+            // Mock the GET request using axios-mock-adapter
+            mockAxios.onGet('https://example.com').reply(200, 'GET response');
+            const response = (await axiosClient.get('https://example.com'));
+            expect(response.type).toBe('success');
+            expect(response.statusCode).toBe(200);
+            expect(response.responseBody).toBe('GET response');
+        });
+        // Scenario 2: POST request and receive a response
+        it('should make a POST request and receive a response', async () => {
+            // Mock the axios.post method to return a response
+            mockAxios.onPost('https://example.com').reply(201, 'POST response');
+            const response = (await axiosClient.post('https://example.com', {
+                foo: 'bar',
+            }));
+            expect(response.type).toBe('success');
+            expect(response.statusCode).toBe(201);
+            expect(response.responseBody).toBe('POST response');
+        });
+        // Scenario 3: PUT request and receive a response
+        it('should make a PUT request and receive a response', async () => {
+            // Mock the axios.put method to return a response
+            mockAxios.onPut('https://example.com').reply(204);
+            const response = (await axiosClient.put('https://example.com', {
+                foo: 'bar',
+            }));
+            expect(response.type).toBe('success');
+            expect(response.statusCode).toBe(204);
+            expect(response.responseBody).toBeUndefined(); // No response body for PUT
+        });
+        // Scenario 4: PATCH request and receive a response
+        it('should make a PATCH request and receive a response', async () => {
+            // Mock the axios.patch method to return a response
+            mockAxios.onPatch('https://example.com').reply(200, 'PATCH response');
+            const response = (await axiosClient.patch('https://example.com', {
+                foo: 'bar',
+            }));
+            expect(response.type).toBe('success');
+            expect(response.statusCode).toBe(200);
+            expect(response.responseBody).toBe('PATCH response');
+        });
+        // Scenario 5: DELETE request and receive a response
+        it('should make a DELETE request and receive a response', async () => {
+            // Mock the axios.delete method to return a response
+            mockAxios.onDelete('https://example.com').reply(204);
+            const response = (await axiosClient.delete('https://example.com'));
+            expect(response.type).toBe('success');
+            expect(response.statusCode).toBe(204);
+            expect(response.responseBody).toBeUndefined(); // No response body for DELETE
+        });
+        // Scenario 6: GET request with a response parser
+        it('should make a GET request with a response parser', async () => {
+            // Mock the GET request using axios-mock-adapter
+            mockAxios.onGet('https://example.com').reply(200, 'GET response');
+            const response = (await axiosClient.get('https://example.com', {}, (data) => {
+                return `Parsed ${data}`;
+            }));
+            expect(response.type).toBe('success');
+            expect(response.statusCode).toBe(200);
+            expect(response.responseBody).toBe('Parsed GET response');
+        });
+        // Scenario 7: POST request with a response parser
+        it('should make a POST request with a response parser', async () => {
+            // Mock the axios.post method to return a response
+            mockAxios.onPost('https://example.com').reply(201, 'POST response');
+            const response = (await axiosClient.post('https://example.com', {
+                foo: 'bar',
+            }, {}, (data) => {
+                return `Parsed ${data}`;
+            }));
+            expect(response.type).toBe('success');
+            expect(response.statusCode).toBe(201);
+            expect(response.responseBody).toBe('Parsed POST response');
+        });
+        // Scenario 8: PUT request with a response parser
+        it('should make a PUT request with a response parser', async () => {
+            // Mock the axios.put method to return a response
+            mockAxios.onPut('https://example.com').reply(204);
+            const response = (await axiosClient.put('https://example.com', {
+                foo: 'bar',
+            }, {}, (data) => {
+                return `Parsed ${data}`;
+            }));
+            expect(response.type).toBe('success');
+            expect(response.statusCode).toBe(204);
+            expect(response.responseBody).toBe('Parsed undefined'); // No response body for PUT
+        });
+        // Scenario 9: PATCH request with a response parser
+        it('should make a PATCH request with a response parser', async () => {
+            // Mock the axios.patch method to return a response
+            mockAxios.onPatch('https://example.com').reply(200, 'PATCH response');
+            const response = (await axiosClient.patch('https://example.com', {
+                foo: 'bar',
+            }, {}, (data) => {
+                return `Parsed ${data}`;
+            }));
+            expect(response.type).toBe('success');
+            expect(response.statusCode).toBe(200);
+            expect(response.responseBody).toBe('Parsed PATCH response');
+        });
+        // Scenario 10: DELETE request with a response parser
+        it('should make a DELETE request with a response parser', async () => {
+            // Mock the axios.delete method to return a response
+            mockAxios.onDelete('https://example.com').reply(204);
+            const response = (await axiosClient.delete('https://example.com', {}, (data) => {
+                return `Parsed ${data}`;
+            }));
+            expect(response.type).toBe('success');
+            expect(response.statusCode).toBe(204);
+            expect(response.responseBody).toBe('Parsed undefined'); // No response body for DELETE
+        });
+        // Scenario 11: GET request with headers
+        it('should make a GET request with headers', async () => {
+            // Mock the GET request using axios-mock-adapter
+            mockAxios.onGet('https://example.com').reply((config) => {
+                expect(config.headers['foo']).toEqual('bar');
+                return [
+                    200,
+                    'GET response',
+                    {
+                        Authorization: `Bearer Token`,
+                        'Content-type': 'application/x-www-form-urlencoded',
+                    },
+                ];
+            });
+            const response = (await axiosClient.get('https://example.com', {
+                headers: { foo: 'bar' },
+            }));
+            expect(response.type).toBe('success');
+            expect(response.statusCode).toBe(200);
+            expect(response.responseBody).toBe('GET response');
+        });
+        // other happy flow tests
+        // Scenario 12:
+    });
+    describe('error flow tests', () => {
+        // Scenario 1: GET request and receive a network error
+        it('should make a GET request and receive a network error', async () => {
+            // Mock the GET request using axios-mock-adapter
+            mockAxios.onGet('https://example.com').abortRequest();
+            const response = (await axiosClient.get('https://example.com'));
+            expect(response.type).toBe('client-error');
+            expect(response.statusCode).toBe(500);
+            expect(response.message).toBe('Unknown Error:Request aborted');
+        });
+        // should handle timeout errors
+        it('should make a GET request and receive a timeout error', async () => {
+            // Mock the GET request using axios-mock-adapter
+            mockAxios.onGet('https://example.com').timeout();
+            const response = (await axiosClient.get('https://example.com'));
+            expect(response.type).toBe('client-error');
+            expect(response.statusCode).toBe(500);
+            expect(response.message).toBe('Unknown Error:timeout of 0ms exceeded');
+        });
+        it('should make a GET request and receive a network error', async () => {
+            // Mock the GET request using axios-mock-adapter
+            mockAxios.onGet('https://example.com').networkError();
+            const response = (await axiosClient.get('https://example.com'));
+            expect(response.type).toBe('client-error');
+            expect(response.statusCode).toBe(500);
+            expect(response.message).toBe('Network Error');
+        });
+        // should handle application errors (4xx)
+        it('should make a GET request and receive a 400 error', async () => {
+            // Mock the GET request using axios-mock-adapter
+            mockAxios.onGet('https://example.com').reply(400, 'Bad Request Received');
+            const response = (await axiosClient.get('https://example.com'));
+            expect(response.type).toBe('application-error');
+            expect(response.statusCode).toBe(400);
+            expect(response.responseBody).toBe('Bad Request Received');
+        });
+        // should handle application errors (5xx)
+        it('should make a GET request and receive a 500 error', async () => {
+            // Mock the GET request using axios-mock-adapter
+            mockAxios.onGet('https://example.com').reply(500, 'Internal Server Error');
+            const response = (await axiosClient.get('https://example.com'));
+            expect(response.type).toBe('application-error');
+            expect(response.statusCode).toBe(500);
+            expect(response.responseBody).toBe('Internal Server Error');
+        });
+        // should handle unexpected errors
+        it('should make a GET request and receive an unexpected error', async () => {
+            // Mock the GET request using axios-mock-adapter
+            mockAxios.onGet('https://example.com').reply(200, 'GET response');
+            const response = (await axiosClient.get('https://example.com', {}, (data) => {
+                throw new Error('Unexpected Error');
+            }));
+            expect(response.type).toBe('client-error');
+            expect(response.statusCode).toBe(500);
+            expect(response.message).toBe('Failed to parse response data: Unexpected Error');
+        });
+        // should handle empty response body
+        it('should make a GET request and receive an empty response body', async () => {
+            // Mock the GET request using axios-mock-adapter
+            mockAxios.onGet('https://example.com').reply(200);
+            const response = (await axiosClient.get('https://example.com'));
+            expect(response.type).toBe('success');
+            expect(response.statusCode).toBe(200);
+            expect(response.responseBody).toBeUndefined();
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"axios_client.test.js","sourceRoot":"","sources":["../../../src/network/clients/axios_client.test.ts"],"names":[],"mappings":"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","sourcesContent":["import axios from 'axios';\nimport MockAdapter from 'axios-mock-adapter';\nimport { AxiosClient } from './axios_client'; // Import the AxiosClient class\nimport {\n  ApplicationErrorApiResponse,\n  ClientErrorApiResponse,\n  SuccessfulApiResponse,\n} from './types';\n\n// Mock Axios for testing\njest.mock('axios', () => {\n  return {\n    ...(jest.requireActual('axios') as object),\n    create: jest.fn().mockReturnValue(jest.requireActual('axios')),\n  };\n});\n\n// Test cases\ndescribe('AxiosClient', () => {\n  let axiosClient: AxiosClient;\n  let mockAxios;\n\n  beforeEach(() => {\n    mockAxios = new MockAdapter(axios); // Create a MockAdapter for Axios\n    axiosClient = new AxiosClient(); // Create a new AxiosClient instance for each test\n  });\n\n  afterEach(() => {\n    mockAxios.restore();\n  });\n\n  describe('happy flow tests', () => {\n    // Scenario 1: GET request and receive a response\n    it('should make a GET request and receive a response', async () => {\n      // Mock the GET request using axios-mock-adapter\n      mockAxios.onGet('https://example.com').reply(200, 'GET response');\n      const response = (await axiosClient.get(\n        'https://example.com',\n      )) as SuccessfulApiResponse<string>;\n      expect(response.type).toBe('success');\n      expect(response.statusCode).toBe(200);\n      expect(response.responseBody).toBe('GET response');\n    });\n\n    // Scenario 2: POST request and receive a response\n    it('should make a POST request and receive a response', async () => {\n      // Mock the axios.post method to return a response\n      mockAxios.onPost('https://example.com').reply(201, 'POST response');\n\n      const response = (await axiosClient.post('https://example.com', {\n        foo: 'bar',\n      })) as SuccessfulApiResponse<string>;\n      expect(response.type).toBe('success');\n      expect(response.statusCode).toBe(201);\n      expect(response.responseBody).toBe('POST response');\n    });\n\n    // Scenario 3: PUT request and receive a response\n    it('should make a PUT request and receive a response', async () => {\n      // Mock the axios.put method to return a response\n      mockAxios.onPut('https://example.com').reply(204);\n\n      const response = (await axiosClient.put('https://example.com', {\n        foo: 'bar',\n      })) as SuccessfulApiResponse<string>;\n      expect(response.type).toBe('success');\n      expect(response.statusCode).toBe(204);\n      expect(response.responseBody).toBeUndefined(); // No response body for PUT\n    });\n\n    // Scenario 4: PATCH request and receive a response\n    it('should make a PATCH request and receive a response', async () => {\n      // Mock the axios.patch method to return a response\n      mockAxios.onPatch('https://example.com').reply(200, 'PATCH response');\n\n      const response = (await axiosClient.patch('https://example.com', {\n        foo: 'bar',\n      })) as SuccessfulApiResponse<string>;\n      expect(response.type).toBe('success');\n      expect(response.statusCode).toBe(200);\n      expect(response.responseBody).toBe('PATCH response');\n    });\n\n    // Scenario 5: DELETE request and receive a response\n    it('should make a DELETE request and receive a response', async () => {\n      // Mock the axios.delete method to return a response\n      mockAxios.onDelete('https://example.com').reply(204);\n\n      const response = (await axiosClient.delete(\n        'https://example.com',\n      )) as SuccessfulApiResponse<string>;\n      expect(response.type).toBe('success');\n      expect(response.statusCode).toBe(204);\n      expect(response.responseBody).toBeUndefined(); // No response body for DELETE\n    });\n\n    // Scenario 6: GET request with a response parser\n    it('should make a GET request with a response parser', async () => {\n      // Mock the GET request using axios-mock-adapter\n      mockAxios.onGet('https://example.com').reply(200, 'GET response');\n\n      const response = (await axiosClient.get('https://example.com', {}, (data) => {\n        return `Parsed ${data}`;\n      })) as SuccessfulApiResponse<string>;\n      expect(response.type).toBe('success');\n      expect(response.statusCode).toBe(200);\n      expect(response.responseBody).toBe('Parsed GET response');\n    });\n\n    // Scenario 7: POST request with a response parser\n    it('should make a POST request with a response parser', async () => {\n      // Mock the axios.post method to return a response\n      mockAxios.onPost('https://example.com').reply(201, 'POST response');\n\n      const response = (await axiosClient.post(\n        'https://example.com',\n        {\n          foo: 'bar',\n        },\n        {},\n        (data) => {\n          return `Parsed ${data}`;\n        },\n      )) as SuccessfulApiResponse<string>;\n      expect(response.type).toBe('success');\n      expect(response.statusCode).toBe(201);\n      expect(response.responseBody).toBe('Parsed POST response');\n    });\n\n    // Scenario 8: PUT request with a response parser\n    it('should make a PUT request with a response parser', async () => {\n      // Mock the axios.put method to return a response\n      mockAxios.onPut('https://example.com').reply(204);\n\n      const response = (await axiosClient.put(\n        'https://example.com',\n        {\n          foo: 'bar',\n        },\n        {},\n        (data) => {\n          return `Parsed ${data}`;\n        },\n      )) as SuccessfulApiResponse<string>;\n      expect(response.type).toBe('success');\n      expect(response.statusCode).toBe(204);\n      expect(response.responseBody).toBe('Parsed undefined'); // No response body for PUT\n    });\n\n    // Scenario 9: PATCH request with a response parser\n    it('should make a PATCH request with a response parser', async () => {\n      // Mock the axios.patch method to return a response\n      mockAxios.onPatch('https://example.com').reply(200, 'PATCH response');\n\n      const response = (await axiosClient.patch(\n        'https://example.com',\n        {\n          foo: 'bar',\n        },\n        {},\n        (data) => {\n          return `Parsed ${data}`;\n        },\n      )) as SuccessfulApiResponse<string>;\n      expect(response.type).toBe('success');\n      expect(response.statusCode).toBe(200);\n      expect(response.responseBody).toBe('Parsed PATCH response');\n    });\n\n    // Scenario 10: DELETE request with a response parser\n    it('should make a DELETE request with a response parser', async () => {\n      // Mock the axios.delete method to return a response\n      mockAxios.onDelete('https://example.com').reply(204);\n\n      const response = (await axiosClient.delete('https://example.com', {}, (data) => {\n        return `Parsed ${data}`;\n      })) as SuccessfulApiResponse<string>;\n      expect(response.type).toBe('success');\n      expect(response.statusCode).toBe(204);\n      expect(response.responseBody).toBe('Parsed undefined'); // No response body for DELETE\n    });\n\n    // Scenario 11: GET request with headers\n    it('should make a GET request with headers', async () => {\n      // Mock the GET request using axios-mock-adapter\n      mockAxios.onGet('https://example.com').reply((config) => {\n        expect(config.headers['foo']).toEqual('bar');\n        return [\n          200,\n          'GET response',\n          {\n            Authorization: `Bearer Token`,\n            'Content-type': 'application/x-www-form-urlencoded',\n          },\n        ];\n      });\n\n      const response = (await axiosClient.get('https://example.com', {\n        headers: { foo: 'bar' },\n      })) as SuccessfulApiResponse<string>;\n      expect(response.type).toBe('success');\n      expect(response.statusCode).toBe(200);\n      expect(response.responseBody).toBe('GET response');\n    });\n\n    // other happy flow tests\n    // Scenario 12:\n  });\n\n  describe('error flow tests', () => {\n    // Scenario 1: GET request and receive a network error\n    it('should make a GET request and receive a network error', async () => {\n      // Mock the GET request using axios-mock-adapter\n      mockAxios.onGet('https://example.com').abortRequest();\n\n      const response = (await axiosClient.get('https://example.com')) as ClientErrorApiResponse;\n      expect(response.type).toBe('client-error');\n      expect(response.statusCode).toBe(500);\n      expect(response.message).toBe('Unknown Error:Request aborted');\n    });\n\n    // should handle timeout errors\n    it('should make a GET request and receive a timeout error', async () => {\n      // Mock the GET request using axios-mock-adapter\n      mockAxios.onGet('https://example.com').timeout();\n\n      const response = (await axiosClient.get('https://example.com')) as ClientErrorApiResponse;\n      expect(response.type).toBe('client-error');\n      expect(response.statusCode).toBe(500);\n      expect(response.message).toBe('Unknown Error:timeout of 0ms exceeded');\n    });\n\n    it('should make a GET request and receive a network error', async () => {\n      // Mock the GET request using axios-mock-adapter\n      mockAxios.onGet('https://example.com').networkError();\n\n      const response = (await axiosClient.get('https://example.com')) as ClientErrorApiResponse;\n      expect(response.type).toBe('client-error');\n      expect(response.statusCode).toBe(500);\n      expect(response.message).toBe('Network Error');\n    });\n\n    // should handle application errors (4xx)\n    it('should make a GET request and receive a 400 error', async () => {\n      // Mock the GET request using axios-mock-adapter\n      mockAxios.onGet('https://example.com').reply(400, 'Bad Request Received');\n\n      const response = (await axiosClient.get(\n        'https://example.com',\n      )) as ApplicationErrorApiResponse;\n      expect(response.type).toBe('application-error');\n      expect(response.statusCode).toBe(400);\n      expect(response.responseBody).toBe('Bad Request Received');\n    });\n\n    // should handle application errors (5xx)\n    it('should make a GET request and receive a 500 error', async () => {\n      // Mock the GET request using axios-mock-adapter\n      mockAxios.onGet('https://example.com').reply(500, 'Internal Server Error');\n\n      const response = (await axiosClient.get(\n        'https://example.com',\n      )) as ApplicationErrorApiResponse;\n      expect(response.type).toBe('application-error');\n      expect(response.statusCode).toBe(500);\n      expect(response.responseBody).toBe('Internal Server Error');\n    });\n\n    // should handle unexpected errors\n    it('should make a GET request and receive an unexpected error', async () => {\n      // Mock the GET request using axios-mock-adapter\n      mockAxios.onGet('https://example.com').reply(200, 'GET response');\n\n      const response = (await axiosClient.get('https://example.com', {}, (data) => {\n        throw new Error('Unexpected Error');\n      })) as ClientErrorApiResponse;\n      expect(response.type).toBe('client-error');\n      expect(response.statusCode).toBe(500);\n      expect(response.message).toBe('Failed to parse response data: Unexpected Error');\n    });\n\n    // should handle empty response body\n    it('should make a GET request and receive an empty response body', async () => {\n      // Mock the GET request using axios-mock-adapter\n      mockAxios.onGet('https://example.com').reply(200);\n\n      const response = (await axiosClient.get(\n        'https://example.com',\n      )) as SuccessfulApiResponse<string>;\n      expect(response.type).toBe('success');\n      expect(response.statusCode).toBe(200);\n      expect(response.responseBody).toBeUndefined();\n    });\n  });\n});\n"]}

package/build/network/factory.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HttpClientFactory = exports.ClientNames = void 0;
 const platform_error_1 = require("../errors/platform_error");
-const axios_1 = require("./clients/axios");
+const axios_client_1 = require("./clients/axios_client");
 var ClientNames;
 (function (ClientNames) {
     ClientNames["Axios"] = "axios";
@@ -32,7 +32,7 @@ class HttpClientFactory {
     static getHttpClient(name, options) {
         switch (name) {
             case ClientNames.Axios:
-                return new axios_1.AxiosClient(options);
+                return new axios_client_1.AxiosClient(options);
             // case ClientNames.Fetch:
             //     return require('./clients/fetch').FetchClient;
             // case ClientNames.Xhr:
@@ -43,4 +43,4 @@ class HttpClientFactory {
     }
 }
 exports.HttpClientFactory = HttpClientFactory;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/build/network/factory.test.js

@@ -2,19 +2,19 @@
 // Generated by CodiumAI
 Object.defineProperty(exports, "__esModule", { value: true });
 const errors_1 = require("../errors");
-const axios_1 = require("./clients/axios");
+const axios_client_1 = require("./clients/axios_client");
 const factory_1 = require("./factory");
 describe('getHttpClient', () => {
     // Tests that getHttpClient returns an instance of AxiosClient when name is ClientNames.Axios and options are not provided
     it('should return an instance of AxiosClient when name is ClientNames.Axios and options are not provided', () => {
         const httpClient = factory_1.HttpClientFactory.getHttpClient(factory_1.ClientNames.Axios);
-        expect(httpClient).toBeInstanceOf(axios_1.AxiosClient);
+        expect(httpClient).toBeInstanceOf(axios_client_1.AxiosClient);
     });
     // Tests that getHttpClient returns an instance of AxiosClient with provided options when name is ClientNames.Axios and options are provided
     it('should return an instance of AxiosClient with provided options when name is ClientNames.Axios and options are provided', () => {
         const options = { timeout: 5000 };
         const httpClient = factory_1.HttpClientFactory.getHttpClient(factory_1.ClientNames.Axios, options);
-        expect(httpClient).toBeInstanceOf(axios_1.AxiosClient);
+        expect(httpClient).toBeInstanceOf(axios_client_1.AxiosClient);
         expect(httpClient['options'].timeout).toEqual(options.timeout);
     });
     // Tests that getHttpClient throws a PlatformError with message 'Invalid client name' when name is not a valid ClientNames enum value
@@ -47,4 +47,4 @@ describe('getHttpClient', () => {
     //   expect(httpClient).toBe(XhrClient);
     // });
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rudderstack/integrations-lib",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "",
   "main": "build/index.js",
   "module": "build/index.js",

package/build/network/clients/axios.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"axios.d.ts","sourceRoot":"","sources":["../../../src/network/clients/axios.ts"],"names":[],"mappings":"AAAA,OAAc,EAAE,kBAAkB,EAA6B,MAAM,OAAO,CAAC;AAI7E,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAGlE;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBAAa,WAAY,YAAW,UAAU;IAC5C,OAAO,CAAC,OAAO,CAAqB;IACpC,OAAO,CAAC,QAAQ,CAAgB;gBAEpB,OAAO,CAAC,EAAE,kBAAkB;YAoB1B,WAAW;IAoEZ,GAAG,CAAC,CAAC,EAChB,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE,kBAAkB,EAC5B,cAAc,CAAC,EAAE,cAAc,CAAC,CAAC,CAAC,GACjC,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;IAWb,IAAI,CAAC,CAAC,EACjB,GAAG,EAAE,MAAM,EACX,IAAI,CAAC,EAAE,GAAG,EACV,OAAO,CAAC,EAAE,kBAAkB,EAC5B,cAAc,CAAC,EAAE,cAAc,CAAC,CAAC,CAAC,GACjC,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;IAYb,GAAG,CAAC,CAAC,EAChB,GAAG,EAAE,MAAM,EACX,IAAI,CAAC,EAAE,GAAG,EACV,OAAO,CAAC,EAAE,kBAAkB,EAC5B,cAAc,CAAC,EAAE,cAAc,CAAC,CAAC,CAAC,GACjC,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;IAYb,KAAK,CAAC,CAAC,EAClB,GAAG,EAAE,MAAM,EACX,IAAI,CAAC,EAAE,GAAG,EACV,OAAO,CAAC,EAAE,kBAAkB,EAC5B,cAAc,CAAC,EAAE,cAAc,CAAC,CAAC,CAAC,GACjC,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;IAYb,MAAM,CAAC,CAAC,EACnB,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE,kBAAkB,EAC5B,cAAc,CAAC,EAAE,cAAc,CAAC,CAAC,CAAC,GACjC,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;CAY3B"}

package/build/network/clients/axios.js

@@ -1,197 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AxiosClient = void 0;
-const axios_1 = __importStar(require("axios"));
-const http_1 = __importDefault(require("http"));
-const https_1 = __importDefault(require("https"));
-const constants_1 = require("../../constants");
-const utils_1 = require("../../utils");
-/**
- * A wrapper around axios to make http requests
- *
- * @class AxiosClient
- * @classdesc
- * The `AxiosClient` class is a wrapper around the axios library that provides a simplified interface for making HTTP requests. It handles various types of errors and provides a consistent response format.
- *
- * @param {AxiosRequestConfig} options - The default options for the http client
- *
- * @example
- * const axiosClient = new AxiosClient({ timeout: 1000 * 10 });
- * const response = await axiosClient.post("https://example.com", { foo: "bar" });
- * if (response.type === "success") {
- *   console.log(response.statusCode);
- *   console.log(response.responseBody);
- * } else if (response.type === "application-error") {
- *   console.log(response.statusCode);
- *   console.log(response.message);
- *   console.log(response.responseBody);
- * } else if (response.type === "client-error") {
- *   console.log(response.statusCode);
- *   console.log(response.message);
- * }
- */
-class AxiosClient {
-    constructor(options) {
-        const defaultOptions = {
-            timeout: 1000 * 10,
-            // `withCredentials` indicates whether or not cross-site Access-Control requests should be made using credentials
-            withCredentials: false,
-            // `responseEncoding` indicates encoding to use for decoding responses (Node.js only),
-            responseEncoding: 'utf8',
-            // `maxBodyLength` (Node only option) defines the max size of the http request content in bytes allowed,
-            maxBodyLength: 1000 * 1000 * 10,
-            // `maxRedirects` defines the maximum number of redirects to follow in node.js,
-            maxRedirects: 5,
-            // `httpAgent` and `httpsAgent` define a custom agent to be used when performing http
-            httpAgent: new http_1.default.Agent({ keepAlive: true }),
-            // and https requests, respectively, in node.js. This allows options to be added like `keepAlive` that are not enabled by default.
-            httpsAgent: new https_1.default.Agent({ keepAlive: true }),
-        };
-        this.options = { ...defaultOptions, ...options };
-        this.instance = axios_1.default.create(this.options);
-    }
-    async makeRequest(config, responseParser) {
-        let output;
-        try {
-            const requestConfig = config;
-            const response = await this.instance.request(requestConfig);
-            const { status, data, headers } = response;
-            if (responseParser) {
-                try {
-                    const parsedData = responseParser(data);
-                    output = {
-                        type: 'success',
-                        statusCode: status,
-                        responseBody: parsedData,
-                        headers,
-                    };
-                    return output;
-                }
-                catch (error) {
-                    const unknownError = error;
-                    return {
-                        type: 'client-error',
-                        statusCode: unknownError['status'] || 500,
-                        message: `Failed to parse response data: ${unknownError.message}`,
-                    };
-                }
-            }
-            return { type: 'success', statusCode: status, responseBody: data, headers };
-        }
-        catch (error) {
-            if (error instanceof axios_1.AxiosError) {
-                const axiosError = error;
-                if (axiosError.response) {
-                    const { response } = axiosError;
-                    return {
-                        type: 'application-error',
-                        statusCode: response.status,
-                        message: response.statusText,
-                        responseBody: response.data,
-                        headers: response.headers,
-                    };
-                }
-                if (axiosError.code) {
-                    const resp = constants_1.NETWORK_STATUS_ERR_MAP[axiosError.code];
-                    if (!resp) {
-                        return {
-                            type: 'client-error',
-                            statusCode: 500,
-                            message: `Unknown Error:${axiosError.message}`,
-                        };
-                    }
-                    return {
-                        type: 'client-error',
-                        statusCode: resp.status,
-                        message: resp.message,
-                    };
-                }
-            }
-            const unknownError = error;
-            const status = 500;
-            const message = unknownError.message || 'Unknown Error';
-            return { type: 'client-error', statusCode: status, message };
-        }
-    }
-    async get(url, options, responseParser) {
-        let config = {
-            method: 'get',
-            url: url,
-        };
-        if ((0, utils_1.isNotEmpty)(options)) {
-            config = { ...config, ...options };
-        }
-        return this.makeRequest(config, responseParser);
-    }
-    async post(url, data, options, responseParser) {
-        let config = {
-            method: 'post',
-            url: url,
-            data,
-        };
-        if ((0, utils_1.isNotEmpty)(options)) {
-            config = { ...config, ...options };
-        }
-        return this.makeRequest(config, responseParser);
-    }
-    async put(url, data, options, responseParser) {
-        let config = {
-            method: 'put',
-            url: url,
-            data,
-        };
-        if ((0, utils_1.isNotEmpty)(options)) {
-            config = { ...config, ...options };
-        }
-        return this.makeRequest(config, responseParser);
-    }
-    async patch(url, data, options, responseParser) {
-        let config = {
-            method: 'patch',
-            url: url,
-            data,
-        };
-        if ((0, utils_1.isNotEmpty)(options)) {
-            config = { ...config, ...options };
-        }
-        return this.makeRequest(config, responseParser);
-    }
-    async delete(url, options, responseParser) {
-        let config = {
-            method: 'delete',
-            url: url,
-        };
-        if ((0, utils_1.isNotEmpty)(options)) {
-            config = { ...config, ...options };
-        }
-        return this.makeRequest(config, responseParser);
-    }
-}
-exports.AxiosClient = AxiosClient;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"axios.js","sourceRoot":"","sources":["../../../src/network/clients/axios.ts"],"names":[],"mappings":"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","sourcesContent":["import axios, { AxiosRequestConfig, AxiosError, AxiosInstance } from 'axios';\nimport http from 'http';\nimport https from 'https';\nimport { NETWORK_STATUS_ERR_MAP } from '../../constants';\nimport { ApiResponse, HttpClient, ResponseParser } from './types';\nimport { isNotEmpty } from '../../utils';\n\n/**\n * A wrapper around axios to make http requests\n *\n * @class AxiosClient\n * @classdesc\n * The `AxiosClient` class is a wrapper around the axios library that provides a simplified interface for making HTTP requests. It handles various types of errors and provides a consistent response format.\n *\n * @param {AxiosRequestConfig} options - The default options for the http client\n *\n * @example\n * const axiosClient = new AxiosClient({ timeout: 1000 * 10 });\n * const response = await axiosClient.post(\"https://example.com\", { foo: \"bar\" });\n * if (response.type === \"success\") {\n *   console.log(response.statusCode);\n *   console.log(response.responseBody);\n * } else if (response.type === \"application-error\") {\n *   console.log(response.statusCode);\n *   console.log(response.message);\n *   console.log(response.responseBody);\n * } else if (response.type === \"client-error\") {\n *   console.log(response.statusCode);\n *   console.log(response.message);\n * }\n */\nexport class AxiosClient implements HttpClient {\n  private options: AxiosRequestConfig;\n  private instance: AxiosInstance;\n\n  constructor(options?: AxiosRequestConfig) {\n    const defaultOptions = {\n      timeout: 1000 * 10,\n      // `withCredentials` indicates whether or not cross-site Access-Control requests should be made using credentials\n      withCredentials: false,\n      // `responseEncoding` indicates encoding to use for decoding responses (Node.js only),\n      responseEncoding: 'utf8',\n      // `maxBodyLength` (Node only option) defines the max size of the http request content in bytes allowed,\n      maxBodyLength: 1000 * 1000 * 10,\n      // `maxRedirects` defines the maximum number of redirects to follow in node.js,\n      maxRedirects: 5,\n      // `httpAgent` and `httpsAgent` define a custom agent to be used when performing http\n      httpAgent: new http.Agent({ keepAlive: true }),\n      // and https requests, respectively, in node.js. This allows options to be added like `keepAlive` that are not enabled by default.\n      httpsAgent: new https.Agent({ keepAlive: true }),\n    };\n    this.options = { ...defaultOptions, ...options };\n    this.instance = axios.create(this.options);\n  }\n\n  private async makeRequest<T>(\n    config: AxiosRequestConfig,\n    responseParser?: ResponseParser<T>,\n  ): Promise<ApiResponse<T>> {\n    let output: ApiResponse<T>;\n    try {\n      const requestConfig = config;\n      const response = await this.instance.request(requestConfig);\n      const { status, data, headers } = response;\n\n      if (responseParser) {\n        try {\n          const parsedData = responseParser(data);\n          output = {\n            type: 'success',\n            statusCode: status,\n            responseBody: parsedData,\n            headers,\n          };\n          return output;\n        } catch (error) {\n          const unknownError = error as Error;\n          return {\n            type: 'client-error',\n            statusCode: unknownError['status'] || 500,\n            message: `Failed to parse response data: ${unknownError.message}`,\n          };\n        }\n      }\n      return { type: 'success', statusCode: status, responseBody: data, headers };\n    } catch (error) {\n      if (error instanceof AxiosError) {\n        const axiosError = error as AxiosError;\n        if (axiosError.response) {\n          const { response } = axiosError;\n          return {\n            type: 'application-error',\n            statusCode: response.status,\n            message: response.statusText,\n            responseBody: response.data,\n            headers: response.headers,\n          };\n        }\n        if (axiosError.code) {\n          const resp = NETWORK_STATUS_ERR_MAP[axiosError.code];\n          if (!resp) {\n            return {\n              type: 'client-error',\n              statusCode: 500,\n              message: `Unknown Error:${axiosError.message}`,\n            };\n          }\n          return {\n            type: 'client-error',\n            statusCode: resp.status,\n            message: resp.message,\n          };\n        }\n      }\n\n      const unknownError = error as Error;\n      const status = 500;\n      const message = unknownError.message || 'Unknown Error';\n\n      return { type: 'client-error', statusCode: status, message };\n    }\n  }\n\n  public async get<T>(\n    url: string,\n    options?: AxiosRequestConfig,\n    responseParser?: ResponseParser<T>,\n  ): Promise<ApiResponse<T>> {\n    let config: AxiosRequestConfig = {\n      method: 'get',\n      url: url,\n    };\n    if (isNotEmpty(options)) {\n      config = { ...config, ...options };\n    }\n    return this.makeRequest<T>(config, responseParser);\n  }\n\n  public async post<T>(\n    url: string,\n    data?: any,\n    options?: AxiosRequestConfig,\n    responseParser?: ResponseParser<T>,\n  ): Promise<ApiResponse<T>> {\n    let config: AxiosRequestConfig = {\n      method: 'post',\n      url: url,\n      data,\n    };\n    if (isNotEmpty(options)) {\n      config = { ...config, ...options };\n    }\n    return this.makeRequest<T>(config, responseParser);\n  }\n\n  public async put<T>(\n    url: string,\n    data?: any,\n    options?: AxiosRequestConfig,\n    responseParser?: ResponseParser<T>,\n  ): Promise<ApiResponse<T>> {\n    let config: AxiosRequestConfig = {\n      method: 'put',\n      url: url,\n      data,\n    };\n    if (isNotEmpty(options)) {\n      config = { ...config, ...options };\n    }\n    return this.makeRequest<T>(config, responseParser);\n  }\n\n  public async patch<T>(\n    url: string,\n    data?: any,\n    options?: AxiosRequestConfig,\n    responseParser?: ResponseParser<T>,\n  ): Promise<ApiResponse<T>> {\n    let config: AxiosRequestConfig = {\n      method: 'patch',\n      url: url,\n      data,\n    };\n    if (isNotEmpty(options)) {\n      config = { ...config, ...options };\n    }\n    return this.makeRequest<T>(config, responseParser);\n  }\n\n  public async delete<T>(\n    url: string,\n    options?: AxiosRequestConfig,\n    responseParser?: ResponseParser<T>,\n  ): Promise<ApiResponse<T>> {\n    let config: AxiosRequestConfig = {\n      method: 'delete',\n      url: url,\n    };\n    if (isNotEmpty(options)) {\n      config = { ...config, ...options };\n    }\n    return this.makeRequest<T>(config, responseParser);\n  }\n\n  // Add other HTTP methods as needed\n}\n"]}

package/build/network/clients/axios.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=axios.test.d.ts.map

package/build/network/clients/axios.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"axios.test.d.ts","sourceRoot":"","sources":["../../../src/network/clients/axios.test.ts"],"names":[],"mappings":""}