@convex-dev/better-auth 0.8.0-alpha.8 → 0.8.0

package/src/plugins/convex/index.ts

@@ -2,45 +2,21 @@ import { createAuthMiddleware, sessionMiddleware } from "better-auth/api";
 import {
   BetterAuthPlugin,
   createAuthEndpoint,
-  customSession as customSessionPlugin,
   jwt as jwtPlugin,
   bearer as bearerPlugin,
   oidcProvider as oidcProviderPlugin,
 } from "better-auth/plugins";
-import { BetterAuthOptions } from "better-auth/types";
-import { omit } from "convex-helpers";
-import { z } from "zod";
 
 export const JWT_COOKIE_NAME = "convex_jwt";
 
-export const convex = <O extends BetterAuthOptions>(
+export const convex = (
   opts: {
     jwtExpirationSeconds?: number;
     deleteExpiredSessionsOnLogin?: boolean;
-    options?: O;
+    options?: { basePath?: string };
   } = {}
 ) => {
-  const {
-    jwtExpirationSeconds = 60 * 15,
-    deleteExpiredSessionsOnLogin = false,
-  } = opts;
-  const customSession = customSessionPlugin(async ({ user, session }) => {
-    // Doing terrible things with types because user and session aren't actually
-    // objects and we need plugin inference to work
-    const { userId, ...userData } = omit(
-      user as typeof user & { id: string; userId: string },
-      ["id"]
-    ) as typeof user & {
-      userId: string;
-    };
-    return {
-      user: { ...userData, id: userId },
-      session: {
-        ...(session as typeof session & {}),
-        userId,
-      },
-    };
-  }, opts.options);
+  const { jwtExpirationSeconds = 60 * 15 } = opts;
   const oidcProvider = oidcProviderPlugin({
     loginPage: "/not-used",
     metadata: {
@@ -53,14 +29,11 @@ export const convex = <O extends BetterAuthOptions>(
       issuer: `${process.env.CONVEX_SITE_URL}`,
       audience: "convex",
       expirationTime: `${jwtExpirationSeconds}s`,
-      getSubject: (session) => {
-        // Return the userId from the app user table
-        return session.user.userId;
-      },
       // eslint-disable-next-line @typescript-eslint/no-unused-vars
-      definePayload: ({ user: { id, userId, image, ...user }, session }) => ({
+      definePayload: ({ user: { id, image, ...user }, session }) => ({
         ...user,
         sessionId: session.id,
+        iat: Math.floor(new Date().getTime() / 1000),
       }),
     },
   });
@@ -76,69 +49,20 @@ export const convex = <O extends BetterAuthOptions>(
   };
   return {
     id: "convex",
+    init: ({ logger, options }) => {
+      if (
+        options.plugins?.every((p) => p.id !== "cross-domain") &&
+        !options.baseURL
+      ) {
+        logger.warn(
+          "Better Auth baseURL is undefined. This is probably a mistake."
+        );
+      }
+    },
     hooks: {
-      before: [
-        {
-          matcher: (ctx) => {
-            return !!ctx.body?.userId;
-          },
-          handler: createAuthMiddleware(async (ctx) => {
-            const user: { id: string } | null =
-              await ctx.context.adapter.findOne({
-                model: "user",
-                where: [
-                  {
-                    field: "userId",
-                    operator: "eq",
-                    value: ctx.body?.userId,
-                  },
-                ],
-              });
-            if (!user) {
-              throw new Error("User not found");
-            }
-            ctx.body.userId = user.id;
-            return {
-              context: ctx,
-            };
-          }),
-        },
-        ...bearer.hooks.before,
-      ],
+      before: [...bearer.hooks.before],
       after: [
         ...oidcProvider.hooks.after,
-        {
-          matcher: (ctx) => {
-            return (
-              deleteExpiredSessionsOnLogin &&
-              (ctx.path?.startsWith("/sign-in") ||
-                ctx.path?.startsWith("/callback"))
-            );
-          },
-          handler: createAuthMiddleware(async (ctx) => {
-            // Delete expired sessions at login
-            const userId = ctx.context.newSession?.user.id;
-            if (!userId) {
-              return;
-            }
-            await ctx.context.adapter.deleteMany({
-              model: "session",
-              where: [
-                {
-                  field: "userId",
-                  operator: "eq",
-                  value: userId,
-                  connector: "AND",
-                },
-                {
-                  operator: "lte",
-                  field: "expiresAt",
-                  value: new Date().getTime(),
-                },
-              ],
-            });
-          }),
-        },
         {
           matcher: (ctx) => {
             return (
@@ -193,61 +117,6 @@ export const convex = <O extends BetterAuthOptions>(
       ],
     },
     endpoints: {
-      getSession: createAuthEndpoint(
-        "/get-session",
-        {
-          method: "GET",
-          query: z.optional(
-            z.object({
-              // If cookie cache is enabled, it will disable the cache
-              // and fetch the session from the database
-              disableCookieCache: z
-                .boolean({
-                  description:
-                    "Disable cookie cache and fetch session from database",
-                })
-                .or(z.string().transform((v) => v === "true"))
-                .optional(),
-              disableRefresh: z
-                .boolean({
-                  description:
-                    "Disable session refresh. Useful for checking session status, without updating the session",
-                })
-                .optional(),
-            })
-          ),
-          metadata: {
-            CUSTOM_SESSION: true,
-            openapi: {
-              description: "Get custom session data",
-              responses: {
-                "200": {
-                  description: "Success",
-                  content: {
-                    "application/json": {
-                      schema: {
-                        type: "array",
-                        nullable: true,
-                        items: {
-                          $ref: "#/components/schemas/Session",
-                        },
-                      },
-                    },
-                  },
-                },
-              },
-            },
-          },
-          requireHeaders: true,
-        },
-        async (ctx) => {
-          const response = await customSession.endpoints.getSession({
-            ...ctx,
-            returnHeaders: false,
-          });
-          return response;
-        }
-      ),
       getOpenIdConfig: createAuthEndpoint(
         "/convex/.well-known/openid-configuration",
         {

package/src/plugins/cross-domain/index.ts

@@ -129,7 +129,7 @@ export const crossDomain = ({ siteUrl }: { siteUrl: string }) => {
             // Mostly copied from the one-time-token plugin
             const session = ctx.context.newSession;
             if (!session) {
-              console.error("No session found");
+              ctx.context.logger.error("No session found");
               return;
             }
             const token = generateRandomString(32);
@@ -141,7 +141,7 @@ export const crossDomain = ({ siteUrl }: { siteUrl: string }) => {
             });
             const redirectTo = ctx.context.responseHeaders?.get("location");
             if (!redirectTo) {
-              console.error("No redirect to found");
+              ctx.context.logger.error("No redirect to found");
               return;
             }
             const url = new URL(redirectTo);

package/src/react-start/index.ts

@@ -1,38 +1,72 @@
 import { betterAuth } from "better-auth";
 import { createCookieGetter } from "better-auth/cookies";
 import { betterFetch } from "@better-fetch/fetch";
-import { GenericActionCtx } from "convex/server";
+import {
+  FunctionReference,
+  FunctionReturnType,
+  GenericActionCtx,
+} from "convex/server";
 import { JWT_COOKIE_NAME } from "../plugins/convex";
-import { oneLine } from "common-tags";
+import { ConvexHttpClient } from "convex/browser";
 
-export const getCookieName = async (
-  createAuth: (ctx: GenericActionCtx<any>) => ReturnType<typeof betterAuth>
+export const getCookieName = (
+  createAuth: (ctx: any) => ReturnType<typeof betterAuth>
 ) => {
-  const auth = createAuth({} as any);
-  const createCookie = createCookieGetter(auth.options);
+  const createCookie = createCookieGetter(createAuth({} as any).options);
   const cookie = createCookie(JWT_COOKIE_NAME);
   return cookie.name;
 };
 
-const requireConvexSiteUrl = (
-  opts: { convexSiteUrl: string; verbose?: boolean },
-  calledFrom: string
+export const setupFetchClient = async (
+  createAuth: (ctx: any) => ReturnType<typeof betterAuth>
 ) => {
-  if (!opts.convexSiteUrl) {
-    throw new Error(`${calledFrom}: opts.convexSiteUrl is required`);
-  }
-  if (opts.verbose) {
-    console.log(`${calledFrom}: opts.convexSiteUrl: ${opts.convexSiteUrl}`);
-  }
-  return opts.convexSiteUrl;
+  const { getCookie } = await import("@tanstack/react-start/server");
+  const createClient = () => {
+    const sessionCookieName = getCookieName(createAuth);
+    const token = getCookie(sessionCookieName);
+    const client = new ConvexHttpClient(process.env.VITE_CONVEX_URL!);
+    if (token) {
+      client.setAuth(token);
+    }
+    return client;
+  };
+  return {
+    fetchQuery<
+      Query extends FunctionReference<"query">,
+      FuncRef extends FunctionReference<any, any>,
+    >(
+      query: Query,
+      args: FuncRef["_args"]
+    ): Promise<FunctionReturnType<Query>> {
+      return createClient().query(query, args);
+    },
+    fetchMutation<
+      Mutation extends FunctionReference<"mutation">,
+      FuncRef extends FunctionReference<any, any>,
+    >(
+      mutation: Mutation,
+      args: FuncRef["_args"]
+    ): Promise<FunctionReturnType<Mutation>> {
+      return createClient().mutation(mutation, args);
+    },
+    fetchAction<
+      Action extends FunctionReference<"action">,
+      FuncRef extends FunctionReference<any, any>,
+    >(
+      action: Action,
+      args: FuncRef["_args"]
+    ): Promise<FunctionReturnType<Action>> {
+      return createClient().action(action, args);
+    },
+  };
 };
 
 export const fetchSession = async <
   T extends (ctx: GenericActionCtx<any>) => ReturnType<typeof betterAuth>,
 >(
   request: Request,
-  opts: {
-    convexSiteUrl: string;
+  opts?: {
+    convexSiteUrl?: string;
     verbose?: boolean;
   }
 ) => {
@@ -41,7 +75,10 @@ export const fetchSession = async <
   if (!request) {
     throw new Error("No request found");
   }
-  const convexSiteUrl = requireConvexSiteUrl(opts, "fetchSession");
+  const convexSiteUrl = opts?.convexSiteUrl ?? process.env.VITE_CONVEX_SITE_URL;
+  if (!convexSiteUrl) {
+    throw new Error("VITE_CONVEX_SITE_URL is not set");
+  }
   const { data: session } = await betterFetch<Session>(
     "/api/auth/get-session",
     {
@@ -56,36 +93,31 @@ export const fetchSession = async <
   };
 };
 
+export const getAuth = async (
+  request: Request,
+  createAuth: (ctx: any) => ReturnType<typeof betterAuth>,
+  opts?: { convexSiteUrl?: string }
+) => {
+  const { getCookie } = await import("@tanstack/react-start/server");
+  const sessionCookieName = getCookieName(createAuth);
+  const token = getCookie(sessionCookieName);
+  const { session } = await fetchSession(request, opts);
+  return {
+    userId: session?.user.id,
+    token,
+  };
+};
+
 export const reactStartHandler = (
   request: Request,
-  opts: { convexSiteUrl: string; verbose?: boolean }
+  opts?: { convexSiteUrl?: string; verbose?: boolean }
 ) => {
   const requestUrl = new URL(request.url);
-  const convexSiteUrl = requireConvexSiteUrl(opts, "reactStartHandler");
+  const convexSiteUrl = opts?.convexSiteUrl ?? process.env.VITE_CONVEX_SITE_URL;
+  if (!convexSiteUrl) {
+    throw new Error("VITE_CONVEX_SITE_URL is not set");
+  }
   const nextUrl = `${convexSiteUrl}${requestUrl.pathname}${requestUrl.search}`;
   request.headers.set("accept-encoding", "application/json");
   return fetch(nextUrl, new Request(request, { redirect: "manual" }));
 };
-
-export const reactStartHelpers = (
-  createAuth: (ctx: GenericActionCtx<any>) => ReturnType<typeof betterAuth>,
-  opts: { convexSiteUrl: string; verbose?: boolean }
-) => {
-  if (!opts.convexSiteUrl) {
-    throw new Error("opts.convexSiteUrl is required");
-  }
-  if (opts.convexSiteUrl.endsWith(".convex.cloud")) {
-    throw new Error(
-      oneLine(`
-        opts.convexSiteUrl ends with .convex.cloud, which is your cloud URL.
-        Use your Convex site URL instead.
-        https://docs.convex.dev/production/environment-variables#system-environment-variables
-      `)
-    );
-  }
-  return {
-    fetchSession: (request: Request) => fetchSession(request, opts),
-    reactStartHandler: (request: Request) => reactStartHandler(request, opts),
-    getCookieName: () => getCookieName(createAuth),
-  };
-};

package/src/component/util.ts

@@ -1,4 +0,0 @@
-import { typedV } from "convex-helpers/validators";
-import schema from "./schema";
-
-export const vv = typedV(schema);