next-firebase-auth-edge

Next.js 13 Firebase Authentication for Edge and Node.js runtimes. Dedicated for Next 13 server components. Compatible with Next.js middleware.

Example

The demo is available at next-firebase-auth-edge-static-demo.vercel.app

You can find source code for the demo in examples/next13-typescript-static-pages

Why

Official firebase-admin library relies heavily on Node.js internal crypto library and primitives that are unavailable inside Next.js Edge Runtime.

This library aims to solve the problem of creating and verifying custom JWT tokens provided by Firebase Authentication using Web Crypto API available inside Edge runtimes

What's new in version 0.7

Compatibility with Next.js 13.4. In the latest release of Next.js, the app router has reached a stable state and is no longer considered experimental.

With the introduction of version 0.7, several deprecated APIs have been removed, including the isTokenValid option.

To successfully migrate to version 0.7, make sure to eliminate all deprecated options from your codebase. If you had any validation logic previously implemented in the isTokenValid option, you should now transition it to the handleValidToken option. Here's an example:

1    // Before
2    isTokenValid: (token) => token.email_verified ?? false, 
3    handleValidToken: async ({ token, decodedToken }) => {
4      return NextResponse.next();
5    }

1    // After
2    handleValidToken: async ({ token, decodedToken }) => {
3      if (!token.email_verified) {
4        // Handle this in handleError
5        throw new Error("User email not verified");
6      }
7      
8      return NextResponse.next();
9    }, 
10    handleError: async (error) => {
11      // Avoid redirect loop
12      if (request.nextUrl.pathname === "/login") {
13        return NextResponse.next();
14      }
15    
16      const url = request.nextUrl.clone();
17      url.pathname = "/login";
18      url.search = `redirect=${request.nextUrl.pathname}${url.search}`;
19      return NextResponse.redirect(url);
20    },

Built on top of Web Crypto API

next-firebase-auth-edge is built entirely upon Web Crypto API. Although it seems fine at first, please remember that it is still in an experimental stage. Any feedback or contribution is welcome.

Node.js Edge runtime polyfill is provided by Vercel's edge-runtime library

Installation

With npm

1npm install next-firebase-auth-edge

With yarn

1yarn add next-firebase-auth-edge

With pnpm

1pnpm add next-firebase-auth-edge

Authentication middleware

In order to set encrypted authentication cookies, we need to define server endpoints to handle logging in and logging out of users.

This can be achieved quite easily using the authentication middleware function:

All examples below are based on working Next.js 13 app examples found in /examples directory

1// middleware.ts
2import type { NextRequest } from "next/server";
3import { authentication } from "next-firebase-auth-edge/lib/next/middleware";
4
5export async function middleware(request: NextRequest) {
6  return authentication(request, {
7    loginPath: "/api/login",
8    logoutPath: "/api/logout",
9    apiKey: "firebase-api-key",
10    cookieName: "AuthToken",
11    cookieSignatureKeys: ["secret1", "secret2"],
12    cookieSerializeOptions: {
13      path: "/",
14      httpOnly: true,
15      secure: false, // Set this to true on HTTPS environments
16      sameSite: "strict" as const,
17      maxAge: 12 * 60 * 60 * 24 * 1000, // twelve days
18    },
19    serviceAccount: {
20      projectId: "firebase-project-id",
21      privateKey: "firebase service account private key",
22      clientEmail: "firebase service account client email",
23    },
24    // Optional
25    checkRevoked: false,
26    handleValidToken: async ({ token, decodedToken }) => {
27      console.log("Successfully authenticated", { token, decodedToken });
28      return NextResponse.next();
29    },
30    handleInvalidToken: async () => {
31      // Avoid redirect loop
32      if (request.nextUrl.pathname === "/login") {
33        return NextResponse.next();
34      }
35
36      // Redirect to /login?redirect=/prev-path when request is unauthenticated
37      const url = request.nextUrl.clone();
38      url.pathname = "/login";
39      url.search = `redirect=${request.nextUrl.pathname}${url.search}`;
40      return NextResponse.redirect(url);
41    },
42    handleError: async (error) => {
43      console.error("Unhandled authentication error", { error });
44      // Avoid redirect loop
45      if (request.nextUrl.pathname === "/login") {
46        return NextResponse.next();
47      }
48
49      // Redirect to /login?redirect=/prev-path on unhandled authentication error
50      const url = request.nextUrl.clone();
51      url.pathname = "/login";
52      url.search = `redirect=${request.nextUrl.pathname}${url.search}`;
53      return NextResponse.redirect(url);
54    },
55  });
56}
57
58export const config = {
59  matcher: ["/", "/((?!_next/static|favicon.ico|logo.svg).*)"],
60};

Options

Required

Name	Description
loginPath	Defines API login endpoint. When called with auth firebase token from the client (see examples below), responds with Set-Cookie headers containing signed id and refresh tokens.
logoutPath	Defines API logout endpoint. When called from the client (see examples below), returns empty Set-Cookie headers that remove previously set credentials
apiKey	Firebase project API key used to fetch firebase id and refresh tokens
cookieName	The name for cookie set by loginPath api route.
cookieSignatureKeys	Rotating keys the cookie is validated against
cookieSerializeOptions	Defines additional cookie options sent along Set-Cookie headers
serviceAccount	Firebase project service account

Optional

Name	Type	Description
checkRevoked	boolean By default false	If true, validates the token against firebase server on each request. Unless you have a good reason, it's better not to use it.
handleValidToken	(tokens: { token: string, decodedToken: DecodedIdToken }) => Promise<NextResponse> By default returns NextResponse.next()	Receives id and decoded tokens and should return a promise that resolves with NextResponse.
handleInvalidToken	() => Promise<NextResponse> By default returns NextResponse.next()	If passed, is called and returned if request has not been authenticated (either does not have credentials attached or credentials have expired). Can be used to redirect unauthenticated users to specific page or pages.
handleError	(error: unknown) => Promise<NextResponse> By default returns NextResponse.next()	Receives an unhandled error that happened during authentication and should resolve with NextResponse. By default, in case of unhandled error during authentication, we just allow application to render. This allows you to customize error handling

Troubleshooting

error - Too big integer

One of the common issues during setup is error - Too big integer thrown by crypto-signer. If you stumble on it, please make sure to follow resolution mentioned in https://github.com/awinogrodzki/next-firebase-auth-edge/issues/17#issuecomment-1376298292

The error is caused by malformed firebase private key. We are working on providing correct private key validation and more user friendly error message. Until then, please follow the quick fix in aforementioned issue comment.

Example AuthProvider

Below is example implementation of custom AuthProvider component that handles the calling of authentication endpoints.

GET /api/login endpoint should be called with firebase token (see examples below). It responds with Set-Cookie header containing encrypted cookies.

GET /api/logout removes authentication cookies. Make sure to sign out the user from firebase before calling the endpoint.

You can see a working demo at next-firebase-auth-edge-static-demo.vercel.app

The source code for the demo can be found here examples/next13-typescript-static-pages

1export const AuthProvider: React.FunctionComponent<AuthProviderProps> = ({
2  defaultTenant,
3  children,
4}) => {
5  const { getFirebaseAuth } = useFirebaseAuth(clientConfig);
6  const firstLoadRef = React.useRef(true);
7  const [tenant, setTenant] = React.useState(defaultTenant);
8
9  // Call logout any time
10  const handleLogout = async () => {
11    const auth = await getFirebaseAuth();
12    const { signOut } = await import("firebase/auth");
13    await signOut(auth);
14    // Removes authentication cookies
15    await fetch("/api/logout", {
16      method: "GET",
17    });
18  };
19
20  const handleIdTokenChanged = async (firebaseUser: FirebaseUser | null) => {
21    if (firebaseUser && tenant && firebaseUser.uid === tenant.id) {
22      firstLoadRef.current = false;
23      return;
24    }
25
26    const auth = await getFirebaseAuth();
27
28    if (!firebaseUser && firstLoadRef.current) {
29      const { signInAnonymously } = await import("firebase/auth");
30      firstLoadRef.current = false;
31      await signInAnonymously(auth);
32      return;
33    }
34
35    if (!firebaseUser) {
36      firstLoadRef.current = false;
37      startTransition(() => {
38        setTenant(null);
39      });
40      return;
41    }
42
43    firstLoadRef.current = false;
44    const tokenResult = await firebaseUser.getIdTokenResult();
45    // Sets authentication cookies
46    await fetch("/api/login", {
47      method: "GET",
48      headers: {
49        Authorization: `Bearer ${tokenResult.token}`,
50      },
51    });
52    startTransition(() => {
53      setTenant(mapFirebaseResponseToTenant(tokenResult, firebaseUser));
54    });
55  };
56
57  const registerChangeListener = async () => {
58    const auth = await getFirebaseAuth();
59    const { onIdTokenChanged } = await import("firebase/auth");
60    return onIdTokenChanged(auth, handleIdTokenChanged);
61  };
62
63  React.useEffect(() => {
64    const unsubscribePromise = registerChangeListener();
65
66    return () => {
67      unsubscribePromise.then((unsubscribe) => unsubscribe());
68    };
69  }, []);
70
71  return (
72    <AuthContext.Provider
73      value={{
74        tenant,
75      }}
76    >
77      {children}
78    </AuthContext.Provider>
79  );
80};

Server Components

next-firebase-auth-edge is designed to work with React Server Components and Next.js 13.

Below is an example of root app/layout.tsx server component using getTokens function to extract user tokens from request cookies

1import "./globals.css";
2import { getTokens } from "next-firebase-auth-edge/lib/next/tokens";
3import { cookies } from "next/headers";
4import { AuthProvider } from "./auth-provider";
5import { serverConfig } from "./server-config";
6import { Tokens } from "next-firebase-auth-edge/lib/auth";
7import { Tenant } from "../auth/types";
8
9//...
10export default async function AuthenticatedLayout({
11  children,
12}: {
13  children: React.ReactNode;
14}) {
15  const tokens = await getTokens(cookies(), {
16    apiKey: "firebase-api-key",
17    serviceAccount: {
18      projectId: "firebase-project-id",
19      privateKey: "firebase service account private key",
20      clientEmail: "firebase service account client email",
21    },
22    cookieName: "AuthToken",
23    cookieSignatureKeys: ["secret1", "secret2"],
24  });
25
26  const tenant = tokens ? mapTokensToTenant(tokens) : null;
27
28  return (
29    <html lang="en">
30      <head />
31      <body>
32        <AuthProvider defaultTenant={tenant}>{children}</AuthProvider>
33      </body>
34    </html>
35  );
36}

API Routes or getServerSideProps

Library provides getTokensFromObject function that allows us to authenticate users inside API routes or getServerSideProps.

API Route example

1import { NextApiRequest, NextApiResponse } from "next";
2import { getTokensFromObject } from "next-firebase-auth-edge/lib/next/tokens";
3
4export default async function handler(
5  req: NextApiRequest,
6  res: NextApiResponse
7) {
8  const tokens = await getTokensFromObject(req.cookies, {
9    apiKey: "firebase-api-key",
10    cookieName: "AuthToken",
11    cookieSignatureKeys: ["secret1", "secret2"],
12    serviceAccount: {
13      projectId: "firebase-project-id",
14      privateKey: "firebase service account private key",
15      clientEmail: "firebase service account client email",
16    },
17  });
18
19  return res.status(200).json({ tokens });
20}

GetServerSideProps example

1import { GetServerSidePropsContext } from 'next';
2import { getTokensFromObject } from 'next-firebase-auth-edge/lib/next/tokens';
3
4export async function getServerSideProps(context: GetServerSidePropsContext) {
5  const tokens = await getTokensFromObject(context.req.cookies, {
6    apiKey: "firebase-api-key",
7    cookieName: "AuthToken",
8    cookieSignatureKeys: ["secret1", "secret2"],
9    serviceAccount: {
10      projectId: "firebase-project-id",
11      privateKey: "firebase service account private key",
12      clientEmail: "firebase service account client email",
13    },
14  });
15  
16  return { props: {} };
17}

Advanced usage

Authentication middleware might not fully support every use-case. To help you with more complex authentication flows, next-firebase-auth-edge provides a set of low-level building blocks.

getFirebaseAuth

1const {
2  getCustomIdAndRefreshTokens,
3  verifyIdToken,
4  createCustomToken,
5  handleTokenRefresh,
6  getUser,
7  deleteUser,
8  verifyAndRefreshExpiredIdToken,
9  setCustomUserClaims,
10} = getFirebaseAuth(
11  {
12    projectId: "firebase-project-id",
13    privateKey: "firebase service account private key",
14    clientEmail: "firebase service account client email",
15  },
16  "firebase-api-key"
17);

Methods

Name	Type	Description
getCustomIdAndRefreshTokens	(idToken: string, firebaseApiKey: string) => Promise<IdAndRefreshTokens>	Generates a new set of id and refresh tokens for user identified by provided idToken
verifyIdToken	(idToken: string, checkRevoked?: boolean) => Promise<DecodedIdToken>	Verifies provided idToken. Throws FirebaseAuthError. See source code for possible error types.
createCustomToken	(uid: string, developerClaims?: object) => Promise<string>	Creates a custom token for given firebase user. Optionally, it's possible to attach additional developerClaims
handleTokenRefresh	(refreshToken: string, firebaseApiKey: string) => Promise<Tokens>	Returns id token and decodedToken for given refreshToken
getUser	(uid: string) => Promise<UserRecord>	Returns Firebase UserRecord by uid
deleteUser	(uid: string) => Promise<void>	Deletes user
setCustomUserClaims	(uid: string, customClaims: object ∣ null) => Promise<void>	Sets custom claims for given user. Overwrites existing values. Use getUser to fetch current claims
verifyAndRefreshExpiredIdToken	(token: string, refreshToken: string) => Promise<Tokens ∣ null>	Verifies provided idToken. If token is expired, uses refreshToken to validate it. Returns null if token is not valid.

refreshAuthCookies in middleware

Can be used inside Next.js Edge runtime to refresh user's authentication cookies. Useful when we want to refresh credentials after updating custom claims with setCustomUserClaims function

Usage in static pages example

Using refreshAuthCookies automatically sets Set-Cookie headers with updated cookies in response. Additionally, it returns a set of updated idToken and refreshToken, in case you want to do something with it

1// middleware.ts
2import type { NextRequest } from "next/server";
3import {
4  authentication,
5  refreshAuthCookies,
6} from "next-firebase-auth-edge/lib/next/middleware";
7import { getFirebaseAuth } from "next-firebase-auth-edge/lib/auth";
8
9const commonOptions = {
10  apiKey: "firebase-api-key",
11  cookieName: "AuthToken",
12  cookieSignatureKeys: ["secret1", "secret2"],
13  cookieSerializeOptions: {
14    path: "/",
15    httpOnly: true,
16    secure: false, // Set this to true on HTTPS environments
17    sameSite: "strict" as const,
18    maxAge: 12 * 60 * 60 * 24 * 1000, // twelve days
19  },
20  serviceAccount: {
21    projectId: "firebase-project-id",
22    privateKey: "firebase service account private key",
23    clientEmail: "firebase service account client email",
24  },
25};
26
27const { setCustomUserClaims, getUser } = getFirebaseAuth(
28  commonOptions.serviceAccount,
29  commonOptions.apiKey
30);
31
32export async function middleware(request: NextRequest) {
33  return authentication(request, {
34    loginPath: "/api/login",
35    logoutPath: "/api/logout",
36    handleValidToken: async ({ token, decodedToken }) => {
37      if (request.nextUrl.pathname === "/api/custom-claims") {
38        await setCustomUserClaims(decodedToken.uid, {
39          someClaims: ["someValue"],
40        });
41
42        const user = await getUser(decodedToken.uid);
43        const response = new NextResponse(JSON.stringify(user.customClaims), {
44          status: 200,
45          headers: { "content-type": "application/json" },
46        });
47
48        await refreshAuthCookies(token, response, commonOptions);
49        return response;
50      }
51
52      return NextResponse.next();
53    },
54    ...commonOptions,
55  });
56}
57
58export const config = {
59  matcher: ["/", "/((?!_next/static|favicon.ico|logo.svg).*)"],
60};

refreshAuthCookies in API handler

Can be used inside Next.js API routes to refresh user's authentication cookies. Useful when we want to refresh credentials after updating custom claims or user profile data

Usage in static pages example

Using refreshAuthCookies automatically sets Set-Cookie headers with updated cookies in api response. Additionally, it returns a set of updated idToken and refreshToken, in case you want to do something with it

1// pages/api/refresh-tokens.ts
2// Next.js API route support: https://nextjs.org/docs/api-routes/introduction
3import type { NextApiRequest, NextApiResponse } from "next";
4import { serverConfig } from "../../config/server-config";
5import { refreshAuthCookies } from "next-firebase-auth-edge/lib/next/cookies";
6import { getFirebaseAuth } from "next-firebase-auth-edge/lib/auth";
7
8export default async function handler(
9  req: NextApiRequest,
10  res: NextApiResponse
11) {
12  const bearerToken = req.headers["authorization"]?.split(" ")[1] ?? "";
13
14  // ...use bearer token to update custom claims using "firebase-admin" library and then:
15
16  const { idToken, refreshToken } = await refreshAuthCookies(bearerToken, res, {
17    serviceAccount: {
18      projectId: "firebase-project-id",
19      privateKey: "firebase service account private key",
20      clientEmail: "firebase service account client email",
21    },
22    apiKey: "firebase-api-key",
23    cookieName: "AuthToken",
24    cookieSignatureKeys: ["secret1", "secret2"],
25    cookieSerializeOptions: {
26      path: "/",
27      httpOnly: true,
28      secure: false, // Set this to true on HTTPS environments
29      sameSite: "strict" as const,
30      maxAge: 12 * 60 * 60 * 24 * 1000, // twelve days
31    },
32  });
33
34  // Optionally do something with new `idToken` and `refreshToken`
35
36  res.status(200).json({ example: true });
37}

Make sure to call the endpoint with correct Authorization headers:

1await fetch("/api/refresh-tokens", {
2  method: "GET",
3  headers: {
4    Authorization: `Bearer ${idToken}`,
5  },
6});

Emulator support

Library provides Firebase Authentication Emulator support. An example can be found in examples/next13-typescript-firebase-emulator

Please remember to copy .env.dist file into .env and fill all needed credentials, especially:

1NEXT_PUBLIC_EMULATOR_HOST=http://localhost:9099
2FIREBASE_AUTH_EMULATOR_HOST=localhost:9099

FIREBASE_AUTH_EMULATOR_HOST is used internally by the library NEXT_PUBLIC_EMULATOR_HOST is used only by provided example

Please note that even in emulator mode, library needs actual service account credentials to sign tokens with x509 certificate fetched from Google, a step that does not currently support emulation. Make sure to provide valid service account credentials even if using emulator.

Also, don't forget to put correct Firebase Project ID in .firebaserc file.