@vroskus/library-api 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,33 @@
+import type { AxiosInstance, AxiosRequestConfig, AxiosResponse } from 'axios';
+import AxiosMockAdapter from 'axios-mock-adapter';
+import type { $Config, $RequestContext, $ResponseContext } from './types';
+export * from './types';
+type $RequestContextListener = (arg0: $RequestContext) => void;
+type $SetRequestContextListenerParams = {
+    listener: $RequestContextListener;
+};
+type $SetRequestContextListenerResponse = void;
+type $ResponseContextListener = (arg0: $ResponseContext) => void;
+type $SetResponseContextListenerParams = {
+    listener: $ResponseContextListener;
+};
+type $SetResponseContextListenerResponse = void;
+type $UnauthenticatedHandler = () => unknown;
+type $SetUnauthenticatedHandlerParams = {
+    handler: $UnauthenticatedHandler;
+};
+type $SetUnauthenticatedHandlerResponse = void;
+export declare const getMock: () => AxiosMockAdapter;
+declare class ApiService<C extends $Config> {
+    connection: AxiosInstance;
+    unauthenticatedHandler: $UnauthenticatedHandler;
+    requestContextListener: $RequestContextListener;
+    responseContextListener: $ResponseContextListener;
+    constructor({ apiUrl, timeout, }: C);
+    setUnauthenticatedHandler({ handler, }: $SetUnauthenticatedHandlerParams): $SetUnauthenticatedHandlerResponse;
+    setRequestContextListener({ listener, }: $SetRequestContextListenerParams): $SetRequestContextListenerResponse;
+    setResponseContextListener({ listener, }: $SetResponseContextListenerParams): $SetResponseContextListenerResponse;
+    pushRequestContext(config: AxiosRequestConfig<unknown>, requestId: string): void;
+    pushResponseContext(response: AxiosResponse<unknown>): void;
+}
+export default ApiService;

package/dist/index.js

@@ -0,0 +1,127 @@
+"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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMock = void 0;
+const axios_1 = __importDefault(require("axios"));
+const axios_mock_adapter_1 = __importDefault(require("axios-mock-adapter"));
+const lodash_1 = __importDefault(require("lodash"));
+const uuid_1 = require("uuid");
+__exportStar(require("./types"), exports);
+const getMock = () => new axios_mock_adapter_1.default(axios_1.default);
+exports.getMock = getMock;
+class ApiService {
+    constructor({ apiUrl, timeout, }) {
+        const connectionConfig = {
+            baseURL: apiUrl,
+            headers: {
+                Accept: 'application/json',
+                'Content-Type': 'application/json',
+            },
+            timeout,
+            withCredentials: true,
+        };
+        this.connection = axios_1.default.create(connectionConfig);
+        this.unauthenticatedHandler = () => { };
+        this.requestContextListener = () => { };
+        this.responseContextListener = () => { };
+        this.connection.interceptors.response.use((response) => response, (error) => {
+            const status = lodash_1.default.get(error, 'response.status');
+            if (status === 401) {
+                this.unauthenticatedHandler();
+            }
+            return Promise.reject(error);
+        });
+        this.connection.interceptors.response.use((response) => {
+            this.pushResponseContext(response);
+            return response;
+        }, (error) => {
+            const response = lodash_1.default.get(error, 'response');
+            if (response) {
+                this.pushResponseContext(response);
+            }
+            return Promise.reject(error);
+        });
+        this.connection.interceptors.response.use(undefined, (error) => {
+            const message = lodash_1.default.get(error, 'message');
+            const config = lodash_1.default.get(error, 'config');
+            if (config
+                && config.retryQty !== 0
+                && ['Network Error', 'timeout'].some((e) => message.includes(e))) {
+                config.retryQty = typeof config.retryQty === 'undefined' ? 3 : config.retryQty - 1;
+                const delayRetryRequest = new Promise((resolve) => {
+                    setTimeout(() => {
+                        resolve(null);
+                    }, config.retryDelay || 3000);
+                });
+                return delayRetryRequest.then(() => this.connection.request(config));
+            }
+            return Promise.reject(error);
+        });
+        this.connection.interceptors.request.use((config) => {
+            const requestId = (0, uuid_1.v4)();
+            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;
+        });
+    }
+    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,
+        };
+        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,
+            Status: status,
+        };
+        const cleanResponseContext = lodash_1.default.omitBy(responseContext, lodash_1.default.isUndefined);
+        this.responseContextListener(cleanResponseContext);
+    }
+}
+exports.default = ApiService;

package/dist/types.d.ts

@@ -0,0 +1,24 @@
+export type $Config = {
+    apiUrl: string;
+    timeout: number;
+};
+export type $RequestContext = {
+    Method: string;
+    RequestData?: unknown;
+    RequestHeaders: unknown;
+    RequestId: string;
+    RequestParams?: Record<string, unknown>;
+    Route: string;
+};
+export type $ResponseContext = {
+    Duration: number;
+    Method: string;
+    RequestData?: Record<string, unknown>;
+    RequestHeaders: unknown;
+    RequestId: string;
+    RequestParams?: Record<string, unknown>;
+    ResponseData?: unknown;
+    ResponseHeaders: unknown;
+    Route: string;
+    Status: number;
+};

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@vroskus/library-api",
+  "version": "1.0.0",
+  "description": "Api",
+  "author": "Vilius Roškus <vilius@regattas.eu>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vroskus/library-api.git"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "npm run test:eslint && npm run test:e2e",
+    "test:eslint": "eslint src --fix",
+    "test:e2e": "echo 'No tests'"
+  },
+  "dependencies": {
+    "axios": "1.6.2",
+    "axios-mock-adapter": "1.22.0",
+    "lodash": "4.17.21",
+    "uuid": "9.0.1"
+  },
+  "devDependencies": {
+    "@types/jest": "29.5.7",
+    "@types/lodash": "4.14.200",
+    "@types/node": "20.8.10",
+    "@types/query-string": "6.3.0",
+    "@typescript-eslint/eslint-plugin": "6.9.1",
+    "@typescript-eslint/parser": "6.9.1",
+    "eslint": "8.53.0",
+    "eslint-config-airbnb-base": "15.0.0",
+    "eslint-config-airbnb-typescript": "17.1.0",
+    "eslint-plugin-import": "2.29.0",
+    "eslint-plugin-import-newlines": "1.3.4",
+    "eslint-plugin-react": "7.33.2",
+    "eslint-plugin-sort": "2.11.0",
+    "npm-check": "6.0.1",
+    "typescript": "5.2.2"
+  }
+}