@auth/solid-start

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 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;

import Auth, { type AuthConfig } from "@auth/core"
 
export const authConfig: AuthConfig = {...}
 
const request = new Request("https://example.com")
const response = await AuthHandler(request, authConfig)

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>;
};

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 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'
  }

optional prefix: string;

'/api/auth'

providers: Provider[];

[]

optional raw: typeof raw;

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;

optional email: null | string;

optional id: string;

optional image: null | string;

optional name: null | string;

type GetSessionResult: Promise<Session | null>;

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 })]
})

SolidAuth(config): {
  GET: Promise<undefined | Response>;
  POST: Promise<undefined | Response>;
}

AUTH_SECRET=your_auth_secret

GITHUB_ID=your_github_oauth_id
GITHUB_SECRET=your_github_oauth_secret

// routes/api/auth/[...solidauth].ts
import { SolidAuth, type SolidAuthConfig } from "@auth/solid-start"
import GitHub from "@auth/core/providers/github"
 
export const authOpts: SolidAuthConfig = {
  providers: [
    GitHub({
      clientId: process.env.GITHUB_ID,
      clientSecret: process.env.GITHUB_SECRET,
    }),
  ],
  debug: false,
}
 
export const { GET, POST } = SolidAuth(authOpts)

import { getSession } from "@auth/solid-start"
import { createServerData$ } from "solid-start/server"
import { authOpts } from "~/routes/api/auth/[...solidauth]"
 
export const useSession = () => {
  return createServerData$(
    async (_, { request }) => {
      return await getSession(request, authOpts)
    },
    { key: () => ["auth_user"] }
  )
}
 
// useSession returns a resource:
const session = useSession()
const loading = session.loading
const user = () => session()?.user

// components/Protected.tsx
import { type Session } from "@auth/core/types";
import { getSession } from "@auth/solid-start";
import { Component, Show } from "solid-js";
import { useRouteData } from "solid-start";
import { createServerData$, redirect } from "solid-start/server";
import { authOpts } from "~/routes/api/auth/[...solidauth]";
 
const Protected = (Comp: IProtectedComponent) => {
  const routeData = () => {
    return createServerData$(
      async (_, event) => {
        const session = await getSession(event.request, authOpts);
        if (!session || !session.user) {
          throw redirect("/");
        }
        return session;
      },
      { key: () => ["auth_user"] }
    );
  };
 
  return {
    routeData,
    Page: () => {
      const session = useRouteData<typeof routeData>();
      return (
        <Show when={session()} keyed>
          {(sess) => <Comp {...sess} />}
        </Show>
      );
    },
  };
};
 
type IProtectedComponent = Component<Session>;
 
export default Protected;

// routes/protected.tsx
import Protected from "~/components/Protected";
 
export const { routeData, Page } = Protected((session) => {
  return (
    <main class="flex flex-col gap-2 items-center">
      <h1>This is a protected route</h1>
    </main>
  );
});
 
export default Page;

// entry-server.tsx
import { Session } from "@auth/core";
import { getSession } from "@auth/solid-start";
import { redirect } from "solid-start";
import {
  StartServer,
  createHandler,
  renderAsync,
} from "solid-start/entry-server";
import { authOpts } from "./routes/api/auth/[...solidauth]";
 
const protectedPaths = ["/protected"]; // add any route you wish in here
 
export default createHandler(
  ({ forward }) => {
    return async (event) => {
      if (protectedPaths.includes(new URL(event.request.url).pathname)) {
        const session = await getSession(event.request, authOpts);
        if (!session) {
          return redirect("/");
        }
      }
      return forward(event);
    };
  },
  renderAsync((event) => <StartServer event={event} />)
);

// routes/protected.tsx
export default () => {
  return (
    <main class="flex flex-col gap-2 items-center">
      <h1>This is a protected route</h1>
    </main>
  );
};

{
  GET: Promise<undefined | Response>;
  POST: Promise<undefined | Response>;
}

getSession(req, options): GetSessionResult