@frontegg/nextjs 6.7.8 → 6.7.9-alpha.3757258005

package/common/index.js.map

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

package/common/types.d.ts

@@ -0,0 +1,74 @@
+import { FronteggAppOptions } from '@frontegg/types';
+import { ILoginResponse, ITenantsResponse } from '@frontegg/rest-api';
+import { IncomingMessage } from 'http';
+import { ReactNode } from 'react';
+import { AppRouterInstance } from 'next/dist/shared/lib/app-router-context';
+import { NextRouter } from 'next/router';
+export declare type RequestType = IncomingMessage | Request;
+export interface AccountEnvironment {
+    id: string;
+    createdAt: string;
+    environment: 'production' | 'development';
+}
+export interface CustomClaims {
+    accountEnvironments: AccountEnvironment[];
+}
+export interface FronteggUserTokens {
+    accessToken: string;
+    refreshToken?: string;
+}
+export interface MeAndTenantsResponse {
+    user?: ILoginResponse;
+    tenants?: ITenantsResponse[];
+}
+export interface FronteggUserSession {
+    sub: string;
+    name: string;
+    email: string;
+    email_verified: boolean;
+    metadata: any;
+    roles: string[];
+    permissions: string[];
+    tenantId: string;
+    tenantIds: string[];
+    profilePictureUrl: string;
+    type: string;
+    customClaims: CustomClaims;
+    iat: number;
+    exp: number;
+    aud: string;
+    iss: string;
+}
+export interface FronteggNextJSSession extends FronteggUserTokens {
+    user: FronteggUserSession;
+}
+export interface AppEnvConfig {
+    envAppUrl?: string;
+    envBaseUrl?: string;
+    envClientId?: string;
+}
+export interface FronteggProviderOptions extends Omit<FronteggAppOptions, 'contextOptions'> {
+    session?: FronteggNextJSSession;
+    envAppUrl: string;
+    envBaseUrl: string;
+    envClientId: string;
+    contextOptions?: Omit<FronteggAppOptions['contextOptions'], 'baseUrl'>;
+}
+export interface FronteggProviderProps extends FronteggProviderOptions, MeAndTenantsResponse {
+    children?: ReactNode;
+    router: AppRouterInstance | NextRouter;
+    appName?: string;
+}
+declare module 'iron-session' {
+    interface IronSessionData {
+        accessToken: FronteggNextJSSession['accessToken'];
+        user: FronteggNextJSSession['user'];
+    }
+}
+declare global {
+    interface ProcessEnv {
+        FRONTEGG_BASE_URL: string;
+        PORT?: string;
+        PWD: string;
+    }
+}

package/common/utils/createGetSession.d.ts

@@ -0,0 +1,7 @@
+import { FronteggNextJSSession, FronteggUserTokens } from '../types';
+declare type CreateGetSessionParams = {
+    getCookie: () => string | undefined;
+    cookieResolver: (cookie: string) => Promise<FronteggUserTokens | undefined>;
+};
+export declare const createGetSession: ({ getCookie, cookieResolver, }: CreateGetSessionParams) => Promise<FronteggNextJSSession | undefined>;
+export {};

package/common/utils/getCookieFromRequest.d.ts

@@ -0,0 +1,2 @@
+import { RequestType } from '../types';
+export declare function getCookieFromRequest(req?: RequestType): string | undefined;

package/common/utils/index.d.ts

@@ -0,0 +1,3 @@
+export * from './parseCookie';
+export * from './createGetSession';
+export * from './getCookieFromRequest';

package/common/utils/parseCookie.d.ts

@@ -0,0 +1 @@
+export declare function parseCookie(cookieStr: string): string | undefined;

package/createGetSession-81b1748e.js

@@ -0,0 +1,50 @@
+import { __awaiter, __generator } from 'tslib';
+import { jwtVerify } from 'jose';
+import { F as FronteggConfig } from './FronteggConfig-7ae86562.js';
+
+var createGetSession = function (_a) {
+    var getCookie = _a.getCookie, cookieResolver = _a.cookieResolver;
+    return __awaiter(void 0, void 0, void 0, function () {
+        var cookie, tokens, accessToken, refreshToken, publicKey, payload, session, e_1;
+        return __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*/, 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*/];
+            }
+        });
+    });
+};
+
+export { createGetSession as c };
+//# sourceMappingURL=createGetSession-81b1748e.js.map

package/createGetSession-81b1748e.js.map

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

package/edge/getSessionOnEdge.d.ts

@@ -0,0 +1,2 @@
+import { RequestType } from '../common/types';
+export declare const getSession: (req: RequestType) => Promise<import("../common/types").FronteggNextJSSession | undefined>;

package/edge/index.d.ts

@@ -0,0 +1 @@
+export * from './getSessionOnEdge';

package/edge/index.js

@@ -0,0 +1,29 @@
+import { __awaiter, __generator } from 'tslib';
+import { unsealData } from 'iron-session/edge';
+import { F as FronteggConfig } from '../FronteggConfig-7ae86562.js';
+import 'cookie';
+import { c as createGetSession } from '../createGetSession-81b1748e.js';
+import { g as getCookieFromRequest } from '../getCookieFromRequest-624c37b5.js';
+import 'jose';
+
+function getTokensFromCookieOnEdge(cookie) {
+    return __awaiter(this, void 0, void 0, function () {
+        var jwt;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, unsealData(cookie, {
+                        password: FronteggConfig.passwordsAsMap,
+                    })];
+                case 1:
+                    jwt = _a.sent();
+                    return [2 /*return*/, JSON.parse(jwt)];
+            }
+        });
+    });
+}
+var getSession = function (req) {
+    return createGetSession({ getCookie: function () { return getCookieFromRequest(req); }, cookieResolver: getTokensFromCookieOnEdge });
+};
+
+export { getSession };
+//# sourceMappingURL=index.js.map

package/edge/index.js.map

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

package/getCookieFromRequest-624c37b5.js

@@ -0,0 +1,28 @@
+import cookie from 'cookie';
+import { F as FronteggConfig } from './FronteggConfig-7ae86562.js';
+
+function parseCookie(cookieStr) {
+    var sealFromCookies = '';
+    if (cookie.parse(cookieStr)[FronteggConfig.cookieName]) {
+        sealFromCookies = cookie.parse(cookieStr)[FronteggConfig.cookieName];
+    }
+    else {
+        var i = 1;
+        while (cookie.parse(cookieStr)[FronteggConfig.cookieName + "-" + i]) {
+            sealFromCookies += cookie.parse(cookieStr)[FronteggConfig.cookieName + "-" + i];
+            i++;
+        }
+    }
+    return sealFromCookies !== '' ? sealFromCookies : undefined;
+}
+
+function getCookieFromRequest(req) {
+    if (!req) {
+        return undefined;
+    }
+    var cookieStr = 'credentials' in req ? req.headers.get('cookie') || '' : req.headers.cookie || '';
+    return parseCookie(cookieStr);
+}
+
+export { getCookieFromRequest as g, parseCookie as p };
+//# sourceMappingURL=getCookieFromRequest-624c37b5.js.map

package/getCookieFromRequest-624c37b5.js.map

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

package/helpers-dac4dc7b.js

@@ -0,0 +1,189 @@
+import { __awaiter, __generator, __assign, __spreadArrays } from 'tslib';
+import { g as getUsers, a as getTenants } from './api-70f0e81e.js';
+import cookie from 'cookie';
+import { sealData, unsealData } from 'iron-session';
+import { jwtVerify } from 'jose';
+import { F as FronteggConfig } from './FronteggConfig-7ae86562.js';
+
+function getMeAndTenants(reqHeaders, accessToken) {
+    return __awaiter(this, void 0, void 0, function () {
+        var headers, _a, user, tenants;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    if (!reqHeaders || !accessToken) {
+                        return [2 /*return*/, {}];
+                    }
+                    headers = __assign(__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.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.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', __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', __spreadArrays(existingSetCookie, cookieValue));
+}
+function createSessionFromAccessToken(output) {
+    var _a, _b;
+    return __awaiter(this, void 0, void 0, function () {
+        var data, accessToken, refreshToken, publicKey, decodedJwt, stringifySession, session;
+        return __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*/, 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*/, 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 __awaiter(this, void 0, void 0, function () {
+        var stringifyJwt;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!cookie) {
+                        return [2 /*return*/, undefined];
+                    }
+                    return [4 /*yield*/, unsealData(cookie, {
+                            password: FronteggConfig.passwordsAsMap,
+                        })];
+                case 1:
+                    stringifyJwt = _a.sent();
+                    return [2 /*return*/, JSON.parse(stringifyJwt)];
+            }
+        });
+    });
+}
+
+export { getMeAndTenants as a, addToCookies as b, createCookie as c, removeCookies as d, createSessionFromAccessToken as e, getTokensFromCookie as g, modifySetCookieIfUnsecure as m, parseCookieFromArray as p, rewriteCookieProperty as r };
+//# sourceMappingURL=helpers-dac4dc7b.js.map

package/helpers-dac4dc7b.js.map

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

package/index.d.ts

@@ -1,12 +1,11 @@
 export * from './FronteggProvider';
 export * from './FronteggProviderNoSSR';
 export * from './AuthorizedContent';
-export { default as FronteggConfig } from './FronteggConfig';
 export * from './FronteggRouter';
 export * from './withFronteggApp';
 export * from './session';
 export * from './FronteggMiddleware';
+export * from './common';
 export { AdminPortal } from '@frontegg/js';
 export * from '@frontegg/react-hooks';
 export * from '@frontegg/types';
-export { ContextHolder } from '@frontegg/rest-api';