Rename files and update function singatures

Author: bcbogdan

examples/with-next-ssr-app-directory/app/components/home.tsx

@@ -7,15 +7,13 @@ import { CallAPIButton } from "./callApiButton";
 import { LinksComponent } from "./linksComponent";
 import { SessionAuthForNextJS } from "./sessionAuthForNextJS";
 
-import { getSSRSession, init } from "supertokens-auth-react/nextjs/ssr";
+import { getSSRSession } from "supertokens-auth-react/nextjs/ssr";
 import { ssrConfig } from "../config/ssr";
 
-init(ssrConfig());
-
 export async function HomePage() {
     const cookiesStore = await cookies();
     const headersStore = await headers();
-    const session = await getSSRSession(headersStore, cookiesStore, redirect);
+    const session = await getSSRSession(ssrConfig(), headersStore, cookiesStore, redirect);
     console.log(session);
 
     /**

examples/with-next-ssr-app-directory/app/config/ssr.ts

@@ -1,7 +1,7 @@
 import { appInfo } from "./appInfo";
 import { useRouter } from "next/navigation";
 import { SuperTokensConfig } from "supertokens-auth-react/lib/build/types";
-import { init } from "supertokens-auth-react/nextjs";
+import { init } from "supertokens-auth-react/nextjs/middleware";
 
 const routerInfo: { router?: ReturnType<typeof useRouter>; pathName?: string } = {};
 

examples/with-next-ssr-app-directory/middleware.ts

@@ -4,12 +4,10 @@ import { SessionContainer } from "supertokens-node/recipe/session";
 import { withSession } from "supertokens-node/nextjs";
 import { ensureSuperTokensInit } from "./app/config/backend";
 import { ssrConfig } from "./app/config/ssr";
-import { superTokensSessionMiddleware } from "supertokens-auth-react/nextjs";
+import { superTokensMiddleware } from "supertokens-auth-react/nextjs/middleware";
 
 ensureSuperTokensInit();
 
-init(ssrConfig());
-
 export async function middleware(request: NextRequest & { session?: SessionContainer }) {
     if (request.nextUrl.pathname.startsWith("/api")) {
         if (request.headers.has("x-user-id")) {
@@ -40,7 +38,7 @@ export async function middleware(request: NextRequest & { session?: SessionConta
         });
     }
 
-    return superTokensSessionMiddleware(request, NextResponse);
+    return superTokensMiddleware(ssrConfig(), request, NextResponse);
 }
 
 const refreshTokenCookieName = "sRefreshToken";

lib/ts/nextjs/middleware.ts

@@ -1,7 +1,6 @@
 import { enableLogging, logDebugMessage } from "../logger";
 
-import type { NextRequest, NextResponse } from "./types";
-import type { SuperTokensConfig } from "../types";
+import type { NextRequest, NextResponse, SuperTokensNextjsConfig } from "./types";
 
 const ACCESS_TOKEN_COOKIE_NAME = "sAccessToken";
 const ACCESS_TOKEN_HEADER_NAME = "st-access-token";
@@ -10,83 +9,62 @@ const FRONT_TOKEN_HEADER_NAME = "front-token";
 const REFRESH_TOKEN_COOKIE_NAME = "sRefreshToken";
 const REFRESH_TOKEN_HEADER_NAME = "st-refresh-token";
 
-export default class SuperTokensNextjsEdgeAPIWrapper {
-    static config: SuperTokensConfig;
+let AppInfo: SuperTokensNextjsConfig["appInfo"];
 
-    static getConfigOrThrow(): SuperTokensConfig {
-        if (!SuperTokensNextjsEdgeAPIWrapper.config) {
-            throw new Error("SuperTokens must be initialized before calling this method.");
-        }
-
-        return SuperTokensNextjsEdgeAPIWrapper.config;
+export function superTokensMiddleware(config: SuperTokensNextjsConfig, request: NextRequest, response: NextResponse) {
+    AppInfo = config.appInfo;
+    if (config.enableDebugLogs) {
+        enableLogging();
     }
 
-    static init(config: SuperTokensConfig) {
-        if (config.enableDebugLogs) {
-            enableLogging();
-        }
-        SuperTokensNextjsEdgeAPIWrapper.config = config;
+    const url = new URL(request.url);
+    const shouldRefresh = url.searchParams.get("forceRefresh") === "true";
+    if (shouldRefresh) {
+        return refreshSession(request, response);
     }
 
-    static middleware(request: NextRequest, response: NextResponse) {
-        const url = new URL(request.url);
-        const shouldRefresh = url.searchParams.get("forceRefresh") === "true";
-        if (shouldRefresh) {
-            return refreshSession(request, response);
-        }
+    // Save the current path so that we can use it during SSR
+    // Used to redirect the user to the correct path after login/refresh
+    return response.next({
+        headers: {
+            "x-current-path": url.pathname,
+        },
+    });
+}
 
-        // Save the current path so that we can use it during SSR
-        // Used to redirect the user to the correct path after login/refresh
-        return response.next({
-            headers: {
-                "x-current-path": url.pathname,
-            },
-        });
+async function refreshSession(request: NextRequest, response: NextResponse): Promise<NextResponse> {
+    const refreshToken =
+        request.cookies.get(REFRESH_TOKEN_COOKIE_NAME)?.value || request.headers.get(REFRESH_TOKEN_HEADER_NAME);
+    if (!refreshToken) {
+        logDebugMessage("Refresh token not found");
+        return redirectToAuthPage(request, response);
     }
 
-    static async refreshSession(request: NextRequest, response: NextResponse): Promise<NextResponse> {
-        const refreshToken =
-            request.cookies.get(REFRESH_TOKEN_COOKIE_NAME)?.value || request.headers.get(REFRESH_TOKEN_HEADER_NAME);
-        if (!refreshToken) {
-            logDebugMessage("Refresh token not found");
+    try {
+        const tokens = await fetchNewTokens(refreshToken);
+        if (!tokens.accessToken || !tokens.refreshToken || !tokens.frontToken) {
+            logDebugMessage("Missing tokens from refresh response");
             return redirectToAuthPage(request, response);
         }
 
-        try {
-            const tokens = await fetchNewTokens(refreshToken);
-            if (!tokens.accessToken || !tokens.refreshToken || !tokens.frontToken) {
-                logDebugMessage("Missing tokens from refresh response");
-                return redirectToAuthPage(request, response);
-            }
-
-            const redirectUrl = new URL(request.url);
-            redirectUrl.searchParams.delete("forceRefresh");
-            const finalResponse = response.redirect(redirectUrl);
-            finalResponse.headers.set("x-current-path", redirectUrl.pathname);
-            // @ts-expect-error TS(2345) It complains about tokens being null although we check for that in the previous if condition
-            attachTokensToResponse(finalResponse, tokens);
-            logDebugMessage("Attached new tokens to response");
-            return finalResponse;
-        } catch (err) {
-            logDebugMessage("Error refreshing session");
-            logDebugMessage(err as unknown as string);
-            return redirectToAuthPage(request, response);
-        }
+        const redirectUrl = new URL(request.url);
+        redirectUrl.searchParams.delete("forceRefresh");
+        const finalResponse = response.redirect(redirectUrl);
+        finalResponse.headers.set("x-current-path", redirectUrl.pathname);
+        // @ts-expect-error TS(2345) It complains about tokens being null although we check for that in the previous if condition
+        attachTokensToResponse(finalResponse, tokens);
+        logDebugMessage("Attached new tokens to response");
+        return finalResponse;
+    } catch (err) {
+        logDebugMessage("Error refreshing session");
+        console.error(err);
+        logDebugMessage(err as unknown as string);
+        return redirectToAuthPage(request, response);
     }
 }
 
-export const init = SuperTokensNextjsEdgeAPIWrapper.init;
-export const refreshSession = SuperTokensNextjsEdgeAPIWrapper.refreshSession;
-export const superTokensSSRMiddleware = SuperTokensNextjsEdgeAPIWrapper.middleware;
-
-function getRefreshApiURL(): string {
-    const appInfo = SuperTokensNextjsEdgeAPIWrapper.getConfigOrThrow().appInfo;
-    return sanitizeUrl(`${appInfo.apiDomain}/${appInfo.apiBasePath}/session/refresh`);
-}
-
 function redirectToAuthPage(request: NextRequest, response: NextResponse): NextResponse {
-    const appInfo = SuperTokensNextjsEdgeAPIWrapper.getConfigOrThrow().appInfo;
-    const authPagePath = appInfo.websiteBasePath || "/auth";
+    const authPagePath = AppInfo.websiteBasePath || "/auth";
     const redirectUrl = new URL(authPagePath, request.url);
     logDebugMessage(`Redirecting to: ${redirectUrl}`);
     return response.redirect(redirectUrl);
@@ -95,7 +73,9 @@ function redirectToAuthPage(request: NextRequest, response: NextResponse): NextR
 async function fetchNewTokens(
     currentRefreshToken: string
 ): Promise<{ accessToken: string | null; refreshToken: string | null; frontToken: string | null }> {
-    const refreshResponse = await fetch(getRefreshApiURL(), {
+    const refreshApiURL = new URL(`${AppInfo.apiBasePath}/session/refresh`, AppInfo.apiDomain);
+    console.log(refreshApiURL.pathname);
+    const refreshResponse = await fetch(refreshApiURL, {
         method: "POST",
         headers: {
             "Content-Type": "application/json",
@@ -145,9 +125,6 @@ function attachTokensToResponse(
     response.cookies.set(FRONT_TOKEN_COOKIE_NAME, tokens.frontToken);
 }
 
-function sanitizeUrl(url: string) {
-    return url.replace(/([^:]\/)\/+/g, "$1");
-}
 export function getCookieValue(header: string, name: string): string | null {
     const match = header.match(new RegExp(`${name}=([^;]+)`));
     return match ? match[1] : null;