Papermark is the open-source DocSend alternative and secure data rooms with built-in analytics and custom domains.
import { isSamlEnforcedForEmailDomain } from "@/lib/api/teams/is-saml-enforced-for-email-domain";
import { PrismaAdapter } from "@next-auth/prisma-adapter";
import PasskeyProvider from "@teamhanko/passkeys-next-auth-provider";
import { type NextAuthOptions } from "next-auth";
import CredentialsProvider from "next-auth/providers/credentials";
import EmailProvider from "next-auth/providers/email";
import GoogleProvider from "next-auth/providers/google";
import LinkedInProvider from "next-auth/providers/linkedin";
import { identifyUser, trackAnalytics } from "@/lib/analytics";
import { qstash } from "@/lib/cron";
import { sendVerificationRequestEmail } from "@/lib/emails/send-verification-request";
import hanko from "@/lib/hanko";
import { jackson } from "@/lib/jackson";
import prisma from "@/lib/prisma";
import { CustomUser } from "@/lib/types";
const VERCEL_DEPLOYMENT = !!process.env.VERCEL_URL;
function getMainDomainUrl(): string {
if (process.env.NODE_ENV === "development") {
return process.env.NEXTAUTH_URL || "http://localhost:3000";
}
return process.env.NEXTAUTH_URL || "https://app.papermark.com";
}
export const authOptions: NextAuthOptions = {
pages: {
error: "/login",
},
providers: [
GoogleProvider({
clientId: process.env.GOOGLE_CLIENT_ID as string,
clientSecret: process.env.GOOGLE_CLIENT_SECRET as string,
allowDangerousEmailAccountLinking: true,
}),
LinkedInProvider({
clientId: process.env.LINKEDIN_CLIENT_ID as string,
clientSecret: process.env.LINKEDIN_CLIENT_SECRET as string,
authorization: {
params: { scope: "openid profile email" },
},
issuer: "https://www.linkedin.com/oauth",
jwks_endpoint: "https://www.linkedin.com/oauth/openid/jwks",
profile(profile, tokens) {
const defaultImage =
"https://cdn-icons-png.flaticon.com/512/174/174857.png";
return {
id: profile.sub,
name: profile.name,
email: profile.email,
image: profile.picture ?? defaultImage,
};
},
allowDangerousEmailAccountLinking: true,
}),
EmailProvider({
async sendVerificationRequest({ identifier, url }) {
const hasValidNextAuthUrl = !!process.env.NEXTAUTH_URL;
let finalUrl = url;
if (!hasValidNextAuthUrl) {
const mainDomainUrl = getMainDomainUrl();
const urlObj = new URL(url);
const mainDomainObj = new URL(mainDomainUrl);
urlObj.hostname = mainDomainObj.hostname;
urlObj.protocol = mainDomainObj.protocol;
urlObj.port = mainDomainObj.port || "";
finalUrl = urlObj.toString();
}
if (process.env.NODE_ENV === "development") {
await sendVerificationRequestEmail({
url: finalUrl,
email: identifier,
});
console.log("[Login Email Sent] Check your inbox for:", identifier);
} else {
await sendVerificationRequestEmail({
url: finalUrl,
email: identifier,
});
}
},
}),
PasskeyProvider({
tenant: hanko,
async authorize({ userId }) {
const user = await prisma.user.findUnique({ where: { id: userId } });
if (!user) return null;
return user;
},
}),
{
id: "saml",
name: "BoxyHQ SAML",
type: "oauth",
version: "2.0",
checks: ["pkce", "state"],
authorization: {
url: `${getMainDomainUrl()}/api/auth/saml/authorize`,
params: {
scope: "",
response_type: "code",
provider: "saml",
},
},
token: {
url: `${getMainDomainUrl()}/api/auth/saml/token`,
params: { grant_type: "authorization_code" },
},
userinfo: `${getMainDomainUrl()}/api/auth/saml/userinfo`,
profile: async (profile) => {
const name =
`${profile.firstName || ""} ${profile.lastName || ""}`.trim() ||
null;
return {
id: profile.id || profile.email,
name,
email: profile.email,
image: null,
};
},
options: {
clientId: "dummy",
clientSecret: process.env.NEXTAUTH_SECRET as string,
},
allowDangerousEmailAccountLinking: true,
},
CredentialsProvider({
id: "saml-idp",
name: "IdP Login",
credentials: {
code: { type: "text" },
},
async authorize(credentials) {
if (!credentials?.code) return null;
try {
const { oauthController } = await jackson();
const { access_token } = await oauthController.token({
code: credentials.code,
grant_type: "authorization_code",
redirect_uri: getMainDomainUrl(),
client_id: "dummy",
client_secret: process.env.NEXTAUTH_SECRET!,
});
if (!access_token) return null;
const userInfo = await oauthController.userInfo(access_token);
if (!userInfo) return null;
const { email, firstName, lastName, requested } = userInfo as any;
if (!email) return null;
const name = [firstName, lastName].filter(Boolean).join(" ") || email;
const user = await prisma.user.upsert({
where: { email },
create: { email, name },
update: { name: name || undefined },
});
return {
id: user.id,
email: user.email,
name: user.name,
profile: userInfo,
} as any;
} catch (error) {
console.error("[SAML] Error during SAML authorization:", error);
return null;
}
},
}),
],
adapter: PrismaAdapter(prisma),
session: { strategy: "jwt" },
cookies: {
sessionToken: {
name: `${VERCEL_DEPLOYMENT ? "__Secure-" : ""}next-auth.session-token`,
options: {
httpOnly: true,
sameSite: "lax",
path: "/",
domain: VERCEL_DEPLOYMENT ? ".papermark.com" : undefined,
secure: VERCEL_DEPLOYMENT,
},
},
},
callbacks: {
jwt: async (params) => {
const { token, user, trigger, account } = params;
if (!token.email) {
return {};
}
if (user) {
token.user = user;
}
if (
(account?.provider === "saml" || account?.provider === "saml-idp") &&
user
) {
token.provider = "saml";
}
if (trigger === "update") {
const user = token?.user as CustomUser;
const refreshedUser = await prisma.user.findUnique({
where: { id: user.id },
});
if (refreshedUser) {
token.user = refreshedUser;
} else {
return {};
}
if (refreshedUser?.email !== user.email) {
if (user.id && refreshedUser.email) {
await prisma.account.deleteMany({
where: { userId: user.id },
});
}
}
}
return token;
},
session: async ({ session, token }) => {
(session.user as CustomUser) = {
id: token.sub,
// @ts-ignore
...(token || session).user,
};
return session;
},
},
events: {
async createUser(message) {
await identifyUser(message.user.email ?? message.user.id);
await trackAnalytics({
event: "User Signed Up",
email: message.user.email,
userId: message.user.id,
});
await qstash.publishJSON({
url: `${process.env.NEXT_PUBLIC_BASE_URL ?? getMainDomainUrl()}/api/cron/welcome-user`,
body: {
userId: message.user.id,
},
delay: 15 * 60,
});
},
},
};