@fusionauth/angular-sdk 1.0.1 → 1.1.0

package/fesm2022/fusionauth-angular-sdk.mjs

@@ -1,57 +1,45 @@
-import { BehaviorSubject, Observable, catchError } from 'rxjs';
 import * as i0 from '@angular/core';
-import { Component, Input, NgModule } from '@angular/core';
+import { InjectionToken, PLATFORM_ID, Injectable, Inject, Component, Input, NgModule } from '@angular/core';
+import { isPlatformBrowser } from '@angular/common';
+import { BehaviorSubject, Observable, catchError } from 'rxjs';
 
-// @ts-nocheck
-const u = Object.defineProperty;
-const d = (r, e, t) => e in r
-    ? u(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t })
-    : (r[e] = t);
-const i = (r, e, t) => (d(r, typeof e != 'symbol' ? e + '' : e, t), t);
-class g {
-    constructor(e) {
-        i(this, 'serverUrl');
-        i(this, 'clientId');
-        i(this, 'redirectUri');
-        i(this, 'scope');
-        i(this, 'mePath');
-        i(this, 'loginPath');
-        i(this, 'registerPath');
-        i(this, 'logoutPath');
-        i(this, 'tokenRefreshPath');
-        (this.serverUrl = e.serverUrl),
-            (this.clientId = e.clientId),
-            (this.redirectUri = e.redirectUri),
-            (this.scope = e.scope),
-            (this.mePath = e.mePath ?? '/app/me'),
-            (this.loginPath = e.loginPath ?? '/app/login'),
-            (this.registerPath = e.registerPath ?? '/app/register'),
-            (this.logoutPath = e.logoutPath ?? '/app/logout'),
-            (this.tokenRefreshPath = e.tokenRefreshPath ?? '/app/refresh');
+/** A class responsible for generating URLs that FusionAuth SDKs interact with. */
+class UrlHelper {
+    constructor(config) {
+        this.serverUrl = config.serverUrl;
+        this.clientId = config.clientId;
+        this.redirectUri = config.redirectUri;
+        this.scope = config.scope;
+        this.postLogoutRedirectUri = config.postLogoutRedirectUri;
+        this.mePath = config.mePath ?? '/app/me';
+        this.loginPath = config.loginPath ?? '/app/login';
+        this.registerPath = config.registerPath ?? '/app/register';
+        this.logoutPath = config.logoutPath ?? '/app/logout';
+        this.tokenRefreshPath = config.tokenRefreshPath ?? '/app/refresh';
     }
     getMeUrl() {
         return this.generateUrl(this.mePath);
     }
-    getLoginUrl(e) {
+    getLoginUrl(state) {
         return this.generateUrl(this.loginPath, {
             client_id: this.clientId,
             redirect_uri: this.redirectUri,
             scope: this.scope,
-            state: e,
+            state,
         });
     }
-    getRegisterUrl(e) {
+    getRegisterUrl(state) {
         return this.generateUrl(this.registerPath, {
             client_id: this.clientId,
             redirect_uri: this.redirectUri,
             scope: this.scope,
-            state: e,
+            state,
         });
     }
     getLogoutUrl() {
         return this.generateUrl(this.logoutPath, {
             client_id: this.clientId,
-            post_logout_redirect_uri: this.redirectUri,
+            post_logout_redirect_uri: this.postLogoutRedirectUri || this.redirectUri,
         });
     }
     getTokenRefreshUrl() {
@@ -59,199 +47,264 @@ class g {
             client_id: this.clientId,
         });
     }
-    generateUrl(e, t) {
-        const s = new URL(this.serverUrl);
-        if (((s.pathname = e), t)) {
-            const n = this.generateURLSearchParams(t);
-            s.search = n.toString();
+    generateUrl(path, params) {
+        const url = new URL(this.serverUrl);
+        url.pathname = path;
+        if (params) {
+            const urlSearchParams = this.generateURLSearchParams(params);
+            url.search = urlSearchParams.toString();
         }
-        return s;
-    }
-    generateURLSearchParams(e) {
-        const t = new URLSearchParams();
-        return (Object.entries(e).forEach(([s, n]) => {
-            n && t.append(s, n);
-        }),
-            t);
-    }
-}
-class o {
-    /**
-     * Parses document.cookie for the access token expiration cookie value.
-     * @returns {(number | null)} The moment of expiration in milliseconds since epoch.
-     */
-    static getAccessTokenExpirationMoment(e = 'app.at_exp') {
-        const t = document.cookie
-            .split('; ')
-            .map(n => n.split('='))
-            .find(([n]) => n === e), s = t == null ? void 0 : t[1];
-        return s ? parseInt(s) * 1e3 : null;
-    }
-}
-class p {
-    constructor(e) {
-        i(this, 'url');
-        this.url = e;
+        return url;
     }
-    /** Refresh token a single time */
-    async refreshToken() {
-        const e = await fetch(this.url.href, {
-            method: 'POST',
-            credentials: 'include',
-            headers: {
-                'Content-Type': 'text/plain',
-            },
-        });
-        if (!(e.status >= 200 && e.status < 300))
-            throw new Error('error refreshing access token in fusionauth');
-    }
-    /** Initializes continuous automatic token refresh. */
-    initAutoRefresh(e = 10, t) {
-        const s = o.getAccessTokenExpirationMoment(t);
-        if (!s)
-            return;
-        const n = e * 1e3, a = /* @__PURE__ */ new Date().getTime(), h = s - n, c = Math.max(h - a, 0);
-        return setTimeout(async () => {
-            try {
-                await this.refreshToken(), this.initAutoRefresh(e);
-            }
-            catch (l) {
-                console.error(l);
+    generateURLSearchParams(params) {
+        const urlSearchParams = new URLSearchParams();
+        Object.entries(params).forEach(([key, value]) => {
+            if (value) {
+                urlSearchParams.append(key, value);
             }
-        }, c);
-    }
-}
-class m {
-    /**
-     * Schedules a callback to be invoked at the given moment.
-     * @param expirationMoment - the access token expiration moment in milliseconds since the epoch.
-     * @param onExpiration - the callback to be invoked at the `expirationMoment`.
-     */
-    static scheduleTokenExpirationCallback(e, t) {
-        const s = /* @__PURE__ */ new Date().getTime(), n = e - s;
-        n > 0 && setTimeout(t, n);
+        });
+        return urlSearchParams;
     }
 }
-class R {
+
+/** A class responsible for storing a redirect value in localStorage and cleanup afterward. */
+class RedirectHelper {
     constructor() {
-        i(this, 'REDIRECT_VALUE', 'fa-sdk-redirect-value');
+        this.REDIRECT_VALUE = 'fa-sdk-redirect-value';
     }
-    handlePreRedirect(e) {
-        const t = `${this.generateRandomString()}:${e ?? ''}`;
-        localStorage.setItem(this.REDIRECT_VALUE, t);
+    get storage() {
+        try {
+            return localStorage;
+        }
+        catch {
+            // fallback for non-browser environments where localStorage is not defined.
+            return {
+                /* eslint-disable */
+                setItem(_key, _value) { },
+                getItem(_key) { },
+                removeItem(_key) { },
+                /* eslint-enable */
+            };
+        }
+    }
+    handlePreRedirect(state) {
+        const valueForStorage = `${this.generateRandomString()}:${state ?? ''}`;
+        this.storage.setItem(this.REDIRECT_VALUE, valueForStorage);
     }
-    handlePostRedirect(e) {
-        const t = this.stateValue ?? void 0;
-        e == null || e(t), localStorage.removeItem(this.REDIRECT_VALUE);
+    handlePostRedirect(callback) {
+        const stateValue = this.stateValue ?? undefined;
+        callback?.(stateValue);
+        this.storage.removeItem(this.REDIRECT_VALUE);
     }
     get didRedirect() {
-        return !!localStorage.getItem(this.REDIRECT_VALUE);
+        return Boolean(this.storage.getItem(this.REDIRECT_VALUE));
     }
     get stateValue() {
-        const e = localStorage.getItem(this.REDIRECT_VALUE);
-        if (!e)
+        const redirectValue = this.storage.getItem(this.REDIRECT_VALUE);
+        if (!redirectValue) {
             return null;
-        const [, ...t] = e.split(':');
-        return t.join(':');
+        }
+        const [, ...stateValue] = redirectValue.split(':');
+        return stateValue.join(':');
     }
     generateRandomString() {
-        const e = new Uint32Array(28);
-        return (window.crypto.getRandomValues(e),
-            Array.from(e, t => ('0' + t.toString(16)).substring(-2)).join(''));
+        const array = new Uint32Array(56 / 2);
+        window.crypto.getRandomValues(array);
+        return Array.from(array, (n) => ('0' + n.toString(16)).substring(-2)).join('');
     }
 }
-class T {
-    constructor(e) {
-        i(this, 'config');
-        i(this, 'urlHelper');
-        i(this, 'tokenRefresher');
-        i(this, 'redirectHelper', new R());
-        (this.config = e),
-            (this.urlHelper = new g({
-                serverUrl: e.serverUrl,
-                clientId: e.clientId,
-                redirectUri: e.redirectUri,
-                scope: e.scope,
-                mePath: e.mePath,
-                loginPath: e.loginPath,
-                registerPath: e.registerPath,
-                logoutPath: e.logoutPath,
-                tokenRefreshPath: e.tokenRefreshPath,
-            })),
-            (this.tokenRefresher = new p(this.urlHelper.getTokenRefreshUrl())),
-            this.scheduleTokenExpirationEvent();
-    }
-    startLogin(e) {
-        this.redirectHelper.handlePreRedirect(e),
-            window.location.assign(this.urlHelper.getLoginUrl(e));
-    }
-    startRegister(e) {
-        this.redirectHelper.handlePreRedirect(e),
-            window.location.assign(this.urlHelper.getRegisterUrl(e));
+
+/**
+ * Gets the `app.at_exp` cookie and converts it to milliseconds since epoch.
+ * Returns -1 if the cookie is not present.
+ * @param cookieName - defaults to `app.at_exp`.
+ * @param adapter - SSR frameworks like Nuxt, Next, and angular/ssr will pass in an adapter.
+ */
+function getAccessTokenExpirationMoment(cookieName = 'app.at_exp', adapter) {
+    if (adapter) {
+        return toMilliseconds(adapter.at_exp(cookieName));
+    }
+    let cookie;
+    try {
+        // `document` throws a ReferenceError if this runs in a
+        // non-browser environment such as an SSR framework like Nuxt or Next.
+        cookie = document.cookie;
+    }
+    catch {
+        console.error('Error accessing cookies in fusionauth. If you are using SSR you must configure the SDK with a cookie adapter');
+        return -1;
+    }
+    const expCookie = cookie
+        .split('; ')
+        .map(c => c.split('='))
+        .find(([name]) => name === cookieName);
+    const cookieValue = expCookie?.[1];
+    return toMilliseconds(cookieValue);
+}
+function toMilliseconds(seconds) {
+    if (!seconds)
+        return -1;
+    else
+        return Number(seconds) * 1000;
+}
+
+/** A class containing framework-agnostic SDK methods */
+class SDKCore {
+    constructor(config) {
+        this.redirectHelper = new RedirectHelper();
+        this.config = config;
+        this.urlHelper = new UrlHelper({
+            serverUrl: config.serverUrl,
+            clientId: config.clientId,
+            redirectUri: config.redirectUri,
+            scope: config.scope,
+            mePath: config.mePath,
+            loginPath: config.loginPath,
+            registerPath: config.registerPath,
+            logoutPath: config.logoutPath,
+            tokenRefreshPath: config.tokenRefreshPath,
+            postLogoutRedirectUri: config.postLogoutRedirectUri,
+        });
+        this.scheduleTokenExpiration();
+    }
+    startLogin(state) {
+        this.redirectHelper.handlePreRedirect(state);
+        window.location.assign(this.urlHelper.getLoginUrl(state));
+    }
+    startRegister(state) {
+        this.redirectHelper.handlePreRedirect(state);
+        window.location.assign(this.urlHelper.getRegisterUrl(state));
     }
     startLogout() {
         window.location.assign(this.urlHelper.getLogoutUrl());
     }
     async fetchUserInfo() {
-        const e = await fetch(this.urlHelper.getMeUrl(), {
+        const userInfoResponse = await fetch(this.urlHelper.getMeUrl(), {
             credentials: 'include',
         });
-        if (!e.ok)
-            throw new Error(`Unable to fetch userInfo in fusionauth. Request failed with status code ${e == null ? void 0 : e.status}`);
-        return await e.json();
+        if (!userInfoResponse.ok) {
+            throw new Error(`Unable to fetch userInfo in fusionauth. Request failed with status code ${userInfoResponse?.status}`);
+        }
+        const userInfo = await userInfoResponse.json();
+        return userInfo;
     }
     async refreshToken() {
-        return await this.tokenRefresher.refreshToken();
+        const response = await fetch(this.urlHelper.getTokenRefreshUrl(), {
+            method: 'POST',
+            credentials: 'include',
+            headers: {
+                'Content-Type': 'text/plain',
+            },
+        });
+        if (!(response.status >= 200 && response.status < 300)) {
+            const message = (await response?.text()) ||
+                'Error refreshing access token in fusionauth';
+            throw new Error(message);
+        }
+        // a successful request means that app_exp was bumped into the future.
+        // reschedule the access token expiration event.
+        this.scheduleTokenExpiration();
+        return response;
     }
     initAutoRefresh() {
-        return this.tokenRefresher.initAutoRefresh(this.config.autoRefreshSecondsBeforeExpiry, this.config.accessTokenExpireCookieName);
+        if (!this.isLoggedIn) {
+            return;
+        }
+        const secondsBeforeRefresh = this.config.autoRefreshSecondsBeforeExpiry ?? 10;
+        const millisecondsBeforeRefresh = secondsBeforeRefresh * 1000;
+        const now = new Date().getTime();
+        const refreshTime = this.at_exp - millisecondsBeforeRefresh;
+        const timeTillRefresh = Math.max(refreshTime - now, 0);
+        return setTimeout(async () => {
+            try {
+                await this.refreshToken();
+                this.initAutoRefresh();
+            }
+            catch (error) {
+                this.config.onAutoRefreshFailure?.(error);
+            }
+        }, timeTillRefresh);
     }
-    handlePostRedirect(e) {
-        this.isLoggedIn &&
-            this.redirectHelper.didRedirect &&
-            this.redirectHelper.handlePostRedirect(e);
+    handlePostRedirect(callback) {
+        if (this.isLoggedIn && this.redirectHelper.didRedirect) {
+            this.redirectHelper.handlePostRedirect(callback);
+        }
     }
     get isLoggedIn() {
-        return this.accessTokenExpirationMoment
-            ? this.accessTokenExpirationMoment > /* @__PURE__ */ new Date().getTime()
-            : !1;
-    }
-    get accessTokenExpirationMoment() {
-        return o.getAccessTokenExpirationMoment(this.config.accessTokenExpireCookieName);
-    }
-    scheduleTokenExpirationEvent() {
-        this.accessTokenExpirationMoment &&
-            this.config.onTokenExpiration &&
-            m.scheduleTokenExpirationCallback(this.accessTokenExpirationMoment, this.config.onTokenExpiration);
+        return this.at_exp > new Date().getTime();
+    }
+    /** The moment of access token expiration in milliseconds since epoch. */
+    get at_exp() {
+        return getAccessTokenExpirationMoment(this.config.accessTokenExpireCookieName, this.config.cookieAdapter);
+    }
+    /** Schedules `onTokenExpiration` at moment of access token expiration. */
+    scheduleTokenExpiration() {
+        clearTimeout(this.tokenExpirationTimeout);
+        const now = new Date().getTime();
+        const millisecondsTillExpiration = this.at_exp - now;
+        if (millisecondsTillExpiration > 0) {
+            this.tokenExpirationTimeout = setTimeout(this.config.onTokenExpiration, millisecondsTillExpiration);
+        }
     }
 }
-function U() {
-    const r = /* @__PURE__ */ new Date();
-    r.setHours(r.getHours() + 1);
-    const e = r.getTime() / 1e3;
-    document.cookie = `app.at_exp=${e}`;
+
+/** Sets `app.at_exp` moment cookie so the user will be logged in for 1 hour. */
+function mockIsLoggedIn() {
+    const expirationMoment = new Date();
+    expirationMoment.setHours(expirationMoment.getHours() + 1);
+    const oneHourInTheFutureInMilliseconds = expirationMoment.getTime() / 1000;
+    document.cookie = `app.at_exp=${oneHourInTheFutureInMilliseconds}`;
 }
-function P() {
-    document.cookie = 'app.at_exp=;expires=Thu, 01 Jan 1970 00:00:00 GMT';
+/** Removes the `app.at_exp` cookie. */
+function removeAt_expCookie() {
+    document.cookie = 'app.at_exp' + '=;expires=Thu, 01 Jan 1970 00:00:00 GMT';
 }
-function E(r) {
-    const e = {
+
+function mockWindowLocation(vi) {
+    const mockedLocation = {
         ...window.location,
-        assign: r.fn(),
+        assign: vi.fn(),
     };
-    return r.spyOn(window, 'location', 'get').mockReturnValue(e), e;
+    vi.spyOn(window, 'location', 'get').mockReturnValue(mockedLocation);
+    return mockedLocation;
+}
+
+/** An adapter class that supports accessing cookies with SSR */
+class SSRCookieAdapter {
+    constructor(isBrowser) {
+        this.isBrowser = isBrowser;
+    }
+    at_exp(cookieName = 'app.at_exp') {
+        if (!this.isBrowser) {
+            return;
+        }
+        try {
+            const expCookie = document.cookie
+                .split('; ')
+                .map(c => c.split('='))
+                .find(([name]) => name === cookieName);
+            return expCookie?.[1];
+        }
+        catch (error) {
+            console.error('Error within the SSRCookieAdapter: ', error);
+            return -1;
+        }
+    }
 }
 
+const FUSIONAUTH_SERVICE_CONFIG = new InjectionToken('FUSIONAUTH_SERVICE_CONFIG');
+
 /**
  * Service class to use with FusionAuth backend endpoints.
  */
 class FusionAuthService {
-    constructor(config) {
-        this.core = new T({
+    constructor(config, platformId) {
+        this.core = new SDKCore({
             ...config,
             onTokenExpiration: () => {
                 this.isLoggedInSubject.next(false);
             },
+            cookieAdapter: new SSRCookieAdapter(isPlatformBrowser(platformId)),
         });
         this.isLoggedInSubject = new BehaviorSubject(this.core.isLoggedIn);
         this.isLoggedIn$ = this.isLoggedInSubject.asObservable();
@@ -329,7 +382,21 @@ class FusionAuthService {
     logout() {
         this.core.startLogout();
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.1", ngImport: i0, type: FusionAuthService, deps: [{ token: FUSIONAUTH_SERVICE_CONFIG }, { token: PLATFORM_ID }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.1", ngImport: i0, type: FusionAuthService, providedIn: 'root' }); }
 }
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.1", ngImport: i0, type: FusionAuthService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [FUSIONAUTH_SERVICE_CONFIG]
+                }] }, { type: Object, decorators: [{
+                    type: Inject,
+                    args: [PLATFORM_ID]
+                }] }] });
 
 class FusionAuthLoginButtonComponent {
     constructor(fusionAuth) {
@@ -385,10 +452,8 @@ class FusionAuthModule {
         return {
             ngModule: FusionAuthModule,
             providers: [
-                {
-                    provide: FusionAuthService,
-                    useValue: new FusionAuthService(fusionAuthConfig),
-                },
+                { provide: FUSIONAUTH_SERVICE_CONFIG, useValue: fusionAuthConfig },
+                FusionAuthService,
             ],
         };
     }