The modern link attribution platform. Loved by world-class engineering teams at Twilio, Zillow, Jobber, Vercel, Raycast, and more.
TypeScript clickhousemysqlnextjsopen-sourceplanetscaleprismatailwindcsstinybirdtypescriptupstashvercel
import { isBlacklistedEmail } from "@/lib/edge-config";
import { jackson } from "@/lib/jackson";
import { welcomeUserJob } from "@/lib/jobs/handlers/welcome-user-job";
import { prisma } from "@/lib/prisma";
import { isStored, storage } from "@/lib/storage";
import { UserProps } from "@/lib/types";
import { assertRateLimit } from "@/lib/upstash/assert-rate-limit";
import { RATELIMIT_POLICIES } from "@/lib/upstash/ratelimit-policies";
import { sendEmail } from "@dub/email";
import LoginLink from "@dub/email/templates/login-link";
import { APP_DOMAIN } from "@dub/utils";
import { PrismaAdapter } from "@next-auth/prisma-adapter";
import { PrismaClient } from "@prisma/client";
import { waitUntil } from "@vercel/functions";
import { User, type NextAuthOptions } from "next-auth";
import { AdapterAccount, AdapterUser } from "next-auth/adapters";
import { JWT } from "next-auth/jwt";
import CredentialsProvider from "next-auth/providers/credentials";
import EmailProvider from "next-auth/providers/email";
import GithubProvider from "next-auth/providers/github";
import GoogleProvider from "next-auth/providers/google";
import { headers } from "next/headers";
import { createId } from "../api/create-id";
import { isProduction } from "../api/environment";
import { isSamlEnforcedForEmailDomain } from "../api/workspaces/is-saml-enforced-for-email-domain";
import {
exceededLoginAttemptsThreshold,
incrementLoginAttempts,
} from "./lock-account";
import { validatePassword } from "./password";
import { trackDubLead } from "./track-dub-lead";
const VERCEL_DEPLOYMENT = !!process.env.VERCEL_URL;
const CustomPrismaAdapter = (p: PrismaClient) => {
return {
...PrismaAdapter(p),
createUser: async (data: any) => {
return p.user.create({
data: {
...data,
id: createId({ prefix: "user_" }),
notificationPreferences: {
create: {},
},
},
});
},
// Some IdPs (e.g. Beehiiv) return extra token fields
// so we need to only include the fields that are valid columns on Account table
linkAccount: (account: AdapterAccount) =>
p.account.create({
data: {
userId: account.userId,
type: account.type,
provider: account.provider,
providerAccountId: account.providerAccountId,
refresh_token: account.refresh_token,
refresh_token_expires_in: account.refresh_token_expires_in as any,
access_token: account.access_token,
expires_at: account.expires_at,
token_type: account.token_type,
scope: account.scope,
id_token: account.id_token,
session_state: account.session_state,
},
}),
// simplified version of https://github.com/nextauthjs/next-auth/blob/main/packages/adapter-prisma/src/index.ts#L80
useVerificationToken: async ({ identifier, token }) => {
try {
const verificationToken = await p.verificationToken.delete({
where: { identifier_token: { identifier, token } },
});
return verificationToken;
} catch (error: any) {
if (error.code === "P2025") {
return null;
}
throw error;
}
},
};
};
export const authOptions: NextAuthOptions = {
providers: [
EmailProvider({
async sendVerificationRequest({ identifier, url }) {
await assertRateLimit({
policy: RATELIMIT_POLICIES.loginLinkSend,
identifier,
});
if (!isProduction) {
console.log(`Login link: ${url}`);
return;
}
sendEmail({
to: identifier,
subject: "Your Dub Login Link",
react: LoginLink({ url, email: identifier }),
});
},
}),
GoogleProvider({
clientId: process.env.GOOGLE_CLIENT_ID as string,
clientSecret: process.env.GOOGLE_CLIENT_SECRET as string,
allowDangerousEmailAccountLinking: true,
}),
GithubProvider({
clientId: process.env.GITHUB_CLIENT_ID as string,
clientSecret: process.env.GITHUB_CLIENT_SECRET as string,
issuer: "https://github.com/login/oauth",
allowDangerousEmailAccountLinking: true,
}),
{
id: "saml",
name: "BoxyHQ",
type: "oauth",
version: "2.0",
checks: ["pkce", "state"],
authorization: {
url: `${APP_DOMAIN}/api/auth/saml/authorize`,
params: {
scope: "",
response_type: "code",
provider: "saml",
},
},
token: {
url: `${APP_DOMAIN}/api/auth/saml/token`,
params: { grant_type: "authorization_code" },
},
userinfo: `${APP_DOMAIN}/api/auth/saml/userinfo`,
profile: async (profile) => {
let existingUser = await prisma.user.findUnique({
where: { email: profile.email },
});
// user is authorized but doesn't have a Dub account, create one for them
if (!existingUser) {
existingUser = await prisma.user.create({
data: {
id: createId({ prefix: "user_" }),
email: profile.email,
name: `${profile.firstName || ""} ${
profile.lastName || ""
}`.trim(),
notificationPreferences: {
create: {},
},
},
});
}
const { id, name, email, image } = existingUser;
return {
id,
name,
email,
image,
};
},
options: {
clientId: "dummy",
clientSecret: process.env.NEXTAUTH_SECRET as string,
},
allowDangerousEmailAccountLinking: true,
},
CredentialsProvider({
id: "saml-idp",
name: "IdP Login",
credentials: {
code: {},
},
async authorize(credentials) {
if (!credentials) {
return null;
}
const { code } = credentials;
if (!code) {
return null;
}
const { oauthController } = await jackson();
// Fetch access token
const { access_token } = await oauthController.token({
code,
grant_type: "authorization_code",
redirect_uri: APP_DOMAIN,
client_id: "dummy",
client_secret: process.env.NEXTAUTH_SECRET as string,
});
if (!access_token) {
return null;
}
// Fetch user info
const userInfo = await oauthController.userInfo(access_token);
if (!userInfo) {
return null;
}
let existingUser = await prisma.user.findUnique({
where: { email: userInfo.email },
});
// user is authorized but doesn't have a Dub account, create one for them
if (!existingUser) {
existingUser = await prisma.user.create({
data: {
id: createId({ prefix: "user_" }),
email: userInfo.email,
name: `${userInfo.firstName || ""} ${
userInfo.lastName || ""
}`.trim(),
notificationPreferences: {
create: {},
},
},
});
}
const { id, name, email, image } = existingUser;
return {
id,
email,
name,
email_verified: true,
image,
// adding profile here so we can access it in signIn callback
profile: userInfo,
};
},
}),
// Sign in with email and password
CredentialsProvider({
id: "credentials",
name: "Dub.co",
type: "credentials",
credentials: {
email: { type: "email" },
password: { type: "password" },
},
async authorize(credentials, req) {
if (!credentials) {
throw new Error("no-credentials");
}
const { email, password } = credentials;
if (!email || !password) {
throw new Error("no-credentials");
}
await assertRateLimit({
policy: RATELIMIT_POLICIES.login,
identifier: email.trim().toLowerCase(),
});
// SSO enforcement check
const ssoEnforced = await isSamlEnforcedForEmailDomain(email);
if (ssoEnforced) {
throw new Error("require-saml-sso");
}
const user = await prisma.user.findUnique({
where: { email },
select: {
id: true,
passwordHash: true,
name: true,
email: true,
image: true,
invalidLoginAttempts: true,
emailVerified: true,
},
});
if (!user || !user.passwordHash) {
throw new Error("invalid-credentials");
}
if (exceededLoginAttemptsThreshold(user)) {
throw new Error("exceeded-login-attempts");
}
const passwordMatch = await validatePassword({
password,
passwordHash: user.passwordHash,
});
if (!passwordMatch) {
const exceededLoginAttempts = exceededLoginAttemptsThreshold(
await incrementLoginAttempts(user),
);
if (exceededLoginAttempts) {
throw new Error("exceeded-login-attempts");
} else {
throw new Error("invalid-credentials");
}
}
if (!user.emailVerified) {
throw new Error("email-not-verified");
}
// Reset invalid login attempts
await prisma.user.update({
where: { id: user.id },
data: {
invalidLoginAttempts: 0,
},
});
return {
id: user.id,
name: user.name,
email: user.email,
image: user.image,
};
},
}),
],
// @ts-ignore
adapter: CustomPrismaAdapter(prisma),
session: { strategy: "jwt" },
cookies: {
sessionToken: {
name: `${VERCEL_DEPLOYMENT ? "__Secure-" : ""}next-auth.session-token`,
options: {
httpOnly: true,
sameSite: "lax",
path: "/",
// When working on localhost, the cookie domain must be omitted entirely (https://stackoverflow.com/a/1188145)
domain: VERCEL_DEPLOYMENT ? ".dub.co" : undefined,
secure: VERCEL_DEPLOYMENT,
},
},
},
pages: {
signIn: "/login",
error: "/login",
},
callbacks: {
signIn: async ({ user, account, profile }) => {
if (!user.email || (await isBlacklistedEmail(user.email))) {
return false;
}
if (user?.lockedAt) {
throw new Error("exceeded-login-attempts");
}
// If the user is not using SAML, we need to check if SAML is enforced for the email domain
if (
account?.provider !== "saml" &&
account?.provider !== "saml-idp" &&
account?.provider !== "credentials" // for credentials, we do the check in the CredentialsProvider
) {
const ssoEnforced = await isSamlEnforcedForEmailDomain(user.email);
if (ssoEnforced) {
throw new Error("require-saml-sso");
}
}
if (account?.provider === "google" || account?.provider === "github") {
const userExists = await prisma.user.findUnique({
where: { email: user.email },
select: { id: true, name: true, image: true },
});
if (!userExists || !profile) {
return true;
}
// if the user already exists via email,
// update the user with their name and image
if (userExists && profile) {
const profilePic =
profile[account.provider === "google" ? "picture" : "avatar_url"];
let newAvatar: string | null = null;
// if the existing user doesn't have an image or the image is not stored in R2
if (
(!userExists.image || !isStored(userExists.image)) &&
profilePic
) {
const { url } = await storage.upload({
key: `avatars/${userExists.id}`,
body: profilePic,
});
newAvatar = url;
}
await prisma.user.update({
where: { email: user.email },
data: {
// @ts-expect-error - this is a bug in the types, `login` is a valid on the `Profile` type
...(!userExists.name && { name: profile.name || profile.login }),
...(newAvatar && { image: newAvatar }),
},
});
}
} else if (
account?.provider === "saml" ||
account?.provider === "saml-idp"
) {
let samlProfile;
if (account?.provider === "saml-idp") {
// @ts-ignore
samlProfile = user.profile;
if (!samlProfile) {
return true;
}
} else {
samlProfile = profile;
}
if (!samlProfile?.requested?.tenant) {
return false;
}
const workspace = await prisma.project.findUnique({
where: {
id: samlProfile.requested.tenant,
},
select: {
id: true,
ssoEmailDomain: true,
},
});
if (workspace) {
const { ssoEmailDomain } = workspace;
const emailDomain = user.email.split("@")[1];
// ssoEmailDomain should be required for all SAML enabled workspace
// this should not happen
if (!ssoEmailDomain) {
return false;
}
if (
emailDomain.toLocaleLowerCase() !==
ssoEmailDomain.toLocaleLowerCase()
) {
return false;
}
await Promise.allSettled([
// add user to workspace
prisma.projectUsers.upsert({
where: {
userId_projectId: {
userId: user.id,
projectId: workspace.id,
},
},
update: {},
create: {
projectId: workspace.id,
userId: user.id,
},
}),
// delete any pending invites for this user
prisma.projectInvite.delete({
where: {
email_projectId: {
email: user.email,
projectId: workspace.id,
},
},
}),
]);
}
}
return true;
},
// baseUrl is NEXTAUTH_URL when it is set (e.g. on localhost), so resolve
// against the request's host instead
redirect: async ({ url, baseUrl }) => {
const trustedOrigins = [baseUrl, APP_DOMAIN];
const host = (await headers()).get("host");
const base =
trustedOrigins.find((origin) => new URL(origin).host === host) ??
baseUrl;
let resolved: URL;
try {
resolved = new URL(url, base);
} catch {
return base;
}
const { origin, href } = resolved;
return trustedOrigins.includes(origin) ? href : base;
},
jwt: async ({
token,
user,
trigger,
}: {
token: JWT;
user: User | AdapterUser | UserProps;
trigger?: "signIn" | "update" | "signUp";
}) => {
if (user) {
token.user = user;
}
// refresh the user's data if they update their name / email
if (trigger === "update") {
const refreshedUser = await prisma.user.findUnique({
where: {
id: token.sub,
},
select: {
id: true,
name: true,
email: true,
image: true,
isMachine: true,
defaultWorkspace: true,
},
});
if (refreshedUser) {
token.user = refreshedUser;
} else {
return {};
}
}
return token;
},
session: async ({ session, token }) => {
session.user = {
id: token.sub,
// @ts-ignore
...(token || session).user,
};
return session;
},
},
events: {
async signIn(message) {
const email = message.user.email as string;
const user = await prisma.user.findUnique({
where: { email },
select: {
id: true,
name: true,
email: true,
image: true,
createdAt: true,
},
});
if (!user) {
console.log(
`User ${message.user.email} not found, skipping welcome workflow...`,
);
return;
}
// only process new user workflow if the user was created in the last 15s (newly created user)
if (
user.createdAt &&
new Date(user.createdAt).getTime() > Date.now() - 15000
) {
console.log(
`New user ${user.email} created, triggering welcome workflow...`,
);
waitUntil(
Promise.allSettled([
// track lead if dub_id cookie is present
trackDubLead(user),
// trigger welcome workflow 45 minutes after the user signed up
welcomeUserJob.dispatch(
{
userId: user.id,
},
{
delay: 45 * 60,
label: user.id,
},
),
]),
);
}
// lazily backup user avatar to R2
const currentImage = message.user.image;
if (currentImage && !isStored(currentImage)) {
waitUntil(
(async () => {
const { url } = await storage.upload({
key: `avatars/${message.user.id}`,
body: currentImage,
});
await prisma.user.update({
where: {
id: message.user.id,
},
data: {
image: url,
},
});
})(),
);
}
},
},
};