Convex adapter

[ATLAS2002]

Goals

1. A database adapter for the realtime managed backend service Convex.
2. CLI tool to auto generate the schema and handler files. (optional)

Non-Goals

No response

Background

I have always loved using next-auth for my projects, it gives me enough flexibility to merge different technologies.
In a recent personal project of mine, I wanted to try out Convex. I checked the supabase and prisma adapters and made my own fully functional convex adapter. My implementation might not be most optimized as of now, but it works. And I plan to improve it.

Proposal

So each time a new convex project is created, a /convex directory is created in the root.
It contains a schema.ts file and handler files for each model, such as user.ts, account.ts, session.ts and verificationToken.ts.

This is the how the schema.ts would look like in general:

// convex/schema.ts

import { v } from "convex/values";
import { defineSchema, defineTable } from "convex/server";

export const userSchema = {
  name: v.string(),
  email: v.string(),
  image: v.optional(v.string()),
  emailVerified: v.optional(v.string()),
};

export const accountSchema = {
  userId: v.id("user"),
  type: v.string(),
  provider: v.string(),
  providerAccountId: v.string(),
  refreshToken: v.optional(v.string()),
  accessToken: v.optional(v.string()),
  expiresAt: v.optional(v.number()),
  tokenType: v.optional(v.string()),
  scope: v.optional(v.string()),
  idToken: v.optional(v.string()),
  sessionState: v.optional(v.string()),
};

export const sessionSchema = {
  userId: v.id("user"),
  expires: v.string(),
  sessionToken: v.string(),
};

export const verificationTokenSchema = {
  identifier: v.string(),
  token: v.string(),
  expires: v.string(),
};

export default defineSchema({
  user: defineTable(userSchema).index("by_email", ["email"]),
  account: defineTable(accountSchema).index("by_provider_account", [
    "providerAccountId",
    "provider",
  ]),
  session: defineTable(sessionSchema).index("by_token", ["sessionToken"]),
  verificationToken: defineTable(verificationTokenSchema).index(
    "by_token_identifier",
    ["token", "identifier"],
  ),
});

To use the adapter, user has to copy these 4 files into their /convex directory. We can further implement a cli tool to have these files auto generated.

I was also wondering if I need to follow a naming convention for column names (snake_case / camelCase). The docs were a little confusing as it had both being used together. I would really appreciate some feedback on this.

[ninjrdevelop]

I can only see your example schema, which four files comprise the adapter?

[ATLAS2002]

You can find those 4 files here: https://github.com/ATLAS2002/exam-wizard/tree/main/convex. I have changed the user model quite a bit. Those files only include the query and mutation functions for each models, the adapter code is not present there.

[ninjrdevelop]

Really cool, thanks ATLAS! I was having troubles with my Sessions and your adapter works better than mine haha.

[mad-coder-365]

@ATLAS2002 Where is the adapter file?

[ATLAS2002]

This is more or less the implemented, a lot more can be done here.

import type { Adapter } from "next-auth/adapters";

import { api } from "@convex/_generated/api";
import type { Id } from "@convex/_generated/dataModel";
import { fetchQuery, fetchMutation, fetchAction } from "convex/nextjs";
import { dto, doc } from "../utils";

export default function ConvexAdapter(): Adapter {
  return {
    async createUser(userData) {
      const userId = await fetchMutation(
        api.user.create,
        doc.getUser(userData),
      );
      return {
        ...userData,
        id: userId,
      };
    },
    async getUser(id) {
      const userId = id as Id<"user">;
      const user = await fetchQuery(api.user.get, { id: userId });

      if (!user) return null;
      return dto.getUser(user);
    },
    async getUserByEmail(email) {
      const user = await fetchQuery(api.user.getByEmail, { email });

      if (!user) return null;
      return dto.getUser(user);
    },
    async getUserByAccount(providerData) {
      const user = await fetchQuery(api.user.getByAccount, providerData);

      if (!user) return null;
      return dto.getUser(user);
    },
    async updateUser(userData) {
      const user = await fetchMutation(
        api.user.update,
        doc.getPartialUserData(userData),
      );

      return dto.getUser(user);
    },
    async deleteUser(userId) {
      const id = userId as Id<"user">;
      await fetchMutation(api.user.remove, { id });
    },
    async linkAccount(account) {
      try {
        await fetchMutation(api.account.link, doc.getAccount(account));
        return account;
      } catch {
        throw new Error("Failed to create account");
      }
    },
    async unlinkAccount(providerData) {
      try {
        await fetchAction(api.account.unlink, providerData);
      } catch {
        throw new Error("Failed to delete account");
      }
    },
    async createSession(sessionData) {
      await fetchMutation(api.session.create, {
        userId: sessionData.userId as Id<"user">,
        expires: sessionData.expires.toISOString(),
        sessionToken: sessionData.sessionToken,
      });

      return sessionData;
    },
    async getSessionAndUser(sessionToken) {
      const data = await fetchQuery(api.user.getBySession, { sessionToken });
      if (!data?.user || !data?.session) return null;

      return {
        user: dto.getUser(data.user),
        session: {
          userId: data.session.userId as string,
          expires: new Date(data.session.expires),
          sessionToken,
        },
      };
    },
    // async updateSession({ sessionToken }) {
    //   return;
    // },
    // async deleteSession(sessionToken) {
    //   return;
    // },
    async createVerificationToken(token) {
      console.log("Creating token...");
      await fetchMutation(api.verificationToken.create, {
        ...token,
        expires: token.expires.toISOString(),
      });
      return token;
    },
    async useVerificationToken(tokenData) {
      console.log("Verifying token...");
      const verificationToken = await fetchQuery(
        api.verificationToken.getByIdToken,
        tokenData,
      );

      if (!verificationToken?._id) throw new Error("Could not use token");
      await fetchMutation(api.verificationToken.remove, {
        id: verificationToken._id,
      });
      return {
        token: verificationToken.token,
        identifier: verificationToken.identifier,
        expires: new Date(verificationToken.expires),
      };
    },
  };
}

[mad-coder-365]

@ATLAS2002 Thanks! Can you please also share the code for "dto" and "doc" from the utils file as I can see it's been used in the adapter?

[ATLAS2002]

This is a low effort version: https://github.com/ATLAS2002/exam-wizard/blob/main/src/lib/utils/util.adapter.ts. If an adapter for convex gets added, a more dynamic approach will be chosen.

[kevalRabadiya]

why identity was getting a null and given error is Unauthorized, even i sign in with clerk successfully? and create entry in database

export const create = mutation({
args:{
email:v.string()
},
handler:async(ctx,args)=>{
const identity = await ctx.auth.getUserIdentity();
if(!identity) throw new ConvexError("Unauthorized")
if(args.email===identity.email){
throw new ConvexError("Can't send Request Yourself..")
}