@convex-dev/better-auth 0.10.5 → 0.10.7

package/src/component/adapterTest.ts

@@ -1,116 +1,473 @@
-import { convexAdapter } from "../client/index.js";
+import { runAdapterTest } from "better-auth/adapters/test";
+import { createClient } from "../client/index.js";
 import type { GenericCtx } from "../client/index.js";
 import { api } from "./_generated/api.js";
-import { mutation, query } from "./_generated/server.js";
-import type {
-  GenericDataModel,
-  GenericMutationCtx,
-  GenericQueryCtx,
-  RegisteredMutation,
-  RegisteredQuery,
-} from "convex/server";
+import { action } from "./_generated/server.js";
+import type { GenericActionCtx } from "convex/server";
+import type { DataModel } from "./_generated/dataModel.js";
+import type { BetterAuthOptions } from "better-auth";
+import type { EmptyObject } from "convex-helpers";
+import { beforeEach, expect, test } from "vitest";
 
-export const createAdapter = <DataModel extends GenericDataModel>(
+export const getAdapter: (
   ctx: GenericCtx<DataModel>
-) =>
-  convexAdapter(ctx as any, api as any, {
-    debugLogs: {
-      isRunningAdapterTests: true,
-    },
-  });
-
-export const deserialize = (data: any) => {
-  const dateStringRegex =
-    /\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d\.\d+([+-][0-2]\d:[0-5]\d|Z)/;
-  return Object.fromEntries(
-    Object.entries(data).map(([key, value]) => [
-      key,
-      dateStringRegex.test(value as string) ? new Date(value as string) : value,
-    ])
-  );
-};
-
-export const serialize = (data: any) => {
-  if (!data) {
-    return data;
-  }
-  return Object.fromEntries(
-    Object.entries(data).map(([key, value]) => [
-      key,
-      value instanceof Date ? value.toISOString() : value,
-    ])
-  );
-};
+) => Parameters<typeof runAdapterTest>[0]["getAdapter"] =
+  (ctx: GenericCtx<DataModel>) =>
+  async (opts?: Omit<BetterAuthOptions, "database">) => {
+    const authComponent = createClient<DataModel>(api as any, {
+      verbose: false,
+    });
+    const adapterFactory = authComponent.adapter(ctx);
+    const options = {
+      ...(opts ?? {}),
+      user: {
+        ...(opts?.user ?? {}),
+        // We don't currently support custom schema for tests, need to find a
+        // way to do this.
+        fields: undefined,
+      },
+    };
+    return adapterFactory(options);
+  };
 
-export const create: RegisteredMutation<"public", any, Promise<any>> = mutation(
-  async (ctx: GenericMutationCtx<any>, args: any) => {
-    const adapter = createAdapter(ctx);
-    const result = await adapter({}).create({
-      ...args,
-      data: deserialize(args.data),
-    });
-    return serialize(result);
+// Tests need to run inside of a Convex function to use the Convex adapter
+export const runTests = action(
+  async (
+    ctx: GenericActionCtx<DataModel>,
+    args: { disableTests: Record<string, boolean> }
+  ) => {
+    runAdapterTest({
+      getAdapter: getAdapter(ctx),
+      disableTests: args.disableTests,
+    });
   }
 );
 
-export const findOne: RegisteredQuery<"public", any, Promise<any>> = query(
-  async (ctx: GenericQueryCtx<any>, args: any) => {
-    const adapter = createAdapter(ctx);
-    const result = await adapter({}).findOne(args);
-    return serialize(result);
+export const runCustomTests = action(
+  async (ctx: GenericActionCtx<DataModel>, _args: EmptyObject) => {
+    runCustomAdapterTests({
+      getAdapter: getAdapter(ctx),
+    });
   }
 );
 
-export const findMany: RegisteredQuery<"public", any, Promise<any>> = query(
-  async (ctx: GenericQueryCtx<any>, args: any) => {
-    const adapter = createAdapter(ctx);
-    const result = await adapter({}).findMany(args);
-    return result.map(serialize);
-  }
-);
+function runCustomAdapterTests({
+  getAdapter,
+}: {
+  getAdapter: Parameters<typeof runAdapterTest>[0]["getAdapter"];
+}) {
+  beforeEach(async () => {
+    const adapter = await getAdapter();
+    await adapter.deleteMany({
+      model: "user",
+      where: [],
+    });
+    await adapter.deleteMany({
+      model: "session",
+      where: [],
+    });
+  });
+  test("should handle lone range operators", async () => {
+    const adapter = await getAdapter();
+    const user = await adapter.create({
+      model: "user",
+      data: {
+        name: "ab",
+        email: "a@a.com",
+      },
+    });
+    expect(
+      await adapter.findMany({
+        model: "user",
+        where: [
+          {
+            field: "name",
+            operator: "lt",
+            value: "a",
+          },
+        ],
+      })
+    ).toEqual([]);
+    expect(
+      await adapter.findMany({
+        model: "user",
+        where: [
+          {
+            field: "name",
+            operator: "lte",
+            value: "a",
+          },
+        ],
+      })
+    ).toEqual([]);
+    expect(
+      await adapter.findMany({
+        model: "user",
+        where: [
+          {
+            field: "name",
+            operator: "gt",
+            value: "a",
+          },
+        ],
+      })
+    ).toEqual([user]);
+    expect(
+      await adapter.findMany({
+        model: "user",
+        where: [
+          {
+            field: "name",
+            operator: "gte",
+            value: "ab",
+          },
+        ],
+      })
+    ).toEqual([user]);
+  });
 
-export const count: RegisteredQuery<"public", any, Promise<any>> = query(
-  async (ctx: GenericQueryCtx<any>, args: any) => {
-    const adapter = createAdapter(ctx);
-    return adapter({}).count(args);
-  }
-);
+  test("should handle compound indexes that include id field", async () => {
+    const adapter = await getAdapter();
+    const user = await adapter.create({
+      model: "user",
+      data: {
+        name: "foo",
+        email: "foo@bar.com",
+      },
+    });
+    expect(
+      await adapter.findOne({
+        model: "user",
+        where: [
+          {
+            field: "id",
+            value: user.id,
+          },
+          {
+            field: "name",
+            value: "wrong name",
+          },
+        ],
+      })
+    ).toEqual(null);
+    expect(
+      await adapter.findOne({
+        model: "user",
+        where: [
+          {
+            field: "id",
+            value: user.id,
+          },
+          {
+            field: "name",
+            value: "foo",
+          },
+        ],
+      })
+    ).toEqual(user);
+    expect(
+      await adapter.findOne({
+        model: "user",
+        where: [
+          {
+            field: "id",
+            value: user.id,
+          },
+          {
+            field: "name",
+            value: "foo",
+            operator: "lt",
+          },
+        ],
+      })
+    ).toEqual(null);
+    expect(
+      await adapter.findOne({
+        model: "user",
+        where: [
+          {
+            field: "id",
+            value: user.id,
+          },
+          {
+            field: "name",
+            value: "foo",
+            operator: "lte",
+          },
+        ],
+      })
+    ).toEqual(user);
+    expect(
+      await adapter.findOne({
+        model: "user",
+        where: [
+          {
+            field: "id",
+            value: user.id,
+          },
+          {
+            field: "name",
+            value: "foo",
+            operator: "gt",
+          },
+        ],
+      })
+    ).toEqual(null);
+    expect(
+      await adapter.findOne({
+        model: "user",
+        where: [
+          {
+            field: "id",
+            value: user.id,
+          },
+          {
+            field: "name",
+            value: "foo",
+            operator: "gte",
+          },
+        ],
+      })
+    ).toEqual(user);
+    expect(
+      await adapter.findOne({
+        model: "user",
+        where: [
+          {
+            field: "id",
+            value: user.id,
+          },
+          {
+            field: "name",
+            operator: "in",
+            value: ["wrong", "name"],
+          },
+        ],
+      })
+    ).toEqual(null);
+    expect(
+      await adapter.findOne({
+        model: "user",
+        where: [
+          {
+            field: "id",
+            value: user.id,
+          },
+          {
+            field: "name",
+            operator: "in",
+            value: ["foo"],
+          },
+        ],
+      })
+    ).toEqual(user);
+  });
+  test("should automatically paginate", async () => {
+    const adapter = await getAdapter();
+    for (let i = 0; i < 300; i++) {
+      await adapter.create({
+        model: "user",
+        data: {
+          name: `foo${i}`,
+          email: `foo${i}@bar.com`,
+        },
+      });
+    }
+    // Better Auth defaults to a limit of 100
+    expect(
+      await adapter.findMany({
+        model: "user",
+      })
+    ).toHaveLength(100);
 
-export const update: RegisteredMutation<"public", any, Promise<any>> = mutation(
-  async (ctx: GenericMutationCtx<any>, args: any) => {
-    const adapter = createAdapter(ctx);
-    const result = await adapter({}).update({
-      ...args,
-      update: deserialize(args.update),
-    });
-    return serialize(result);
-  }
-);
+    // Pagination has a hardcoded numItems max of 200, this tests that it can handle
+    // specified limits beyond that
+    expect(
+      await adapter.findMany({
+        model: "user",
+        limit: 250,
+      })
+    ).toHaveLength(250);
+    expect(
+      await adapter.findMany({
+        model: "user",
+        limit: 350,
+      })
+    ).toHaveLength(300);
+  });
+  test("should handle OR where clauses", async () => {
+    const adapter = await getAdapter();
+    const user = await adapter.create({
+      model: "user",
+      data: {
+        name: "foo",
+        email: "foo@bar.com",
+      },
+    });
+    expect(
+      await adapter.findOne({
+        model: "user",
+        where: [
+          { field: "name", value: "bar", connector: "OR" },
+          { field: "name", value: "foo", connector: "OR" },
+        ],
+      })
+    ).toEqual(user);
+  });
+  test("should handle OR where clauses with sortBy", async () => {
+    const adapter = await getAdapter();
+    const fooUser = await adapter.create({
+      model: "user",
+      data: {
+        name: "foo",
+        email: "foo@bar.com",
+      },
+    });
+    const barUser = await adapter.create({
+      model: "user",
+      data: {
+        name: "bar",
+        email: "bar@bar.com",
+      },
+    });
+    await adapter.create({
+      model: "user",
+      data: {
+        name: "baz",
+        email: "baz@bar.com",
+      },
+    });
+    expect(
+      await adapter.findMany({
+        model: "user",
+        where: [
+          { field: "name", value: "bar", connector: "OR" },
+          { field: "name", value: "foo", connector: "OR" },
+        ],
+        sortBy: { field: "name", direction: "asc" },
+      })
+    ).toEqual([barUser, fooUser]);
+    expect(
+      await adapter.findMany({
+        model: "user",
+        where: [
+          { field: "name", value: "bar", connector: "OR" },
+          { field: "name", value: "foo", connector: "OR" },
+        ],
+        sortBy: { field: "name", direction: "desc" },
+      })
+    ).toEqual([fooUser, barUser]);
+  });
+  test("should handle count", async () => {
+    const adapter = await getAdapter();
+    await adapter.create({
+      model: "user",
+      data: {
+        name: "foo",
+        email: "foo@bar.com",
+      },
+    });
+    await adapter.create({
+      model: "user",
+      data: {
+        name: "bar",
+        email: "bar@bar.com",
+      },
+    });
+    expect(
+      await adapter.count({
+        model: "user",
+        where: [{ field: "name", value: "foo" }],
+      })
+    ).toEqual(1);
+  });
+  test("should handle queries with no index", async () => {
+    const adapter = await getAdapter();
+    const user = await adapter.create({
+      model: "user",
+      data: {
+        name: "foo",
+        email: "foo@bar.com",
+        emailVerified: true,
+      },
+    });
+    expect(
+      await adapter.findOne({
+        model: "user",
+        where: [{ field: "emailVerified", value: true }],
+      })
+    ).toEqual(user);
+    expect(
+      await adapter.findOne({
+        model: "user",
+        where: [{ field: "emailVerified", value: false }],
+      })
+    ).toEqual(null);
+  });
 
-export const updateMany: RegisteredMutation<
-  "public",
-  any,
-  Promise<any>
-> = mutation(async (ctx: GenericMutationCtx<any>, args: any) => {
-  const adapter = createAdapter(ctx);
-  return adapter({}).updateMany(args);
-});
+  test("should handle compound operator on non-unique field without an index", async () => {
+    const adapter = await getAdapter();
+    await adapter.create({
+      model: "account",
+      data: {
+        accountId: "foo",
+        providerId: "bar",
+        userId: "baz",
+        accessTokenExpiresAt: null,
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+      },
+    });
+    expect(
+      await adapter.findOne({
+        model: "account",
+        where: [
+          {
+            operator: "lt",
+            connector: "AND",
+            field: "accessTokenExpiresAt",
+            value: Date.now(),
+          },
+          {
+            operator: "ne",
+            connector: "AND",
+            field: "accessTokenExpiresAt",
+            value: null,
+          },
+        ],
+      })
+    ).toEqual(null);
+  });
 
-const deleteMutation: RegisteredMutation<
-  "public",
-  any,
-  Promise<any>
-> = mutation(async (ctx: GenericMutationCtx<any>, args: any) => {
-  const adapter = createAdapter(ctx);
-  await adapter({}).delete(args);
-});
-export { deleteMutation as delete };
+  test("should fail to create a record with a unique field that already exists", async () => {
+    const adapter = await getAdapter();
+    await adapter.create({
+      model: "user",
+      data: { name: "foo", email: "foo@bar.com" },
+    });
+    await expect(
+      adapter.create({
+        model: "user",
+        data: { name: "foo", email: "foo@bar.com" },
+      })
+    ).rejects.toThrow("user email already exists");
+  });
 
-export const deleteMany: RegisteredMutation<
-  "public",
-  any,
-  Promise<any>
-> = mutation(async (ctx: GenericMutationCtx<any>, args: any) => {
-  const adapter = createAdapter(ctx);
-  return adapter({}).deleteMany(args);
-});
+  test("should be able to compare against a date", async () => {
+    const adapter = await getAdapter();
+    const user = await adapter.create({
+      model: "user",
+      data: {
+        name: "foo",
+        email: "foo@bar.com",
+        createdAt: new Date().toISOString(),
+      },
+    });
+    expect(
+      await adapter.findOne({
+        model: "user",
+        where: [{ field: "createdAt", value: new Date().toISOString() }],
+      })
+    ).toEqual(user);
+  });
+}

package/src/nextjs/index.ts

@@ -45,7 +45,7 @@ const handler = (request: Request, siteUrl: string) => {
   const nextUrl = `${siteUrl}${requestUrl.pathname}${requestUrl.search}`;
   const newRequest = new Request(nextUrl, request);
   newRequest.headers.set("accept-encoding", "application/json");
-  newRequest.headers.set("host", siteUrl);
+  newRequest.headers.set("host", new URL(siteUrl).host);
   return fetch(newRequest, { method: request.method, redirect: "manual" });
 };
 

package/src/plugins/convex/index.ts

@@ -1,9 +1,9 @@
 import type {
-  BetterAuthOptions,
   BetterAuthPlugin,
   Session,
   User,
 } from "better-auth";
+import type { BetterAuthOptions } from "better-auth/minimal";
 import { createAuthMiddleware, sessionMiddleware } from "better-auth/api";
 import {
   createAuthEndpoint,
@@ -53,6 +53,7 @@ const parseAuthConfig = (authConfig: AuthConfig, opts: { jwks?: string }) => {
     );
   }
   if (!isDataUriJwks && opts.jwks) {
+    // eslint-disable-next-line no-console
     console.warn(
       "Static JWKS provided to Convex plugin, but not to auth config. This adds an unnecessary network request for token verification."
     );
@@ -241,8 +242,9 @@ export const convex = (opts: {
   return {
     id: "convex",
     init: (ctx) => {
-      const { options, logger } = ctx;
+      const { options, logger: _logger } = ctx;
       if (options.basePath !== "/api/auth" && !opts.options?.basePath) {
+        // eslint-disable-next-line no-console
         console.warn(
           `Better Auth basePath set to ${options.basePath} but no basePath is set in the Convex plugin. This is probably a mistake.`
         );
@@ -251,18 +253,11 @@ export const convex = (opts: {
         opts.options?.basePath &&
         options.basePath !== opts.options?.basePath
       ) {
+        // eslint-disable-next-line no-console
         console.warn(
           `Better Auth basePath ${options.basePath} does not match Convex plugin basePath ${opts.options?.basePath}. This is probably a mistake.`
         );
       }
-      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: [
@@ -585,6 +580,7 @@ export const convex = (opts: {
                 });
                 return await runEndpoint();
               } else {
+                // eslint-disable-next-line no-console
                 console.error(
                   "Try temporarily setting jwksRotateOnTokenGenerationError: true on the Convex Better Auth plugin."
                 );

package/src/react-start/index.ts

@@ -64,7 +64,7 @@ const handler = (request: Request, opts: { convexSiteUrl: string }) => {
   const nextUrl = `${opts.convexSiteUrl}${requestUrl.pathname}${requestUrl.search}`;
   const headers = new Headers(request.headers);
   headers.set("accept-encoding", "application/json");
-  headers.set("host", opts.convexSiteUrl);
+  headers.set("host", new URL(opts.convexSiteUrl).host);
   return fetch(nextUrl, {
     method: request.method,
     headers,

package/src/utils/index.ts

@@ -1,5 +1,6 @@
 import { betterFetch } from "@better-fetch/fetch";
-import type { Auth, betterAuth } from "better-auth";
+import type { Auth } from "better-auth";
+import type { betterAuth } from "better-auth/minimal";
 import { getSessionCookie } from "better-auth/cookies";
 import type {
   AuthProvider,
@@ -143,6 +144,7 @@ export const getToken = async (
       return { isFresh: false, token };
     }
   } catch (error) {
+    // eslint-disable-next-line no-console
     console.error("Error decoding JWT", error);
   }
   return await fetchToken();