@frontegg/nextjs 6.7.8 → 6.7.9-alpha.3757258005

package/index.js

@@ -0,0 +1,1168 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var router = require('next/router');
+var React = require('react');
+var reactHooks = require('@frontegg/react-hooks');
+var restApi = require('@frontegg/rest-api');
+var js = require('@frontegg/js');
+var reduxStore = require('@frontegg/redux-store');
+var jose = require('jose');
+var cookie = require('cookie');
+var ironSession = require('iron-session');
+var url = require('url');
+var httpProxy = require('http-proxy');
+var types = require('@frontegg/types');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
+var cookie__default = /*#__PURE__*/_interopDefaultLegacy(cookie);
+var httpProxy__default = /*#__PURE__*/_interopDefaultLegacy(httpProxy);
+
+var AppContext = React.createContext(null);
+
+var createOrGetFronteggApp = function (_a) {
+    var _b, _c, _d, _e, _f, _g, _h, _j, _k;
+    var options = _a.options, onRedirectTo = _a.onRedirectTo, appName = _a.appName, user = _a.user, tenants = _a.tenants, storeHolder = _a.storeHolder;
+    var _l = (_b = options.session) !== null && _b !== void 0 ? _b : {}, accessToken = _l.accessToken, refreshToken = _l.refreshToken;
+    var contextOptions = tslib.__assign(tslib.__assign({ requestCredentials: 'include' }, options.contextOptions), { baseUrl: function (path) {
+            if (restApi.fronteggAuthApiRoutes.indexOf(path) !== -1 ||
+                path.endsWith('/postlogin') ||
+                path.endsWith('/prelogin') ||
+                path === '/oauth/token') {
+                return options.envAppUrl + "/api";
+            }
+            else {
+                return options.envBaseUrl;
+            }
+        }, clientId: options.envClientId });
+    var tenantsState = tenants
+        ? tslib.__assign({ tenantTree: null, subTenants: [], tenants: tenants, loading: false }, (_c = options.authOptions) === null || _c === void 0 ? void 0 : _c.tenantsState) : undefined;
+    var userData = user
+        ? tslib.__assign(tslib.__assign(tslib.__assign({}, user), { accessToken: accessToken !== null && accessToken !== void 0 ? accessToken : '', refreshToken: refreshToken !== null && refreshToken !== void 0 ? refreshToken : undefined }), (_d = options.authOptions) === null || _d === void 0 ? void 0 : _d.user) : null;
+    var authOptions = tslib.__assign(tslib.__assign({}, options.authOptions), { onRedirectTo: onRedirectTo, isLoading: false, isAuthenticated: !!options.session, hostedLoginBox: (_e = options.hostedLoginBox) !== null && _e !== void 0 ? _e : false, disableSilentRefresh: (_g = (_f = options.authOptions) === null || _f === void 0 ? void 0 : _f.disableSilentRefresh) !== null && _g !== void 0 ? _g : false, user: userData, tenantsState: tenantsState });
+    var sharedStore = reduxStore.createFronteggStore({ context: contextOptions }, storeHolder.current, options.previewMode, authOptions, {
+        auth: authOptions !== null && authOptions !== void 0 ? authOptions : {},
+        audits: (_h = options.auditsOptions) !== null && _h !== void 0 ? _h : {},
+    }, false, options.urlStrategy);
+    var createdApp;
+    try {
+        createdApp = js.AppHolder.getInstance(appName !== null && appName !== void 0 ? appName : 'default');
+        createdApp.store = sharedStore;
+    }
+    catch (e) {
+        createdApp = js.initialize(tslib.__assign(tslib.__assign({}, options), { store: sharedStore, hostedLoginBox: (_j = options.hostedLoginBox) !== null && _j !== void 0 ? _j : false, customLoginBox: (_k = options.customLoginBox) !== null && _k !== void 0 ? _k : false, basename: options.basename, authOptions: authOptions,
+            contextOptions: contextOptions,
+            onRedirectTo: onRedirectTo }), appName !== null && appName !== void 0 ? appName : 'default');
+    }
+    return createdApp;
+};
+
+var ExpireInListener = function () {
+    var user = reactHooks.useAuthUserOrNull();
+    var actions = reactHooks.useAuthActions();
+    React.useEffect(function () {
+        if (user && (user === null || user === void 0 ? void 0 : user.expiresIn) == null) {
+            actions.setUser(tslib.__assign(tslib.__assign({}, user), { expiresIn: Math.floor((user['exp'] * 1000 - Date.now()) / 1000) }));
+        }
+    }, [actions, user]);
+    // eslint-disable-next-line react/jsx-no-useless-fragment
+    return React__default["default"].createElement(React__default["default"].Fragment, null);
+};
+
+var useRequestAuthorizeSSR = function (_a) {
+    var app = _a.app, accessToken = _a.accessToken, user = _a.user, tenants = _a.tenants, refreshToken = _a.refreshToken;
+    React.useEffect(function () {
+        app === null || app === void 0 ? void 0 : app.store.dispatch({
+            type: 'auth/requestAuthorizeSSR',
+            payload: {
+                accessToken: accessToken,
+                user: user ? tslib.__assign(tslib.__assign({}, user), { refreshToken: refreshToken }) : null,
+                tenants: tenants,
+            },
+        });
+    }, [app]);
+};
+
+var Connector$1 = function (_a) {
+    var _b, _c;
+    var router = _a.router, _d = _a.appName, appName = _d === void 0 ? 'default' : _d, user = _a.user, tenants = _a.tenants, props = tslib.__rest(_a, ["router", "appName", "user", "tenants"]);
+    var isSSR = typeof window === 'undefined';
+    var _e = (_b = props.session) !== null && _b !== void 0 ? _b : {}, accessToken = _e.accessToken, refreshToken = _e.refreshToken;
+    var baseName = (_c = props.basename) !== null && _c !== void 0 ? _c : '';
+    var storeHolder = React.useRef({});
+    var onRedirectTo = React.useCallback(function (_path, opts) {
+        var path = _path;
+        if (path.startsWith(baseName)) {
+            path = path.substring(baseName.length);
+        }
+        if (opts === null || opts === void 0 ? void 0 : opts.preserveQueryParams) {
+            path = "" + path + window.location.search;
+        }
+        if ((opts === null || opts === void 0 ? void 0 : opts.refresh) && !isSSR) {
+            // @ts-ignore
+            window.Cypress ? router.push(path) : (window.location.href = path);
+        }
+        else {
+            (opts === null || opts === void 0 ? void 0 : opts.replace) ? router.replace(path) : router.push(path);
+        }
+    }, []);
+    var app = React.useMemo(function () {
+        return createOrGetFronteggApp({
+            options: tslib.__assign(tslib.__assign({}, props), { basename: baseName }),
+            user: user,
+            tenants: tenants,
+            onRedirectTo: onRedirectTo,
+            appName: appName,
+            storeHolder: storeHolder,
+        });
+    }, [props]);
+    restApi.ContextHolder.setOnRedirectTo(onRedirectTo);
+    useRequestAuthorizeSSR({ app: app, accessToken: accessToken, user: user, tenants: tenants, refreshToken: refreshToken });
+    return (React__default["default"].createElement(AppContext.Provider, { value: app },
+        React__default["default"].createElement(reactHooks.FronteggStoreProvider, tslib.__assign({}, tslib.__assign(tslib.__assign({}, props), { app: app })), props.children)));
+};
+var FronteggBaseProvider = function (props) {
+    return (React__default["default"].createElement(Connector$1, tslib.__assign({}, props, { framework: 'nextjs' }),
+        React__default["default"].createElement(ExpireInListener, null),
+        props.children));
+};
+
+var FronteggProvider = function (_a) {
+    var children = _a.children, basename = _a.basename, props = tslib.__rest(_a, ["children", "basename"]);
+    var router$1 = router.useRouter();
+    var baseName = basename !== null && basename !== void 0 ? basename : router$1.basePath;
+    return (React__default["default"].createElement(FronteggBaseProvider, tslib.__assign({ router: router$1, basename: baseName }, props), children));
+};
+
+var Connector = function (_props) {
+    var _a;
+    var router = _props.router, appName = _props.appName, hostedLoginBox = _props.hostedLoginBox; _props.customLoginBox; var props = tslib.__rest(_props, ["router", "appName", "hostedLoginBox", "customLoginBox"]);
+    var isSSR = typeof window === 'undefined';
+    var baseName = (_a = props.basename) !== null && _a !== void 0 ? _a : router.basePath;
+    var onRedirectTo = React.useCallback(function (_path, opts) {
+        var path = _path;
+        if (path.startsWith(baseName)) {
+            path = path.substring(baseName.length);
+        }
+        if (opts === null || opts === void 0 ? void 0 : opts.preserveQueryParams) {
+            path = "" + path + window.location.search;
+        }
+        if ((opts === null || opts === void 0 ? void 0 : opts.refresh) && !isSSR) {
+            // @ts-ignore
+            window.Cypress ? router.push(path) : (window.location.href = path);
+        }
+        else {
+            (opts === null || opts === void 0 ? void 0 : opts.replace) ? router.replace(path) : router.push(path);
+        }
+    }, []);
+    var app = React.useMemo(function () {
+        var _a;
+        var createdApp;
+        try {
+            createdApp = js.AppHolder.getInstance(appName !== null && appName !== void 0 ? appName : 'default');
+        }
+        catch (e) {
+            createdApp = js.initialize(tslib.__assign(tslib.__assign({}, props), { hostedLoginBox: hostedLoginBox !== null && hostedLoginBox !== void 0 ? hostedLoginBox : false, basename: (_a = props.basename) !== null && _a !== void 0 ? _a : baseName, authOptions: tslib.__assign(tslib.__assign({}, props.authOptions), { onRedirectTo: onRedirectTo }), contextOptions: tslib.__assign({ requestCredentials: 'include' }, props.contextOptions), onRedirectTo: onRedirectTo }), appName !== null && appName !== void 0 ? appName : 'default');
+        }
+        return createdApp;
+    }, [appName, props, hostedLoginBox, baseName, onRedirectTo]);
+    restApi.ContextHolder.setOnRedirectTo(onRedirectTo);
+    React.useEffect(function () {
+        app.store.dispatch({ type: 'auth/requestAuthorize', payload: true });
+    }, [app]);
+    return (React__default["default"].createElement(AppContext.Provider, { value: app },
+        React__default["default"].createElement(reactHooks.FronteggStoreProvider, tslib.__assign({}, tslib.__assign(tslib.__assign({}, props), { app: app })), props.children)));
+};
+var FronteggNextJSProvider = function (props) {
+    var router$1 = router.useRouter();
+    return (React__default["default"].createElement(Connector, tslib.__assign({}, props, { router: router$1 }),
+        React__default["default"].createElement(ExpireInListener, null),
+        props.children));
+};
+var FronteggProviderNoSSR = function (props) {
+    return (React__default["default"].createElement(FronteggNextJSProvider, tslib.__assign({}, props, { framework: 'nextjs' }), props.children));
+};
+
+var AuthorizedContent = function (props) {
+    var _a, _b;
+    var isAuthorized = true; // Initially
+    var user = reactHooks.useAuthUserOrNull();
+    if (!(user === null || user === void 0 ? void 0 : user.superUser)) {
+        if (props.requiredPermissions) {
+            if (!(user === null || user === void 0 ? void 0 : user.permissions) || (user === null || user === void 0 ? void 0 : user.permissions.length) === 0) {
+                isAuthorized = false;
+            }
+            var _loop_1 = function (permission) {
+                if (!((_a = user === null || user === void 0 ? void 0 : user.permissions) === null || _a === void 0 ? void 0 : _a.find(function (_a) {
+                    var key = _a.key;
+                    return key === permission;
+                }))) {
+                    isAuthorized = false;
+                }
+            };
+            for (var _i = 0, _c = props.requiredPermissions; _i < _c.length; _i++) {
+                var permission = _c[_i];
+                _loop_1(permission);
+            }
+        }
+        if (props.requiredRoles) {
+            if (!(user === null || user === void 0 ? void 0 : user.roles) || (user === null || user === void 0 ? void 0 : user.roles.length) === 0) {
+                isAuthorized = false;
+            }
+            var _loop_2 = function (role) {
+                if (!((_b = user === null || user === void 0 ? void 0 : user.roles) === null || _b === void 0 ? void 0 : _b.find(function (_a) {
+                    var key = _a.key;
+                    return key === role;
+                }))) {
+                    isAuthorized = false;
+                }
+            };
+            for (var _d = 0, _e = props.requiredRoles; _d < _e.length; _d++) {
+                var role = _e[_d];
+                _loop_2(role);
+            }
+        }
+    }
+    if (typeof props.render === 'function') {
+        return React__default["default"].createElement(React__default["default"].Fragment, null, props.render(isAuthorized));
+    }
+    return isAuthorized ? React__default["default"].createElement(React__default["default"].Fragment, null, props.children) : null;
+};
+
+function normalizeStringPasswordToMap(password) {
+    return typeof password === 'string' ? { 1: password } : password;
+}
+var FronteggConfig = /** @class */ (function () {
+    function FronteggConfig() {
+        var _a, _b, _c;
+        this.authRoutes = {};
+        this.fronteggAppOptions = {};
+        this._clientId = (_a = process.env['FRONTEGG_CLIENT_ID']) !== null && _a !== void 0 ? _a : '';
+        this._cookieName = (_b = process.env['FRONTEGG_COOKIE_NAME']) !== null && _b !== void 0 ? _b : "fe_next_session";
+        this._password = (_c = process.env['FRONTEGG_ENCRYPTION_PASSWORD']) !== null && _c !== void 0 ? _c : '';
+        this._passwordsAsMap = normalizeStringPasswordToMap(this._password);
+    }
+    Object.defineProperty(FronteggConfig.prototype, "cookieName", {
+        get: function () {
+            return this._cookieName + "-" + this._clientId.replace(/-/g, '');
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FronteggConfig.prototype, "password", {
+        get: function () {
+            return this._password;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FronteggConfig.prototype, "clientId", {
+        get: function () {
+            return this._clientId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FronteggConfig.prototype, "baseUrlHost", {
+        get: function () {
+            var _a;
+            return new URL((_a = process.env['FRONTEGG_BASE_URL']) !== null && _a !== void 0 ? _a : '').hostname;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    FronteggConfig.prototype.getEnvAppUrl = function () {
+        var url = undefined;
+        if (process.env['FRONTEGG_APP_URL']) {
+            url = process.env['FRONTEGG_APP_URL'];
+        }
+        else if (process.env['VERCEL'] && process.env['VERCEL_URL']) {
+            url = process.env['VERCEL_URL'];
+        }
+        if (url && !url.startsWith('http')) {
+            var protocol = url.startsWith('localhost') ? 'http://' : 'https://';
+            url = "" + protocol + url;
+        }
+        return url;
+    };
+    Object.defineProperty(FronteggConfig.prototype, "appUrl", {
+        get: function () {
+            var _a;
+            return (_a = this.getEnvAppUrl()) !== null && _a !== void 0 ? _a : 'http://localhost:3000';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FronteggConfig.prototype, "appEnvConfig", {
+        get: function () {
+            return {
+                envAppUrl: this.getEnvAppUrl(),
+                envBaseUrl: process.env['FRONTEGG_BASE_URL'],
+                envClientId: process.env['FRONTEGG_CLIENT_ID'],
+            };
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FronteggConfig.prototype, "cookieDomain", {
+        get: function () {
+            var _a;
+            return new URL((_a = this.getEnvAppUrl()) !== null && _a !== void 0 ? _a : '').hostname.replace(/:(\d)+$/, '');
+        },
+        enumerable: false,
+        configurable: true
+    });
+    FronteggConfig.prototype.getJwtPublicKey = function () {
+        return tslib.__awaiter(this, void 0, void 0, function () {
+            var response, data, publicKey, _a;
+            return tslib.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!!this._jwtPublicKey) return [3 /*break*/, 4];
+                        return [4 /*yield*/, fetch(process.env['FRONTEGG_BASE_URL'] + "/.well-known/jwks.json")];
+                    case 1:
+                        response = _b.sent();
+                        return [4 /*yield*/, response.json()];
+                    case 2:
+                        data = _b.sent();
+                        publicKey = data.keys.find(function (key) { return key.kty === 'RSA'; });
+                        _a = this;
+                        return [4 /*yield*/, jose.importJWK(publicKey)];
+                    case 3:
+                        _a._jwtPublicKey = _b.sent();
+                        _b.label = 4;
+                    case 4: return [2 /*return*/, this._jwtPublicKey];
+                }
+            });
+        });
+    };
+    Object.defineProperty(FronteggConfig.prototype, "passwordsAsMap", {
+        get: function () {
+            return this._passwordsAsMap;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return FronteggConfig;
+}());
+var fronteggConfig = new FronteggConfig();
+
+var BASE_URL = process.env['FRONTEGG_BASE_URL'] + "/frontegg";
+var Get = function (_a) {
+    var url = _a.url, _b = _a.credentials, credentials = _b === void 0 ? 'include' : _b, headers = _a.headers;
+    return fetch(url, { method: 'GET', credentials: credentials, headers: headers });
+};
+var extractHeaders = function (headers) { return ({
+    'accept-encoding': headers['accept-encoding'],
+    'accept-language': headers['accept-language'],
+    cookie: headers['cookie'],
+    accept: headers['accept'],
+    'user-agent': headers['user-agent'],
+    // connection: headers['connection'],
+    'cache-control': headers['cache-control'],
+    Authorization: headers['Authorization'],
+}); };
+var parseResponse = function (res) { return tslib.__awaiter(void 0, void 0, void 0, function () {
+    var resText;
+    return tslib.__generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (!res.ok) {
+                    return [2 /*return*/, undefined];
+                }
+                return [4 /*yield*/, res.text()];
+            case 1:
+                resText = _a.sent();
+                return [2 /*return*/, JSON.parse(resText)];
+        }
+    });
+}); };
+var getUsers = function (headers) { return tslib.__awaiter(void 0, void 0, void 0, function () {
+    var res;
+    return tslib.__generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, Get({ url: "" + BASE_URL + restApi.fronteggUsersUrl, headers: extractHeaders(headers) })];
+            case 1:
+                res = _a.sent();
+                return [2 /*return*/, parseResponse(res)];
+        }
+    });
+}); };
+var getTenants = function (headers) { return tslib.__awaiter(void 0, void 0, void 0, function () {
+    var res;
+    return tslib.__generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, Get({ url: "" + BASE_URL + restApi.fronteggTenantsUrl, headers: extractHeaders(headers) })];
+            case 1:
+                res = _a.sent();
+                return [2 /*return*/, parseResponse(res)];
+        }
+    });
+}); };
+
+function getMeAndTenants(reqHeaders, accessToken) {
+    return tslib.__awaiter(this, void 0, void 0, function () {
+        var headers, _a, user, tenants;
+        return tslib.__generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    if (!reqHeaders || !accessToken) {
+                        return [2 /*return*/, {}];
+                    }
+                    headers = tslib.__assign(tslib.__assign({}, reqHeaders), { Authorization: "Bearer " + accessToken });
+                    return [4 /*yield*/, Promise.all([getUsers(headers), getTenants(headers)])];
+                case 1:
+                    _a = _b.sent(), user = _a[0], tenants = _a[1];
+                    return [2 /*return*/, { user: user, tenants: tenants }];
+            }
+        });
+    });
+}
+
+function rewriteCookieProperty(header, config, property) {
+    if (Array.isArray(header)) {
+        return header.map(function (headerElement) {
+            return rewriteCookieProperty(headerElement, config, property);
+        });
+    }
+    return header.replace(new RegExp('(;\\s*' + property + '=)([^;]+)', 'i'), function (match, prefix, previousValue) {
+        var newValue;
+        if (previousValue in config) {
+            newValue = config[previousValue];
+        }
+        else if ('*' in config) {
+            newValue = config['*'];
+        }
+        else {
+            // no match, return previous value
+            return match;
+        }
+        if (newValue) {
+            // replace value
+            return prefix + newValue;
+        }
+        else {
+            // remove value
+            return '';
+        }
+    });
+}
+var COOKIE_MAX_LENGTH = 4096;
+function createCookie(_a) {
+    var _b = _a.cookieName, cookieName = _b === void 0 ? fronteggConfig.cookieName : _b, session = _a.session, expires = _a.expires, isSecured = _a.isSecured, _c = _a.cookieDomain, cookieDomain = _c === void 0 ? fronteggConfig.cookieDomain : _c, _d = _a.httpOnly, httpOnly = _d === void 0 ? true : _d, _e = _a.path, path = _e === void 0 ? '/' : _e;
+    var options = {
+        expires: expires,
+        httpOnly: httpOnly,
+        domain: cookieDomain,
+        path: path,
+        sameSite: isSecured ? 'none' : undefined,
+        secure: isSecured,
+    };
+    var cookieValue = cookie__default["default"].serialize(cookieName, session, options);
+    if (cookieValue.length < COOKIE_MAX_LENGTH) {
+        return [cookieValue];
+    }
+    return createSplitCookie(cookieName, session, options, cookieValue.length);
+}
+function createSplitCookie(cookieName, session, options, cookieLength) {
+    var numberOfCookies = Math.ceil(cookieLength / COOKIE_MAX_LENGTH);
+    var splitSession = chunkString(session, numberOfCookies);
+    var allCookies = [];
+    for (var i = 1; i <= numberOfCookies; i++) {
+        allCookies.push(cookie__default["default"].serialize(cookieName + "-" + i, splitSession[i - 1], options));
+    }
+    return allCookies;
+}
+function chunkString(str, numChunks) {
+    var chunkSize = Math.ceil(str.length / numChunks);
+    var chunks = [];
+    for (var i = 0; i < numChunks; i + chunkSize) {
+        var limit = i + chunkSize;
+        chunks.push(str.substring(i, limit < str.length ? limit : str.length));
+    }
+    return chunks;
+}
+function parseCookieFromArray(cookies) {
+    var userCookie = cookies.find(function (c) { return c.name === fronteggConfig.cookieName; });
+    if (userCookie) {
+        return userCookie.value;
+    }
+    var cookieChunks = cookies.filter(function (c) { return c.name.includes(fronteggConfig.cookieName); });
+    if (!cookieChunks) {
+        return undefined;
+    }
+    cookieChunks.sort(function (a, b) { return (parseInt(a.name) > parseInt(b.name) ? 1 : -1); });
+    return cookieChunks.map(function (c) { return c.value; }).join();
+}
+function addToCookies(newCookies, res) {
+    var _a;
+    var existingSetCookie = (_a = res.getHeader('set-cookie')) !== null && _a !== void 0 ? _a : [];
+    if (typeof existingSetCookie === 'string') {
+        existingSetCookie = [existingSetCookie];
+    }
+    res.setHeader('set-cookie', tslib.__spreadArrays(existingSetCookie, newCookies));
+}
+function removeCookies(cookieName, isSecured, cookieDomain, res) {
+    var _a;
+    var cookieValue = createCookie({ cookieName: cookieName, session: '', expires: new Date(), isSecured: isSecured, cookieDomain: cookieDomain });
+    var existingSetCookie = (_a = res.getHeader('set-cookie')) !== null && _a !== void 0 ? _a : [];
+    if (typeof existingSetCookie === 'string') {
+        existingSetCookie = [existingSetCookie];
+    }
+    res.setHeader('set-cookie', tslib.__spreadArrays(existingSetCookie, cookieValue));
+}
+function createSessionFromAccessToken(output) {
+    var _a, _b;
+    return tslib.__awaiter(this, void 0, void 0, function () {
+        var data, accessToken, refreshToken, publicKey, decodedJwt, stringifySession, session;
+        return tslib.__generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    _c.trys.push([0, 4, , 5]);
+                    data = JSON.parse(output);
+                    accessToken = (_a = data === null || data === void 0 ? void 0 : data.accessToken) !== null && _a !== void 0 ? _a : data.access_token;
+                    refreshToken = (_b = data === null || data === void 0 ? void 0 : data.refreshToken) !== null && _b !== void 0 ? _b : data.refresh_token;
+                    return [4 /*yield*/, fronteggConfig.getJwtPublicKey()];
+                case 1:
+                    publicKey = _c.sent();
+                    return [4 /*yield*/, jose.jwtVerify(accessToken, publicKey)];
+                case 2:
+                    decodedJwt = (_c.sent()).payload;
+                    decodedJwt.expiresIn = Math.floor((decodedJwt.exp * 1000 - Date.now()) / 1000);
+                    stringifySession = JSON.stringify({ accessToken: accessToken, refreshToken: refreshToken });
+                    return [4 /*yield*/, ironSession.sealData(stringifySession, {
+                            password: fronteggConfig.passwordsAsMap,
+                            ttl: decodedJwt.exp,
+                        })];
+                case 3:
+                    session = _c.sent();
+                    return [2 /*return*/, [session, decodedJwt, refreshToken]];
+                case 4:
+                    _c.sent();
+                    return [2 /*return*/, []];
+                case 5: return [2 /*return*/];
+            }
+        });
+    });
+}
+var modifySetCookieIfUnsecure = function (setCookieValue, isSecured) {
+    if (!setCookieValue) {
+        return setCookieValue;
+    }
+    if (setCookieValue.length > 0) {
+        return setCookieValue.map(function (c) {
+            var cookie = c.split('; ');
+            if (isSecured) {
+                return c;
+            }
+            return cookie.filter(function (property) { return property !== 'Secure' && property !== 'SameSite=None'; }).join('; ');
+        });
+    }
+    return setCookieValue;
+};
+function getTokensFromCookie(cookie) {
+    return tslib.__awaiter(this, void 0, void 0, function () {
+        var stringifyJwt;
+        return tslib.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!cookie) {
+                        return [2 /*return*/, undefined];
+                    }
+                    return [4 /*yield*/, ironSession.unsealData(cookie, {
+                            password: fronteggConfig.passwordsAsMap,
+                        })];
+                case 1:
+                    stringifyJwt = _a.sent();
+                    return [2 /*return*/, JSON.parse(stringifyJwt)];
+            }
+        });
+    });
+}
+
+function parseCookie(cookieStr) {
+    var sealFromCookies = '';
+    if (cookie__default["default"].parse(cookieStr)[fronteggConfig.cookieName]) {
+        sealFromCookies = cookie__default["default"].parse(cookieStr)[fronteggConfig.cookieName];
+    }
+    else {
+        var i = 1;
+        while (cookie__default["default"].parse(cookieStr)[fronteggConfig.cookieName + "-" + i]) {
+            sealFromCookies += cookie__default["default"].parse(cookieStr)[fronteggConfig.cookieName + "-" + i];
+            i++;
+        }
+    }
+    return sealFromCookies !== '' ? sealFromCookies : undefined;
+}
+
+var createGetSession = function (_a) {
+    var getCookie = _a.getCookie, cookieResolver = _a.cookieResolver;
+    return tslib.__awaiter(void 0, void 0, void 0, function () {
+        var cookie, tokens, accessToken, refreshToken, publicKey, payload, session, e_1;
+        return tslib.__generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _b.trys.push([0, 4, , 5]);
+                    cookie = getCookie();
+                    if (!cookie) {
+                        return [2 /*return*/, undefined];
+                    }
+                    return [4 /*yield*/, cookieResolver(cookie)];
+                case 1:
+                    tokens = _b.sent();
+                    if (!(tokens === null || tokens === void 0 ? void 0 : tokens.accessToken)) {
+                        return [2 /*return*/, undefined];
+                    }
+                    accessToken = tokens.accessToken, refreshToken = tokens.refreshToken;
+                    return [4 /*yield*/, fronteggConfig.getJwtPublicKey()];
+                case 2:
+                    publicKey = _b.sent();
+                    return [4 /*yield*/, jose.jwtVerify(accessToken, publicKey)];
+                case 3:
+                    payload = (_b.sent()).payload;
+                    session = {
+                        accessToken: accessToken,
+                        user: payload,
+                        refreshToken: refreshToken,
+                    };
+                    if (session.user.exp * 1000 < Date.now()) {
+                        return [2 /*return*/, undefined];
+                    }
+                    return [2 /*return*/, session];
+                case 4:
+                    e_1 = _b.sent();
+                    console.error(e_1);
+                    return [2 /*return*/, undefined];
+                case 5: return [2 /*return*/];
+            }
+        });
+    });
+};
+
+function getCookieFromRequest(req) {
+    if (!req) {
+        return undefined;
+    }
+    var cookieStr = 'credentials' in req ? req.headers.get('cookie') || '' : req.headers.cookie || '';
+    return parseCookie(cookieStr);
+}
+
+var envError = function (varName) { return "@frontegg/nextjs: .env.local must contain " + varName; };
+var fronteggErrors = {
+    envAppUrl: envError('FRONTEGG_APP_URL'),
+    envBaseUrl: envError('FRONTEGG_BASE_URL'),
+    envClientId: envError('FRONTEGG_CLIENT_ID'),
+};
+
+function FronteggRouter() {
+    var app = React.useContext(AppContext);
+    var _a = router.useRouter(), query = _a.query, replace = _a.replace;
+    var loginWithRedirect = reactHooks.useLoginWithRedirect();
+    var logout = reactHooks.useLoginActions().logout;
+    React.useEffect(function () {
+        if (!app) {
+            return;
+        }
+        if (app.options.hostedLoginBox) {
+            var routesObj = tslib.__assign(tslib.__assign({}, reduxStore.authInitialState.routes), fronteggConfig.authRoutes);
+            var _a = query, pathArr = _a["frontegg-router"], queryParams = tslib.__rest(_a, ['frontegg-router']);
+            var pathname = "/" + pathArr.join('/');
+            if (pathname === routesObj.loginUrl) {
+                if (queryParams.redirectUrl) {
+                    localStorage.setItem('FRONTEGG_AFTER_AUTH_REDIRECT_URL', "" + window.location.origin + queryParams.redirectUrl);
+                }
+                loginWithRedirect();
+            }
+            else if (pathname === routesObj.logoutUrl) {
+                var _baseUrl = app.options.contextOptions.baseUrl;
+                var baseUrl_1 = typeof _baseUrl === 'string' ? _baseUrl : _baseUrl('');
+                logout(function () {
+                    window.location.href = baseUrl_1 + "/oauth/logout?post_logout_redirect_uri=" + encodeURIComponent(window.location.origin);
+                });
+            }
+        }
+    }, [app, query, loginWithRedirect, logout, replace]);
+    return '';
+}
+function FronteggRouterProps(context) {
+    var _a;
+    var routesObj = tslib.__assign(tslib.__assign({}, reduxStore.authInitialState.routes), fronteggConfig.authRoutes);
+    var routesArr = Object.keys(routesObj).reduce(function (p, key) { return tslib.__spreadArrays(p, [routesObj[key]]); }, []);
+    var pathname = url.parse((_a = context.resolvedUrl) !== null && _a !== void 0 ? _a : context.req.url, true).pathname;
+    if (!pathname || pathname.startsWith('/_next/data')) {
+        var query = context.req.query[Object.keys(context.req.query)[0]];
+        pathname = "/" + (Array.isArray(query) ? query.join('/') : query);
+    }
+    var notFound = routesArr.indexOf(pathname) === -1;
+    if (fronteggConfig.fronteggAppOptions.hostedLoginBox) {
+        var notFound_1 = !(routesObj.loginUrl === pathname ||
+            routesObj.logoutUrl === pathname ||
+            routesObj.hostedLoginRedirectUrl === pathname);
+        return { notFound: notFound_1, props: {} };
+    }
+    return {
+        notFound: notFound,
+        props: {},
+    };
+}
+
+var getSession = function (req) {
+    return createGetSession({ getCookie: function () { return getCookieFromRequest(req); }, cookieResolver: getTokensFromCookie });
+};
+function withSSRSession(handler) {
+    var _this = this;
+    return function (context) { return tslib.__awaiter(_this, void 0, void 0, function () {
+        var session, loginUrl;
+        var _a, _b;
+        return tslib.__generator(this, function (_c) {
+            switch (_c.label) {
+                case 0: return [4 /*yield*/, getSession(context.req)];
+                case 1:
+                    session = _c.sent();
+                    if (session) {
+                        return [2 /*return*/, handler(context, session)];
+                    }
+                    else {
+                        loginUrl = (_a = fronteggConfig.authRoutes.loginUrl) !== null && _a !== void 0 ? _a : reduxStore.authInitialState.routes.loginUrl;
+                        if (!loginUrl.startsWith('/')) {
+                            loginUrl = "/" + loginUrl;
+                        }
+                        return [2 /*return*/, {
+                                redirect: {
+                                    permanent: false,
+                                    destination: loginUrl + "?redirectUrl=" + encodeURIComponent((_b = context.resolvedUrl) !== null && _b !== void 0 ? _b : context.req.url),
+                                },
+                                props: {},
+                            }];
+                    }
+            }
+        });
+    }); };
+}
+
+function refreshTokenHostedLogin(ctx, headers) {
+    return tslib.__awaiter(this, void 0, void 0, function () {
+        var sealFromCookies, tokens;
+        return tslib.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 3, , 4]);
+                    sealFromCookies = getCookieFromRequest(ctx === null || ctx === void 0 ? void 0 : ctx.req);
+                    return [4 /*yield*/, getTokensFromCookie(sealFromCookies)];
+                case 1:
+                    tokens = _a.sent();
+                    if (!(tokens === null || tokens === void 0 ? void 0 : tokens.refreshToken)) {
+                        return [2 /*return*/, null];
+                    }
+                    return [4 /*yield*/, fetch(process.env['FRONTEGG_BASE_URL'] + "/frontegg" + restApi.fronteggSilentRefreshTokenUrl, {
+                            method: 'POST',
+                            credentials: 'include',
+                            body: JSON.stringify({
+                                grant_type: 'refresh_token',
+                                refresh_token: tokens.refreshToken,
+                            }),
+                            headers: {
+                                'accept-encoding': headers['accept-encoding'],
+                                'accept-language': headers['accept-language'],
+                                cookie: headers['cookie'],
+                                accept: headers['accept'],
+                                'user-agent': headers['user-agent'],
+                                connection: headers['connection'],
+                                'cache-control': headers['cache-control'],
+                            },
+                        })];
+                case 2: return [2 /*return*/, _a.sent()];
+                case 3:
+                    _a.sent();
+                    return [2 /*return*/, null];
+                case 4: return [2 /*return*/];
+            }
+        });
+    });
+}
+function refreshTokenEmbedded(ctx, headers, cookies) {
+    return tslib.__awaiter(this, void 0, void 0, function () {
+        var refreshTokenKey, cookieKey;
+        return tslib.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    refreshTokenKey = ("fe_refresh_" + fronteggConfig.clientId).replace(/-/g, '');
+                    cookieKey = Object.keys(cookies).find(function (cookie) {
+                        return cookie.replace(/-/g, '') === refreshTokenKey;
+                    });
+                    if (!cookieKey) {
+                        // ctx.res?.setHeader('set-cookie', removedCookies);
+                        // remove all fe_nextjs-session cookies
+                        return [2 /*return*/, null];
+                    }
+                    return [4 /*yield*/, fetch(process.env['FRONTEGG_BASE_URL'] + "/frontegg" + restApi.fronteggRefreshTokenUrl, {
+                            method: 'POST',
+                            credentials: 'include',
+                            body: '{}',
+                            headers: {
+                                'accept-encoding': headers['accept-encoding'],
+                                'accept-language': headers['accept-language'],
+                                cookie: headers['cookie'],
+                                accept: headers['accept'],
+                                'user-agent': headers['user-agent'],
+                                connection: headers['connection'],
+                                'cache-control': headers['cache-control'],
+                            },
+                        })];
+                case 1: return [2 /*return*/, _a.sent()];
+            }
+        });
+    });
+}
+function refreshToken(ctx) {
+    var _a;
+    return tslib.__awaiter(this, void 0, void 0, function () {
+        var request, session, isSecured, headers, cookies, response, data, rewriteCookieDomainConfig, cookieHeader, newSetCookie, _b, session, decodedJwt, refreshToken_1, cookieValue;
+        var _c;
+        return tslib.__generator(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    _d.trys.push([0, 13, , 14]);
+                    request = ctx.req;
+                    if (!request) {
+                        return [2 /*return*/, null];
+                    }
+                    _d.label = 1;
+                case 1:
+                    _d.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, getSession(ctx.req)];
+                case 2:
+                    session = _d.sent();
+                    if (session) {
+                        return [2 /*return*/, session];
+                    }
+                    return [3 /*break*/, 4];
+                case 3:
+                    _d.sent();
+                    return [3 /*break*/, 4];
+                case 4:
+                    isSecured = new URL(fronteggConfig.appUrl).protocol === 'https:';
+                    headers = request.headers;
+                    cookies = request.cookies;
+                    if (ctx.req.url.startsWith('/oauth/callback')) {
+                        return [2 /*return*/, null];
+                    }
+                    response = void 0;
+                    if (!fronteggConfig.fronteggAppOptions.hostedLoginBox) return [3 /*break*/, 6];
+                    return [4 /*yield*/, refreshTokenHostedLogin(ctx, headers)];
+                case 5:
+                    response = _d.sent();
+                    return [3 /*break*/, 8];
+                case 6: return [4 /*yield*/, refreshTokenEmbedded(ctx, headers, cookies)];
+                case 7:
+                    response = _d.sent();
+                    _d.label = 8;
+                case 8:
+                    if (!response) {
+                        removeCookies(fronteggConfig.cookieName, isSecured, fronteggConfig.cookieDomain, ctx.res);
+                        return [2 /*return*/, null];
+                    }
+                    if (!response.ok) return [3 /*break*/, 11];
+                    return [4 /*yield*/, response.text()];
+                case 9:
+                    data = _d.sent();
+                    rewriteCookieDomainConfig = (_c = {},
+                        _c[fronteggConfig.baseUrlHost] = fronteggConfig.cookieDomain,
+                        _c);
+                    cookieHeader = response.headers.raw()['set-cookie'];
+                    newSetCookie = rewriteCookieProperty(cookieHeader, rewriteCookieDomainConfig, 'domain');
+                    return [4 /*yield*/, createSessionFromAccessToken(data)];
+                case 10:
+                    _b = _d.sent(), session = _b[0], decodedJwt = _b[1], refreshToken_1 = _b[2];
+                    if (!session) {
+                        return [2 /*return*/, null];
+                    }
+                    cookieValue = createCookie({ session: session, expires: new Date(decodedJwt.exp * 1000), isSecured: isSecured });
+                    if (typeof newSetCookie === 'string') {
+                        newSetCookie = [newSetCookie];
+                    }
+                    newSetCookie.push.apply(newSetCookie, cookieValue);
+                    (_a = ctx.res) === null || _a === void 0 ? void 0 : _a.setHeader('set-cookie', newSetCookie);
+                    return [2 /*return*/, {
+                            accessToken: JSON.parse(data).accessToken,
+                            user: decodedJwt,
+                            refreshToken: refreshToken_1,
+                        }];
+                case 11: 
+                // remove all fe_nextjs-session cookies
+                // ctx.res?.setHeader('set-cookie', removedCookies);
+                return [2 /*return*/, null];
+                case 12: return [3 /*break*/, 14];
+                case 13:
+                    _d.sent();
+                    return [2 /*return*/, null];
+                case 14: return [2 /*return*/];
+            }
+        });
+    });
+}
+
+var withFronteggApp = function (app, options) {
+    var _a, _b;
+    var originalGetInitialProps = app.getInitialProps;
+    app.getInitialProps = function (appContext) { return tslib.__awaiter(void 0, void 0, void 0, function () {
+        var ctx, Component, session, _a, user, tenants, _b, envAppUrl, envBaseUrl, envClientId, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+        var _o;
+        return tslib.__generator(this, function (_p) {
+            switch (_p.label) {
+                case 0:
+                    ctx = appContext.ctx, Component = appContext.Component;
+                    if (!ctx.req) return [3 /*break*/, 9];
+                    return [4 /*yield*/, refreshToken(ctx)];
+                case 1:
+                    session = _p.sent();
+                    return [4 /*yield*/, getMeAndTenants((_o = ctx.req) === null || _o === void 0 ? void 0 : _o.headers, session === null || session === void 0 ? void 0 : session.accessToken)];
+                case 2:
+                    _a = _p.sent(), user = _a.user, tenants = _a.tenants;
+                    appContext.session = session;
+                    appContext.user = user;
+                    appContext.tenants = tenants;
+                    _b = fronteggConfig.appEnvConfig, envAppUrl = _b.envAppUrl, envBaseUrl = _b.envBaseUrl, envClientId = _b.envClientId;
+                    if (!envAppUrl) {
+                        throw Error(fronteggErrors.envAppUrl);
+                    }
+                    if (!envBaseUrl) {
+                        throw Error(fronteggErrors.envBaseUrl);
+                    }
+                    if (!envClientId) {
+                        throw Error(fronteggErrors.envClientId);
+                    }
+                    _c = {};
+                    _d = [{}];
+                    if (!originalGetInitialProps) return [3 /*break*/, 4];
+                    return [4 /*yield*/, originalGetInitialProps(appContext)];
+                case 3:
+                    _e = _p.sent();
+                    return [3 /*break*/, 5];
+                case 4:
+                    _e = {};
+                    _p.label = 5;
+                case 5:
+                    _f = [tslib.__assign.apply(void 0, _d.concat([(_e)]))];
+                    if (!Component.getInitialProps) return [3 /*break*/, 7];
+                    return [4 /*yield*/, Component.getInitialProps(ctx)];
+                case 6:
+                    _g = _p.sent();
+                    return [3 /*break*/, 8];
+                case 7:
+                    _g = {};
+                    _p.label = 8;
+                case 8: return [2 /*return*/, (_c.pageProps = tslib.__assign.apply(void 0, [tslib.__assign.apply(void 0, _f.concat([(_g)])), { session: session,
+                            user: user,
+                            tenants: tenants,
+                            envAppUrl: envAppUrl, envBaseUrl: process.env['FRONTEGG_BASE_URL'], envClientId: process.env['FRONTEGG_CLIENT_ID'] }]),
+                        _c)];
+                case 9:
+                    appContext.session = null;
+                    _h = {};
+                    _j = [{}];
+                    if (!originalGetInitialProps) return [3 /*break*/, 11];
+                    return [4 /*yield*/, originalGetInitialProps(appContext)];
+                case 10:
+                    _k = _p.sent();
+                    return [3 /*break*/, 12];
+                case 11:
+                    _k = {};
+                    _p.label = 12;
+                case 12:
+                    _l = [tslib.__assign.apply(void 0, _j.concat([(_k)]))];
+                    if (!Component.getInitialProps) return [3 /*break*/, 14];
+                    return [4 /*yield*/, Component.getInitialProps(ctx)];
+                case 13:
+                    _m = _p.sent();
+                    return [3 /*break*/, 15];
+                case 14:
+                    _m = {};
+                    _p.label = 15;
+                case 15: return [2 /*return*/, (_h.pageProps = tslib.__assign.apply(void 0, _l.concat([(_m)])),
+                        _h)];
+            }
+        });
+    }); };
+    fronteggConfig.authRoutes = (_b = (_a = options === null || options === void 0 ? void 0 : options.authOptions) === null || _a === void 0 ? void 0 : _a.routes) !== null && _b !== void 0 ? _b : {};
+    fronteggConfig.fronteggAppOptions = options !== null && options !== void 0 ? options : {};
+    function CustomFronteggApp(appProps) {
+        var _a = appProps.pageProps, user = _a.user, tenants = _a.tenants, session = _a.session, envAppUrl = _a.envAppUrl, envBaseUrl = _a.envBaseUrl, envClientId = _a.envClientId;
+        return (React__default["default"].createElement(FronteggProvider, tslib.__assign({}, options, { user: user, tenants: tenants, session: session, envAppUrl: envAppUrl, envBaseUrl: envBaseUrl, envClientId: envClientId }), app(appProps)));
+    }
+    CustomFronteggApp.getInitialProps = app.getInitialProps;
+    return CustomFronteggApp;
+};
+
+/**
+ * @see https://www.npmjs.com/package/http-proxy
+ */
+var proxy = httpProxy__default["default"].createProxyServer({
+    target: process.env['FRONTEGG_BASE_URL'],
+});
+/**
+ * Please refer to the following links for the specification document for HTTP.
+ * @see https://tools.ietf.org/html/rfc7231
+ * @see https://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol
+ */
+var hasRequestBodyMethods = ['HEAD', 'POST', 'PUT', 'DELETE', 'CONNECT', 'OPTIONS', 'PATCH'];
+/**
+ * If pattern information matching the input url information is found in the `pathRewrite` array,
+ * the url value is partially replaced with the `pathRewrite.replaceStr` value.
+ * @param url
+ * @param pathRewrite
+ */
+var rewritePath = function (url, pathRewrite) {
+    if (Array.isArray(pathRewrite)) {
+        for (var _i = 0, pathRewrite_1 = pathRewrite; _i < pathRewrite_1.length; _i++) {
+            var item = pathRewrite_1[_i];
+            var patternStr = item.patternStr, replaceStr = item.replaceStr;
+            var pattern = RegExp(patternStr);
+            if (pattern.test(url)) {
+                return url.replace(pattern, replaceStr);
+            }
+        }
+    }
+    else {
+        // tslint:disable-next-line:forin
+        for (var patternStr in pathRewrite) {
+            var pattern = RegExp(patternStr);
+            var path = pathRewrite[patternStr];
+            if (pattern.test(url)) {
+                return url.replace(pattern, path);
+            }
+        }
+    }
+    return url;
+};
+/**
+ * Next.js HTTP Proxy Middleware
+ * @see https://nextjs.org/docs/api-routes/api-middlewares
+ * @param {NextApiRequest} req
+ * @param {NextApiResponse} res
+ */
+function fronteggMiddleware(req, res) {
+    var _this = this;
+    return new Promise(function (resolve, reject) {
+        var _a;
+        var pathRewrite = [
+            {
+                patternStr: '^/api/',
+                replaceStr: '/',
+            },
+        ];
+        if (pathRewrite) {
+            req.url = rewritePath(req.url, pathRewrite);
+        }
+        if (hasRequestBodyMethods.indexOf(req.method) >= 0 && typeof req.body === 'object') {
+            req.body = JSON.stringify(req.body);
+        }
+        var isSecured = new URL(fronteggConfig.appUrl).protocol === 'https:';
+        proxy
+            .once('proxyReq', function (proxyReq, req) {
+            if (hasRequestBodyMethods.indexOf(req.method) >= 0 && typeof req.body === 'string') {
+                proxyReq.write(req.body);
+                proxyReq.end();
+            }
+        })
+            .once('proxyRes', function (proxyRes, req, serverResponse) {
+            proxyRes.headers['set-cookie'] = modifySetCookieIfUnsecure(proxyRes.headers['set-cookie'], isSecured);
+            var _end = res.end;
+            var buffer = new Buffer('');
+            proxyRes
+                .on('data', function (chunk) {
+                buffer = Buffer.concat([buffer, chunk]);
+            })
+                .on('end', function () { return tslib.__awaiter(_this, void 0, void 0, function () {
+                var output, isLogout, _a, session, decodedJwt, sessionCookie;
+                var _b, _c;
+                return tslib.__generator(this, function (_d) {
+                    switch (_d.label) {
+                        case 0:
+                            output = buffer.toString('utf-8');
+                            isLogout = (_b = req === null || req === void 0 ? void 0 : req.url) === null || _b === void 0 ? void 0 : _b.endsWith((_c = restApi.fronteggAuthApiRoutes.find(function (path) { return path.endsWith('/logout'); })) !== null && _c !== void 0 ? _c : '/logout');
+                            if (!isLogout) return [3 /*break*/, 1];
+                            removeCookies(fronteggConfig.cookieName, isSecured, fronteggConfig.cookieDomain, serverResponse);
+                            return [3 /*break*/, 3];
+                        case 1: return [4 /*yield*/, createSessionFromAccessToken(output)];
+                        case 2:
+                            _a = _d.sent(), session = _a[0], decodedJwt = _a[1];
+                            if (session) {
+                                sessionCookie = createCookie({
+                                    session: session,
+                                    expires: new Date(decodedJwt.exp * 1000),
+                                    isSecured: isSecured,
+                                });
+                                addToCookies(sessionCookie, serverResponse);
+                            }
+                            _d.label = 3;
+                        case 3:
+                            res.setHeader('content-length', output.length);
+                            res.setHeader('content-encoding', '');
+                            // @ts-ignore
+                            _end.apply(res, [output]);
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+            // disable default behavior to read jwt
+            // @ts-ignore
+            serverResponse.write = function () { return undefined; };
+            // @ts-ignore
+            serverResponse.end = function () { return undefined; };
+        })
+            .once('error', reject)
+            .web(req, res, {
+            changeOrigin: true,
+            cookieDomainRewrite: (_a = {},
+                _a[fronteggConfig.baseUrlHost] = fronteggConfig.cookieDomain,
+                _a),
+        });
+    });
+}
+
+Object.defineProperty(exports, 'AdminPortal', {
+  enumerable: true,
+  get: function () { return js.AdminPortal; }
+});
+exports.AuthorizedContent = AuthorizedContent;
+exports.FronteggConfig = fronteggConfig;
+exports.FronteggProvider = FronteggProvider;
+exports.FronteggProviderNoSSR = FronteggProviderNoSSR;
+exports.FronteggRouter = FronteggRouter;
+exports.FronteggRouterProps = FronteggRouterProps;
+exports.addToCookies = addToCookies;
+exports.createCookie = createCookie;
+exports.createGetSession = createGetSession;
+exports.createSessionFromAccessToken = createSessionFromAccessToken;
+exports.fronteggErrors = fronteggErrors;
+exports.fronteggMiddleware = fronteggMiddleware;
+exports.getCookieFromRequest = getCookieFromRequest;
+exports.getMeAndTenants = getMeAndTenants;
+exports.getSession = getSession;
+exports.getTokensFromCookie = getTokensFromCookie;
+exports.modifySetCookieIfUnsecure = modifySetCookieIfUnsecure;
+exports.parseCookie = parseCookie;
+exports.parseCookieFromArray = parseCookieFromArray;
+exports.removeCookies = removeCookies;
+exports.rewriteCookieProperty = rewriteCookieProperty;
+exports.rewritePath = rewritePath;
+exports.withFronteggApp = withFronteggApp;
+exports.withSSRSession = withSSRSession;
+Object.keys(reactHooks).forEach(function (k) {
+  if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return reactHooks[k]; }
+  });
+});
+Object.keys(types).forEach(function (k) {
+  if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return types[k]; }
+  });
+});
+//# sourceMappingURL=index.js.map