@ethlete/query 0.1.0-next.16 → 0.1.0-next.18

package/esm2020/lib/auth/auth-provider.types.mjs

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0aC1wcm92aWRlci50eXBlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvcXVlcnkvc3JjL2xpYi9hdXRoL2F1dGgtcHJvdmlkZXIudHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFJvdXRlU3RyaW5nIH0gZnJvbSAnLi4vcXVlcnknO1xuaW1wb3J0IHsgUXVlcnlDbGllbnQgfSBmcm9tICcuLi9xdWVyeS1jbGllbnQnO1xuaW1wb3J0IHsgTWV0aG9kIH0gZnJvbSAnLi4vcmVxdWVzdCc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgQXV0aFByb3ZpZGVyIHtcbiAgLyoqXG4gICAqIFRoZSB1cCB0byBkYXRlIGF1dGggaGVhZGVyLlxuICAgKiBUaGlzIHdpbGwgYXV0b21hdGljYWxseSBnZXQgaW5qZWN0ZWQgaW50byBldmVyeSBxdWVyeSB0aGF0IGhhcyB0aGUgYHNlY3VyZWAgcHJvcGVydHkgc2V0IHRvIGB0cnVlYC5cbiAgICovXG4gIGhlYWRlcjogUmVjb3JkPHN0cmluZywgc3RyaW5nPjtcblxuICAvKipcbiAgICogQ2xlYW51cCBmdW5jdGlvbiB0aGF0IGdldHMgY2FsbGVkIG9uY2UgdGhlIGF1dGggcHJvdmlkZXIgZ2V0cyBkZXN0cm95ZWQuXG4gICAqIEBpbnRlcm5hbFxuICAgKi9cbiAgY2xlYW5VcCgpOiB2b2lkO1xuXG4gIC8qKlxuICAgKiBSZWZlcmVuY2UgdG8gdGhlIHF1ZXJ5IGNsaWVudFxuICAgKi9cbiAgcXVlcnlDbGllbnQ6IFF1ZXJ5Q2xpZW50IHwgbnVsbDtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBBdXRoUHJvdmlkZXJCYXNpY0NvbmZpZyB7XG4gIC8qKlxuICAgKiBCYXNpYyBhdXRoIHVzZXJuYW1lXG4gICAqL1xuICB1c2VybmFtZTogc3RyaW5nO1xuXG4gIC8qKlxuICAgKiBCYXNpYyBhdXRoIHBhc3N3b3JkXG4gICAqL1xuICBwYXNzd29yZDogc3RyaW5nO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIEF1dGhQcm92aWRlckN1c3RvbUhlYWRlckNvbmZpZyB7XG4gIC8qKlxuICAgKiBUaGUgY3VzdG9tIGhlYWRlciBuYW1lXG4gICAqIEBleGFtcGxlIGBYLUFwaS1LZXlgXG4gICAqL1xuICBuYW1lOiBzdHJpbmc7XG5cbiAgLyoqXG4gICAqIFRoZSBjdXN0b20gaGVhZGVyIHZhbHVlXG4gICAqIEBleGFtcGxlIGBteUFwaUtleWBcbiAgICovXG4gIHZhbHVlOiBzdHJpbmc7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgQXV0aFByb3ZpZGVyQmVhcmVyQ29uZmlnPFQgPSB1bmtub3duPiB7XG4gIC8qKlxuICAgKiBUaGUgaW5pdGlhbCBqd3RcbiAgICovXG4gIHRva2VuPzogc3RyaW5nO1xuXG4gIC8qKlxuICAgKiBSZWZyZXNoIHRva2VuIGNvbmZpZ3VyYXRpb25cbiAgICovXG4gIHJlZnJlc2hDb25maWc/OiBCZWFyZXJSZWZyZXNoQ29uZmlnPFQ+O1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIEJlYXJlclJlZnJlc2hDb25maWc8VCA9IHVua25vd24+IHtcbiAgLyoqXG4gICAqIFRoZSBpbml0aWFsIHJlZnJlc2ggdG9rZW5cbiAgICovXG4gIHRva2VuPzogc3RyaW5nO1xuXG4gIC8qKlxuICAgKiBUaGUgYXBpJ3MgcmVmcmVzaCByb3V0ZVxuICAgKiBAZXhhbXBsZSAvYXBpL2F1dGgvcmVmcmVzaC10b2tlblxuICAgKi9cbiAgcm91dGU6IFJvdXRlU3RyaW5nO1xuXG4gIC8qKlxuICAgKiBUaGUgYXBpJ3MgcmVmcmVzaCByb3V0ZSBtZXRob2RcbiAgICovXG4gIG1ldGhvZDogTWV0aG9kO1xuXG4gIC8qKlxuICAgKiBUaGUgbWF4aW11bSBudW1iZXIgb2YgcmVmcmVzaCBhdHRlbXB0c1xuICAgKiBAZGVmYXVsdCAzXG4gICAqL1xuICBtYXhSZWZyZXNoQXR0ZW1wdHM/OiBudW1iZXI7XG5cbiAgLyoqXG4gICAqIFRoZSB3YXkgdGhlIHJlZnJlc2ggdG9rZW4gaXMgc2VudCB0byB0aGUgYXBpXG4gICAqIEBkZWZhdWx0ICdib2R5J1xuICAgKi9cbiAgcGFyYW1Mb2NhdGlvbj86ICdib2R5JyB8ICdxdWVyeSc7XG5cbiAgLyoqXG4gICAqIFRoZSBjb29raWUgbmFtZSB3aGVyZSB0aGUgcmVmcmVzaCB0b2tlbiBpcyBzdG9yZWRcbiAgICovXG4gIGNvb2tpZU5hbWU/OiBzdHJpbmc7XG5cbiAgLyoqXG4gICAqIFRoZSB0aW1lIGluIG1pbGxpc2Vjb25kcyBiZWZvcmUgdGhlIHRva2VuIGV4cGlyZXMgd2hlbiB0aGUgcmVmcmVzaCBzaG91bGQgYmUgdHJpZ2dlcmVkLlxuICAgKiBAZGVmYXVsdCAzMDAwMDAgKDUgbWludXRlcylcbiAgICovXG4gIHJlZnJlc2hCdWZmZXI/OiBudW1iZXI7XG5cbiAgLyoqXG4gICAqIFRoZSBleHBpcmVzIGluIHByb3BlcnR5IG5hbWUgaW5zaWRlIHRoZSBqd3QgYm9keVxuICAgKiBAZGVmYXVsdCAnZXhwJ1xuICAgKi9cbiAgZXhwaXJlc0luUHJvcGVydHlOYW1lPzogc3RyaW5nO1xuXG4gIC8qKlxuICAgKiBEZXRlcm1pbmVzIHdoZW4gdGhlIHRva2VuIHNob3VsZCBiZSByZWZyZXNoZWQuXG4gICAqIEBkZWZhdWx0IEF1dGhCZWFyZXJSZWZyZXNoU3RyYXRlZ3kuQmVmb3JlRXhwaXJhdGlvblxuICAgKi9cbiAgc3RyYXRlZ3k/OiBBdXRoQmVhcmVyUmVmcmVzaFN0cmF0ZWd5O1xuXG4gIC8qKlxuICAgKiBBZGFwdGVyIGZ1bmN0aW9uIHVzZWQgdG8gYnVpbGQgdGhlIHJlcXVlc3QgYm9keSBmb3IgdGhlIHJlZnJlc2ggcmVxdWVzdC5cbiAgICogQGRlZmF1bHQgeyByZWZyZXNoVG9rZW46IFwicmVmcmVzaFRva2VuXCIgfVxuICAgKi9cbiAgcmVxdWVzdEFkYXB0ZXI/OiAocmVmcmVzaFRva2VuOiBzdHJpbmcpID0+IFJlY29yZDxzdHJpbmcsIHN0cmluZz47XG5cbiAgLyoqXG4gICAqIEFkYXB0ZXIgZnVuY3Rpb24gdXNlZCB0byBleHRyYWN0IHRoZSB0b2tlbiBhbmQgcmVmcmVzaFRva2VuIGZyb20gdGhlIHJlc3BvbnNlLlxuICAgKiBAZGVmYXVsdCB7IHRva2VuOiBcInRva2VuXCIsIHJlZnJlc2hUb2tlbjogXCJyZWZyZXNoVG9rZW5cIiB9XG4gICAqL1xuICByZXNwb25zZUFkYXB0ZXI/OiAocmVzcG9uc2U6IFQpID0+IFRva2VuUmVzcG9uc2U7XG59XG5cbmV4cG9ydCBjb25zdCBlbnVtIEF1dGhCZWFyZXJSZWZyZXNoU3RyYXRlZ3kge1xuICAvKipcbiAgICogQXV0b21hdGljYWxseSByZWZyZXNoIHRoZSB0b2tlbiA1IG1pbnV0ZXMgYmVmb3JlIGV4cGlyYXRpb24uXG4gICAqL1xuICBCZWZvcmVFeHBpcmF0aW9uID0gJ2JlZm9yZUV4cGlyYXRpb24nLFxufVxuXG5leHBvcnQgaW50ZXJmYWNlIFRva2VuUmVzcG9uc2Uge1xuICAvKipcbiAgICogVGhlIGFjY2VzcyB0b2tlbiB1c2VkIGluc2lkZSB0aGUgYXV0aG9yaXphdGlvbiBodHRwIGhlYWRlci5cbiAgICovXG4gIHRva2VuOiBzdHJpbmc7XG5cbiAgLyoqXG4gICAqIFRoZSByZWZyZXNoIHRva2VuIHVzZWQgZm9yIHJlcXVlc3RpbmcgYSBuZXcgdG9rZW4gcmVzcG9uc2Ugb25jZSB0aGUgY3VycmVudCB0b2tlcyBpcyBleHBpcmVkLlxuICAgKiBUaGlzIHByb3BlcnR5IGlzIHJlcXVpcmVkIGlmIHRoZSBiZWFyZXIgcmVmcmVzaCBjb25maWcgaXMgc2V0LlxuICAgKi9cbiAgcmVmcmVzaFRva2VuPzogc3RyaW5nO1xufVxuIl19
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/auth/auth-provider.utils.mjs

@@ -19,4 +19,4 @@ export const decryptBearer = (token) => {
         return null;
     }
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/auth/basic-auth-provider.mjs

@@ -7,10 +7,9 @@ export class BasicAuthProvider {
     }
     constructor(_config) {
         this._config = _config;
-        this.queryClient = null;
     }
     cleanUp() {
         // noop
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzaWMtYXV0aC1wcm92aWRlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvcXVlcnkvc3JjL2xpYi9hdXRoL2Jhc2ljLWF1dGgtcHJvdmlkZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBR0EsTUFBTSxPQUFPLGlCQUFpQjtJQUM1QixJQUFJLE1BQU07UUFDUixPQUFPLEVBQUUsYUFBYSxFQUFFLFNBQVMsSUFBSSxDQUFDLGdCQUFnQixFQUFFLEVBQUUsQ0FBQztJQUM3RCxDQUFDO0lBRUQsSUFBWSxnQkFBZ0I7UUFDMUIsT0FBTyxJQUFJLENBQUMsR0FBRyxJQUFJLENBQUMsT0FBTyxDQUFDLFFBQVEsSUFBSSxJQUFJLENBQUMsT0FBTyxDQUFDLFFBQVEsRUFBRSxDQUFDLENBQUM7SUFDbkUsQ0FBQztJQUlELFlBQW9CLE9BQWdDO1FBQWhDLFlBQU8sR0FBUCxPQUFPLENBQXlCO1FBRnBELGdCQUFXLEdBQXVCLElBQUksQ0FBQztJQUVnQixDQUFDO0lBRXhELE9BQU87UUFDTCxPQUFPO0lBQ1QsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUXVlcnlDbGllbnQgfSBmcm9tICcuLi9xdWVyeS1jbGllbnQnO1xuaW1wb3J0IHsgQXV0aFByb3ZpZGVyLCBBdXRoUHJvdmlkZXJCYXNpY0NvbmZpZyB9IGZyb20gJy4vYXV0aC1wcm92aWRlci50eXBlcyc7XG5cbmV4cG9ydCBjbGFzcyBCYXNpY0F1dGhQcm92aWRlciBpbXBsZW1lbnRzIEF1dGhQcm92aWRlciB7XG4gIGdldCBoZWFkZXIoKSB7XG4gICAgcmV0dXJuIHsgQXV0aG9yaXphdGlvbjogYEJhc2ljICR7dGhpcy5fYmFzaWNBdXRoU3RyaW5nfWAgfTtcbiAgfVxuXG4gIHByaXZhdGUgZ2V0IF9iYXNpY0F1dGhTdHJpbmcoKSB7XG4gICAgcmV0dXJuIGJ0b2EoYCR7dGhpcy5fY29uZmlnLnVzZXJuYW1lfToke3RoaXMuX2NvbmZpZy5wYXNzd29yZH1gKTtcbiAgfVxuXG4gIHF1ZXJ5Q2xpZW50OiBRdWVyeUNsaWVudCB8IG51bGwgPSBudWxsO1xuXG4gIGNvbnN0cnVjdG9yKHByaXZhdGUgX2NvbmZpZzogQXV0aFByb3ZpZGVyQmFzaWNDb25maWcpIHt9XG5cbiAgY2xlYW5VcCgpOiB2b2lkIHtcbiAgICAvLyBub29wXG4gIH1cbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzaWMtYXV0aC1wcm92aWRlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvcXVlcnkvc3JjL2xpYi9hdXRoL2Jhc2ljLWF1dGgtcHJvdmlkZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsTUFBTSxPQUFPLGlCQUFpQjtJQUM1QixJQUFJLE1BQU07UUFDUixPQUFPLEVBQUUsYUFBYSxFQUFFLFNBQVMsSUFBSSxDQUFDLGdCQUFnQixFQUFFLEVBQUUsQ0FBQztJQUM3RCxDQUFDO0lBRUQsSUFBWSxnQkFBZ0I7UUFDMUIsT0FBTyxJQUFJLENBQUMsR0FBRyxJQUFJLENBQUMsT0FBTyxDQUFDLFFBQVEsSUFBSSxJQUFJLENBQUMsT0FBTyxDQUFDLFFBQVEsRUFBRSxDQUFDLENBQUM7SUFDbkUsQ0FBQztJQUVELFlBQW9CLE9BQWdDO1FBQWhDLFlBQU8sR0FBUCxPQUFPLENBQXlCO0lBQUcsQ0FBQztJQUV4RCxPQUFPO1FBQ0wsT0FBTztJQUNULENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEF1dGhQcm92aWRlciwgQXV0aFByb3ZpZGVyQmFzaWNDb25maWcgfSBmcm9tICcuL2F1dGgtcHJvdmlkZXIudHlwZXMnO1xuXG5leHBvcnQgY2xhc3MgQmFzaWNBdXRoUHJvdmlkZXIgaW1wbGVtZW50cyBBdXRoUHJvdmlkZXIge1xuICBnZXQgaGVhZGVyKCkge1xuICAgIHJldHVybiB7IEF1dGhvcml6YXRpb246IGBCYXNpYyAke3RoaXMuX2Jhc2ljQXV0aFN0cmluZ31gIH07XG4gIH1cblxuICBwcml2YXRlIGdldCBfYmFzaWNBdXRoU3RyaW5nKCkge1xuICAgIHJldHVybiBidG9hKGAke3RoaXMuX2NvbmZpZy51c2VybmFtZX06JHt0aGlzLl9jb25maWcucGFzc3dvcmR9YCk7XG4gIH1cblxuICBjb25zdHJ1Y3Rvcihwcml2YXRlIF9jb25maWc6IEF1dGhQcm92aWRlckJhc2ljQ29uZmlnKSB7fVxuXG4gIGNsZWFuVXAoKTogdm9pZCB7XG4gICAgLy8gbm9vcFxuICB9XG59XG4iXX0=

package/esm2020/lib/auth/bearer-auth-provider.mjs

@@ -1,127 +1,120 @@
 import { deleteCookie, getCookie, setCookie } from '@ethlete/core';
-import { Subject, timer } from 'rxjs';
-import { buildBody, buildRequestError, buildRoute, request } from '../request';
+import { BehaviorSubject, Subject, takeUntil, tap, timer } from 'rxjs';
+import { isQueryStateFailure, isQueryStateSuccess, switchQueryState, takeUntilResponse } from '../query';
 import { decryptBearer } from './auth-provider.utils';
 export class BearerAuthProvider {
     get header() {
-        return { Authorization: `Bearer ${this._token}` };
+        return { Authorization: `Bearer ${this._tokens$.getValue().token}` };
+    }
+    get tokens$() {
+        return this._tokens$.asObservable();
+    }
+    get tokens() {
+        return this._tokens$.getValue();
+    }
+    get currentRefreshQuery$() {
+        return this._currentRefreshQuery$.asObservable();
+    }
+    get currentRefreshQuery() {
+        return this._currentRefreshQuery$.getValue();
     }
     constructor(_config) {
         this._config = _config;
-        this._token = null;
-        this._refreshToken = null;
-        this._refreshTimerSubscription = null;
-        this._failureCount = 0;
-        this.queryClient = null;
-        this.onRefreshInitiation$ = new Subject();
-        this.onRefreshSuccess$ = new Subject();
-        this.onRefreshFailure$ = new Subject();
-        this._token = _config.token || null;
-        this._refreshToken = _config.refreshConfig?.token ?? null;
-        if (this._config.refreshConfig && this._token) {
-            this._setupRefresh(this._config.refreshConfig);
+        this._destroy$ = new Subject();
+        this._currentRefreshQuery$ = new BehaviorSubject(null);
+        this._tokens$ = new BehaviorSubject({
+            token: null,
+            refreshToken: null,
+        });
+        const cookieToken = _config.refreshConfig?.cookieName ? getCookie(_config.refreshConfig.cookieName) ?? null : null;
+        this._tokens$.next({
+            token: _config.token || null,
+            refreshToken: _config.refreshConfig?.token || cookieToken || null,
+        });
+        if (!this.tokens.token && !this.tokens.refreshToken) {
+            if (!_config.refreshConfig?.cookieName) {
+                console.error('A BearerAuthProvider was created without token or refresh token. You should provide at least a cookieName where the refresh token might be stored.');
+            }
+            return;
         }
-        else if (this._config.refreshConfig?.cookieName) {
-            const cookie = getCookie(this._config.refreshConfig.cookieName);
-            if (!cookie) {
-                this._autoDestruct();
-                return;
+        if (this.tokens.token) {
+            this._prepareForRefresh();
+            if (this.tokens.refreshToken && this._config.refreshConfig?.cookieName) {
+                setCookie(this._config.refreshConfig.cookieName, this.tokens.refreshToken);
             }
-            this._refreshToken = cookie;
-            this._refresh(this._config.refreshConfig);
         }
-        else {
-            this._autoDestruct();
-            console.error('A BearerAuthProvider was created without token or refresh token. You should provide at least a cookieName where the refresh token might be stored.');
+        else if (this.tokens.refreshToken) {
+            this._refreshQuery();
         }
     }
-    cleanUp(config) {
-        this._refreshTimerSubscription?.unsubscribe();
-        this._refreshTimerSubscription = null;
-        if (this._config.refreshConfig?.cookieName && !config?.keepCookie) {
+    cleanUp() {
+        this._destroy$.next(true);
+        this._destroy$.unsubscribe();
+        this._currentRefreshQuery$.next(null);
+        if (this._config.refreshConfig?.cookieName) {
             deleteCookie(this._config.refreshConfig.cookieName, '/');
         }
     }
-    _autoDestruct() {
-        this.cleanUp();
-        this.queryClient?.clearAuthProvider();
-    }
-    _setupRefresh(config) {
-        this.cleanUp({ keepCookie: true });
-        if (!this._token) {
+    _prepareForRefresh() {
+        if (!this.tokens.token || !this._config.refreshConfig) {
             return;
         }
-        const bearer = decryptBearer(this._token);
+        const bearer = decryptBearer(this.tokens.token);
         if (!bearer) {
             return;
         }
-        const expiresInPropertyName = config.expiresInPropertyName || 'exp';
+        const expiresInPropertyName = this._config.refreshConfig.expiresInPropertyName || 'exp';
         const expiresIn = bearer[expiresInPropertyName];
         const fiveMinutes = 5 * 60 * 1000;
-        const refreshBuffer = config.refreshBuffer ?? fiveMinutes;
+        const refreshBuffer = this._config.refreshConfig.refreshBuffer ?? fiveMinutes;
         if (expiresIn === undefined) {
             throw new Error(`Bearer token does not contain an '${expiresInPropertyName}' property`);
         }
         const remainingTime = new Date(expiresIn * 1000).getTime() - refreshBuffer - new Date().getTime();
-        const strategy = config.strategy ?? "beforeExpiration" /* AuthBearerRefreshStrategy.BeforeExpiration */;
+        const strategy = this._config.refreshConfig.strategy ?? "beforeExpiration" /* AuthBearerRefreshStrategy.BeforeExpiration */;
         switch (strategy) {
             case "beforeExpiration" /* AuthBearerRefreshStrategy.BeforeExpiration */:
-                this._refreshTimerSubscription = timer(remainingTime).subscribe(() => this._refresh(config));
+                timer(remainingTime)
+                    .pipe(takeUntil(this._destroy$))
+                    .subscribe(() => this._refreshQuery());
                 break;
         }
     }
-    async _refresh(config) {
-        if (!this._refreshToken) {
-            throw new Error('No refresh token found');
-        }
-        if (!this.queryClient) {
-            throw new Error('Query client instance is null');
-        }
-        const { method, route, requestAdapter, responseAdapter, paramLocation } = config;
-        const data = requestAdapter?.(this._refreshToken) ?? { refreshToken: this._refreshToken };
-        const fullRoute = buildRoute({
-            base: this.queryClient.config.baseRoute,
-            route,
-            queryParams: paramLocation === 'query' ? data : undefined,
-        });
-        const requestInit = { body: paramLocation === 'body' ? buildBody(data) : undefined, method };
-        this.onRefreshInitiation$.next();
-        try {
-            const result = await request({
-                route: fullRoute,
-                init: requestInit,
-            });
-            const tokens = responseAdapter ? responseAdapter(result.data) : result.data;
-            if (!tokens.token) {
-                throw new Error('Token not found in response');
-            }
-            if (!tokens.refreshToken) {
-                throw new Error('Refresh token not found in response');
-            }
-            this._token = tokens.token;
-            this._refreshToken = tokens.refreshToken;
-            this.onRefreshSuccess$.next(tokens);
-            if (config.cookieName) {
-                setCookie(config.cookieName, tokens.refreshToken);
-            }
-            this._setupRefresh(config);
-            this._failureCount = 0;
+    _refreshQuery() {
+        if (!this.tokens.refreshToken || !this._config.refreshConfig) {
+            return;
         }
-        catch (error) {
-            if (error instanceof Error) {
-                this.onRefreshFailure$.next(await buildRequestError(error, fullRoute, requestInit));
-            }
-            else {
-                this.onRefreshFailure$.next(error);
+        const args = this._config.refreshConfig.requestArgsAdapter?.(this.tokens) ?? {
+            body: { refreshToken: this.tokens.refreshToken },
+        };
+        const query = this._config.refreshConfig.queryCreator.prepare(args).execute({ skipCache: true });
+        this._currentRefreshQuery$.next(query);
+        this._currentRefreshQuery$
+            .pipe(switchQueryState(), tap((state) => {
+            if (isQueryStateSuccess(state)) {
+                if (this._config.refreshConfig?.responseAdapter) {
+                    const tokens = this._config.refreshConfig.responseAdapter(state.response);
+                    this._tokens$.next(tokens);
+                }
+                else {
+                    this._tokens$.next({
+                        token: state.response['token'],
+                        refreshToken: state.response['refreshToken'],
+                    });
+                }
+                if (this._config.refreshConfig?.cookieName && this.tokens.refreshToken) {
+                    setCookie(this._config.refreshConfig.cookieName, this.tokens.refreshToken);
+                }
+                this._prepareForRefresh();
             }
-            this._failureCount++;
-            if (this._failureCount <= (config.maxRefreshAttempts ?? 3)) {
-                this._setupRefresh(config);
+            else if (isQueryStateFailure(state)) {
+                this._tokens$.next({ token: null, refreshToken: null });
+                if (this._config.refreshConfig?.cookieName) {
+                    deleteCookie(this._config.refreshConfig.cookieName, '/');
+                }
             }
-            else {
-                this._autoDestruct();
-            }
-        }
+        }), takeUntilResponse(), takeUntil(this._destroy$))
+            .subscribe();
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bearer-auth-provider.js","sourceRoot":"","sources":["../../../../../../libs/query/src/lib/auth/bearer-auth-provider.ts"],"names":[],"mappings":"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","sourcesContent":["import { deleteCookie, getCookie, setCookie } from '@ethlete/core';\nimport { Subject, Subscription, timer } from 'rxjs';\nimport { QueryClient } from '../query-client';\nimport { buildBody, buildRequestError, buildRoute, request, RequestError } from '../request';\nimport {\n  AuthBearerRefreshStrategy,\n  AuthProvider,\n  AuthProviderBearerConfig,\n  BearerRefreshConfig,\n  TokenResponse,\n} from './auth-provider.types';\nimport { decryptBearer } from './auth-provider.utils';\n\nexport class BearerAuthProvider<T = unknown> implements AuthProvider {\n  private _token: string | null = null;\n  private _refreshToken: string | null = null;\n  private _refreshTimerSubscription: Subscription | null = null;\n  private _failureCount = 0;\n\n  get header() {\n    return { Authorization: `Bearer ${this._token}` };\n  }\n\n  queryClient: QueryClient | null = null;\n\n  onRefreshInitiation$ = new Subject<void>();\n  onRefreshSuccess$ = new Subject<TokenResponse>();\n  onRefreshFailure$ = new Subject<RequestError>();\n\n  constructor(private _config: AuthProviderBearerConfig<T>) {\n    this._token = _config.token || null;\n    this._refreshToken = _config.refreshConfig?.token ?? null;\n\n    if (this._config.refreshConfig && this._token) {\n      this._setupRefresh(this._config.refreshConfig);\n    } else if (this._config.refreshConfig?.cookieName) {\n      const cookie = getCookie(this._config.refreshConfig.cookieName);\n\n      if (!cookie) {\n        this._autoDestruct();\n        return;\n      }\n\n      this._refreshToken = cookie;\n\n      this._refresh(this._config.refreshConfig);\n    } else {\n      this._autoDestruct();\n      console.error(\n        'A BearerAuthProvider was created without token or refresh token. You should provide at least a cookieName where the refresh token might be stored.',\n      );\n    }\n  }\n\n  cleanUp(config?: { keepCookie: boolean }): void {\n    this._refreshTimerSubscription?.unsubscribe();\n    this._refreshTimerSubscription = null;\n\n    if (this._config.refreshConfig?.cookieName && !config?.keepCookie) {\n      deleteCookie(this._config.refreshConfig.cookieName, '/');\n    }\n  }\n\n  private _autoDestruct() {\n    this.cleanUp();\n\n    this.queryClient?.clearAuthProvider();\n  }\n\n  private _setupRefresh(config: BearerRefreshConfig<T>) {\n    this.cleanUp({ keepCookie: true });\n\n    if (!this._token) {\n      return;\n    }\n\n    const bearer = decryptBearer(this._token);\n\n    if (!bearer) {\n      return;\n    }\n\n    const expiresInPropertyName = config.expiresInPropertyName || 'exp';\n    const expiresIn = bearer[expiresInPropertyName] as number | undefined;\n    const fiveMinutes = 5 * 60 * 1000;\n    const refreshBuffer = config.refreshBuffer ?? fiveMinutes;\n\n    if (expiresIn === undefined) {\n      throw new Error(`Bearer token does not contain an '${expiresInPropertyName}' property`);\n    }\n\n    const remainingTime = new Date(expiresIn * 1000).getTime() - refreshBuffer - new Date().getTime();\n\n    const strategy = config.strategy ?? AuthBearerRefreshStrategy.BeforeExpiration;\n\n    switch (strategy) {\n      case AuthBearerRefreshStrategy.BeforeExpiration:\n        this._refreshTimerSubscription = timer(remainingTime).subscribe(() => this._refresh(config));\n        break;\n    }\n  }\n\n  private async _refresh(config: BearerRefreshConfig<T>) {\n    if (!this._refreshToken) {\n      throw new Error('No refresh token found');\n    }\n\n    if (!this.queryClient) {\n      throw new Error('Query client instance is null');\n    }\n\n    const { method, route, requestAdapter, responseAdapter, paramLocation } = config;\n\n    const data = requestAdapter?.(this._refreshToken) ?? { refreshToken: this._refreshToken };\n\n    const fullRoute = buildRoute({\n      base: this.queryClient.config.baseRoute,\n      route,\n      queryParams: paramLocation === 'query' ? data : undefined,\n    });\n\n    const requestInit: RequestInit = { body: paramLocation === 'body' ? buildBody(data) : undefined, method };\n\n    this.onRefreshInitiation$.next();\n\n    try {\n      const result = await request<T>({\n        route: fullRoute,\n        init: requestInit,\n      });\n\n      const tokens = responseAdapter ? responseAdapter(result.data) : (result.data as TokenResponse);\n\n      if (!tokens.token) {\n        throw new Error('Token not found in response');\n      }\n\n      if (!tokens.refreshToken) {\n        throw new Error('Refresh token not found in response');\n      }\n\n      this._token = tokens.token;\n      this._refreshToken = tokens.refreshToken;\n\n      this.onRefreshSuccess$.next(tokens);\n\n      if (config.cookieName) {\n        setCookie(config.cookieName, tokens.refreshToken);\n      }\n\n      this._setupRefresh(config);\n\n      this._failureCount = 0;\n    } catch (error) {\n      if (error instanceof Error) {\n        this.onRefreshFailure$.next(await buildRequestError(error, fullRoute, requestInit));\n      } else {\n        this.onRefreshFailure$.next(error as RequestError);\n      }\n\n      this._failureCount++;\n\n      if (this._failureCount <= (config.maxRefreshAttempts ?? 3)) {\n        this._setupRefresh(config);\n      } else {\n        this._autoDestruct();\n      }\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bearer-auth-provider.js","sourceRoot":"","sources":["../../../../../../libs/query/src/lib/auth/bearer-auth-provider.ts"],"names":[],"mappings":"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","sourcesContent":["import { deleteCookie, getCookie, setCookie } from '@ethlete/core';\nimport { BehaviorSubject, Subject, takeUntil, tap, timer } from 'rxjs';\nimport { isQueryStateFailure, isQueryStateSuccess, switchQueryState, takeUntilResponse } from '../query';\nimport { AnyQueryCreator, QueryCreatorReturnType } from '../query-client';\nimport {\n  AuthBearerRefreshStrategy,\n  AuthProvider,\n  AuthProviderBearerConfig,\n  TokenResponse,\n} from './auth-provider.types';\nimport { decryptBearer } from './auth-provider.utils';\n\nexport class BearerAuthProvider<T extends AnyQueryCreator> implements AuthProvider {\n  private readonly _destroy$ = new Subject<boolean>();\n  private readonly _currentRefreshQuery$ = new BehaviorSubject<QueryCreatorReturnType<T> | null>(null);\n\n  private readonly _tokens$ = new BehaviorSubject<TokenResponse>({\n    token: null,\n    refreshToken: null,\n  });\n\n  get header() {\n    return { Authorization: `Bearer ${this._tokens$.getValue().token}` };\n  }\n\n  get tokens$() {\n    return this._tokens$.asObservable();\n  }\n\n  get tokens() {\n    return this._tokens$.getValue();\n  }\n\n  get currentRefreshQuery$() {\n    return this._currentRefreshQuery$.asObservable();\n  }\n\n  get currentRefreshQuery() {\n    return this._currentRefreshQuery$.getValue();\n  }\n\n  constructor(private _config: AuthProviderBearerConfig<T>) {\n    const cookieToken = _config.refreshConfig?.cookieName ? getCookie(_config.refreshConfig.cookieName) ?? null : null;\n\n    this._tokens$.next({\n      token: _config.token || null,\n      refreshToken: _config.refreshConfig?.token || cookieToken || null,\n    });\n\n    if (!this.tokens.token && !this.tokens.refreshToken) {\n      if (!_config.refreshConfig?.cookieName) {\n        console.error(\n          'A BearerAuthProvider was created without token or refresh token. You should provide at least a cookieName where the refresh token might be stored.',\n        );\n      }\n\n      return;\n    }\n\n    if (this.tokens.token) {\n      this._prepareForRefresh();\n\n      if (this.tokens.refreshToken && this._config.refreshConfig?.cookieName) {\n        setCookie(this._config.refreshConfig.cookieName, this.tokens.refreshToken);\n      }\n    } else if (this.tokens.refreshToken) {\n      this._refreshQuery();\n    }\n  }\n\n  cleanUp(): void {\n    this._destroy$.next(true);\n    this._destroy$.unsubscribe();\n    this._currentRefreshQuery$.next(null);\n\n    if (this._config.refreshConfig?.cookieName) {\n      deleteCookie(this._config.refreshConfig.cookieName, '/');\n    }\n  }\n\n  private _prepareForRefresh() {\n    if (!this.tokens.token || !this._config.refreshConfig) {\n      return;\n    }\n\n    const bearer = decryptBearer(this.tokens.token);\n\n    if (!bearer) {\n      return;\n    }\n\n    const expiresInPropertyName = this._config.refreshConfig.expiresInPropertyName || 'exp';\n    const expiresIn = bearer[expiresInPropertyName] as number | undefined;\n    const fiveMinutes = 5 * 60 * 1000;\n    const refreshBuffer = this._config.refreshConfig.refreshBuffer ?? fiveMinutes;\n\n    if (expiresIn === undefined) {\n      throw new Error(`Bearer token does not contain an '${expiresInPropertyName}' property`);\n    }\n\n    const remainingTime = new Date(expiresIn * 1000).getTime() - refreshBuffer - new Date().getTime();\n\n    const strategy = this._config.refreshConfig.strategy ?? AuthBearerRefreshStrategy.BeforeExpiration;\n\n    switch (strategy) {\n      case AuthBearerRefreshStrategy.BeforeExpiration:\n        timer(remainingTime)\n          .pipe(takeUntil(this._destroy$))\n          .subscribe(() => this._refreshQuery());\n        break;\n    }\n  }\n\n  private _refreshQuery() {\n    if (!this.tokens.refreshToken || !this._config.refreshConfig) {\n      return;\n    }\n\n    const args = this._config.refreshConfig.requestArgsAdapter?.(this.tokens) ?? {\n      body: { refreshToken: this.tokens.refreshToken },\n    };\n\n    const query = this._config.refreshConfig.queryCreator.prepare(args).execute({ skipCache: true });\n\n    this._currentRefreshQuery$.next(query as QueryCreatorReturnType<T>);\n\n    this._currentRefreshQuery$\n      .pipe(\n        switchQueryState(),\n        tap((state) => {\n          if (isQueryStateSuccess(state)) {\n            if (this._config.refreshConfig?.responseAdapter) {\n              const tokens = this._config.refreshConfig.responseAdapter(state.response);\n\n              this._tokens$.next(tokens);\n            } else {\n              this._tokens$.next({\n                token: state.response['token'],\n                refreshToken: state.response['refreshToken'],\n              });\n            }\n\n            if (this._config.refreshConfig?.cookieName && this.tokens.refreshToken) {\n              setCookie(this._config.refreshConfig.cookieName, this.tokens.refreshToken);\n            }\n\n            this._prepareForRefresh();\n          } else if (isQueryStateFailure(state)) {\n            this._tokens$.next({ token: null, refreshToken: null });\n\n            if (this._config.refreshConfig?.cookieName) {\n              deleteCookie(this._config.refreshConfig.cookieName, '/');\n            }\n          }\n        }),\n        takeUntilResponse(),\n        takeUntil(this._destroy$),\n      )\n      .subscribe();\n  }\n}\n"]}

package/esm2020/lib/auth/custom-header-auth-provider.mjs

@@ -4,10 +4,9 @@ export class CustomHeaderAuthProvider {
     }
     constructor(_config) {
         this._config = _config;
-        this.queryClient = null;
     }
     cleanUp() {
         // noop
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3VzdG9tLWhlYWRlci1hdXRoLXByb3ZpZGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9xdWVyeS9zcmMvbGliL2F1dGgvY3VzdG9tLWhlYWRlci1hdXRoLXByb3ZpZGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLE1BQU0sT0FBTyx3QkFBd0I7SUFDbkMsSUFBSSxNQUFNO1FBQ1IsT0FBTyxFQUFFLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsRUFBRSxJQUFJLENBQUMsT0FBTyxDQUFDLEtBQUssRUFBRSxDQUFDO0lBQ3JELENBQUM7SUFJRCxZQUFvQixPQUF1QztRQUF2QyxZQUFPLEdBQVAsT0FBTyxDQUFnQztRQUYzRCxnQkFBVyxHQUF1QixJQUFJLENBQUM7SUFFdUIsQ0FBQztJQUUvRCxPQUFPO1FBQ0wsT0FBTztJQUNULENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFF1ZXJ5Q2xpZW50IH0gZnJvbSAnLi4vcXVlcnktY2xpZW50JztcbmltcG9ydCB7IEF1dGhQcm92aWRlciwgQXV0aFByb3ZpZGVyQ3VzdG9tSGVhZGVyQ29uZmlnIH0gZnJvbSAnLi9hdXRoLXByb3ZpZGVyLnR5cGVzJztcblxuZXhwb3J0IGNsYXNzIEN1c3RvbUhlYWRlckF1dGhQcm92aWRlciBpbXBsZW1lbnRzIEF1dGhQcm92aWRlciB7XG4gIGdldCBoZWFkZXIoKSB7XG4gICAgcmV0dXJuIHsgW3RoaXMuX2NvbmZpZy5uYW1lXTogdGhpcy5fY29uZmlnLnZhbHVlIH07XG4gIH1cblxuICBxdWVyeUNsaWVudDogUXVlcnlDbGllbnQgfCBudWxsID0gbnVsbDtcblxuICBjb25zdHJ1Y3Rvcihwcml2YXRlIF9jb25maWc6IEF1dGhQcm92aWRlckN1c3RvbUhlYWRlckNvbmZpZykge31cblxuICBjbGVhblVwKCk6IHZvaWQge1xuICAgIC8vIG5vb3BcbiAgfVxufVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3VzdG9tLWhlYWRlci1hdXRoLXByb3ZpZGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9xdWVyeS9zcmMvbGliL2F1dGgvY3VzdG9tLWhlYWRlci1hdXRoLXByb3ZpZGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE1BQU0sT0FBTyx3QkFBd0I7SUFDbkMsSUFBSSxNQUFNO1FBQ1IsT0FBTyxFQUFFLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsRUFBRSxJQUFJLENBQUMsT0FBTyxDQUFDLEtBQUssRUFBRSxDQUFDO0lBQ3JELENBQUM7SUFFRCxZQUFvQixPQUF1QztRQUF2QyxZQUFPLEdBQVAsT0FBTyxDQUFnQztJQUFHLENBQUM7SUFFL0QsT0FBTztRQUNMLE9BQU87SUFDVCxDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBBdXRoUHJvdmlkZXIsIEF1dGhQcm92aWRlckN1c3RvbUhlYWRlckNvbmZpZyB9IGZyb20gJy4vYXV0aC1wcm92aWRlci50eXBlcyc7XG5cbmV4cG9ydCBjbGFzcyBDdXN0b21IZWFkZXJBdXRoUHJvdmlkZXIgaW1wbGVtZW50cyBBdXRoUHJvdmlkZXIge1xuICBnZXQgaGVhZGVyKCkge1xuICAgIHJldHVybiB7IFt0aGlzLl9jb25maWcubmFtZV06IHRoaXMuX2NvbmZpZy52YWx1ZSB9O1xuICB9XG5cbiAgY29uc3RydWN0b3IocHJpdmF0ZSBfY29uZmlnOiBBdXRoUHJvdmlkZXJDdXN0b21IZWFkZXJDb25maWcpIHt9XG5cbiAgY2xlYW5VcCgpOiB2b2lkIHtcbiAgICAvLyBub29wXG4gIH1cbn1cbiJdfQ==

package/esm2020/lib/query/query.utils.mjs

@@ -14,9 +14,14 @@ export function filterQueryStates(allowedStates) {
         return source.pipe(filter((value) => value && allowedStates.includes(value.type)));
     };
 }
-export function takeUntilResponse() {
+export function takeUntilResponse(config) {
     return function (source) {
-        return source.pipe(takeWhile((value) => isQueryStateLoading(value), true));
+        return source.pipe(takeWhile((value) => {
+            if (config?.excludeNull && value === null) {
+                return false;
+            }
+            return isQueryStateLoading(value) || value === null;
+        }, true));
     };
 }
 export function filterNull() {
@@ -67,4 +72,4 @@ export const createQueryCollection = (
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 queryMap) => new BehaviorSubject(null);
 export const extractQuery = (v) => (isQuery(v) ? v : v?.query) ?? null;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query.utils.js","sourceRoot":"","sources":["../../../../../../libs/query/src/lib/query/query.utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { BehaviorSubject, filter, Observable, of, switchMap, takeWhile } from 'rxjs';\nimport { ResponseTransformerType } from '../query-client';\nimport { RequestHeaders } from '../request';\nimport {\n  AnyQuery,\n  AnyQueryCreatorCollection,\n  AnyQueryOfCreatorCollection,\n  BaseArguments,\n  Cancelled,\n  Failure,\n  GqlQueryConfig,\n  Loading,\n  Prepared,\n  QueryRawResponseType,\n  QueryResponseType,\n  QueryState,\n  QueryStateData,\n  QueryStateRawData,\n  QueryStateType,\n  RouteType,\n  Success,\n} from './query.types';\n\ntype OmitNull<T> = T extends null ? never : T;\n\nexport function filterSuccess() {\n  return function <\n    T extends QueryState | null,\n    Response extends QueryStateData<OmitNull<T>>,\n    RawResponse extends QueryStateRawData<OmitNull<T>>,\n  >(source: Observable<T>) {\n    return source.pipe(filter((value) => isQueryStateSuccess(value))) as Observable<Success<Response, RawResponse>>;\n  };\n}\n\nexport function filterFailure() {\n  return function <T extends QueryState | null>(source: Observable<T>) {\n    return source.pipe(filter((value) => isQueryStateFailure(value))) as Observable<Failure>;\n  };\n}\n\nexport function filterQueryStates(allowedStates: QueryStateType[]) {\n  return function <T extends QueryState | null>(source: Observable<T>) {\n    return source.pipe(filter((value) => value && allowedStates.includes(value.type))) as Observable<T>;\n  };\n}\n\nexport function takeUntilResponse() {\n  return function <T extends QueryState>(source: Observable<T>) {\n    return source.pipe(takeWhile((value) => isQueryStateLoading(value), true));\n  };\n}\n\nexport function filterNull() {\n  return function <T>(source: Observable<T>) {\n    return source.pipe(filter((value): value is OmitNull<T> => value !== null));\n  };\n}\n\nexport function switchQueryState() {\n  return function <\n    T extends AnyQuery | null,\n    Response extends QueryResponseType<OmitNull<T>>,\n    RawResponse extends QueryRawResponseType<OmitNull<T>>,\n  >(source: Observable<T>) {\n    return source.pipe(switchMap((value) => value?.state$ ?? of(null))) as Observable<QueryState<\n      OmitNull<Response>,\n      OmitNull<RawResponse>\n    > | null>;\n  };\n}\n\nexport const isQueryStateLoading = (state: QueryState | null | undefined): state is Loading =>\n  state?.type === QueryStateType.Loading;\n\nexport const isQueryStateSuccess = (state: QueryState | null | undefined): state is Success =>\n  state?.type === QueryStateType.Success;\n\nexport const isQueryStateFailure = (state: QueryState | null | undefined): state is Failure =>\n  state?.type === QueryStateType.Failure;\n\nexport const isQueryStateCancelled = (state: QueryState | null | undefined): state is Cancelled =>\n  state?.type === QueryStateType.Cancelled;\n\nexport const isQueryStatePrepared = (state: QueryState | null | undefined): state is Prepared =>\n  state?.type === QueryStateType.Prepared;\n\nexport const mergeHeaders = (...headers: Array<RequestHeaders | null | undefined>) => {\n  return headers.reduce((acc, headers) => {\n    if (!headers) {\n      return acc;\n    }\n\n    return {\n      ...acc,\n      ...headers,\n    };\n  }, {});\n};\n\nexport const isGqlQueryConfig = <\n  Response,\n  Arguments extends BaseArguments | undefined,\n  Route extends RouteType<Arguments> | undefined,\n  ResponseTransformer extends ResponseTransformerType<Response> | undefined,\n>(\n  config: unknown,\n): config is GqlQueryConfig<Route, Response, Arguments, ResponseTransformer> => {\n  if (!config || typeof config !== 'object' || Array.isArray(config)) {\n    return false;\n  }\n\n  if (!('query' in config)) {\n    return false;\n  }\n\n  return true;\n};\n\nexport const isQuery = <T extends AnyQuery>(query: unknown): query is T => {\n  if (!query || typeof query !== 'object' || Array.isArray(query)) {\n    return false;\n  }\n\n  if (!('state$' in query)) {\n    return false;\n  }\n\n  return true;\n};\n\nexport const createQueryCollection = <T extends AnyQueryCreatorCollection, R extends AnyQueryOfCreatorCollection<T>>(\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  queryMap: T,\n) => new BehaviorSubject<R | null>(null);\n\nexport const extractQuery = <T extends AnyQuery | AnyQueryOfCreatorCollection<AnyQueryCreatorCollection> | null>(\n  v: T,\n) => (isQuery(v) ? v : v?.query) ?? null;\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query.utils.js","sourceRoot":"","sources":["../../../../../../libs/query/src/lib/query/query.utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { BehaviorSubject, filter, Observable, of, switchMap, takeWhile } from 'rxjs';\nimport { ResponseTransformerType } from '../query-client';\nimport { RequestHeaders } from '../request';\nimport {\n  AnyQuery,\n  AnyQueryCreatorCollection,\n  AnyQueryOfCreatorCollection,\n  BaseArguments,\n  Cancelled,\n  Failure,\n  GqlQueryConfig,\n  Loading,\n  Prepared,\n  QueryRawResponseType,\n  QueryResponseType,\n  QueryState,\n  QueryStateData,\n  QueryStateRawData,\n  QueryStateType,\n  RouteType,\n  Success,\n} from './query.types';\n\ntype OmitNull<T> = T extends null ? never : T;\n\nexport function filterSuccess() {\n  return function <\n    T extends QueryState | null,\n    Response extends QueryStateData<OmitNull<T>>,\n    RawResponse extends QueryStateRawData<OmitNull<T>>,\n  >(source: Observable<T>) {\n    return source.pipe(filter((value) => isQueryStateSuccess(value))) as Observable<Success<Response, RawResponse>>;\n  };\n}\n\nexport function filterFailure() {\n  return function <T extends QueryState | null>(source: Observable<T>) {\n    return source.pipe(filter((value) => isQueryStateFailure(value))) as Observable<Failure>;\n  };\n}\n\nexport function filterQueryStates(allowedStates: QueryStateType[]) {\n  return function <T extends QueryState | null>(source: Observable<T>) {\n    return source.pipe(filter((value) => value && allowedStates.includes(value.type))) as Observable<T>;\n  };\n}\n\nexport function takeUntilResponse(config?: { excludeNull?: boolean }) {\n  return function <T extends QueryState | null>(source: Observable<T>) {\n    return source.pipe(\n      takeWhile((value) => {\n        if (config?.excludeNull && value === null) {\n          return false;\n        }\n\n        return isQueryStateLoading(value) || value === null;\n      }, true),\n    );\n  };\n}\n\nexport function filterNull() {\n  return function <T>(source: Observable<T>) {\n    return source.pipe(filter((value): value is OmitNull<T> => value !== null));\n  };\n}\n\nexport function switchQueryState() {\n  return function <\n    T extends AnyQuery | null,\n    Response extends QueryResponseType<OmitNull<T>>,\n    RawResponse extends QueryRawResponseType<OmitNull<T>>,\n  >(source: Observable<T>) {\n    return source.pipe(switchMap((value) => value?.state$ ?? of(null))) as Observable<QueryState<\n      OmitNull<Response>,\n      OmitNull<RawResponse>\n    > | null>;\n  };\n}\n\nexport const isQueryStateLoading = (state: QueryState | null | undefined): state is Loading =>\n  state?.type === QueryStateType.Loading;\n\nexport const isQueryStateSuccess = (state: QueryState | null | undefined): state is Success =>\n  state?.type === QueryStateType.Success;\n\nexport const isQueryStateFailure = (state: QueryState | null | undefined): state is Failure =>\n  state?.type === QueryStateType.Failure;\n\nexport const isQueryStateCancelled = (state: QueryState | null | undefined): state is Cancelled =>\n  state?.type === QueryStateType.Cancelled;\n\nexport const isQueryStatePrepared = (state: QueryState | null | undefined): state is Prepared =>\n  state?.type === QueryStateType.Prepared;\n\nexport const mergeHeaders = (...headers: Array<RequestHeaders | null | undefined>) => {\n  return headers.reduce((acc, headers) => {\n    if (!headers) {\n      return acc;\n    }\n\n    return {\n      ...acc,\n      ...headers,\n    };\n  }, {});\n};\n\nexport const isGqlQueryConfig = <\n  Response,\n  Arguments extends BaseArguments | undefined,\n  Route extends RouteType<Arguments> | undefined,\n  ResponseTransformer extends ResponseTransformerType<Response> | undefined,\n>(\n  config: unknown,\n): config is GqlQueryConfig<Route, Response, Arguments, ResponseTransformer> => {\n  if (!config || typeof config !== 'object' || Array.isArray(config)) {\n    return false;\n  }\n\n  if (!('query' in config)) {\n    return false;\n  }\n\n  return true;\n};\n\nexport const isQuery = <T extends AnyQuery>(query: unknown): query is T => {\n  if (!query || typeof query !== 'object' || Array.isArray(query)) {\n    return false;\n  }\n\n  if (!('state$' in query)) {\n    return false;\n  }\n\n  return true;\n};\n\nexport const createQueryCollection = <T extends AnyQueryCreatorCollection, R extends AnyQueryOfCreatorCollection<T>>(\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  queryMap: T,\n) => new BehaviorSubject<R | null>(null);\n\nexport const extractQuery = <T extends AnyQuery | AnyQueryOfCreatorCollection<AnyQueryCreatorCollection> | null>(\n  v: T,\n) => (isQuery(v) ? v : v?.query) ?? null;\n"]}

package/esm2020/lib/query-client/query-client.mjs

@@ -76,7 +76,6 @@ export class QueryClient {
                 throw new Error('The auth provider is already set. Please call clearAuthProvider() first.');
             }
             this._authProvider$.next(authProvider);
-            authProvider.queryClient = this;
         };
         this.clearAuthProvider = () => {
             this.authProvider?.cleanUp();
@@ -88,4 +87,4 @@ export class QueryClient {
         });
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query-client.js","sourceRoot":"","sources":["../../../../../../libs/query/src/lib/query-client/query-client.ts"],"names":[],"mappings":"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","sourcesContent":["import { BehaviorSubject } from 'rxjs';\nimport { AuthProvider } from '../auth';\nimport {\n  BaseArguments,\n  GqlQueryConfig,\n  GqlQueryConfigWithoutMethod,\n  isGqlQueryConfig,\n  Query,\n  QueryConfigWithoutMethod,\n  RestQueryConfig,\n  RouteType,\n} from '../query';\nimport { QueryStore } from '../query-store';\nimport { buildRoute, Method as MethodType } from '../request';\nimport {\n  DefaultResponseTransformer,\n  QueryClientConfig,\n  QueryCreator,\n  ResponseTransformerType,\n} from './query-client.types';\nimport { buildGqlCacheKey, shouldCacheQuery } from './query-client.utils';\n\nexport class QueryClient {\n  private readonly _store: QueryStore;\n\n  get config() {\n    return this._clientConfig;\n  }\n\n  get authProvider() {\n    return this._authProvider$.getValue();\n  }\n  get authProvider$() {\n    return this._authProvider$.asObservable();\n  }\n  private readonly _authProvider$ = new BehaviorSubject<AuthProvider | null>(null);\n\n  constructor(private _clientConfig: QueryClientConfig) {\n    this._store = new QueryStore({\n      enableChangeLogging: _clientConfig.logging?.queryStateChanges,\n      enableGarbageCollectorLogging: _clientConfig.logging?.queryStateGarbageCollector,\n    });\n  }\n\n  get = <\n    Route extends RouteType<Arguments>,\n    Response,\n    Arguments extends BaseArguments | undefined = undefined,\n    ResponseTransformer extends ResponseTransformerType<Response> = DefaultResponseTransformer<Response>,\n  >(\n    queryConfig: QueryConfigWithoutMethod<Route, Response, Arguments, ResponseTransformer>,\n  ) =>\n    this.fetch<Route, Response, Arguments, 'GET', ResponseTransformer>({\n      ...queryConfig,\n      method: 'GET',\n    });\n\n  post = <\n    Route extends RouteType<Arguments>,\n    Response,\n    Arguments extends BaseArguments | undefined = undefined,\n    ResponseTransformer extends ResponseTransformerType<Response> = DefaultResponseTransformer<Response>,\n  >(\n    queryConfig: QueryConfigWithoutMethod<Route, Response, Arguments, ResponseTransformer>,\n  ) =>\n    this.fetch<Route, Response, Arguments, 'POST', ResponseTransformer>({\n      ...queryConfig,\n      method: 'POST',\n    });\n\n  put = <\n    Route extends RouteType<Arguments>,\n    Response,\n    Arguments extends BaseArguments | undefined = undefined,\n    ResponseTransformer extends ResponseTransformerType<Response> = DefaultResponseTransformer<Response>,\n  >(\n    queryConfig: QueryConfigWithoutMethod<Route, Response, Arguments, ResponseTransformer>,\n  ) =>\n    this.fetch<Route, Response, Arguments, 'PUT', ResponseTransformer>({\n      ...queryConfig,\n      method: 'PUT',\n    });\n\n  patch = <\n    Route extends RouteType<Arguments>,\n    Response,\n    Arguments extends BaseArguments | undefined = undefined,\n    ResponseTransformer extends ResponseTransformerType<Response> = DefaultResponseTransformer<Response>,\n  >(\n    queryConfig: QueryConfigWithoutMethod<Route, Response, Arguments, ResponseTransformer>,\n  ) =>\n    this.fetch<Route, Response, Arguments, 'PATCH', ResponseTransformer>({\n      ...queryConfig,\n      method: 'PATCH',\n    });\n\n  delete = <\n    Route extends RouteType<Arguments>,\n    Response,\n    Arguments extends BaseArguments | undefined = undefined,\n    ResponseTransformer extends ResponseTransformerType<Response> = DefaultResponseTransformer<Response>,\n  >(\n    queryConfig: QueryConfigWithoutMethod<Route, Response, Arguments, ResponseTransformer>,\n  ) =>\n    this.fetch<Route, Response, Arguments, 'DELETE', ResponseTransformer>({\n      ...queryConfig,\n      method: 'DELETE',\n    });\n\n  gqlQuery = <\n    Route extends RouteType<Arguments>,\n    Response,\n    Arguments extends BaseArguments | undefined = undefined,\n    ResponseTransformer extends ResponseTransformerType<Response> = DefaultResponseTransformer<Response>,\n  >(\n    queryConfig: GqlQueryConfigWithoutMethod<Route, Response, Arguments, ResponseTransformer>,\n  ) =>\n    this.fetch<Route, Response, Arguments, 'GQL_QUERY', ResponseTransformer>({\n      ...queryConfig,\n      method: 'GQL_QUERY',\n    });\n\n  gqlMutate = <\n    Route extends RouteType<Arguments>,\n    Response,\n    Arguments extends BaseArguments | undefined = undefined,\n    ResponseTransformer extends ResponseTransformerType<Response> = DefaultResponseTransformer<Response>,\n  >(\n    queryConfig: GqlQueryConfigWithoutMethod<Route, Response, Arguments, ResponseTransformer>,\n  ) =>\n    this.fetch<Route, Response, Arguments, 'GQL_MUTATE', ResponseTransformer>({\n      ...queryConfig,\n      method: 'GQL_MUTATE',\n    });\n\n  fetch = <\n    Route extends RouteType<Arguments>,\n    Response,\n    Arguments extends BaseArguments | undefined,\n    Method extends MethodType,\n    ResponseTransformer extends ResponseTransformerType<Response> = DefaultResponseTransformer<Response>,\n  >(\n    queryConfig:\n      | RestQueryConfig<Route, Response, Arguments, ResponseTransformer>\n      | GqlQueryConfig<Route, Response, Arguments, ResponseTransformer>,\n  ): QueryCreator<Arguments, Method, Response, Route, ResponseTransformer> => {\n    const prepare = (args?: Arguments) => {\n      const route = buildRoute({\n        base: this._clientConfig.baseRoute,\n        route: queryConfig.route,\n        pathParams: (args as BaseArguments)?.pathParams,\n        queryParams: (args as BaseArguments)?.queryParams,\n      }) as Route;\n\n      const cacheKey = isGqlQueryConfig(queryConfig) ? buildGqlCacheKey(queryConfig, args) : route;\n\n      if (shouldCacheQuery(queryConfig.method)) {\n        const existingQuery = this._store.get(cacheKey);\n\n        if (existingQuery) {\n          return existingQuery as Query<Response, Arguments, Route, Method, ResponseTransformer>;\n        }\n      }\n\n      const query = new Query<Response, Arguments, Route, Method, ResponseTransformer>(this, queryConfig, route, args);\n\n      if (shouldCacheQuery(queryConfig.method)) {\n        this._store.add(cacheKey, query);\n      }\n\n      return query;\n    };\n\n    const behaviorSubject = <T extends ReturnType<typeof prepare>>(initialValue: T | null = null) =>\n      new BehaviorSubject<T | null>(initialValue);\n\n    return {\n      prepare,\n      behaviorSubject,\n    } as unknown as QueryCreator<Arguments, Method, Response, Route, ResponseTransformer>;\n  };\n\n  setAuthProvider = (authProvider: AuthProvider) => {\n    if (this.authProvider) {\n      throw new Error('The auth provider is already set. Please call clearAuthProvider() first.');\n    }\n\n    this._authProvider$.next(authProvider);\n    authProvider.queryClient = this;\n  };\n\n  clearAuthProvider = () => {\n    this.authProvider?.cleanUp();\n    this._authProvider$.next(null);\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query-client.js","sourceRoot":"","sources":["../../../../../../libs/query/src/lib/query-client/query-client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,MAAM,CAAC;AAEvC,OAAO,EAIL,gBAAgB,EAChB,KAAK,GAIN,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC5C,OAAO,EAAE,UAAU,EAAwB,MAAM,YAAY,CAAC;AAO9D,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAE1E,MAAM,OAAO,WAAW;IAGtB,IAAI,MAAM;QACR,OAAO,IAAI,CAAC,aAAa,CAAC;IAC5B,CAAC;IAED,IAAI,YAAY;QACd,OAAO,IAAI,CAAC,cAAc,CAAC,QAAQ,EAAE,CAAC;IACxC,CAAC;IACD,IAAI,aAAa;QACf,OAAO,IAAI,CAAC,cAAc,CAAC,YAAY,EAAE,CAAC;IAC5C,CAAC;IAGD,YAAoB,aAAgC;QAAhC,kBAAa,GAAb,aAAa,CAAmB;QAFnC,mBAAc,GAAG,IAAI,eAAe,CAAsB,IAAI,CAAC,CAAC;QASjF,QAAG,GAAG,CAMJ,WAAsF,EACtF,EAAE,CACF,IAAI,CAAC,KAAK,CAAyD;YACjE,GAAG,WAAW;YACd,MAAM,EAAE,KAAK;SACd,CAAC,CAAC;QAEL,SAAI,GAAG,CAML,WAAsF,EACtF,EAAE,CACF,IAAI,CAAC,KAAK,CAA0D;YAClE,GAAG,WAAW;YACd,MAAM,EAAE,MAAM;SACf,CAAC,CAAC;QAEL,QAAG,GAAG,CAMJ,WAAsF,EACtF,EAAE,CACF,IAAI,CAAC,KAAK,CAAyD;YACjE,GAAG,WAAW;YACd,MAAM,EAAE,KAAK;SACd,CAAC,CAAC;QAEL,UAAK,GAAG,CAMN,WAAsF,EACtF,EAAE,CACF,IAAI,CAAC,KAAK,CAA2D;YACnE,GAAG,WAAW;YACd,MAAM,EAAE,OAAO;SAChB,CAAC,CAAC;QAEL,WAAM,GAAG,CAMP,WAAsF,EACtF,EAAE,CACF,IAAI,CAAC,KAAK,CAA4D;YACpE,GAAG,WAAW;YACd,MAAM,EAAE,QAAQ;SACjB,CAAC,CAAC;QAEL,aAAQ,GAAG,CAMT,WAAyF,EACzF,EAAE,CACF,IAAI,CAAC,KAAK,CAA+D;YACvE,GAAG,WAAW;YACd,MAAM,EAAE,WAAW;SACpB,CAAC,CAAC;QAEL,cAAS,GAAG,CAMV,WAAyF,EACzF,EAAE,CACF,IAAI,CAAC,KAAK,CAAgE;YACxE,GAAG,WAAW;YACd,MAAM,EAAE,YAAY;SACrB,CAAC,CAAC;QAEL,UAAK,GAAG,CAON,WAEmE,EACI,EAAE;YACzE,MAAM,OAAO,GAAG,CAAC,IAAgB,EAAE,EAAE;gBACnC,MAAM,KAAK,GAAG,UAAU,CAAC;oBACvB,IAAI,EAAE,IAAI,CAAC,aAAa,CAAC,SAAS;oBAClC,KAAK,EAAE,WAAW,CAAC,KAAK;oBACxB,UAAU,EAAG,IAAsB,EAAE,UAAU;oBAC/C,WAAW,EAAG,IAAsB,EAAE,WAAW;iBAClD,CAAU,CAAC;gBAEZ,MAAM,QAAQ,GAAG,gBAAgB,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,gBAAgB,CAAC,WAAW,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;gBAE7F,IAAI,gBAAgB,CAAC,WAAW,CAAC,MAAM,CAAC,EAAE;oBACxC,MAAM,aAAa,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;oBAEhD,IAAI,aAAa,EAAE;wBACjB,OAAO,aAA+E,CAAC;qBACxF;iBACF;gBAED,MAAM,KAAK,GAAG,IAAI,KAAK,CAA0D,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;gBAEjH,IAAI,gBAAgB,CAAC,WAAW,CAAC,MAAM,CAAC,EAAE;oBACxC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;iBAClC;gBAED,OAAO,KAAK,CAAC;YACf,CAAC,CAAC;YAEF,MAAM,eAAe,GAAG,CAAuC,eAAyB,IAAI,EAAE,EAAE,CAC9F,IAAI,eAAe,CAAW,YAAY,CAAC,CAAC;YAE9C,OAAO;gBACL,OAAO;gBACP,eAAe;aACoE,CAAC;QACxF,CAAC,CAAC;QAEF,oBAAe,GAAG,CAAC,YAA0B,EAAE,EAAE;YAC/C,IAAI,IAAI,CAAC,YAAY,EAAE;gBACrB,MAAM,IAAI,KAAK,CAAC,0EAA0E,CAAC,CAAC;aAC7F;YAED,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QACzC,CAAC,CAAC;QAEF,sBAAiB,GAAG,GAAG,EAAE;YACvB,IAAI,CAAC,YAAY,EAAE,OAAO,EAAE,CAAC;YAC7B,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACjC,CAAC,CAAC;QA3JA,IAAI,CAAC,MAAM,GAAG,IAAI,UAAU,CAAC;YAC3B,mBAAmB,EAAE,aAAa,CAAC,OAAO,EAAE,iBAAiB;YAC7D,6BAA6B,EAAE,aAAa,CAAC,OAAO,EAAE,0BAA0B;SACjF,CAAC,CAAC;IACL,CAAC;CAwJF","sourcesContent":["import { BehaviorSubject } from 'rxjs';\nimport { AuthProvider } from '../auth';\nimport {\n  BaseArguments,\n  GqlQueryConfig,\n  GqlQueryConfigWithoutMethod,\n  isGqlQueryConfig,\n  Query,\n  QueryConfigWithoutMethod,\n  RestQueryConfig,\n  RouteType,\n} from '../query';\nimport { QueryStore } from '../query-store';\nimport { buildRoute, Method as MethodType } from '../request';\nimport {\n  DefaultResponseTransformer,\n  QueryClientConfig,\n  QueryCreator,\n  ResponseTransformerType,\n} from './query-client.types';\nimport { buildGqlCacheKey, shouldCacheQuery } from './query-client.utils';\n\nexport class QueryClient {\n  private readonly _store: QueryStore;\n\n  get config() {\n    return this._clientConfig;\n  }\n\n  get authProvider() {\n    return this._authProvider$.getValue();\n  }\n  get authProvider$() {\n    return this._authProvider$.asObservable();\n  }\n  private readonly _authProvider$ = new BehaviorSubject<AuthProvider | null>(null);\n\n  constructor(private _clientConfig: QueryClientConfig) {\n    this._store = new QueryStore({\n      enableChangeLogging: _clientConfig.logging?.queryStateChanges,\n      enableGarbageCollectorLogging: _clientConfig.logging?.queryStateGarbageCollector,\n    });\n  }\n\n  get = <\n    Route extends RouteType<Arguments>,\n    Response,\n    Arguments extends BaseArguments | undefined = undefined,\n    ResponseTransformer extends ResponseTransformerType<Response> = DefaultResponseTransformer<Response>,\n  >(\n    queryConfig: QueryConfigWithoutMethod<Route, Response, Arguments, ResponseTransformer>,\n  ) =>\n    this.fetch<Route, Response, Arguments, 'GET', ResponseTransformer>({\n      ...queryConfig,\n      method: 'GET',\n    });\n\n  post = <\n    Route extends RouteType<Arguments>,\n    Response,\n    Arguments extends BaseArguments | undefined = undefined,\n    ResponseTransformer extends ResponseTransformerType<Response> = DefaultResponseTransformer<Response>,\n  >(\n    queryConfig: QueryConfigWithoutMethod<Route, Response, Arguments, ResponseTransformer>,\n  ) =>\n    this.fetch<Route, Response, Arguments, 'POST', ResponseTransformer>({\n      ...queryConfig,\n      method: 'POST',\n    });\n\n  put = <\n    Route extends RouteType<Arguments>,\n    Response,\n    Arguments extends BaseArguments | undefined = undefined,\n    ResponseTransformer extends ResponseTransformerType<Response> = DefaultResponseTransformer<Response>,\n  >(\n    queryConfig: QueryConfigWithoutMethod<Route, Response, Arguments, ResponseTransformer>,\n  ) =>\n    this.fetch<Route, Response, Arguments, 'PUT', ResponseTransformer>({\n      ...queryConfig,\n      method: 'PUT',\n    });\n\n  patch = <\n    Route extends RouteType<Arguments>,\n    Response,\n    Arguments extends BaseArguments | undefined = undefined,\n    ResponseTransformer extends ResponseTransformerType<Response> = DefaultResponseTransformer<Response>,\n  >(\n    queryConfig: QueryConfigWithoutMethod<Route, Response, Arguments, ResponseTransformer>,\n  ) =>\n    this.fetch<Route, Response, Arguments, 'PATCH', ResponseTransformer>({\n      ...queryConfig,\n      method: 'PATCH',\n    });\n\n  delete = <\n    Route extends RouteType<Arguments>,\n    Response,\n    Arguments extends BaseArguments | undefined = undefined,\n    ResponseTransformer extends ResponseTransformerType<Response> = DefaultResponseTransformer<Response>,\n  >(\n    queryConfig: QueryConfigWithoutMethod<Route, Response, Arguments, ResponseTransformer>,\n  ) =>\n    this.fetch<Route, Response, Arguments, 'DELETE', ResponseTransformer>({\n      ...queryConfig,\n      method: 'DELETE',\n    });\n\n  gqlQuery = <\n    Route extends RouteType<Arguments>,\n    Response,\n    Arguments extends BaseArguments | undefined = undefined,\n    ResponseTransformer extends ResponseTransformerType<Response> = DefaultResponseTransformer<Response>,\n  >(\n    queryConfig: GqlQueryConfigWithoutMethod<Route, Response, Arguments, ResponseTransformer>,\n  ) =>\n    this.fetch<Route, Response, Arguments, 'GQL_QUERY', ResponseTransformer>({\n      ...queryConfig,\n      method: 'GQL_QUERY',\n    });\n\n  gqlMutate = <\n    Route extends RouteType<Arguments>,\n    Response,\n    Arguments extends BaseArguments | undefined = undefined,\n    ResponseTransformer extends ResponseTransformerType<Response> = DefaultResponseTransformer<Response>,\n  >(\n    queryConfig: GqlQueryConfigWithoutMethod<Route, Response, Arguments, ResponseTransformer>,\n  ) =>\n    this.fetch<Route, Response, Arguments, 'GQL_MUTATE', ResponseTransformer>({\n      ...queryConfig,\n      method: 'GQL_MUTATE',\n    });\n\n  fetch = <\n    Route extends RouteType<Arguments>,\n    Response,\n    Arguments extends BaseArguments | undefined,\n    Method extends MethodType,\n    ResponseTransformer extends ResponseTransformerType<Response> = DefaultResponseTransformer<Response>,\n  >(\n    queryConfig:\n      | RestQueryConfig<Route, Response, Arguments, ResponseTransformer>\n      | GqlQueryConfig<Route, Response, Arguments, ResponseTransformer>,\n  ): QueryCreator<Arguments, Method, Response, Route, ResponseTransformer> => {\n    const prepare = (args?: Arguments) => {\n      const route = buildRoute({\n        base: this._clientConfig.baseRoute,\n        route: queryConfig.route,\n        pathParams: (args as BaseArguments)?.pathParams,\n        queryParams: (args as BaseArguments)?.queryParams,\n      }) as Route;\n\n      const cacheKey = isGqlQueryConfig(queryConfig) ? buildGqlCacheKey(queryConfig, args) : route;\n\n      if (shouldCacheQuery(queryConfig.method)) {\n        const existingQuery = this._store.get(cacheKey);\n\n        if (existingQuery) {\n          return existingQuery as Query<Response, Arguments, Route, Method, ResponseTransformer>;\n        }\n      }\n\n      const query = new Query<Response, Arguments, Route, Method, ResponseTransformer>(this, queryConfig, route, args);\n\n      if (shouldCacheQuery(queryConfig.method)) {\n        this._store.add(cacheKey, query);\n      }\n\n      return query;\n    };\n\n    const behaviorSubject = <T extends ReturnType<typeof prepare>>(initialValue: T | null = null) =>\n      new BehaviorSubject<T | null>(initialValue);\n\n    return {\n      prepare,\n      behaviorSubject,\n    } as unknown as QueryCreator<Arguments, Method, Response, Route, ResponseTransformer>;\n  };\n\n  setAuthProvider = (authProvider: AuthProvider) => {\n    if (this.authProvider) {\n      throw new Error('The auth provider is already set. Please call clearAuthProvider() first.');\n    }\n\n    this._authProvider$.next(authProvider);\n  };\n\n  clearAuthProvider = () => {\n    this.authProvider?.cleanUp();\n    this._authProvider$.next(null);\n  };\n}\n"]}