next-auth

import NextAuth from "next-auth"
import GitHub from "next-auth/providers/github"
export const { handlers, auth } = NextAuth({ providers: [ GitHub ] })

AUTH_GITHUB_ID=...
AUTH_GITHUB_SECRET=...
AUTH_SECRET=...

import NextAuth from "next-auth"
import GitHub from "next-auth/providers/github"
export const { handlers, auth } = NextAuth(req => {
 if (req) {
  console.log(req) // do something with the request
 }
 return { providers: [ GitHub ] }
})

new AuthError(message?, errorOptions?): AuthError

optional cause: Record<string, unknown> & {
  err: Error;
};

optional err: Error;

message: string;

name: string;

optional stack: string;

type: ErrorType;

static optional prepareStackTrace: (err, stackTraces) => any;

static stackTraceLimit: number;

static captureStackTrace(targetObject, constructorOpt?): void

new CredentialsSignin(message?, errorOptions?): CredentialsSignin

optional cause: Record<string, unknown> & {
  err: Error;
};

optional err: Error;

code: string;

message: string;

name: string;

optional stack: string;

type: ErrorType;

static kind: string;

static optional prepareStackTrace: (err, stackTraces) => any;

static stackTraceLimit: number;

static type: string;

static captureStackTrace(targetObject, constructorOpt?): void

optional readonly access_token: string;

optional readonly authorization_details: AuthorizationDetails[];

optional expires_at: number;

optional readonly expires_in: number;

optional readonly id_token: string;

provider: string;

providerAccountId: string;

optional readonly refresh_token: string;

optional readonly scope: string;

optional readonly token_type: Lowercase<string>;

type: ProviderType;

optional userId: string;

expires: string;

optional user: User;

optional adapter: Adapter;

optional basePath: string;

"/api/auth" in "next-auth"; "/auth" with all other frameworks

optional callbacks: {
  jwt: (params) => Awaitable<null | JWT>;
  redirect: (params) => Awaitable<string>;
  session: (params) => Awaitable<Session | DefaultSession>;
  signIn: (params) => Awaitable<string | boolean>;
  } & {
  authorized: (params) => any;
};

optional jwt: (params) => Awaitable<null | JWT>;

optional redirect: (params) => Awaitable<string>;

callbacks: {
  async redirect({ url, baseUrl }) {
    // Allows relative callback URLs
    if (url.startsWith("/")) return `${baseUrl}${url}`
 
    // Allows callback URLs on the same origin
    if (new URL(url).origin === baseUrl) return url
 
    return baseUrl
  }
}

optional session: (params) => Awaitable<Session | DefaultSession>;

callbacks: {
  async session({ session, token, user }) {
    // Send properties to the client, like an access_token from a provider.
    session.accessToken = token.accessToken
 
    return session
  }
}

optional signIn: (params) => Awaitable<string | boolean>;

callbacks: {
 async signIn({ profile }) {
  // Only allow sign in for users with email addresses ending with "yourdomain.com"
  return profile?.email?.endsWith("@yourdomain.com")
}

optional authorized: (params) => any;

async authorized({ request, auth }) {
  const url = request.nextUrl
 
  if(request.method === "POST") {
    const { authToken } = (await request.json()) ?? {}
    // If the request has a valid auth token, it is authorized
    const valid = await validateAuthToken(authToken)
    if(valid) return true
    return NextResponse.json("Invalid auth token", { status: 401 })
  }
 
  // Logged in users are authenticated, otherwise redirect to login page
  return !!auth.user
}

optional cookies: Partial<CookiesOptions>;

{}

optional debug: boolean;

false

optional events: {
  createUser: (message) => Awaitable<void>;
  linkAccount: (message) => Awaitable<void>;
  session: (message) => Awaitable<void>;
  signIn: (message) => Awaitable<void>;
  signOut: (message) => Awaitable<void>;
  updateUser: (message) => Awaitable<void>;
};

{}

optional createUser: (message) => Awaitable<void>;

optional linkAccount: (message) => Awaitable<void>;

optional session: (message) => Awaitable<void>;

optional signIn: (message) => Awaitable<void>;

optional signOut: (message) => Awaitable<void>;

optional updateUser: (message) => Awaitable<void>;

optional experimental: {
  enableWebAuthn: boolean;
};

{}

optional enableWebAuthn: boolean;

false

optional jwt: Partial<JWTOptions>;

optional logger: Partial<LoggerInstance>;

// /auth.ts
import log from "logging-service"
 
export const { handlers, auth, signIn, signOut } = NextAuth({
  logger: {
    error(code, ...message) {
      log.error(code, message)
    },
    warn(code, ...message) {
      log.warn(code, message)
    },
    debug(code, ...message) {
      log.debug(code, message)
    }
  }
})

console

optional pages: Partial<PagesOptions>;

{}

  pages: {
    signIn: '/auth/signin',
    signOut: '/auth/signout',
    error: '/auth/error',
    verifyRequest: '/auth/verify-request',
    newUser: '/auth/new-user'
  }

providers: Provider[];

[]

optional redirectProxyUrl: string;

"https://authjs.example.com/api/auth"

GitHub({
  ...
  redirectProxyUrl: "https://github.example.com/api/auth"
})

optional secret: string | string[];

optional session: {
  generateSessionToken: () => string;
  maxAge: number;
  strategy: "jwt" | "database";
  updateAge: number;
};

optional generateSessionToken: () => string;

optional maxAge: number;

2592000 // 30 days

optional strategy: "jwt" | "database";

optional updateAge: number;

86400 // 1 day

optional skipCSRFCheck: typeof skipCSRFCheck;

optional theme: Theme;

optional trustHost: boolean;

optional useSecureCookies: boolean;

auth: (...args) => Promise<null | Session> & (...args) => Promise<null | Session> & (...args) => Promise<null | Session> & (...args) => AppRouteHandlerFn;

export { auth as middleware } from "./auth"

import { auth } from "./auth"
export default auth((req) => {
  // req.auth
})

// Optionally, don't invoke Middleware on some paths
// Read more: https://nextjs.dokyumento.jp/docs/app/building-your-application/routing/middleware#matcher
export const config = {
  matcher: ["/((?!api|_next/static|_next/image|favicon.ico).*)"],
}

import { auth } from "../auth"
 
export default async function Page() {
  const { user } = await auth()
  return <p>Hello {user?.name}</p>
}

import { auth } from "../../auth"
 
export const POST = auth((req) => {
  // req.auth
})

import { auth } from "../../auth"
 
export default auth((req) => {
  // req.auth
})
 
export const config = { runtime: "edge" }

import { auth } from "../auth"
import type { NextApiRequest, NextApiResponse } from "next"
 
export default async (req: NextApiRequest, res: NextApiResponse) => {
  const session = await auth(req, res)
  if (session) {
    // Do something with the session
    return res.json("This is protected content.")
  }
  res.status(401).json("You must be signed in.")
}

import { auth } from "../auth"
 
export const getServerSideProps: GetServerSideProps = async (context) => {
  const session = await auth(context)
 
  if (session) {
    // Do something with the session
    return { props: { session, content: (await res.json()).content } }
  }
 
  return { props: {} }
}

handlers: AppRouteHandlers;

export { GET, POST } from "../../../../auth"
export const runtime = "edge" // optional

// ...
export const { handlers: { GET, POST }, auth } = NextAuth({...})

signIn: <P, R>(provider?, options?, authorizationParams?) => Promise<R extends false ? any : never>;

import { signIn } from "../auth"
 
export default function Layout() {
 return (
  <form action={async () => {
    "use server"
    await signIn("github")
  }}>
   <button>Sign in with GitHub</button>
  </form>
)

import { AuthError } from "next-auth"
import { signIn } from "../auth"
 
export default function Layout() {
 return (
   <form action={async (formData) => {
     "use server"
     try {
       await signIn("credentials", formData)
    } catch(error) {
      if (error instanceof AuthError) // Handle auth errors
      throw error // Rethrow all other errors
    }
   }}>
    <button>Sign in</button>
  </form>
 )
}

signOut: <R>(options?) => Promise<R extends false ? any : never>;

import { signOut } from "../auth"
 
export default function Layout() {
 return (
  <form action={async () => {
    "use server"
    await signOut()
  }}>
   <button>Sign out</button>
  </form>
)

unstable_update: (data) => Promise<null | Session>;

optional address: null | {
  country: null | string;
  formatted: null | string;
  locality: null | string;
  postal_code: null | string;
  region: null | string;
  street_address: null | string;
};

optional birthdate: null | string;

optional email: null | string;

optional email_verified: null | boolean;

optional family_name: null | string;

optional gender: null | string;

optional given_name: null | string;

optional id: null | string;

optional locale: null | string;

optional middle_name: null | string;

optional name: null | string;

optional nickname: null | string;

optional phone_number: null | string;

optional picture: any;

optional preferred_username: null | string;

optional profile: null | string;

optional sub: null | string;

optional updated_at: null | string | number | Date;

optional website: null | string;

optional zoneinfo: null | string;

expires: string;

optional user: User;

optional email: null | string;

optional id: string;

optional image: null | string;

optional name: null | string;

const customFetch: unique symbol;

import { Auth, customFetch } from "@auth/core"
import GitHub from "@auth/core/providers/github"
 
const dispatcher = new ProxyAgent("my.proxy.server")
function proxy(...args: Parameters<typeof fetch>): ReturnType<typeof fetch> {
  return undici(args[0], { ...(args[1] ?? {}), dispatcher })
}
 
const response = await Auth(request, {
  providers: [GitHub({ [customFetch]: proxy })]
})

default(config): NextAuthResult

import NextAuth from "next-auth"
import GitHub from "@auth/core/providers/github"
 
export const { handlers, auth } = NextAuth({ providers: [GitHub] })

import NextAuth from "next-auth"
import GitHub from "@auth/core/providers/github"
 
export const { handlers, auth } = NextAuth(async (req) => {
  console.log(req) // do something with the request
  return {
    providers: [GitHub],
  },
})