@bravobit/bb-foundation 0.16.3 → 0.20.0

package/esm2020/auth/lib/auth.service.mjs

@@ -1,276 +1,281 @@
-import { HttpContext } from '@angular/common/http';
-import { makeStateKey } from '@angular/platform-browser';
-import { USE_AUTHORIZATION } from './tokens/use-authorization.token';
-import { AuthVerifyProvider } from './providers/verify.provider';
-import { Injectable, Optional } from '@angular/core';
-import { AuthEmailProvider } from './providers/email.provider';
-import { firstValueFrom, of } from 'rxjs';
-import { AuthSession } from './auth.session';
-import { map, tap } from 'rxjs/operators';
-import { Router } from '@angular/router';
-import * as i0 from "@angular/core";
-import * as i1 from "@bravobit/bb-foundation/storage";
-import * as i2 from "./helpers/mapper.helper";
-import * as i3 from "@bravobit/bb-foundation";
-import * as i4 from "@angular/common/http";
-import * as i5 from "./interfaces/config.interface";
-import * as i6 from "@angular/platform-browser";
-import * as i7 from "@bravobit/bb-foundation/http";
-export class Auth {
-    constructor(_storage, _mapper, _injector, _platform, _httpClient, _config, _state, _httpConfig) {
-        this._storage = _storage;
-        this._mapper = _mapper;
-        this._injector = _injector;
-        this._platform = _platform;
-        this._httpClient = _httpClient;
-        this._config = _config;
-        this._state = _state;
-        this._httpConfig = _httpConfig;
-        // Readonly data.
-        this._authStateKey = makeStateKey(`bbAuthStateKey`);
-        this._httpAlias = this._httpConfig?.defaultAlias ?? null;
-        this._refreshHandler = null;
-        // Starting the new session.
-        this.session = new AuthSession({
-            id: this._config?.applicationId,
-            storage: this._storage.select(["cookie" /* Cookie */, "local" /* Local */])
-        });
-        this.user = this.session.user;
-    }
-    initialize() {
-        return async () => {
-            // Check if the app should bootstrap the authentication.
-            const shouldBootstrap = this._config?.bootstrap ?? true;
-            if (!shouldBootstrap) {
-                return this.handleAutoRefreshing();
-            }
-            // Only retrieve from the server when we are actually authenticated.
-            if (!this.session.authenticated()) {
-                return;
-            }
-            // Get the key from the server state.
-            if (this._state && this._state?.hasKey(this._authStateKey)) {
-                const user = this._state?.get(this._authStateKey, null) ?? null;
-                return this.session.setUser(user);
-            }
-            // Try to fetch the user from the server.
-            const user$ = this.me();
-            const user = await firstValueFrom(user$, { defaultValue: null });
-            // Set the state if exists.
-            if (this._state) {
-                this._state?.set(this._authStateKey, user ?? null);
-            }
-            // Save the user in the storage and handle auto refreshing.
-            this.session.setUser(user);
-            this.handleAutoRefreshing();
-        };
-    }
-    me() {
-        const url = this.getUrl('auth/me');
-        return this._httpClient.get(url);
-    }
-    async signIn(provider, as) {
-        const { accessToken, refreshToken, user, ...result } = await provider.authenticate(this._httpClient);
-        // Check if the role matches.
-        if (as && !as.includes(this._mapper.role(user))) {
-            throw new Error('Invalid role.');
-        }
-        // Validate if the provider is one of the available
-        // providers then return the user object and the provider.
-        const apiProvider = result?.provider ?? null;
-        const apiVerifyToken = result?.verifyToken ?? null;
-        const availableProviders = ['email', 'sms', 'totp'];
-        if (availableProviders.includes(apiProvider)) {
-            return { user, provider: apiProvider, verifyToken: apiVerifyToken };
-        }
-        // Set the tokens in storage.
-        this.setTokens(accessToken, refreshToken);
-        // Set the user in storage.
-        this.session.setUser(user);
-        // Return the user.
-        return { user };
-    }
-    async signInWithEmail(email, password, as) {
-        const url = this.getUrl('auth/login');
-        return this.signIn(new AuthEmailProvider(email, password, url), as);
-    }
-    async signInWithVerifyCode(code, verifyToken) {
-        const url = this.getUrl('auth/verify');
-        return this.signIn(new AuthVerifyProvider(code, verifyToken, url));
-    }
-    async resendVerifyCode(verifyToken) {
-        const url = this.getUrl('auth/resend');
-        const result$ = this._httpClient.post(url, {
-            verify_token: verifyToken
-        });
-        return firstValueFrom(result$);
-    }
-    async register(data, options) {
-        // Execute API call.
-        const url = this.getUrl('auth/register');
-        const result$ = this._httpClient.post(url, data, options);
-        const result = await firstValueFrom(result$);
-        // Map to the correct response.
-        const { accessToken, refreshToken, user } = this._mapper.toRegister(result);
-        // Set the tokens in storage.
-        this.setTokens(accessToken, refreshToken);
-        // Set the user in storage.
-        this.session.setUser(user);
-        // Return the user.
-        return user;
-    }
-    logout() {
-        // If we don't have a refresh token just clear the session.
-        // Note: We do this because else we try to invalidate
-        // an "undefined" refresh token.
-        const refreshToken = this.session.refreshToken;
-        if (!refreshToken) {
-            return this.session.clear();
-        }
-        // We do have a refresh token, so try to
-        // invalidate it in the backend.
-        try {
-            const url = this.getUrl('auth/logout');
-            const observable$ = this._httpClient.get(url, {
-                headers: { Authorization: refreshToken }
-            });
-            firstValueFrom(observable$).then(_ => _);
-        }
-        catch {
-            // Do nothing because the tokens will be deleted anyways from the session.
-        }
-        // Delete the tokens from the session.
-        return this.session.clear();
-    }
-    refresh() {
-        // If the refresh token does
-        // not exist just return an observable of null.
-        const refreshToken = this.session.refreshToken;
-        if (!refreshToken) {
-            return of(null);
-        }
-        // Perform the refresh call.
-        const scheme = this._config?.scheme ?? 'Bearer';
-        const url = this.getUrl('auth/refresh');
-        const context = new HttpContext()
-            .set(USE_AUTHORIZATION, false);
-        return this._httpClient.get(url, {
-            headers: { Authorization: `${scheme} ${refreshToken}` },
-            context: context
-        }).pipe(map(data => this._mapper.toRefresh(data)), tap(({ accessToken, refreshToken }) => this.setTokens(accessToken, refreshToken)), map(({ accessToken }) => accessToken));
-    }
-    async requestPassword(email, extraParams = {}) {
-        const url = this.getUrl('auth/reset');
-        const observable$ = this._httpClient.post(url, { ...extraParams, email });
-        return firstValueFrom(observable$);
-    }
-    async resetPassword(token, newPassword, extraParams = {}) {
-        const url = this.getUrl('auth/reset-password');
-        const observable$ = this._httpClient.post(url, { ...extraParams, token, password: newPassword });
-        return firstValueFrom(observable$);
-    }
-    guard(type, redirectUrl) {
-        let newUrl = null;
-        // Get the correct new url.
-        switch (type) {
-            case 'authenticated':
-                newUrl = this._config?.loggedInUrl ?? null;
-                break;
-            case 'unauthenticated':
-                newUrl = this._config?.redirectUrl ?? null;
-                break;
-        }
-        // Append a redirect url if the user is deemed
-        // unauthenticated.
-        if (type === 'unauthenticated') {
-            const setRedirectOnFailedAuth = this._config?.setRedirectOnFailedAuth ?? true;
-            if (setRedirectOnFailedAuth && redirectUrl && newUrl) {
-                newUrl += `?redirectUrl=${redirectUrl}`;
-            }
-        }
-        // Parse the url if it exists.
-        if (this.router && newUrl) {
-            return this.router.parseUrl(newUrl);
-        }
-        // Return false if the user is not allowed.
-        return false;
-    }
-    clearAndRedirect() {
-        // 1. Delete the tokens from the session.
-        this.session.clear();
-        // 2. Compose the route url.
-        const redirectUrl = this._config?.redirectUrl ?? null;
-        // 3. Route back if the user provided a redirect url.
-        if (this.router && redirectUrl) {
-            this.router.navigate([redirectUrl]).then(_ => _);
-        }
-    }
-    setTokens(accessToken, refreshToken) {
-        // Set the tokens in our session.
-        this.session.setTokens(accessToken, refreshToken);
-        // We need to update the auto refresh of the refresh token.
-        this.handleAutoRefreshing();
-    }
-    handleAutoRefreshing() {
-        const shouldAutoRefresh = this._config?.autoRefresh ?? false;
-        if (!shouldAutoRefresh) {
-            return;
-        }
-        const expiresAt = this.session.refreshTokenPayload?.expiresAt ?? null;
-        if (expiresAt === null || !this._platform.isBrowser) {
-            return;
-        }
-        const differenceInMilliseconds = expiresAt.getTime() - Date.now();
-        const offsetInMilliseconds = 10000; // 10 seconds.
-        // We want to start the refresh 10 seconds before it expires.
-        const actualTiming = differenceInMilliseconds - offsetInMilliseconds;
-        if (actualTiming <= 0) {
-            return;
-        }
-        // We need to cap the timings because if
-        // we get large numbers it might cause unwanted results.
-        const maxTiming = 1000 * 60 * 60 * 24; // 24 hours.
-        const cappedTiming = Math.max(1, Math.min(actualTiming, maxTiming));
-        try {
-            if (this._refreshHandler !== null) {
-                clearTimeout?.(this._refreshHandler);
-                this._refreshHandler = null;
-            }
-            this._refreshHandler = setTimeout?.(() => this.autoRefresh(), cappedTiming);
-        }
-        catch {
-            // Just ignore it.
-        }
-    }
-    async autoRefresh() {
-        try {
-            // We just need to wait for it to refresh.
-            const refresh$ = this.refresh();
-            await firstValueFrom(refresh$);
-        }
-        catch {
-            // Something went wrong refreshing, we need to clear.
-            this.clearAndRedirect();
-        }
-    }
-    get router() {
-        return this._injector.get(Router);
-    }
-    getUrl(endpoint) {
-        return [this._httpAlias, endpoint]
-            .filter(item => !!item)
-            .join('/');
-    }
-}
-Auth.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: Auth, deps: [{ token: i1.Storage }, { token: i2.AuthMapper }, { token: i0.Injector }, { token: i3.Platform }, { token: i4.HttpClient }, { token: i5.AuthConfig, optional: true }, { token: i6.TransferState, optional: true }, { token: i7.HttpConfig, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
-Auth.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: Auth });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: Auth, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () { return [{ type: i1.Storage }, { type: i2.AuthMapper }, { type: i0.Injector }, { type: i3.Platform }, { type: i4.HttpClient }, { type: i5.AuthConfig, decorators: [{
-                    type: Optional
-                }] }, { type: i6.TransferState, decorators: [{
-                    type: Optional
-                }] }, { type: i7.HttpConfig, decorators: [{
-                    type: Optional
-                }] }]; } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.service.js","sourceRoot":"","sources":["../../../../../projects/bb-foundation/auth/src/lib/auth.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,WAAW,EAA0B,MAAM,sBAAsB,CAAC;AAEtF,OAAO,EAAC,YAAY,EAA0B,MAAM,2BAA2B,CAAC;AAEhF,OAAO,EAAC,iBAAiB,EAAC,MAAM,kCAAkC,CAAC;AACnE,OAAO,EAAC,kBAAkB,EAAC,MAAM,6BAA6B,CAAC;AAC/D,OAAO,EAAC,UAAU,EAAY,QAAQ,EAAC,MAAM,eAAe,CAAC;AAC7D,OAAO,EAAC,iBAAiB,EAAC,MAAM,4BAA4B,CAAC;AAG7D,OAAO,EAAC,cAAc,EAAc,EAAE,EAAC,MAAM,MAAM,CAAC;AAGpD,OAAO,EAAC,WAAW,EAAC,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAC,GAAG,EAAE,GAAG,EAAC,MAAM,gBAAgB,CAAC;AACxC,OAAO,EAAC,MAAM,EAAC,MAAM,iBAAiB,CAAC;;;;;;;;;AAGvC,MAAM,OAAO,IAAI;IAWb,YAAoB,QAAiB,EACjB,OAAmB,EACnB,SAAmB,EACnB,SAAmB,EACnB,WAAuB,EACX,OAAoB,EACpB,MAAsB,EACtB,WAAwB;QAPpC,aAAQ,GAAR,QAAQ,CAAS;QACjB,YAAO,GAAP,OAAO,CAAY;QACnB,cAAS,GAAT,SAAS,CAAU;QACnB,cAAS,GAAT,SAAS,CAAU;QACnB,gBAAW,GAAX,WAAW,CAAY;QACX,YAAO,GAAP,OAAO,CAAa;QACpB,WAAM,GAAN,MAAM,CAAgB;QACtB,gBAAW,GAAX,WAAW,CAAa;QAhBxD,iBAAiB;QACA,kBAAa,GAAyB,YAAY,CAAC,gBAAgB,CAAC,CAAC;QACrE,eAAU,GAAkB,IAAI,CAAC,WAAW,EAAE,YAAY,IAAI,IAAI,CAAC;QAK5E,oBAAe,GAAkB,IAAI,CAAC;QAU1C,4BAA4B;QAC5B,IAAI,CAAC,OAAO,GAAG,IAAI,WAAW,CAAC;YAC3B,EAAE,EAAE,IAAI,CAAC,OAAO,EAAE,aAAa;YAC/B,OAAO,EAAE,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,4CAA2C,CAAC;SAC7E,CAAC,CAAC;QACH,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC;IAClC,CAAC;IAED,UAAU;QACN,OAAO,KAAK,IAAI,EAAE;YACd,wDAAwD;YACxD,MAAM,eAAe,GAAG,IAAI,CAAC,OAAO,EAAE,SAAS,IAAI,IAAI,CAAC;YACxD,IAAI,CAAC,eAAe,EAAE;gBAClB,OAAO,IAAI,CAAC,oBAAoB,EAAE,CAAC;aACtC;YAED,oEAAoE;YACpE,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE,EAAE;gBAC/B,OAAO;aACV;YAED,qCAAqC;YACrC,IAAI,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,EAAE;gBACxD,MAAM,IAAI,GAAG,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI,CAAC,aAAa,EAAE,IAAI,CAAC,IAAI,IAAI,CAAC;gBAChE,OAAO,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;aACrC;YAED,yCAAyC;YACzC,MAAM,KAAK,GAAG,IAAI,CAAC,EAAE,EAAE,CAAC;YACxB,MAAM,IAAI,GAAG,MAAM,cAAc,CAAC,KAAK,EAAE,EAAC,YAAY,EAAE,IAAI,EAAC,CAAC,CAAC;YAE/D,2BAA2B;YAC3B,IAAI,IAAI,CAAC,MAAM,EAAE;gBACb,IAAI,CAAC,MAAM,EAAE,GAAG,CAAM,IAAI,CAAC,aAAa,EAAE,IAAI,IAAI,IAAI,CAAC,CAAC;aAC3D;YAED,2DAA2D;YAC3D,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;YAC3B,IAAI,CAAC,oBAAoB,EAAE,CAAC;QAChC,CAAC,CAAC;IACN,CAAC;IAED,EAAE;QACE,MAAM,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;QACnC,OAAO,IAAI,CAAC,WAAW,CAAC,GAAG,CAAI,GAAG,CAAC,CAAC;IACxC,CAAC;IAED,KAAK,CAAC,MAAM,CAAC,QAAsB,EAAE,EAAa;QAC9C,MAAM,EAAC,WAAW,EAAE,YAAY,EAAE,IAAI,EAAE,GAAG,MAAM,EAAC,GAAG,MAAM,QAAQ,CAAC,YAAY,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QAEnG,6BAA6B;QAC7B,IAAI,EAAE,IAAI,CAAC,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,EAAE;YAC7C,MAAM,IAAI,KAAK,CAAC,eAAe,CAAC,CAAC;SACpC;QAED,mDAAmD;QACnD,0DAA0D;QAC1D,MAAM,WAAW,GAAG,MAAM,EAAE,QAAQ,IAAI,IAAI,CAAC;QAC7C,MAAM,cAAc,GAAG,MAAM,EAAE,WAAW,IAAI,IAAI,CAAC;QACnD,MAAM,kBAAkB,GAAG,CAAC,OAAO,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC;QACpD,IAAI,kBAAkB,CAAC,QAAQ,CAAC,WAAW,CAAC,EAAE;YAC1C,OAA2B,EAAC,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,WAAW,EAAE,cAAc,EAAC,CAAC;SACzF;QAED,6BAA6B;QAC7B,IAAI,CAAC,SAAS,CAAC,WAAW,EAAE,YAAY,CAAC,CAAC;QAE1C,2BAA2B;QAC3B,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QAE3B,mBAAmB;QACnB,OAA2B,EAAC,IAAI,EAAC,CAAC;IACtC,CAAC;IAED,KAAK,CAAC,eAAe,CAAC,KAAa,EAAE,QAAgB,EAAE,EAAa;QAChE,MAAM,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;QACtC,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,iBAAiB,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC;IACxE,CAAC;IAED,KAAK,CAAC,oBAAoB,CAAC,IAAY,EAAE,WAAmB;QACxD,MAAM,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;QACvC,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,kBAAkB,CAAC,IAAI,EAAE,WAAW,EAAE,GAAG,CAAC,CAAC,CAAC;IACvE,CAAC;IAED,KAAK,CAAC,gBAAgB,CAAC,WAAmB;QACtC,MAAM,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;QACvC,MAAM,OAAO,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,GAAG,EAAE;YACvC,YAAY,EAAE,WAAW;SAC5B,CAAC,CAAC;QAEH,OAAO,cAAc,CAAC,OAAO,CAAC,CAAC;IACnC,CAAC;IAED,KAAK,CAAC,QAAQ,CAAU,IAAS,EAAE,OAOlC;QACG,oBAAoB;QACpB,MAAM,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC;QACzC,MAAM,OAAO,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;QAC1D,MAAM,MAAM,GAAG,MAAM,cAAc,CAAC,OAAO,CAAC,CAAC;QAE7C,+BAA+B;QAC/B,MAAM,EAAC,WAAW,EAAE,YAAY,EAAE,IAAI,EAAC,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;QAE1E,6BAA6B;QAC7B,IAAI,CAAC,SAAS,CAAC,WAAW,EAAE,YAAY,CAAC,CAAC;QAE1C,2BAA2B;QAC3B,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QAE3B,mBAAmB;QACnB,OAAU,IAAI,CAAC;IACnB,CAAC;IAED,MAAM;QACF,2DAA2D;QAC3D,qDAAqD;QACrD,gCAAgC;QAChC,MAAM,YAAY,GAAG,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC;QAC/C,IAAI,CAAC,YAAY,EAAE;YACf,OAAO,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC;SAC/B;QAED,wCAAwC;QACxC,gCAAgC;QAChC,IAAI;YACA,MAAM,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;YACvC,MAAM,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,GAAG,EAAE;gBAC1C,OAAO,EAAE,EAAC,aAAa,EAAE,YAAY,EAAC;aACzC,CAAC,CAAC;YACH,cAAc,CAAC,WAAW,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;SAC5C;QAAC,MAAM;YACJ,0EAA0E;SAC7E;QAED,sCAAsC;QACtC,OAAO,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC;IAChC,CAAC;IAED,OAAO;QACH,4BAA4B;QAC5B,+CAA+C;QAC/C,MAAM,YAAY,GAAG,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC;QAC/C,IAAI,CAAC,YAAY,EAAE;YACf,OAAO,EAAE,CAAS,IAAI,CAAC,CAAC;SAC3B;QAED,4BAA4B;QAC5B,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,EAAE,MAAM,IAAI,QAAQ,CAAC;QAEhD,MAAM,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC;QACxC,MAAM,OAAO,GAAG,IAAI,WAAW,EAAE;aAC5B,GAAG,CAAC,iBAAiB,EAAE,KAAK,CAAC,CAAC;QAEnC,OAAO,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,GAAG,EAAE;YAC7B,OAAO,EAAE,EAAC,aAAa,EAAE,GAAG,MAAM,IAAI,YAAY,EAAE,EAAC;YACrD,OAAO,EAAE,OAAO;SACnB,CAAC,CAAC,IAAI,CACH,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,EACzC,GAAG,CAAC,CAAC,EAAC,WAAW,EAAE,YAAY,EAAC,EAAE,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,WAAW,EAAE,YAAY,CAAC,CAAC,EAC/E,GAAG,CAAC,CAAC,EAAC,WAAW,EAAC,EAAE,EAAE,CAAC,WAAW,CAAC,CACtC,CAAC;IACN,CAAC;IAED,KAAK,CAAC,eAAe,CAAC,KAAa,EAAE,cAAsC,EAAE;QACzE,MAAM,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;QACtC,MAAM,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,GAAG,EAAE,EAAC,GAAG,WAAW,EAAE,KAAK,EAAC,CAAC,CAAC;QACxE,OAAO,cAAc,CAAC,WAAW,CAAC,CAAC;IACvC,CAAC;IAED,KAAK,CAAC,aAAa,CAAC,KAAa,EAAE,WAAmB,EAAE,cAAsC,EAAE;QAC5F,MAAM,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,qBAAqB,CAAC,CAAC;QAC/C,MAAM,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,GAAG,EAAE,EAAC,GAAG,WAAW,EAAE,KAAK,EAAE,QAAQ,EAAE,WAAW,EAAC,CAAC,CAAC;QAC/F,OAAO,cAAc,CAAC,WAAW,CAAC,CAAC;IACvC,CAAC;IAED,KAAK,CAAC,IAAY,EAAE,WAAoB;QACpC,IAAI,MAAM,GAAW,IAAI,CAAC;QAE1B,2BAA2B;QAC3B,QAAQ,IAAI,EAAE;YACV,KAAK,eAAe;gBAChB,MAAM,GAAG,IAAI,CAAC,OAAO,EAAE,WAAW,IAAI,IAAI,CAAC;gBAC3C,MAAM;YACV,KAAK,iBAAiB;gBAClB,MAAM,GAAG,IAAI,CAAC,OAAO,EAAE,WAAW,IAAI,IAAI,CAAC;gBAC3C,MAAM;SACb;QAED,8CAA8C;QAC9C,mBAAmB;QACnB,IAAI,IAAI,KAAK,iBAAiB,EAAE;YAC5B,MAAM,uBAAuB,GAAG,IAAI,CAAC,OAAO,EAAE,uBAAuB,IAAI,IAAI,CAAC;YAC9E,IAAI,uBAAuB,IAAI,WAAW,IAAI,MAAM,EAAE;gBAClD,MAAM,IAAI,gBAAgB,WAAW,EAAE,CAAC;aAC3C;SACJ;QAED,8BAA8B;QAC9B,IAAI,IAAI,CAAC,MAAM,IAAI,MAAM,EAAE;YACvB,OAAO,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;SACvC;QAED,2CAA2C;QAC3C,OAAO,KAAK,CAAC;IACjB,CAAC;IAED,gBAAgB;QACZ,yCAAyC;QACzC,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC;QAErB,4BAA4B;QAC5B,MAAM,WAAW,GAAG,IAAI,CAAC,OAAO,EAAE,WAAW,IAAI,IAAI,CAAC;QAEtD,qDAAqD;QACrD,IAAI,IAAI,CAAC,MAAM,IAAI,WAAW,EAAE;YAC5B,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;SACpD;IACL,CAAC;IAEO,SAAS,CAAC,WAAmB,EAAE,YAAoB;QACvD,iCAAiC;QACjC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,WAAW,EAAE,YAAY,CAAC,CAAC;QAElD,2DAA2D;QAC3D,IAAI,CAAC,oBAAoB,EAAE,CAAC;IAChC,CAAC;IAEO,oBAAoB;QACxB,MAAM,iBAAiB,GAAG,IAAI,CAAC,OAAO,EAAE,WAAW,IAAI,KAAK,CAAC;QAC7D,IAAI,CAAC,iBAAiB,EAAE;YACpB,OAAO;SACV;QAED,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,mBAAmB,EAAE,SAAS,IAAI,IAAI,CAAC;QACtE,IAAI,SAAS,KAAK,IAAI,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,EAAE;YACjD,OAAO;SACV;QAED,MAAM,wBAAwB,GAAG,SAAS,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAClE,MAAM,oBAAoB,GAAG,KAAM,CAAC,CAAC,cAAc;QAEnD,6DAA6D;QAC7D,MAAM,YAAY,GAAG,wBAAwB,GAAG,oBAAoB,CAAC;QACrE,IAAI,YAAY,IAAI,CAAC,EAAE;YACnB,OAAO;SACV;QAED,wCAAwC;QACxC,wDAAwD;QACxD,MAAM,SAAS,GAAG,IAAI,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC,YAAY;QACnD,MAAM,YAAY,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,YAAY,EAAE,SAAS,CAAC,CAAC,CAAC;QACpE,IAAI;YACA,IAAI,IAAI,CAAC,eAAe,KAAK,IAAI,EAAE;gBAC/B,YAAY,EAAE,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;gBACrC,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC;aAC/B;YACD,IAAI,CAAC,eAAe,GAAG,UAAU,EAAE,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,WAAW,EAAE,EAAE,YAAY,CAAC,CAAC;SAC/E;QAAC,MAAM;YACJ,kBAAkB;SACrB;IACL,CAAC;IAEO,KAAK,CAAC,WAAW;QACrB,IAAI;YACA,0CAA0C;YAC1C,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;YAChC,MAAM,cAAc,CAAC,QAAQ,CAAC,CAAC;SAClC;QAAC,MAAM;YACJ,qDAAqD;YACrD,IAAI,CAAC,gBAAgB,EAAE,CAAC;SAC3B;IACL,CAAC;IAED,IAAY,MAAM;QACd,OAAO,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IACtC,CAAC;IAEO,MAAM,CAAC,QAAgB;QAC3B,OAAO,CAAC,IAAI,CAAC,UAAU,EAAE,QAAQ,CAAC;aAC7B,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;aACtB,IAAI,CAAC,GAAG,CAAC,CAAC;IACnB,CAAC;;iGAlTQ,IAAI;qGAAJ,IAAI;2FAAJ,IAAI;kBADhB,UAAU;;0BAiBM,QAAQ;;0BACR,QAAQ;;0BACR,QAAQ","sourcesContent":["import {HttpClient, HttpContext, HttpHeaders, HttpParams} from '@angular/common/http';\nimport {AuthProvider, AuthSignInResponse} from './interfaces/provider.interface';\nimport {makeStateKey, StateKey, TransferState} from '@angular/platform-browser';\nimport {Storage, StorageOption} from '@bravobit/bb-foundation/storage';\nimport {USE_AUTHORIZATION} from './tokens/use-authorization.token';\nimport {AuthVerifyProvider} from './providers/verify.provider';\nimport {Injectable, Injector, Optional} from '@angular/core';\nimport {AuthEmailProvider} from './providers/email.provider';\nimport {AuthConfig} from './interfaces/config.interface';\nimport {HttpConfig} from '@bravobit/bb-foundation/http';\nimport {firstValueFrom, Observable, of} from 'rxjs';\nimport {AuthMapper} from './helpers/mapper.helper';\nimport {Platform} from '@bravobit/bb-foundation';\nimport {AuthSession} from './auth.session';\nimport {map, tap} from 'rxjs/operators';\nimport {Router} from '@angular/router';\n\n@Injectable()\nexport class Auth {\n\n    // Readonly data.\n    private readonly _authStateKey: StateKey<any | null> = makeStateKey(`bbAuthStateKey`);\n    private readonly _httpAlias: string | null = this._httpConfig?.defaultAlias ?? null;\n\n    readonly session: AuthSession;\n    readonly user: Observable<any | null>;\n\n    private _refreshHandler: number | null = null;\n\n    constructor(private _storage: Storage,\n                private _mapper: AuthMapper,\n                private _injector: Injector,\n                private _platform: Platform,\n                private _httpClient: HttpClient,\n                @Optional() private _config?: AuthConfig,\n                @Optional() private _state?: TransferState,\n                @Optional() private _httpConfig?: HttpConfig) {\n        // Starting the new session.\n        this.session = new AuthSession({\n            id: this._config?.applicationId,\n            storage: this._storage.select([StorageOption.Cookie, StorageOption.Local])\n        });\n        this.user = this.session.user;\n    }\n\n    initialize() {\n        return async () => {\n            // Check if the app should bootstrap the authentication.\n            const shouldBootstrap = this._config?.bootstrap ?? true;\n            if (!shouldBootstrap) {\n                return this.handleAutoRefreshing();\n            }\n\n            // Only retrieve from the server when we are actually authenticated.\n            if (!this.session.authenticated()) {\n                return;\n            }\n\n            // Get the key from the server state.\n            if (this._state && this._state?.hasKey(this._authStateKey)) {\n                const user = this._state?.get(this._authStateKey, null) ?? null;\n                return this.session.setUser(user);\n            }\n\n            // Try to fetch the user from the server.\n            const user$ = this.me();\n            const user = await firstValueFrom(user$, {defaultValue: null});\n\n            // Set the state if exists.\n            if (this._state) {\n                this._state?.set<any>(this._authStateKey, user ?? null);\n            }\n\n            // Save the user in the storage and handle auto refreshing.\n            this.session.setUser(user);\n            this.handleAutoRefreshing();\n        };\n    }\n\n    me<T = any>() {\n        const url = this.getUrl('auth/me');\n        return this._httpClient.get<T>(url);\n    }\n\n    async signIn(provider: AuthProvider, as?: string[]) {\n        const {accessToken, refreshToken, user, ...result} = await provider.authenticate(this._httpClient);\n\n        // Check if the role matches.\n        if (as && !as.includes(this._mapper.role(user))) {\n            throw new Error('Invalid role.');\n        }\n\n        // Validate if the provider is one of the available\n        // providers then return the user object and the provider.\n        const apiProvider = result?.provider ?? null;\n        const apiVerifyToken = result?.verifyToken ?? null;\n        const availableProviders = ['email', 'sms', 'totp'];\n        if (availableProviders.includes(apiProvider)) {\n            return <AuthSignInResponse>{user, provider: apiProvider, verifyToken: apiVerifyToken};\n        }\n\n        // Set the tokens in storage.\n        this.setTokens(accessToken, refreshToken);\n\n        // Set the user in storage.\n        this.session.setUser(user);\n\n        // Return the user.\n        return <AuthSignInResponse>{user};\n    }\n\n    async signInWithEmail(email: string, password: string, as?: string[]) {\n        const url = this.getUrl('auth/login');\n        return this.signIn(new AuthEmailProvider(email, password, url), as);\n    }\n\n    async signInWithVerifyCode(code: string, verifyToken: string) {\n        const url = this.getUrl('auth/verify');\n        return this.signIn(new AuthVerifyProvider(code, verifyToken, url));\n    }\n\n    async resendVerifyCode(verifyToken: string) {\n        const url = this.getUrl('auth/resend');\n        const result$ = this._httpClient.post(url, {\n            verify_token: verifyToken\n        });\n\n        return firstValueFrom(result$);\n    }\n\n    async register<T = any>(data: any, options?: {\n        headers?: HttpHeaders | {\n            [header: string]: string | string[];\n        };\n        params?: HttpParams | {\n            [param: string]: string | number | boolean | ReadonlyArray<string | number | boolean>;\n        };\n    }) {\n        // Execute API call.\n        const url = this.getUrl('auth/register');\n        const result$ = this._httpClient.post(url, data, options);\n        const result = await firstValueFrom(result$);\n\n        // Map to the correct response.\n        const {accessToken, refreshToken, user} = this._mapper.toRegister(result);\n\n        // Set the tokens in storage.\n        this.setTokens(accessToken, refreshToken);\n\n        // Set the user in storage.\n        this.session.setUser(user);\n\n        // Return the user.\n        return <T>user;\n    }\n\n    logout() {\n        // If we don't have a refresh token just clear the session.\n        // Note: We do this because else we try to invalidate\n        // an \"undefined\" refresh token.\n        const refreshToken = this.session.refreshToken;\n        if (!refreshToken) {\n            return this.session.clear();\n        }\n\n        // We do have a refresh token, so try to\n        // invalidate it in the backend.\n        try {\n            const url = this.getUrl('auth/logout');\n            const observable$ = this._httpClient.get(url, {\n                headers: {Authorization: refreshToken}\n            });\n            firstValueFrom(observable$).then(_ => _);\n        } catch {\n            // Do nothing because the tokens will be deleted anyways from the session.\n        }\n\n        // Delete the tokens from the session.\n        return this.session.clear();\n    }\n\n    refresh() {\n        // If the refresh token does\n        // not exist just return an observable of null.\n        const refreshToken = this.session.refreshToken;\n        if (!refreshToken) {\n            return of<string>(null);\n        }\n\n        // Perform the refresh call.\n        const scheme = this._config?.scheme ?? 'Bearer';\n\n        const url = this.getUrl('auth/refresh');\n        const context = new HttpContext()\n            .set(USE_AUTHORIZATION, false);\n\n        return this._httpClient.get(url, {\n            headers: {Authorization: `${scheme} ${refreshToken}`},\n            context: context\n        }).pipe(\n            map(data => this._mapper.toRefresh(data)),\n            tap(({accessToken, refreshToken}) => this.setTokens(accessToken, refreshToken)),\n            map(({accessToken}) => accessToken)\n        );\n    }\n\n    async requestPassword(email: string, extraParams: { [key: string]: any } = {}) {\n        const url = this.getUrl('auth/reset');\n        const observable$ = this._httpClient.post(url, {...extraParams, email});\n        return firstValueFrom(observable$);\n    }\n\n    async resetPassword(token: string, newPassword: string, extraParams: { [key: string]: any } = {}) {\n        const url = this.getUrl('auth/reset-password');\n        const observable$ = this._httpClient.post(url, {...extraParams, token, password: newPassword});\n        return firstValueFrom(observable$);\n    }\n\n    guard(type: string, redirectUrl?: string) {\n        let newUrl: string = null;\n\n        // Get the correct new url.\n        switch (type) {\n            case 'authenticated':\n                newUrl = this._config?.loggedInUrl ?? null;\n                break;\n            case 'unauthenticated':\n                newUrl = this._config?.redirectUrl ?? null;\n                break;\n        }\n\n        // Append a redirect url if the user is deemed\n        // unauthenticated.\n        if (type === 'unauthenticated') {\n            const setRedirectOnFailedAuth = this._config?.setRedirectOnFailedAuth ?? true;\n            if (setRedirectOnFailedAuth && redirectUrl && newUrl) {\n                newUrl += `?redirectUrl=${redirectUrl}`;\n            }\n        }\n\n        // Parse the url if it exists.\n        if (this.router && newUrl) {\n            return this.router.parseUrl(newUrl);\n        }\n\n        // Return false if the user is not allowed.\n        return false;\n    }\n\n    clearAndRedirect() {\n        // 1. Delete the tokens from the session.\n        this.session.clear();\n\n        // 2. Compose the route url.\n        const redirectUrl = this._config?.redirectUrl ?? null;\n\n        // 3. Route back if the user provided a redirect url.\n        if (this.router && redirectUrl) {\n            this.router.navigate([redirectUrl]).then(_ => _);\n        }\n    }\n\n    private setTokens(accessToken: string, refreshToken: string) {\n        // Set the tokens in our session.\n        this.session.setTokens(accessToken, refreshToken);\n\n        // We need to update the auto refresh of the refresh token.\n        this.handleAutoRefreshing();\n    }\n\n    private handleAutoRefreshing() {\n        const shouldAutoRefresh = this._config?.autoRefresh ?? false;\n        if (!shouldAutoRefresh) {\n            return;\n        }\n\n        const expiresAt = this.session.refreshTokenPayload?.expiresAt ?? null;\n        if (expiresAt === null || !this._platform.isBrowser) {\n            return;\n        }\n\n        const differenceInMilliseconds = expiresAt.getTime() - Date.now();\n        const offsetInMilliseconds = 10_000; // 10 seconds.\n\n        // We want to start the refresh 10 seconds before it expires.\n        const actualTiming = differenceInMilliseconds - offsetInMilliseconds;\n        if (actualTiming <= 0) {\n            return;\n        }\n\n        // We need to cap the timings because if\n        // we get large numbers it might cause unwanted results.\n        const maxTiming = 1000 * 60 * 60 * 24; // 24 hours.\n        const cappedTiming = Math.max(1, Math.min(actualTiming, maxTiming));\n        try {\n            if (this._refreshHandler !== null) {\n                clearTimeout?.(this._refreshHandler);\n                this._refreshHandler = null;\n            }\n            this._refreshHandler = setTimeout?.(() => this.autoRefresh(), cappedTiming);\n        } catch {\n            // Just ignore it.\n        }\n    }\n\n    private async autoRefresh() {\n        try {\n            // We just need to wait for it to refresh.\n            const refresh$ = this.refresh();\n            await firstValueFrom(refresh$);\n        } catch {\n            // Something went wrong refreshing, we need to clear.\n            this.clearAndRedirect();\n        }\n    }\n\n    private get router() {\n        return this._injector.get(Router);\n    }\n\n    private getUrl(endpoint: string) {\n        return [this._httpAlias, endpoint]\n            .filter(item => !!item)\n            .join('/');\n    }\n\n}\n"]}
+import { HttpContext } from '@angular/common/http';
+import { makeStateKey } from '@angular/platform-browser';
+import { USE_AUTHORIZATION } from './tokens/use-authorization.token';
+import { AuthVerifyProvider } from './providers/verify.provider';
+import { Injectable, Optional } from '@angular/core';
+import { AuthEmailProvider } from './providers/email.provider';
+import { firstValueFrom, of } from 'rxjs';
+import { AuthSession } from './auth.session';
+import { map, tap } from 'rxjs/operators';
+import { Router } from '@angular/router';
+import * as i0 from "@angular/core";
+import * as i1 from "@bravobit/bb-foundation/storage";
+import * as i2 from "./helpers/mapper.helper";
+import * as i3 from "@bravobit/bb-foundation";
+import * as i4 from "@angular/common/http";
+import * as i5 from "./interfaces/config.interface";
+import * as i6 from "@angular/platform-browser";
+import * as i7 from "@bravobit/bb-foundation/http";
+export class Auth {
+    constructor(_storage, _mapper, _injector, _platform, _httpClient, _config, _state, _httpConfig) {
+        this._storage = _storage;
+        this._mapper = _mapper;
+        this._injector = _injector;
+        this._platform = _platform;
+        this._httpClient = _httpClient;
+        this._config = _config;
+        this._state = _state;
+        this._httpConfig = _httpConfig;
+        // Readonly data.
+        this._authStateKey = makeStateKey(`bbAuthStateKey`);
+        this._httpAlias = this._httpConfig?.defaultAlias ?? null;
+        this._refreshHandler = null;
+        // We select a storage strategy based on the server/browser.
+        // Only cookies CAN work on the server.
+        const storageStrategy = this._platform.isBrowser
+            ? this._storage.select(["cookie" /* Cookie */, "local" /* Local */])
+            : this._storage.cookie;
+        // Starting the new session.
+        this.session = new AuthSession({
+            id: this._config?.applicationId,
+            storage: storageStrategy
+        });
+        this.user = this.session.user;
+    }
+    initialize() {
+        return async () => {
+            // Check if the app should bootstrap the authentication.
+            const shouldBootstrap = this._config?.bootstrap ?? true;
+            if (!shouldBootstrap) {
+                return this.handleAutoRefreshing();
+            }
+            // Only retrieve from the server when we are actually authenticated.
+            if (!this.session.authenticated()) {
+                return;
+            }
+            // Get the key from the server state.
+            if (this._state && this._state?.hasKey(this._authStateKey)) {
+                const user = this._state?.get(this._authStateKey, null) ?? null;
+                return this.session.setUser(user);
+            }
+            // Try to fetch the user from the server.
+            const user$ = this.me();
+            const user = await firstValueFrom(user$, { defaultValue: null });
+            // Set the state if exists.
+            if (this._state) {
+                this._state?.set(this._authStateKey, user ?? null);
+            }
+            // Save the user in the storage and handle auto refreshing.
+            this.session.setUser(user);
+            this.handleAutoRefreshing();
+        };
+    }
+    me() {
+        const url = this.getUrl('auth/me');
+        return this._httpClient.get(url);
+    }
+    async signIn(provider, as) {
+        const { accessToken, refreshToken, user, ...result } = await provider.authenticate(this._httpClient);
+        // Check if the role matches.
+        if (as && !as.includes(this._mapper.role(user))) {
+            throw new Error('Invalid role.');
+        }
+        // Validate if the provider is one of the available
+        // providers then return the user object and the provider.
+        const apiProvider = result?.provider ?? null;
+        const apiVerifyToken = result?.verifyToken ?? null;
+        const availableProviders = ['email', 'sms', 'totp'];
+        if (availableProviders.includes(apiProvider)) {
+            return { user, provider: apiProvider, verifyToken: apiVerifyToken };
+        }
+        // Set the tokens in storage.
+        this.setTokens(accessToken, refreshToken);
+        // Set the user in storage.
+        this.session.setUser(user);
+        // Return the user.
+        return { user };
+    }
+    async signInWithEmail(email, password, as) {
+        const url = this.getUrl('auth/login');
+        return this.signIn(new AuthEmailProvider(email, password, url), as);
+    }
+    async signInWithVerifyCode(code, verifyToken) {
+        const url = this.getUrl('auth/verify');
+        return this.signIn(new AuthVerifyProvider(code, verifyToken, url));
+    }
+    async resendVerifyCode(verifyToken) {
+        const url = this.getUrl('auth/resend');
+        const result$ = this._httpClient.post(url, {
+            verify_token: verifyToken
+        });
+        return firstValueFrom(result$);
+    }
+    async register(data, options) {
+        // Execute API call.
+        const url = this.getUrl('auth/register');
+        const result$ = this._httpClient.post(url, data, options);
+        const result = await firstValueFrom(result$);
+        // Map to the correct response.
+        const { accessToken, refreshToken, user } = this._mapper.toRegister(result);
+        // Set the tokens in storage.
+        this.setTokens(accessToken, refreshToken);
+        // Set the user in storage.
+        this.session.setUser(user);
+        // Return the user.
+        return user;
+    }
+    logout() {
+        // If we don't have a refresh token just clear the session.
+        // Note: We do this because else we try to invalidate
+        // an "undefined" refresh token.
+        const refreshToken = this.session.refreshToken;
+        if (!refreshToken) {
+            return this.session.clear();
+        }
+        // We do have a refresh token, so try to
+        // invalidate it in the backend.
+        try {
+            const url = this.getUrl('auth/logout');
+            const observable$ = this._httpClient.get(url, {
+                headers: { Authorization: refreshToken }
+            });
+            firstValueFrom(observable$).then(_ => _);
+        }
+        catch {
+            // Do nothing because the tokens will be deleted anyways from the session.
+        }
+        // Delete the tokens from the session.
+        return this.session.clear();
+    }
+    refresh() {
+        // If the refresh token does
+        // not exist just return an observable of null.
+        const refreshToken = this.session.refreshToken;
+        if (!refreshToken) {
+            return of(null);
+        }
+        // Perform the refresh call.
+        const scheme = this._config?.scheme ?? 'Bearer';
+        const url = this.getUrl('auth/refresh');
+        const context = new HttpContext()
+            .set(USE_AUTHORIZATION, false);
+        return this._httpClient.get(url, {
+            headers: { Authorization: `${scheme} ${refreshToken}` },
+            context: context
+        }).pipe(map(data => this._mapper.toRefresh(data)), tap(({ accessToken, refreshToken }) => this.setTokens(accessToken, refreshToken)), map(({ accessToken }) => accessToken));
+    }
+    async requestPassword(email, extraParams = {}) {
+        const url = this.getUrl('auth/reset');
+        const observable$ = this._httpClient.post(url, { ...extraParams, email });
+        return firstValueFrom(observable$);
+    }
+    async resetPassword(token, newPassword, extraParams = {}) {
+        const url = this.getUrl('auth/reset-password');
+        const observable$ = this._httpClient.post(url, { ...extraParams, token, password: newPassword });
+        return firstValueFrom(observable$);
+    }
+    guard(type, redirectUrl) {
+        let newUrl = null;
+        // Get the correct new url.
+        switch (type) {
+            case 'authenticated':
+                newUrl = this._config?.loggedInUrl ?? null;
+                break;
+            case 'unauthenticated':
+                newUrl = this._config?.redirectUrl ?? null;
+                break;
+        }
+        // Append a redirect url if the user is deemed
+        // unauthenticated.
+        if (type === 'unauthenticated') {
+            const setRedirectOnFailedAuth = this._config?.setRedirectOnFailedAuth ?? true;
+            if (setRedirectOnFailedAuth && redirectUrl && newUrl) {
+                newUrl += `?redirectUrl=${redirectUrl}`;
+            }
+        }
+        // Parse the url if it exists.
+        if (this.router && newUrl) {
+            return this.router.parseUrl(newUrl);
+        }
+        // Return false if the user is not allowed.
+        return false;
+    }
+    clearAndRedirect() {
+        // 1. Delete the tokens from the session.
+        this.session.clear();
+        // 2. Compose the route url.
+        const redirectUrl = this._config?.redirectUrl ?? null;
+        // 3. Route back if the user provided a redirect url.
+        if (this.router && redirectUrl) {
+            this.router.navigate([redirectUrl]).then(_ => _);
+        }
+    }
+    setTokens(accessToken, refreshToken) {
+        // Set the tokens in our session.
+        this.session.setTokens(accessToken, refreshToken);
+        // We need to update the auto refresh of the refresh token.
+        this.handleAutoRefreshing();
+    }
+    handleAutoRefreshing() {
+        const shouldAutoRefresh = this._config?.autoRefresh ?? false;
+        if (!shouldAutoRefresh) {
+            return;
+        }
+        const expiresAt = this.session.refreshTokenPayload?.expiresAt ?? null;
+        if (expiresAt === null || !this._platform.isBrowser) {
+            return;
+        }
+        const differenceInMilliseconds = expiresAt.getTime() - Date.now();
+        const offsetInMilliseconds = 10000; // 10 seconds.
+        // We want to start the refresh 10 seconds before it expires.
+        const actualTiming = differenceInMilliseconds - offsetInMilliseconds;
+        if (actualTiming <= 0) {
+            return;
+        }
+        // We need to cap the timings because if
+        // we get large numbers it might cause unwanted results.
+        const maxTiming = 1000 * 60 * 60 * 24; // 24 hours.
+        const cappedTiming = Math.max(1, Math.min(actualTiming, maxTiming));
+        try {
+            if (this._refreshHandler !== null) {
+                clearTimeout?.(this._refreshHandler);
+                this._refreshHandler = null;
+            }
+            this._refreshHandler = setTimeout?.(() => this.autoRefresh(), cappedTiming);
+        }
+        catch {
+            // Just ignore it.
+        }
+    }
+    async autoRefresh() {
+        try {
+            // We just need to wait for it to refresh.
+            const refresh$ = this.refresh();
+            await firstValueFrom(refresh$);
+        }
+        catch {
+            // Something went wrong refreshing, we need to clear.
+            this.clearAndRedirect();
+        }
+    }
+    get router() {
+        return this._injector.get(Router);
+    }
+    getUrl(endpoint) {
+        return [this._httpAlias, endpoint]
+            .filter(item => !!item)
+            .join('/');
+    }
+}
+Auth.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.6", ngImport: i0, type: Auth, deps: [{ token: i1.Storage }, { token: i2.AuthMapper }, { token: i0.Injector }, { token: i3.Platform }, { token: i4.HttpClient }, { token: i5.AuthConfig, optional: true }, { token: i6.TransferState, optional: true }, { token: i7.HttpConfig, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+Auth.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.6", ngImport: i0, type: Auth });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.6", ngImport: i0, type: Auth, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.Storage }, { type: i2.AuthMapper }, { type: i0.Injector }, { type: i3.Platform }, { type: i4.HttpClient }, { type: i5.AuthConfig, decorators: [{
+                    type: Optional
+                }] }, { type: i6.TransferState, decorators: [{
+                    type: Optional
+                }] }, { type: i7.HttpConfig, decorators: [{
+                    type: Optional
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.service.js","sourceRoot":"","sources":["../../../../../projects/bb-foundation/auth/src/lib/auth.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {HttpClient, HttpContext, HttpHeaders, HttpParams} from '@angular/common/http';\r\nimport {AuthProvider, AuthSignInResponse} from './interfaces/provider.interface';\r\nimport {makeStateKey, StateKey, TransferState} from '@angular/platform-browser';\r\nimport {Storage, StorageOption} from '@bravobit/bb-foundation/storage';\r\nimport {USE_AUTHORIZATION} from './tokens/use-authorization.token';\r\nimport {AuthVerifyProvider} from './providers/verify.provider';\r\nimport {Injectable, Injector, Optional} from '@angular/core';\r\nimport {AuthEmailProvider} from './providers/email.provider';\r\nimport {AuthConfig} from './interfaces/config.interface';\r\nimport {HttpConfig} from '@bravobit/bb-foundation/http';\r\nimport {firstValueFrom, Observable, of} from 'rxjs';\r\nimport {AuthMapper} from './helpers/mapper.helper';\r\nimport {Platform} from '@bravobit/bb-foundation';\r\nimport {AuthSession} from './auth.session';\r\nimport {map, tap} from 'rxjs/operators';\r\nimport {Router} from '@angular/router';\r\n\r\n@Injectable()\r\nexport class Auth {\r\n\r\n    // Readonly data.\r\n    private readonly _authStateKey: StateKey<any | null> = makeStateKey(`bbAuthStateKey`);\r\n    private readonly _httpAlias: string | null = this._httpConfig?.defaultAlias ?? null;\r\n\r\n    readonly session: AuthSession;\r\n    readonly user: Observable<any | null>;\r\n\r\n    private _refreshHandler: number | null = null;\r\n\r\n    constructor(private _storage: Storage,\r\n                private _mapper: AuthMapper,\r\n                private _injector: Injector,\r\n                private _platform: Platform,\r\n                private _httpClient: HttpClient,\r\n                @Optional() private _config?: AuthConfig,\r\n                @Optional() private _state?: TransferState,\r\n                @Optional() private _httpConfig?: HttpConfig) {\r\n        // We select a storage strategy based on the server/browser.\r\n        // Only cookies CAN work on the server.\r\n        const storageStrategy = this._platform.isBrowser\r\n            ? this._storage.select([StorageOption.Cookie, StorageOption.Local])\r\n            : this._storage.cookie;\r\n\r\n        // Starting the new session.\r\n        this.session = new AuthSession({\r\n            id: this._config?.applicationId,\r\n            storage: storageStrategy\r\n        });\r\n        this.user = this.session.user;\r\n    }\r\n\r\n    initialize() {\r\n        return async () => {\r\n            // Check if the app should bootstrap the authentication.\r\n            const shouldBootstrap = this._config?.bootstrap ?? true;\r\n            if (!shouldBootstrap) {\r\n                return this.handleAutoRefreshing();\r\n            }\r\n\r\n            // Only retrieve from the server when we are actually authenticated.\r\n            if (!this.session.authenticated()) {\r\n                return;\r\n            }\r\n\r\n            // Get the key from the server state.\r\n            if (this._state && this._state?.hasKey(this._authStateKey)) {\r\n                const user = this._state?.get(this._authStateKey, null) ?? null;\r\n                return this.session.setUser(user);\r\n            }\r\n\r\n            // Try to fetch the user from the server.\r\n            const user$ = this.me();\r\n            const user = await firstValueFrom(user$, {defaultValue: null});\r\n\r\n            // Set the state if exists.\r\n            if (this._state) {\r\n                this._state?.set<any>(this._authStateKey, user ?? null);\r\n            }\r\n\r\n            // Save the user in the storage and handle auto refreshing.\r\n            this.session.setUser(user);\r\n            this.handleAutoRefreshing();\r\n        };\r\n    }\r\n\r\n    me<T = any>() {\r\n        const url = this.getUrl('auth/me');\r\n        return this._httpClient.get<T>(url);\r\n    }\r\n\r\n    async signIn(provider: AuthProvider, as?: string[]) {\r\n        const {accessToken, refreshToken, user, ...result} = await provider.authenticate(this._httpClient);\r\n\r\n        // Check if the role matches.\r\n        if (as && !as.includes(this._mapper.role(user))) {\r\n            throw new Error('Invalid role.');\r\n        }\r\n\r\n        // Validate if the provider is one of the available\r\n        // providers then return the user object and the provider.\r\n        const apiProvider = result?.provider ?? null;\r\n        const apiVerifyToken = result?.verifyToken ?? null;\r\n        const availableProviders = ['email', 'sms', 'totp'];\r\n        if (availableProviders.includes(apiProvider)) {\r\n            return <AuthSignInResponse>{user, provider: apiProvider, verifyToken: apiVerifyToken};\r\n        }\r\n\r\n        // Set the tokens in storage.\r\n        this.setTokens(accessToken, refreshToken);\r\n\r\n        // Set the user in storage.\r\n        this.session.setUser(user);\r\n\r\n        // Return the user.\r\n        return <AuthSignInResponse>{user};\r\n    }\r\n\r\n    async signInWithEmail(email: string, password: string, as?: string[]) {\r\n        const url = this.getUrl('auth/login');\r\n        return this.signIn(new AuthEmailProvider(email, password, url), as);\r\n    }\r\n\r\n    async signInWithVerifyCode(code: string, verifyToken: string) {\r\n        const url = this.getUrl('auth/verify');\r\n        return this.signIn(new AuthVerifyProvider(code, verifyToken, url));\r\n    }\r\n\r\n    async resendVerifyCode(verifyToken: string) {\r\n        const url = this.getUrl('auth/resend');\r\n        const result$ = this._httpClient.post(url, {\r\n            verify_token: verifyToken\r\n        });\r\n\r\n        return firstValueFrom(result$);\r\n    }\r\n\r\n    async register<T = any>(data: any, options?: {\r\n        headers?: HttpHeaders | {\r\n            [header: string]: string | string[];\r\n        };\r\n        params?: HttpParams | {\r\n            [param: string]: string | number | boolean | ReadonlyArray<string | number | boolean>;\r\n        };\r\n    }) {\r\n        // Execute API call.\r\n        const url = this.getUrl('auth/register');\r\n        const result$ = this._httpClient.post(url, data, options);\r\n        const result = await firstValueFrom(result$);\r\n\r\n        // Map to the correct response.\r\n        const {accessToken, refreshToken, user} = this._mapper.toRegister(result);\r\n\r\n        // Set the tokens in storage.\r\n        this.setTokens(accessToken, refreshToken);\r\n\r\n        // Set the user in storage.\r\n        this.session.setUser(user);\r\n\r\n        // Return the user.\r\n        return <T>user;\r\n    }\r\n\r\n    logout() {\r\n        // If we don't have a refresh token just clear the session.\r\n        // Note: We do this because else we try to invalidate\r\n        // an \"undefined\" refresh token.\r\n        const refreshToken = this.session.refreshToken;\r\n        if (!refreshToken) {\r\n            return this.session.clear();\r\n        }\r\n\r\n        // We do have a refresh token, so try to\r\n        // invalidate it in the backend.\r\n        try {\r\n            const url = this.getUrl('auth/logout');\r\n            const observable$ = this._httpClient.get(url, {\r\n                headers: {Authorization: refreshToken}\r\n            });\r\n            firstValueFrom(observable$).then(_ => _);\r\n        } catch {\r\n            // Do nothing because the tokens will be deleted anyways from the session.\r\n        }\r\n\r\n        // Delete the tokens from the session.\r\n        return this.session.clear();\r\n    }\r\n\r\n    refresh() {\r\n        // If the refresh token does\r\n        // not exist just return an observable of null.\r\n        const refreshToken = this.session.refreshToken;\r\n        if (!refreshToken) {\r\n            return of(null);\r\n        }\r\n\r\n        // Perform the refresh call.\r\n        const scheme = this._config?.scheme ?? 'Bearer';\r\n\r\n        const url = this.getUrl('auth/refresh');\r\n        const context = new HttpContext()\r\n            .set(USE_AUTHORIZATION, false);\r\n\r\n        return this._httpClient.get(url, {\r\n            headers: {Authorization: `${scheme} ${refreshToken}`},\r\n            context: context\r\n        }).pipe(\r\n            map(data => this._mapper.toRefresh(data)),\r\n            tap(({accessToken, refreshToken}) => this.setTokens(accessToken, refreshToken)),\r\n            map(({accessToken}) => accessToken)\r\n        );\r\n    }\r\n\r\n    async requestPassword(email: string, extraParams: { [key: string]: any } = {}) {\r\n        const url = this.getUrl('auth/reset');\r\n        const observable$ = this._httpClient.post(url, {...extraParams, email});\r\n        return firstValueFrom(observable$);\r\n    }\r\n\r\n    async resetPassword(token: string, newPassword: string, extraParams: { [key: string]: any } = {}) {\r\n        const url = this.getUrl('auth/reset-password');\r\n        const observable$ = this._httpClient.post(url, {...extraParams, token, password: newPassword});\r\n        return firstValueFrom(observable$);\r\n    }\r\n\r\n    guard(type: string, redirectUrl?: string) {\r\n        let newUrl: string = null;\r\n\r\n        // Get the correct new url.\r\n        switch (type) {\r\n            case 'authenticated':\r\n                newUrl = this._config?.loggedInUrl ?? null;\r\n                break;\r\n            case 'unauthenticated':\r\n                newUrl = this._config?.redirectUrl ?? null;\r\n                break;\r\n        }\r\n\r\n        // Append a redirect url if the user is deemed\r\n        // unauthenticated.\r\n        if (type === 'unauthenticated') {\r\n            const setRedirectOnFailedAuth = this._config?.setRedirectOnFailedAuth ?? true;\r\n            if (setRedirectOnFailedAuth && redirectUrl && newUrl) {\r\n                newUrl += `?redirectUrl=${redirectUrl}`;\r\n            }\r\n        }\r\n\r\n        // Parse the url if it exists.\r\n        if (this.router && newUrl) {\r\n            return this.router.parseUrl(newUrl);\r\n        }\r\n\r\n        // Return false if the user is not allowed.\r\n        return false;\r\n    }\r\n\r\n    clearAndRedirect() {\r\n        // 1. Delete the tokens from the session.\r\n        this.session.clear();\r\n\r\n        // 2. Compose the route url.\r\n        const redirectUrl = this._config?.redirectUrl ?? null;\r\n\r\n        // 3. Route back if the user provided a redirect url.\r\n        if (this.router && redirectUrl) {\r\n            this.router.navigate([redirectUrl]).then(_ => _);\r\n        }\r\n    }\r\n\r\n    private setTokens(accessToken: string, refreshToken: string) {\r\n        // Set the tokens in our session.\r\n        this.session.setTokens(accessToken, refreshToken);\r\n\r\n        // We need to update the auto refresh of the refresh token.\r\n        this.handleAutoRefreshing();\r\n    }\r\n\r\n    private handleAutoRefreshing() {\r\n        const shouldAutoRefresh = this._config?.autoRefresh ?? false;\r\n        if (!shouldAutoRefresh) {\r\n            return;\r\n        }\r\n\r\n        const expiresAt = this.session.refreshTokenPayload?.expiresAt ?? null;\r\n        if (expiresAt === null || !this._platform.isBrowser) {\r\n            return;\r\n        }\r\n\r\n        const differenceInMilliseconds = expiresAt.getTime() - Date.now();\r\n        const offsetInMilliseconds = 10_000; // 10 seconds.\r\n\r\n        // We want to start the refresh 10 seconds before it expires.\r\n        const actualTiming = differenceInMilliseconds - offsetInMilliseconds;\r\n        if (actualTiming <= 0) {\r\n            return;\r\n        }\r\n\r\n        // We need to cap the timings because if\r\n        // we get large numbers it might cause unwanted results.\r\n        const maxTiming = 1000 * 60 * 60 * 24; // 24 hours.\r\n        const cappedTiming = Math.max(1, Math.min(actualTiming, maxTiming));\r\n        try {\r\n            if (this._refreshHandler !== null) {\r\n                clearTimeout?.(this._refreshHandler);\r\n                this._refreshHandler = null;\r\n            }\r\n            this._refreshHandler = setTimeout?.(() => this.autoRefresh(), cappedTiming);\r\n        } catch {\r\n            // Just ignore it.\r\n        }\r\n    }\r\n\r\n    private async autoRefresh() {\r\n        try {\r\n            // We just need to wait for it to refresh.\r\n            const refresh$ = this.refresh();\r\n            await firstValueFrom(refresh$);\r\n        } catch {\r\n            // Something went wrong refreshing, we need to clear.\r\n            this.clearAndRedirect();\r\n        }\r\n    }\r\n\r\n    private get router() {\r\n        return this._injector.get(Router);\r\n    }\r\n\r\n    private getUrl(endpoint: string) {\r\n        return [this._httpAlias, endpoint]\r\n            .filter(item => !!item)\r\n            .join('/');\r\n    }\r\n\r\n}\r\n"]}