@frontegg/nextjs 6.7.8 → 6.7.9-alpha.3741489660

package/index.js

@@ -0,0 +1,599 @@
+import { __rest, __assign, __spreadArrays, __awaiter, __generator } from 'tslib';
+import { useRouter } from 'next/router';
+import React, { useCallback, useMemo, useEffect, useContext } from 'react';
+import { F as FronteggBaseProvider, E as ExpireInListener, A as AppContext } from './FronteggBaseProvider-5529ded6.js';
+import { AppHolder, initialize } from '@frontegg/js';
+export { AdminPortal } from '@frontegg/js';
+import { authInitialState } from '@frontegg/redux-store';
+import { ContextHolder, fronteggSilentRefreshTokenUrl, fronteggRefreshTokenUrl, fronteggAuthApiRoutes } from '@frontegg/rest-api';
+import { FronteggStoreProvider, useAuthUserOrNull, useLoginWithRedirect, useLoginActions } from '@frontegg/react-hooks';
+export * from '@frontegg/react-hooks';
+import { F as FronteggConfig } from './FronteggConfig-7ae86562.js';
+export { F as FronteggConfig } from './FronteggConfig-7ae86562.js';
+import './api-70f0e81e.js';
+import 'cookie';
+import 'iron-session';
+import 'jose';
+import { parse } from 'url';
+import { g as getTokensFromCookie, c as createCookie, r as rewriteCookieProperty, a as createSessionFromAccessToken, b as removeCookies, d as getMeAndTenants, m as modifySetCookieIfUnsecure, e as addToCookies } from './helpers-dbf29bd5.js';
+export { e as addToCookies, c as createCookie, a as createSessionFromAccessToken, d as getMeAndTenants, g as getTokensFromCookie, m as modifySetCookieIfUnsecure, p as parseCookieFromArray, b as removeCookies, r as rewriteCookieProperty } from './helpers-dbf29bd5.js';
+import { f as fronteggErrors } from './consts-873fdf4e.js';
+export { f as fronteggErrors } from './consts-873fdf4e.js';
+import { g as getCookieFromRequest } from './getCookieFromRequest-624c37b5.js';
+export { g as getCookieFromRequest, p as parseCookie } from './getCookieFromRequest-624c37b5.js';
+import { c as createGetSession } from './createGetSession-81b1748e.js';
+export { c as createGetSession } from './createGetSession-81b1748e.js';
+import httpProxy from 'http-proxy';
+export * from '@frontegg/types';
+
+var FronteggProvider = function (_a) {
+    var children = _a.children, basename = _a.basename, props = __rest(_a, ["children", "basename"]);
+    var router = useRouter();
+    var baseName = basename !== null && basename !== void 0 ? basename : router.basePath;
+    return (React.createElement(FronteggBaseProvider, __assign({ router: router, basename: baseName }, props), children));
+};
+
+var Connector = function (_props) {
+    var _a;
+    var router = _props.router, appName = _props.appName, hostedLoginBox = _props.hostedLoginBox; _props.customLoginBox; var props = __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 = 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 = useMemo(function () {
+        var _a;
+        var createdApp;
+        try {
+            createdApp = AppHolder.getInstance(appName !== null && appName !== void 0 ? appName : 'default');
+        }
+        catch (e) {
+            createdApp = initialize(__assign(__assign({}, props), { hostedLoginBox: hostedLoginBox !== null && hostedLoginBox !== void 0 ? hostedLoginBox : false, basename: (_a = props.basename) !== null && _a !== void 0 ? _a : baseName, authOptions: __assign(__assign({}, props.authOptions), { onRedirectTo: onRedirectTo }), contextOptions: __assign({ requestCredentials: 'include' }, props.contextOptions), onRedirectTo: onRedirectTo }), appName !== null && appName !== void 0 ? appName : 'default');
+        }
+        return createdApp;
+    }, [appName, props, hostedLoginBox, baseName, onRedirectTo]);
+    ContextHolder.setOnRedirectTo(onRedirectTo);
+    useEffect(function () {
+        app.store.dispatch({ type: 'auth/requestAuthorize', payload: true });
+    }, [app]);
+    return (React.createElement(AppContext.Provider, { value: app },
+        React.createElement(FronteggStoreProvider, __assign({}, __assign(__assign({}, props), { app: app })), props.children)));
+};
+var FronteggNextJSProvider = function (props) {
+    var router = useRouter();
+    return (React.createElement(Connector, __assign({}, props, { router: router }),
+        React.createElement(ExpireInListener, null),
+        props.children));
+};
+var FronteggProviderNoSSR = function (props) {
+    return (React.createElement(FronteggNextJSProvider, __assign({}, props, { framework: 'nextjs' }), props.children));
+};
+
+var AuthorizedContent = function (props) {
+    var _a, _b;
+    var isAuthorized = true; // Initially
+    var user = 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.createElement(React.Fragment, null, props.render(isAuthorized));
+    }
+    return isAuthorized ? React.createElement(React.Fragment, null, props.children) : null;
+};
+
+function FronteggRouter() {
+    var app = useContext(AppContext);
+    var _a = useRouter(), query = _a.query, replace = _a.replace;
+    var loginWithRedirect = useLoginWithRedirect();
+    var logout = useLoginActions().logout;
+    useEffect(function () {
+        if (!app) {
+            return;
+        }
+        if (app.options.hostedLoginBox) {
+            var routesObj = __assign(__assign({}, authInitialState.routes), FronteggConfig.authRoutes);
+            var _a = query, pathArr = _a["frontegg-router"], queryParams = __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 = __assign(__assign({}, authInitialState.routes), FronteggConfig.authRoutes);
+    var routesArr = Object.keys(routesObj).reduce(function (p, key) { return __spreadArrays(p, [routesObj[key]]); }, []);
+    var pathname = 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 __awaiter(_this, void 0, void 0, function () {
+        var session, loginUrl;
+        var _a, _b;
+        return __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 : 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 __awaiter(this, void 0, void 0, function () {
+        var sealFromCookies, tokens;
+        return __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" + 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 __awaiter(this, void 0, void 0, function () {
+        var refreshTokenKey, cookieKey;
+        return __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" + 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 __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 __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 __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 __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 = [__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 = __assign.apply(void 0, [__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 = [__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 = __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.createElement(FronteggProvider, __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.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 __awaiter(_this, void 0, void 0, function () {
+                var output, isLogout, _a, session, decodedJwt, sessionCookie;
+                var _b, _c;
+                return __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 = 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),
+        });
+    });
+}
+
+export { AuthorizedContent, FronteggProvider, FronteggProviderNoSSR, FronteggRouter, FronteggRouterProps, fronteggMiddleware, getSession, rewritePath, withFronteggApp, withSSRSession };
+//# sourceMappingURL=index.js.map

package/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/package.json

@@ -1,19 +1,25 @@
 {
   "name": "@frontegg/nextjs",
-  "version": "6.7.8",
+  "libName": "FronteggNextJs",
+  "version": "6.7.9-alpha.3741489660",
+  "author": "Frontegg LTD",
+  "license": "MIT",
+  "types": "index.d.ts",
   "dependencies": {
     "@frontegg/js": "6.52.0",
     "@frontegg/react-hooks": "6.52.0",
-    "jose": "^4.9.2",
-    "iron-session": "^6.2.1",
+    "@types/http-proxy": "^1.17.9",
+    "cookie": "^0.5.0",
     "http-proxy": "^1.18.1",
-    "cookie": "^0.5.0"
+    "iron-session": "^6.3.1",
+    "jose": "^4.9.2"
   },
   "peerDependencies": {
-    "react": ">17.0.0",
-    "next": ">11.0.0"
+    "next": ">10.0.0",
+    "react": ">16.9.0",
+    "react-dom": ">16.9.0"
   },
-  "main": "./index.cjs.js",
-  "module": "./index.esm.js",
-  "typings": "./index.d.ts"
-}
+  "main": "index.js",
+  "module": "index.esm.js",
+  "es2015": "index.es.js"
+}

package/refreshToken.d.ts

@@ -0,0 +1,3 @@
+import { NextPageContext } from 'next/dist/shared/lib/utils';
+import { FronteggNextJSSession } from './common/types';
+export declare function refreshToken(ctx: NextPageContext): Promise<FronteggNextJSSession | null>;

package/server/FronteggProviderNext13.d.ts

@@ -0,0 +1,3 @@
+import { PropsWithChildren } from 'react';
+import { FronteggAppOptions } from '@frontegg/types';
+export declare const FronteggAppProvider: ({ children, ...options }: PropsWithChildren<Omit<FronteggAppOptions, 'contextOptions'>>) => Promise<JSX.Element>;

package/server/getSessionNext13.d.ts

@@ -0,0 +1,4 @@
+import { FronteggUserSession, FronteggUserTokens } from '../common';
+export declare const getSession: () => Promise<import("../common").FronteggNextJSSession | undefined>;
+export declare function getUserSession(): Promise<FronteggUserSession | undefined>;
+export declare function getUserTokens(): Promise<FronteggUserTokens | undefined>;

package/server/index.d.ts

@@ -0,0 +1,2 @@
+export * from './FronteggProviderNext13';
+export * from './getSessionNext13';