@clairejs/client 3.4.8 → 3.5.0

package/README.md

@@ -1,6 +1,6 @@
 ## Change Log
 
-#### 3.4.8:
+#### 3.5.0:
 
 -   refactor http client
 

package/dist/api/AbstractHttpClient.d.ts

@@ -1,16 +1,11 @@
-import { LogHandler } from "@clairejs/core";
 export interface RequestOptions {
     noAuthorization?: boolean;
     withCredentials?: boolean;
     noErrorHandling?: boolean;
+    noCache?: boolean;
 }
 export declare abstract class AbstractHttpClient {
-    protected readonly logger?: LogHandler | undefined;
-    constructor(logger?: LogHandler | undefined);
-    protected issuedGetRequests: Record<string, boolean>;
-    resetCache(pattern: string): void;
-    protected abstract doGet<T = any>(url: string, headers?: object, options?: RequestOptions): Promise<T | undefined>;
-    get<T = any>(url: string, headers?: object, options?: RequestOptions): Promise<T | undefined>;
+    abstract get<T = any>(url: string, headers?: object, options?: RequestOptions): Promise<T | undefined>;
     abstract post<T = any, R = any>(url: string, body: R, headers?: object, options?: RequestOptions): Promise<T | undefined>;
     abstract put<T = any, R = any>(url: string, body: R, headers?: object, options?: RequestOptions): Promise<T | undefined>;
     abstract delete<T = any>(url: string, headers?: object, options?: RequestOptions): Promise<T | undefined>;

package/dist/api/AbstractHttpClient.js

@@ -1,27 +1,2 @@
-import { LogLevel } from "@clairejs/core";
 export class AbstractHttpClient {
-    logger;
-    constructor(logger) {
-        this.logger = logger;
-    }
-    issuedGetRequests = {};
-    /*
-        Keep track off all get request had been sent and allow decache (using regex pattern) those requests
-        so next request will not get from cache
-     */
-    resetCache(pattern) {
-        const regex = new RegExp(pattern);
-        Object.keys(this.issuedGetRequests)
-            .filter((key) => key.match(regex))
-            .forEach((key) => (this.issuedGetRequests[key] = false));
-    }
-    //-- normally T will be returned or error will throw, but in case undefined is returned, that is because error handler
-    //-- has intercepted and decided to return nothing
-    async get(url, headers, options) {
-        const shouldUseCache = this.issuedGetRequests[url];
-        this.logger?.log(LogLevel.DEBUG, `[cache:${!!shouldUseCache}] Request: ${url}`);
-        const result = await this.doGet(url, { ...(!shouldUseCache && { "cache-control": "no-cache" }), ...headers }, options);
-        this.issuedGetRequests[url] = true;
-        return result;
-    }
 }

package/dist/api/CrudApi.d.ts

@@ -1,5 +1,5 @@
 import { AbstractModel, Constructor, CreateManyRequestBody, CreateManyResponseBody, DeepPartial, GetManyQueries, GetManyResponseBody, Identifiable, ReturningQueries, UpdateManyBody, UpdateManyQueries, UpdateManyResponse, UpdateRecordsBody } from "@clairejs/core";
-import { AbstractHttpClient } from "./AbstractHttpClient";
+import { AbstractHttpClient, RequestOptions } from "./AbstractHttpClient";
 export declare const stringifyQueries: (queries: Record<string, any>) => string;
 export declare const removeInstances: <T extends Identifiable>(target: T[], source: T[]) => T[];
 export declare const mergeInstances: <T extends Identifiable>(model: Constructor<T>, target: readonly T[], source: readonly DeepPartial<T>[] | undefined, syncTarget?: boolean) => T[];
@@ -9,7 +9,7 @@ export declare class CrudApi<T extends AbstractModel> {
     private dirty;
     constructor(model: Constructor<T>, httpClient: AbstractHttpClient);
     protected getEndpointBaseUrl(): string;
-    getMany(queries?: GetManyQueries<T>, useCache?: boolean): Promise<GetManyResponseBody<T> | undefined>;
+    getMany(queries?: GetManyQueries<T>, options?: RequestOptions): Promise<GetManyResponseBody<T> | undefined>;
     updateMany(body: UpdateManyBody<T>, queries?: UpdateManyQueries<T>): Promise<UpdateManyResponse<T> | undefined>;
     deleteMany(queries?: UpdateManyQueries<T>): Promise<UpdateManyResponse<T> | undefined>;
     createMany(body: CreateManyRequestBody<T>): Promise<CreateManyResponseBody<T> | undefined>;

package/dist/api/CrudApi.js

@@ -81,13 +81,8 @@ export class CrudApi {
     getEndpointBaseUrl() {
         return `/${this.model.name.toLowerCase()}`;
     }
-    async getMany(queries, useCache = true) {
-        const noCache = !useCache || this.dirty;
-        const result = await this.httpClient.get(`${this.getEndpointBaseUrl()}?${stringifyQueries(queries || {})}`, noCache
-            ? {
-                "cache-control": "no-cache",
-            }
-            : undefined);
+    async getMany(queries, options) {
+        const result = await this.httpClient.get(`${this.getEndpointBaseUrl()}?${stringifyQueries(queries || {})}`, undefined, { ...options, noCache: options?.noCache || this.dirty });
         this.dirty = false;
         return result;
     }

package/dist/api/DefaultHttpClient.d.ts

@@ -15,14 +15,16 @@ export declare abstract class DefaultHttpClient extends AbstractHttpClient {
     protected readonly maxRetryCount: number;
     protected readonly delayMsBetweenRetry: number;
     protected readonly storage?: AbstractStorage | undefined;
-    private readonly api;
+    private readonly axiosClient;
+    protected issuedGetRequests: Record<string, boolean>;
     constructor(apiServerUrl: string, logger?: LogHandler | undefined, maxRetryCount?: number, delayMsBetweenRetry?: number, storage?: AbstractStorage | undefined);
+    resetCache(pattern: string): void;
     protected resolveUrl(url: string): Promise<string>;
     protected abstract getAuthorizationHeader(): Promise<Record<string, string>>;
-    protected errorHandler<T = any>(_operation: () => Promise<T>, err: any): Promise<T | undefined>;
+    protected abstract errorHandler<T = any>(_operation: () => Promise<T>, err: any): Promise<T | undefined>;
     protected retry<T = any>(apiCall: () => Promise<T>, retryCount?: number): Promise<T | undefined>;
     protected performRequest<T = any>(data: RequestData): Promise<T | undefined>;
-    protected doGet<T = any>(url: string, headers?: object, options?: RequestOptions): Promise<T | undefined>;
+    get<T = any>(url: string, headers?: object, options?: RequestOptions): Promise<T | undefined>;
     post<T = any, R = any>(url: string, body: R, headers?: object, options?: RequestOptions): Promise<T | undefined>;
     put<T = any, R = any>(url: string, body: R, headers?: object, options?: RequestOptions): Promise<T | undefined>;
     delete<T = any>(url: string, headers?: object, options?: RequestOptions): Promise<T | undefined>;

package/dist/api/DefaultHttpClient.js

@@ -7,9 +7,10 @@ export class DefaultHttpClient extends AbstractHttpClient {
     maxRetryCount;
     delayMsBetweenRetry;
     storage;
-    api = axios.create();
+    axiosClient = axios.create();
+    issuedGetRequests = {};
     constructor(apiServerUrl, logger, maxRetryCount = 2, delayMsBetweenRetry = 200, storage) {
-        super(logger);
+        super();
         this.apiServerUrl = apiServerUrl;
         this.logger = logger;
         this.maxRetryCount = maxRetryCount;
@@ -17,7 +18,7 @@ export class DefaultHttpClient extends AbstractHttpClient {
         this.storage = storage;
         if (this.storage) {
             //-- setup axios cache
-            this.api.interceptors.request.use(async (config) => {
+            this.axiosClient.interceptors.request.use(async (config) => {
                 if (config.method === "get") {
                     const cacheKey = config.url || "";
                     const cachedData = await this.storage.getItem(cacheKey);
@@ -33,7 +34,7 @@ export class DefaultHttpClient extends AbstractHttpClient {
                 return config;
             });
             // add a response interceptor to cache response data
-            this.api.interceptors.response.use(async (response) => {
+            this.axiosClient.interceptors.response.use(async (response) => {
                 if (response.config.method === "get") {
                     const cacheKey = response.config.url || "";
                     const maxAgeMatch = response.headers["Cache-Control"]?.toString()?.match(/max-age=(\d+)/);
@@ -50,12 +51,19 @@ export class DefaultHttpClient extends AbstractHttpClient {
             });
         }
     }
+    /*
+        Keep track off all get request had been sent and allow decache (using regex pattern) those requests
+        so next request will not get from cache
+     */
+    resetCache(pattern) {
+        const regex = new RegExp(pattern);
+        Object.keys(this.issuedGetRequests)
+            .filter((key) => key.match(regex))
+            .forEach((key) => (this.issuedGetRequests[key] = false));
+    }
     async resolveUrl(url) {
         return this.apiServerUrl + url;
     }
-    async errorHandler(_operation, err) {
-        throw err;
-    }
     async retry(apiCall, retryCount = 0) {
         try {
             return await apiCall();
@@ -77,13 +85,14 @@ export class DefaultHttpClient extends AbstractHttpClient {
         const finalUrl = await this.resolveUrl(data.url);
         const operation = async () => {
             const authHeader = !data.options?.noAuthorization ? await this.getAuthorizationHeader() : {};
-            const result = await this.api({
+            const result = await this.axiosClient({
                 method: data.method,
                 url: finalUrl,
                 data: data.body,
                 headers: {
                     ...data.headers,
                     ...authHeader,
+                    ...(data.options?.noCache && { "Cache-Control": "no-cache" }),
                 },
                 withCredentials: data.options?.withCredentials,
             });
@@ -99,8 +108,17 @@ export class DefaultHttpClient extends AbstractHttpClient {
             return await this.errorHandler(operation, err.response?.data || Errors.HTTP_REQUEST_ERROR());
         }
     }
-    async doGet(url, headers, options) {
-        return await this.performRequest({ method: "GET", url, headers, options });
+    async get(url, headers, options) {
+        const noCache = !!options?.noCache || !this.issuedGetRequests[url];
+        this.logger?.log(LogLevel.DEBUG, `[cache:${!noCache}] Request: ${url}`);
+        const result = await this.performRequest({
+            method: "GET",
+            url,
+            headers,
+            options: { ...options, noCache },
+        });
+        this.issuedGetRequests[url] = true;
+        return result;
     }
     async post(url, body, headers, options) {
         return await this.performRequest({

package/dist/api/RefreshHttpClient.d.ts

@@ -14,7 +14,8 @@ export declare abstract class RefreshHttpClient extends DefaultHttpClient {
     private tokenQueue;
     constructor(apiServerUrl: string, tokenManager: AbstractTokenManager, logger?: LogHandler | undefined, maxRetryCount?: number, delayMsBetweenRetry?: number, storage?: AbstractStorage | undefined);
     protected getAuthorization(): Promise<string>;
-    protected abstract getRefreshedAccessToken(): Promise<AccessToken>;
+    protected abstract refreshSession(refreshToken: string): Promise<AccessToken | undefined>;
+    protected errorHandler<T = any>(operation: () => Promise<T>, err: any): Promise<T | undefined>;
     protected getAuthorizationHeader(): Promise<Record<string, string>>;
     protected refreshToken(token?: AccessToken): Promise<void>;
 }

package/dist/api/RefreshHttpClient.js

@@ -31,6 +31,16 @@ export class RefreshHttpClient extends DefaultHttpClient {
             return accessToken?.token || "";
         }
     }
+    async errorHandler(operation, err) {
+        if (err.name === Errors.TOKEN_EXPIRED().name) {
+            return await this.refreshToken()
+                .then(operation)
+                .catch((err) => {
+                throw err.response.data || err;
+            });
+        }
+        throw err;
+    }
     async getAuthorizationHeader() {
         return { authorization: await this.getAuthorization() };
     }
@@ -42,14 +52,16 @@ export class RefreshHttpClient extends DefaultHttpClient {
             });
         }
         token = token || (await this.tokenManager.getAccessToken());
-        //-- call to api server to refresh token
         if (!token || !token.refreshToken) {
             //-- there is no refresh token to refresh
             throw Errors.SESSION_EXPIRED();
         }
         try {
             this.refreshing = true;
-            token = await this.getRefreshedAccessToken();
+            token = await this.refreshSession(token.refreshToken);
+            if (!token) {
+                throw Errors.SESSION_EXPIRED();
+            }
             await this.tokenManager.setAccessToken(token);
             this.logger?.log(LogLevel.DEBUG, "Access token was refreshed");
         }
@@ -59,7 +71,7 @@ export class RefreshHttpClient extends DefaultHttpClient {
                 resolver();
             }
             for (const resolver of this.tokenQueue) {
-                resolver(token.token);
+                resolver(token?.token || "");
             }
             //-- clear queue
             this.refreshQueue = [];

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@clairejs/client",
-    "version": "3.4.8",
+    "version": "3.5.0",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
     "type": "module",