@vroskus/library-api 1.0.25 → 1.1.0

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import type { AxiosInstance, AxiosRequestConfig, AxiosResponse } from 'axios';
+import type { AxiosInstance } from 'axios';
 import AxiosMockAdapter from 'axios-mock-adapter';
 import type { $Config, $RequestContext, $ResponseContext } from './types';
 export * from './types';
@@ -6,24 +6,14 @@ type $RequestContextListener = (arg0: $RequestContext) => void;
 type $ResponseContextListener = (arg0: $ResponseContext) => void;
 type $UnauthenticatedHandler = () => unknown;
 declare class ApiService<C extends $Config> {
+    #private;
     connection: AxiosInstance;
-    unauthenticatedHandler: $UnauthenticatedHandler;
-    requestContextListener: $RequestContextListener;
-    responseContextListener: $ResponseContextListener;
-    mock: AxiosMockAdapter | null;
-    path: (arg0: string) => RegExp | string;
-    constructor({ apiUrl, headers, httpsAgent, timeout, }: C);
-    setUnauthenticatedHandler({ handler, }: {
-        handler: $UnauthenticatedHandler;
-    }): void;
-    setRequestContextListener({ listener, }: {
-        listener: $RequestContextListener;
-    }): void;
-    setResponseContextListener({ listener, }: {
-        listener: $ResponseContextListener;
-    }): void;
-    pushRequestContext(config: AxiosRequestConfig<unknown>, requestId: string): void;
-    pushResponseContext(response: AxiosResponse<unknown>): void;
-    initMock(mockSetup: (mock: AxiosMockAdapter) => void): void;
+    mockAdapter: AxiosMockAdapter | null;
+    expressRouteToMockRoute: (arg0: string) => RegExp | string;
+    constructor({ apiUrl, headers, httpsAgent, interceptors, timeout, }: C);
+    setUnauthenticatedHandler(handler: $UnauthenticatedHandler): void;
+    setRequestContextListener(listener: $RequestContextListener): void;
+    setResponseContextListener(listener: $ResponseContextListener): void;
+    initMock(mockSetup: (mockAdapter: AxiosMockAdapter) => void, delay?: number): void;
 }
 export default ApiService;

package/dist/index.js

@@ -35,9 +35,21 @@ var __importStar = (this && this.__importStar) || (function () {
 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);
 };
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
+var _ApiService_instances, _ApiService_unauthenticatedHandler, _ApiService_requestContextListener, _ApiService_responseContextListener, _ApiService_initInterceptors, _ApiService_pushRequestContext, _ApiService_pushResponseContext;
 Object.defineProperty(exports, "__esModule", { value: true });
 const axios = __importStar(require("axios"));
 const axios_mock_adapter_1 = __importDefault(require("axios-mock-adapter"));
@@ -49,7 +61,11 @@ const defaultRetryQuantity = 3;
 const defaultRetryIncrementor = 1;
 const zeroValue = 0;
 class ApiService {
-    constructor({ apiUrl, headers, httpsAgent, timeout, }) {
+    constructor({ apiUrl, headers, httpsAgent, interceptors, timeout, }) {
+        _ApiService_instances.add(this);
+        _ApiService_unauthenticatedHandler.set(this, void 0);
+        _ApiService_requestContextListener.set(this, void 0);
+        _ApiService_responseContextListener.set(this, void 0);
         const connectionConfig = {
             baseURL: apiUrl,
             headers: Object.assign({ Accept: 'application/json', 'Content-Type': 'application/json' }, (headers || {})),
@@ -58,26 +74,66 @@ class ApiService {
             withCredentials: true,
         };
         this.connection = axios.default.create(connectionConfig);
-        this.unauthenticatedHandler = () => { };
-        this.requestContextListener = () => { };
-        this.responseContextListener = () => { };
+        __classPrivateFieldSet(this, _ApiService_unauthenticatedHandler, () => { }, "f");
+        __classPrivateFieldSet(this, _ApiService_requestContextListener, () => { }, "f");
+        __classPrivateFieldSet(this, _ApiService_responseContextListener, () => { }, "f");
+        this.mockAdapter = null;
+        this.expressRouteToMockRoute = (v) => {
+            if (v.includes(':')) {
+                return new RegExp(v.replace(/:\w+/g, '[^/]+'));
+            }
+            return v;
+        };
+        const interceptorsConfig = Object.assign({ context: true, requestReplay: true, unauth: true }, interceptors || {});
+        __classPrivateFieldGet(this, _ApiService_instances, "m", _ApiService_initInterceptors).call(this, interceptorsConfig);
+    }
+    setUnauthenticatedHandler(handler) {
+        __classPrivateFieldSet(this, _ApiService_unauthenticatedHandler, handler, "f");
+    }
+    setRequestContextListener(listener) {
+        __classPrivateFieldSet(this, _ApiService_requestContextListener, listener, "f");
+    }
+    setResponseContextListener(listener) {
+        __classPrivateFieldSet(this, _ApiService_responseContextListener, listener, "f");
+    }
+    initMock(mockSetup, delay) {
+        this.mockAdapter = new axios_mock_adapter_1.default(this.connection, {
+            delayResponse: delay,
+        });
+        mockSetup(this.mockAdapter);
+    }
+}
+_ApiService_unauthenticatedHandler = new WeakMap(), _ApiService_requestContextListener = new WeakMap(), _ApiService_responseContextListener = new WeakMap(), _ApiService_instances = new WeakSet(), _ApiService_initInterceptors = function _ApiService_initInterceptors(interceptorsConfig) {
+    if (interceptorsConfig.unauth !== false) {
         this.connection.interceptors.response.use((response) => response, (error) => {
             const status = lodash_1.default.get(error, 'response.status');
             if (status === unauthenticatedStatus) {
-                this.unauthenticatedHandler();
+                __classPrivateFieldGet(this, _ApiService_unauthenticatedHandler, "f").call(this);
             }
             return Promise.reject(error);
         });
+    }
+    if (interceptorsConfig.context !== false) {
+        this.connection.interceptors.request.use((config) => {
+            const requestId = crypto.randomUUID();
+            lodash_1.default.set(config, 'headers.X-Request-Id', requestId);
+            const startTimestamp = performance.now();
+            lodash_1.default.set(config, 'startTimestamp', startTimestamp);
+            __classPrivateFieldGet(this, _ApiService_instances, "m", _ApiService_pushRequestContext).call(this, config, requestId);
+            return config;
+        });
         this.connection.interceptors.response.use((response) => {
-            this.pushResponseContext(response);
+            __classPrivateFieldGet(this, _ApiService_instances, "m", _ApiService_pushResponseContext).call(this, response);
             return response;
         }, (error) => {
             const response = lodash_1.default.get(error, 'response');
             if (response) {
-                this.pushResponseContext(response);
+                __classPrivateFieldGet(this, _ApiService_instances, "m", _ApiService_pushResponseContext).call(this, response);
             }
             return Promise.reject(error);
         });
+    }
+    if (interceptorsConfig.requestReplay !== false) {
         this.connection.interceptors.response.use(undefined, (error) => {
             const message = lodash_1.default.get(error, 'message');
             const config = lodash_1.default.get(error, 'config');
@@ -96,66 +152,36 @@ class ApiService {
             }
             return Promise.reject(error);
         });
-        this.connection.interceptors.request.use((config) => {
-            const requestId = crypto.randomUUID();
-            lodash_1.default.set(config, 'headers.X-Request-Id', requestId);
-            const startTimestamp = performance.now();
-            lodash_1.default.set(config, 'startTimestamp', startTimestamp);
-            this.pushRequestContext(config, requestId);
-            return config;
-        });
-        this.mock = null;
-        this.path = (v) => {
-            if (v.includes(':')) {
-                return new RegExp(v.replace(/:\w+/g, '[^/]+'));
-            }
-            return v;
-        };
-    }
-    setUnauthenticatedHandler({ handler, }) {
-        this.unauthenticatedHandler = handler;
     }
-    setRequestContextListener({ listener, }) {
-        this.requestContextListener = listener;
-    }
-    setResponseContextListener({ listener, }) {
-        this.responseContextListener = listener;
-    }
-    pushRequestContext(config, requestId) {
-        const requestContext = {
-            Method: `${(config.method || 'Unknown').toUpperCase()}`,
-            RequestData: config.data,
-            RequestHeaders: config.headers,
-            RequestId: requestId,
-            RequestParams: config.params,
-            Route: config.url || 'Unknown',
-        };
-        const cleanRequestContext = lodash_1.default.omitBy(requestContext, lodash_1.default.isUndefined);
-        this.requestContextListener(cleanRequestContext);
-    }
-    pushResponseContext(response) {
-        const requestId = lodash_1.default.get(response.config, 'headers.X-Request-Id', '');
-        const { config, data, headers, status, } = response;
-        const endTimestamp = performance.now();
-        const startTimestamp = lodash_1.default.get(config, 'startTimestamp', endTimestamp);
-        const responseContext = {
-            Duration: endTimestamp - startTimestamp,
-            Method: `${(config.method || 'Unknown').toUpperCase()}`,
-            RequestData: config.data,
-            RequestHeaders: config.headers,
-            RequestId: requestId,
-            RequestParams: config.params,
-            ResponseData: data,
-            ResponseHeaders: headers,
-            Route: config.url || 'Unknown',
-            Status: status,
-        };
-        const cleanResponseContext = lodash_1.default.omitBy(responseContext, lodash_1.default.isUndefined);
-        this.responseContextListener(cleanResponseContext);
-    }
-    initMock(mockSetup) {
-        this.mock = new axios_mock_adapter_1.default(this.connection);
-        mockSetup(this.mock);
-    }
-}
+}, _ApiService_pushRequestContext = function _ApiService_pushRequestContext(config, requestId) {
+    const requestContext = {
+        Method: `${(config.method || 'Unknown').toUpperCase()}`,
+        RequestData: config.data,
+        RequestHeaders: config.headers,
+        RequestId: requestId,
+        RequestParams: config.params,
+        Route: config.url || 'Unknown',
+    };
+    const cleanRequestContext = lodash_1.default.omitBy(requestContext, lodash_1.default.isUndefined);
+    __classPrivateFieldGet(this, _ApiService_requestContextListener, "f").call(this, cleanRequestContext);
+}, _ApiService_pushResponseContext = function _ApiService_pushResponseContext(response) {
+    const requestId = lodash_1.default.get(response.config, 'headers.X-Request-Id', '');
+    const { config, data, headers, status, } = response;
+    const endTimestamp = performance.now();
+    const startTimestamp = lodash_1.default.get(config, 'startTimestamp', endTimestamp);
+    const responseContext = {
+        Duration: endTimestamp - startTimestamp,
+        Method: `${(config.method || 'Unknown').toUpperCase()}`,
+        RequestData: config.data ? JSON.parse(config.data) : undefined,
+        RequestHeaders: config.headers,
+        RequestId: requestId,
+        RequestParams: config.params,
+        ResponseData: data,
+        ResponseHeaders: headers,
+        Route: config.url || 'Unknown',
+        Status: status,
+    };
+    const cleanResponseContext = lodash_1.default.omitBy(responseContext, lodash_1.default.isUndefined);
+    __classPrivateFieldGet(this, _ApiService_responseContextListener, "f").call(this, cleanResponseContext);
+};
 exports.default = ApiService;

package/dist/types.d.ts

@@ -1,8 +1,14 @@
 import type { Agent } from 'https';
+export type $ConfigInterceptors = {
+    context?: boolean;
+    requestReplay?: boolean;
+    unauth?: boolean;
+};
 export type $Config = {
     apiUrl: string;
     headers?: Record<string, string>;
     httpsAgent?: Agent;
+    interceptors?: $ConfigInterceptors;
     timeout: number;
 };
 export type $RequestContext = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vroskus/library-api",
-  "version": "1.0.25",
+  "version": "1.1.0",
   "description": "Api",
   "author": "Vilius Roškus <vilius@regattas.eu>",
   "license": "MIT",
@@ -52,10 +52,10 @@
     ],
     "coverageThreshold": {
       "global": {
-        "branches": 52.63,
-        "functions": 50,
-        "lines": 68.42,
-        "statements": 65.45
+        "branches": 59.67,
+        "functions": 74.28,
+        "lines": 87.71,
+        "statements": 79.85
       }
     }
   }