@rudderstack/integrations-lib 0.1.0

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

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

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

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

package/build/network/clients/axios.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_2 = require("./axios"); // 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_2.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.test.js","sourceRoot":"","sources":["../../../src/network/clients/axios.test.ts"],"names":[],"mappings":"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","sourcesContent":["import axios from 'axios';\nimport MockAdapter from 'axios-mock-adapter';\nimport { AxiosClient } from './axios'; // 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/clients/types.d.ts

@@ -0,0 +1,32 @@
+import { AxiosRequestConfig, AxiosResponseHeaders, RawAxiosResponseHeaders } from 'axios';
+type ResponseHeaders = RawAxiosResponseHeaders | AxiosResponseHeaders | undefined;
+export type ResponseParser<T> = (responseData: any) => T;
+export type SuccessfulApiResponse<T> = {
+    type: 'success';
+    statusCode: number;
+    responseBody: T;
+    headers: ResponseHeaders;
+};
+export type ClientErrorApiResponse = {
+    type: 'client-error';
+    statusCode: number;
+    message: string;
+};
+export type ApplicationErrorApiResponse = {
+    type: 'application-error';
+    statusCode: number;
+    message: string;
+    responseBody: any;
+    headers: ResponseHeaders;
+};
+export type ApiResponse<T> = SuccessfulApiResponse<T> | ClientErrorApiResponse | ApplicationErrorApiResponse;
+export type RequestConfig = AxiosRequestConfig;
+export interface HttpClient {
+    post: <T>(url: string, data: any, options?: RequestConfig, responseParser?: ResponseParser<T>) => Promise<ApiResponse<T>>;
+    get: <T>(url: string, options?: RequestConfig, responseParser?: ResponseParser<T>) => Promise<ApiResponse<T>>;
+    put: <T>(url: string, data: any, options?: RequestConfig, responseParser?: ResponseParser<T>) => Promise<ApiResponse<T>>;
+    patch: <T>(url: string, data: any, options?: RequestConfig, responseParser?: ResponseParser<T>) => Promise<ApiResponse<T>>;
+    delete: <T>(url: string, options?: RequestConfig, responseParser?: ResponseParser<T>) => Promise<ApiResponse<T>>;
+}
+export {};
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/network/clients/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,uBAAuB,EAAE,MAAM,OAAO,CAAC;AAE1F,KAAK,eAAe,GAAG,uBAAuB,GAAG,oBAAoB,GAAG,SAAS,CAAC;AAClF,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI,CAAC,YAAY,EAAE,GAAG,KAAK,CAAC,CAAC;AACzD,MAAM,MAAM,qBAAqB,CAAC,CAAC,IAAI;IACrC,IAAI,EAAE,SAAS,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,CAAC,CAAC;IAChB,OAAO,EAAE,eAAe,CAAC;CAC1B,CAAC;AACF,MAAM,MAAM,sBAAsB,GAAG;IACnC,IAAI,EAAE,cAAc,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AACF,MAAM,MAAM,2BAA2B,GAAG;IACxC,IAAI,EAAE,mBAAmB,CAAC;IAC1B,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,GAAG,CAAC;IAClB,OAAO,EAAE,eAAe,CAAC;CAC1B,CAAC;AACF,MAAM,MAAM,WAAW,CAAC,CAAC,IACrB,qBAAqB,CAAC,CAAC,CAAC,GACxB,sBAAsB,GACtB,2BAA2B,CAAC;AAGhC,MAAM,MAAM,aAAa,GAAG,kBAAkB,CAAE;AAEhD,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,CAAC,CAAC,EACN,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,GAAG,EACT,OAAO,CAAC,EAAE,aAAa,EACvB,cAAc,CAAC,EAAE,cAAc,CAAC,CAAC,CAAC,KAC/B,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;IAC7B,GAAG,EAAE,CAAC,CAAC,EACL,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE,aAAa,EACvB,cAAc,CAAC,EAAE,cAAc,CAAC,CAAC,CAAC,KAC/B,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;IAE7B,GAAG,EAAE,CAAC,CAAC,EACL,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,GAAG,EACT,OAAO,CAAC,EAAE,aAAa,EACvB,cAAc,CAAC,EAAE,cAAc,CAAC,CAAC,CAAC,KAC/B,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;IAE7B,KAAK,EAAE,CAAC,CAAC,EACP,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,GAAG,EACT,OAAO,CAAC,EAAE,aAAa,EACvB,cAAc,CAAC,EAAE,cAAc,CAAC,CAAC,CAAC,KAC/B,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;IAE7B,MAAM,EAAE,CAAC,CAAC,EACR,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE,aAAa,EACvB,cAAc,CAAC,EAAE,cAAc,CAAC,CAAC,CAAC,KAC/B,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;CAC9B"}

package/build/network/clients/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,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

package/build/network/factory.d.ts

@@ -0,0 +1,30 @@
+import { HttpClient } from './clients/types';
+import { AxiosRequestConfig } from 'axios';
+export { ApiResponse, ApplicationErrorApiResponse, ClientErrorApiResponse, SuccessfulApiResponse, ResponseParser, } from './clients/types';
+export declare enum ClientNames {
+    Axios = "axios"
+}
+export type clientOptions = AxiosRequestConfig;
+/**
+ * @class HttpClientFactory
+ * @classdesc
+ * A factory class to generate http clients
+ * @example
+ * const httpClient = HttpClientFactory.getHttpClient('axios');
+ * const response = await httpClient.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);
+ * }
+ */
+export declare class HttpClientFactory {
+    static getHttpClient(name: ClientNames, options?: clientOptions): HttpClient;
+}
+//# sourceMappingURL=factory.d.ts.map

package/build/network/factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../src/network/factory.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE7C,OAAO,EAAE,kBAAkB,EAAE,MAAM,OAAO,CAAC;AAC3C,OAAO,EACL,WAAW,EACX,2BAA2B,EAC3B,sBAAsB,EACtB,qBAAqB,EACrB,cAAc,GACf,MAAM,iBAAiB,CAAC;AAEzB,oBAAY,WAAW;IACrB,KAAK,UAAU;CAGhB;AAGD,MAAM,MAAM,aAAa,GAAG,kBAAkB,CAAC;AAE/C;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,iBAAiB;IAC5B,MAAM,CAAC,aAAa,CAAC,IAAI,EAAE,WAAW,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,UAAU;CAY7E"}

package/build/network/factory.js

@@ -0,0 +1,46 @@
+"use strict";
+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");
+var ClientNames;
+(function (ClientNames) {
+    ClientNames["Axios"] = "axios";
+    // Fetch = 'fetch',
+    // Xhr = 'xhr'
+})(ClientNames || (exports.ClientNames = ClientNames = {}));
+/**
+ * @class HttpClientFactory
+ * @classdesc
+ * A factory class to generate http clients
+ * @example
+ * const httpClient = HttpClientFactory.getHttpClient('axios');
+ * const response = await httpClient.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 HttpClientFactory {
+    static getHttpClient(name, options) {
+        switch (name) {
+            case ClientNames.Axios:
+                return new axios_1.AxiosClient(options);
+            // case ClientNames.Fetch:
+            //     return require('./clients/fetch').FetchClient;
+            // case ClientNames.Xhr:
+            //     return require('./clients/xhr').XhrClient;
+            default:
+                throw new platform_error_1.PlatformError('Invalid client name');
+        }
+    }
+}
+exports.HttpClientFactory = HttpClientFactory;
+//# sourceMappingURL=data:application/json;base64,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

package/build/network/factory.test.d.ts

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

package/build/network/factory.test.d.ts.map

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

package/build/network/factory.test.js

@@ -0,0 +1,50 @@
+"use strict";
+// Generated by CodiumAI
+Object.defineProperty(exports, "__esModule", { value: true });
+const errors_1 = require("../errors");
+const axios_1 = require("./clients/axios");
+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);
+    });
+    // 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['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
+    it('should throw a PlatformError with message "Invalid client name" when name is not a valid ClientNames enum value', () => {
+        const invalidName = 'InvalidClient';
+        expect(() => {
+            factory_1.HttpClientFactory.getHttpClient(invalidName);
+        }).toThrowError(errors_1.PlatformError);
+        expect(() => {
+            factory_1.HttpClientFactory.getHttpClient(invalidName);
+        }).toThrowError('Invalid client name');
+    });
+    // Uncomment the following tests as we implement the FetchClient and XhrClient classes
+    // // Tests that getHttpClient returns a FetchClient instance when name is ClientNames.Fetch
+    // it('should return a FetchClient instance when name is ClientNames.Fetch', () => {
+    //   jest.mock('./clients/fetch', () => ({
+    //     FetchClient: jest.fn(),
+    //   }));
+    //   const { FetchClient } = require('./clients/fetch');
+    //   const httpClient = HttpClientFactory.getHttpClient(ClientNames.Fetch);
+    //   expect(httpClient).toBe(FetchClient);
+    // });
+    // // Tests that getHttpClient returns an XhrClient instance when name is ClientNames.Xhr
+    // it('should return an XhrClient instance when name is ClientNames.Xhr', () => {
+    //   jest.mock('./clients/xhr', () => ({
+    //     XhrClient: jest.fn(),
+    //   }));
+    //   const { XhrClient } = require('./clients/xhr');
+    //   const httpClient = HttpClientFactory.getHttpClient(ClientNames.Xhr);
+    //   expect(httpClient).toBe(XhrClient);
+    // });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/build/network/index.d.ts

@@ -0,0 +1,2 @@
+export * from './factory';
+//# sourceMappingURL=index.d.ts.map

package/build/network/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/network/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAA"}

package/build/network/index.js

@@ -0,0 +1,18 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./factory"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbmV0d29yay9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsNENBQXlCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9mYWN0b3J5JyJdfQ==

package/build/tags.d.ts

@@ -0,0 +1,56 @@
+export declare const TAG_NAMES: {
+    MODULE: string;
+    IMPLEMENTATION: string;
+    FEATURE: string;
+    ERROR_CATEGORY: string;
+    ERROR_TYPE: string;
+    META: string;
+    DEST_TYPE: string;
+    SRC_TYPE: string;
+    CLUSTER: string;
+    NAMESPACE: string;
+    CUSTOMER: string;
+    DESTINATION_ID: string;
+    WORKSPACE_ID: string;
+    SOURCE_ID: string;
+};
+export declare const MODULES: {
+    SOURCE: string;
+    DESTINATION: string;
+    MISCELLANEOUS: string;
+};
+export declare const IMPLEMENTATIONS: {
+    NATIVE: string;
+    CDK_V1: string;
+    CDK_V2: string;
+};
+export declare const FEATURES: {
+    PROCESSOR: string;
+    ROUTER: string;
+    BATCH: string;
+    DATA_DELIVERY: string;
+    USER_DELETION: string;
+};
+export declare const ERROR_CATEGORIES: {
+    DATA_VALIDATION: string;
+    NETWORK: string;
+    PLATFORM: string;
+    TRANSFORMATION: string;
+};
+export declare const ERROR_TYPES: {
+    INSTRUMENTATION: string;
+    CONFIGURATION: string;
+    THROTTLED: string;
+    RETRYABLE: string;
+    ABORTED: string;
+    OAUTH_SECRET: string;
+    UNSUPPORTED: string;
+    REDIS: string;
+};
+export declare const METADATA: {
+    INVALID_AUTH_TOKEN: string;
+    UNHANDLED_STATUS_CODE: string;
+    INSTRUMENTATION: string;
+    UNAUTHORIZED: string;
+};
+//# sourceMappingURL=tags.d.ts.map

package/build/tags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tags.d.ts","sourceRoot":"","sources":["../src/tags.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;CAerB,CAAC;AAEF,eAAO,MAAM,OAAO;;;;CAInB,CAAC;AAEF,eAAO,MAAM,eAAe;;;;CAI3B,CAAC;AAEF,eAAO,MAAM,QAAQ;;;;;;CAMpB,CAAC;AAEF,eAAO,MAAM,gBAAgB;;;;;CAK5B,CAAC;AAEF,eAAO,MAAM,WAAW;;;;;;;;;CASvB,CAAC;AAEF,eAAO,MAAM,QAAQ;;;;;CAKpB,CAAC"}