@convex-dev/better-auth 0.8.9 → 0.9.0

package/package.json

@@ -6,7 +6,7 @@
   "bugs": {
     "url": "https://github.com/get-convex/better-auth/issues"
   },
-  "version": "0.8.9",
+  "version": "0.9.0",
   "license": "Apache-2.0",
   "keywords": [
     "convex",
@@ -23,7 +23,7 @@
     "build:cjs": "tsc --project ./commonjs.json && npm run build:cjs:generatePackageJson",
     "build:esm:generatePackageJson": "echo '{\\n  \"type\": \"module\"\\n}' > dist/esm/package.json",
     "build:cjs:generatePackageJson": "echo '{\\n  \"type\": \"commonjs\"\\n}' > dist/commonjs/package.json",
-    "build:watch": "chokidar 'tsconfig*.json' 'src/**/*.ts' -c 'npm run build' --initial",
+    "build:watch": "chokidar 'tsconfig*.json' 'src/**/*.{ts,tsx}' -c 'npm run build' --initial",
     "typecheck": "tsc --noEmit",
     "prepack": "node node10stubs.mjs",
     "prepublishOnly": "npm run build",
@@ -79,10 +79,12 @@
     },
     "./nextjs": {
       "import": {
+        "@convex-dev/component-source": "./src/nextjs/index.ts",
         "types": "./dist/esm/nextjs/index.d.ts",
         "default": "./dist/esm/nextjs/index.js"
       },
       "require": {
+        "@convex-dev/component-source": "./src/nextjs/index.ts",
         "types": "./dist/commonjs/nextjs/index.d.ts",
         "default": "./dist/commonjs/nextjs/index.js"
       }
@@ -113,10 +115,12 @@
     },
     "./react-start": {
       "import": {
+        "@convex-dev/component-source": "./src/react-start/index.ts",
         "types": "./dist/esm/react-start/index.d.ts",
         "default": "./dist/esm/react-start/index.js"
       },
       "require": {
+        "@convex-dev/component-source": "./src/react-start/index.ts",
         "types": "./dist/commonjs/react-start/index.d.ts",
         "default": "./dist/commonjs/react-start/index.js"
       }
@@ -149,18 +153,16 @@
     }
   },
   "peerDependencies": {
-    "better-auth": "1.3.8",
+    "better-auth": "1.3.27",
     "convex": "^1.26.2",
     "react": "^18.3.1 || ^19.0.0",
     "react-dom": "^18.3.1 || ^19.0.0"
   },
   "devDependencies": {
-    "@better-auth/stripe": "1.3.8",
+    "@better-fetch/fetch": "^1.1.18",
     "@edge-runtime/vm": "^5.0.0",
     "@eslint/js": "^9.9.1",
-    "@polar-sh/better-auth": "^1.0.4",
-    "@polar-sh/sdk": "^0.34.5",
-    "@tanstack/react-start": "^1.120.19",
+    "@tanstack/react-start": "^1.132.37",
     "@types/common-tags": "^1.8.4",
     "@types/node": "^20",
     "@types/react": "19.1.6",
@@ -183,11 +185,14 @@
   "types": "./dist/commonjs/client/index.d.ts",
   "module": "./dist/esm/client/index.js",
   "dependencies": {
-    "@better-fetch/fetch": "^1.1.18",
+    "@vitejs/plugin-react": "^5.0.4",
     "common-tags": "^1.8.2",
     "convex-helpers": "^0.1.95",
     "is-network-error": "^1.1.0",
+    "remeda": "^2.32.0",
     "type-fest": "^4.39.1",
+    "vite": "^7.1.9",
+    "vite-tsconfig-paths": "^5.1.4",
     "zod": "^3.24.4"
   }
 }

package/src/client/adapter.test.ts

@@ -42,47 +42,62 @@ export const getAdapter = (t: ReturnType<typeof convexTest>) => async () => {
     deleteMany: async (data) => {
       return t.mutation(api.adapterTest.deleteMany, data);
     },
+    transaction: false as any,
   } satisfies Adapter;
 };
 
 describe("Better Auth Adapter Tests", async () => {
   const _t = convexTest(schema, import.meta.glob("../component/**/*.*s"));
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  const activeTests = [
-    "CREATE_MODEL",
-    "CREATE_MODEL_SHOULD_ALWAYS_RETURN_AN_ID",
-    "FIND_MODEL",
-    "FIND_MODEL_WITHOUT_ID",
-    "FIND_MODEL_WITH_SELECT",
-    "FIND_MODEL_WITH_MODIFIED_FIELD_NAME",
-    "UPDATE_MODEL",
-    "SHOULD_FIND_MANY",
-    "SHOULD_FIND_MANY_WITH_WHERE",
-    "SHOULD_FIND_MANY_WITH_OPERATORS",
-    "SHOULD_WORK_WITH_REFERENCE_FIELDS",
-    "SHOULD_FIND_MANY_WITH_SORT_BY",
-    "SHOULD_FIND_MANY_WITH_LIMIT",
-    "SHOULD_UPDATE_WITH_MULTIPLE_WHERE",
-    "DELETE_MODEL",
-    "SHOULD_DELETE_MANY",
-    "SHOULD_NOT_THROW_ON_DELETE_RECORD_NOT_FOUND",
-    "SHOULD_NOT_THROW_ON_RECORD_NOT_FOUND",
-    "SHOULD_FIND_MANY_WITH_CONTAINS_OPERATOR",
-    "SHOULD_SEARCH_USERS_WITH_STARTS_WITH",
-    "SHOULD_SEARCH_USERS_WITH_ENDS_WITH",
-  ];
-  const inactiveTests = [
-    // not supported
-    "SHOULD_FIND_MANY_WITH_OFFSET",
-    "SHOULD_PREFER_GENERATE_ID_IF_PROVIDED",
-  ];
+  const status = {
+    active: "active",
+    only: "only",
+    notSupported: "not supported",
+  } as const;
+  const tests: Record<string, (typeof status)[keyof typeof status]> = {
+    CREATE_MODEL: status.active,
+    CREATE_MODEL_SHOULD_ALWAYS_RETURN_AN_ID: status.active,
+    FIND_MODEL: status.active,
+    FIND_MODEL_WITHOUT_ID: status.active,
+    FIND_MODEL_WITH_SELECT: status.active,
+    FIND_MODEL_WITH_MODIFIED_FIELD_NAME: status.active,
+    UPDATE_MODEL: status.active,
+    SHOULD_FIND_MANY: status.active,
+    SHOULD_FIND_MANY_WITH_WHERE: status.active,
+    SHOULD_FIND_MANY_WITH_OPERATORS: status.active,
+    SHOULD_WORK_WITH_REFERENCE_FIELDS: status.active,
+    SHOULD_FIND_MANY_WITH_NOT_IN_OPERATOR: status.active,
+    SHOULD_FIND_MANY_WITH_SORT_BY: status.active,
+    SHOULD_FIND_MANY_WITH_LIMIT: status.active,
+    SHOULD_UPDATE_WITH_MULTIPLE_WHERE: status.active,
+    DELETE_MODEL: status.active,
+    SHOULD_DELETE_MANY: status.active,
+    SHOULD_NOT_THROW_ON_DELETE_RECORD_NOT_FOUND: status.active,
+    SHOULD_NOT_THROW_ON_RECORD_NOT_FOUND: status.active,
+    SHOULD_FIND_MANY_WITH_CONTAINS_OPERATOR: status.active,
+    SHOULD_SEARCH_USERS_WITH_STARTS_WITH: status.active,
+    SHOULD_SEARCH_USERS_WITH_ENDS_WITH: status.active,
+    // Use local install and Convex paginated queries
+    SHOULD_FIND_MANY_WITH_OFFSET: status.notSupported,
+    // Convex generates ids on insert
+    SHOULD_PREFER_GENERATE_ID_IF_PROVIDED: status.notSupported,
+    // Transactions are inherent for auth.api and not possible for authClient
+    SHOULD_ROLLBACK_FAILING_TRANSACTION: status.notSupported,
+    SHOULD_RETURN_TRANSACTION_RESULT: status.notSupported,
+    SHOULD_FIND_MANY_WITH_CONNECTORS: status.active,
+  };
+
+  const disableTests = Object.fromEntries(
+    Object.entries(tests).map((entry, idx, arr) => {
+      if (arr.some((e) => e[1] === status.only)) {
+        return [entry[0], !(entry[1] === status.only)];
+      }
+      return [entry[0], !(entry[1] === status.active)];
+    })
+  );
 
   await runAdapterTest({
     getAdapter: getAdapter(_t),
-    disableTests: Object.fromEntries([
-      ...activeTests.map((test) => [test, false]),
-      ...inactiveTests.map((test) => [test, true]),
-    ]),
+    disableTests,
   });
 });
 
@@ -338,6 +353,51 @@ describe("Convex Adapter Tests", async () => {
       })
     ).toEqual(user);
   });
+  test("should handle OR where clauses with sortBy", async () => {
+    const t = convexTest(schema, import.meta.glob("../component/**/*.*s"));
+    const adapter = await getAdapter(t)();
+    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 t = convexTest(schema, import.meta.glob("../component/**/*.*s"));
     const adapter = await getAdapter(t)();
@@ -387,7 +447,7 @@ describe("Convex Adapter Tests", async () => {
     ).toEqual(null);
   });
 
-  test("should handle compound operator on non-unique fieldwithout an index", async () => {
+  test("should handle compound operator on non-unique field without an index", async () => {
     const t = convexTest(schema, import.meta.glob("../component/**/*.*s"));
     const adapter = await getAdapter(t)();
     await adapter.create({

package/src/client/adapter.ts

@@ -1,7 +1,6 @@
 import {
-  AdapterDebugLogs,
-  CleanedWhere,
-  createAdapter,
+  createAdapterFactory,
+  DBAdapterDebugLogOption,
 } from "better-auth/adapters";
 import {
   createFunctionHandle,
@@ -13,10 +12,13 @@ import {
   SchemaDefinition,
 } from "convex/server";
 import { SetOptional } from "type-fest";
-import { createSchema } from "./createSchema";
 import { AuthFunctions, GenericCtx, Triggers, UseApi } from ".";
 import defaultSchema from "../component/schema";
 import { api as componentApi } from "../component/_generated/api";
+import { Where } from "better-auth/types";
+import { asyncMap } from "convex-helpers";
+import { prop, sortBy, unique } from "remeda";
+import { isRunMutationCtx } from "../utils";
 
 const handlePagination = async (
   next: ({
@@ -77,11 +79,11 @@ const handlePagination = async (
   return state;
 };
 
-type ConvexCleanedWhere = CleanedWhere & {
+type ConvexCleanedWhere = Where & {
   value: string | number | boolean | string[] | number[] | null;
 };
 
-const parseWhere = (where?: CleanedWhere[]): ConvexCleanedWhere[] => {
+const parseWhere = (where?: Where[]): ConvexCleanedWhere[] => {
   return where?.map((where) => {
     if (where.value instanceof Date) {
       return {
@@ -99,21 +101,31 @@ export const convexAdapter = <
   Schema extends SchemaDefinition<any, any> = typeof defaultSchema,
 >(
   ctx: Ctx,
-  api: UseApi<typeof componentApi>,
+  api: {
+    adapter: SetOptional<
+      UseApi<typeof componentApi>["adapter"],
+      "migrationRemoveUserId"
+    >;
+    adapterTest?: UseApi<typeof componentApi>["adapterTest"];
+  },
   config: {
-    debugLogs?: AdapterDebugLogs;
+    debugLogs?: DBAdapterDebugLogOption;
     authFunctions?: AuthFunctions;
     triggers?: Triggers<DataModel, Schema>;
   } = {}
 ) => {
-  return createAdapter({
+  return createAdapterFactory({
     config: {
       adapterId: "convex",
       adapterName: "Convex Adapter",
       debugLogs: config.debugLogs || false,
       disableIdGeneration: true,
+      transaction: false,
       supportsNumericIds: false,
       usePlural: false,
+      mapKeysTransformInput: {
+        id: "_id",
+      },
       mapKeysTransformOutput: {
         _id: "id",
       },
@@ -135,10 +147,17 @@ export const convexAdapter = <
       },
     },
     adapter: ({ options }) => {
+      // Disable telemetry in all cases because it requires Node
       options.telemetry = { enabled: false };
       return {
         id: "convex",
-        createSchema,
+        options: {
+          isRunMutationCtx: isRunMutationCtx(ctx),
+        },
+        createSchema: async ({ file, tables }) => {
+          const { createSchema } = await import("./createSchema");
+          return createSchema({ file, tables });
+        },
         create: async ({ model, data, select }): Promise<any> => {
           if (!("runMutation" in ctx)) {
             throw new Error("ctx is not a mutation ctx");
@@ -177,8 +196,30 @@ export const convexAdapter = <
             throw new Error("offset not supported");
           }
           if (data.where?.some((w) => w.connector === "OR")) {
-            throw new Error("OR connector not supported in findMany");
+            const results = await asyncMap(data.where, async (w) =>
+              handlePagination(
+                async ({ paginationOpts }) => {
+                  return await ctx.runQuery(api.adapter.findMany, {
+                    ...data,
+                    where: parseWhere([w]),
+                    paginationOpts,
+                  });
+                },
+                { limit: data.limit }
+              )
+            );
+            const docs = unique(results.flatMap((r) => r.docs));
+            if (data.sortBy) {
+              const result = sortBy(docs, [
+                prop(data.sortBy.field),
+                data.sortBy.direction,
+              ]);
+              console.log(result);
+              return result;
+            }
+            return docs;
           }
+
           const result = await handlePagination(
             async ({ paginationOpts }) => {
               return await ctx.runQuery(api.adapter.findMany, {
@@ -194,8 +235,19 @@ export const convexAdapter = <
         count: async (data) => {
           // Yes, count is just findMany returning a number.
           if (data.where?.some((w) => w.connector === "OR")) {
-            throw new Error("OR connector not supported in findMany");
+            const results = await asyncMap(data.where, async (w) =>
+              handlePagination(async ({ paginationOpts }) => {
+                return await ctx.runQuery(api.adapter.findMany, {
+                  ...data,
+                  where: parseWhere([w]),
+                  paginationOpts,
+                });
+              })
+            );
+            const docs = unique(results.flatMap((r) => r.docs));
+            return docs.length;
           }
+
           const result = await handlePagination(async ({ paginationOpts }) => {
             return await ctx.runQuery(api.adapter.findMany, {
               ...data,
@@ -203,7 +255,7 @@ export const convexAdapter = <
               paginationOpts,
             });
           });
-          return result.docs?.length ?? 0;
+          return result.docs.length;
         },
         update: async (data): Promise<any> => {
           if (!("runMutation" in ctx)) {
@@ -272,7 +324,7 @@ export const convexAdapter = <
         },
         updateMany: async (data) => {
           if (!("runMutation" in ctx)) {
-            throw new Error("ctx is not an action ctx");
+            throw new Error("ctx is not a mutation ctx");
           }
           const onUpdateHandle =
             config.authFunctions?.onUpdate &&

package/src/client/adapterUtils.ts

@@ -24,6 +24,7 @@ export const adapterWhereValidator = v.object({
       v.literal("gte"),
       v.literal("eq"),
       v.literal("in"),
+      v.literal("not_in"),
       v.literal("ne"),
       v.literal("contains"),
       v.literal("starts_with"),
@@ -96,6 +97,7 @@ const findIndex = (
         | "gte"
         | "eq"
         | "in"
+        | "not_in"
         | "ne"
         | "contains"
         | "starts_with"
@@ -120,8 +122,10 @@ const findIndex = (
   const where = args.where?.filter((w) => {
     return (
       (!w.operator ||
-        ["lt", "lte", "gt", "gte", "eq", "in"].includes(w.operator)) &&
-      w.field !== "id"
+        ["lt", "lte", "gt", "gte", "eq", "in", "not_in"].includes(
+          w.operator
+        )) &&
+      w.field !== "_id"
     );
   });
   if (!where?.length && !args.sortBy) {
@@ -341,6 +345,12 @@ const filterByWhere = <
         case "in": {
           return Array.isArray(w.value) && (w.value as any[]).includes(value);
         }
+        case "not_in": {
+          const result =
+            Array.isArray(w.value) && !(w.value as any[]).includes(value);
+          console.log(doc, "not_in", w, value, result);
+          return result;
+        }
         case "lt": {
           return isLessThan(value, w.value);
         }
@@ -439,7 +449,9 @@ const generateQuery = (
       // incompatible with Convex statically.
       (w) =>
         w.operator &&
-        ["contains", "starts_with", "ends_with", "ne"].includes(w.operator)
+        ["contains", "starts_with", "ends_with", "ne", "not_in"].includes(
+          w.operator
+        )
     );
   });
   return filteredQuery;
@@ -470,11 +482,13 @@ export const paginate = async <
   if (
     args.where?.some(
       (w) =>
-        w.field === "id" && w.operator && !["eq", "in"].includes(w.operator)
+        w.field === "_id" &&
+        w.operator &&
+        !["eq", "in", "not_in"].includes(w.operator)
     )
   ) {
     throw new Error(
-      `id can only be used with eq or in operator: ${JSON.stringify(args.where)}`
+      `_id can only be used with eq, in, or not_in operator: ${JSON.stringify(args.where)}`
     );
   }
   // If any where clause is "eq" (or missing operator) on a unique field,
@@ -483,7 +497,8 @@ export const paginate = async <
   const uniqueWhere = args.where?.find(
     (w) =>
       (!w.operator || w.operator === "eq") &&
-      (isUniqueField(betterAuthSchema, args.model, w.field) || w.field === "id")
+      (isUniqueField(betterAuthSchema, args.model, w.field) ||
+        w.field === "_id")
   );
   if (uniqueWhere) {
     const { index } =
@@ -492,7 +507,7 @@ export const paginate = async <
         where: [uniqueWhere],
       }) || {};
     const doc =
-      uniqueWhere.field === "id"
+      uniqueWhere.field === "_id"
         ? await ctx.db.get(uniqueWhere.value as GenericId<T>)
         : await ctx.db
             .query(args.model as any)
@@ -533,7 +548,7 @@ export const paginate = async <
       throw new Error("in clause value must be an array");
     }
     // For ids, just use asyncMap + .get()
-    if (inWhere.field === "id") {
+    if (inWhere.field === "_id") {
       const docs = await asyncMap(inWhere.value as any[], async (value) => {
         return ctx.db.get(value as GenericId<T>);
       });

package/src/client/createSchema.ts

@@ -9,15 +9,7 @@ export const indexFields = {
   verification: ["expiresAt", "identifier"],
   user: [["email", "name"], "name", "userId"],
   passkey: ["credentialID"],
-  apikey: ["key"],
-  member: [["organizationId", "userId"]],
-  invitation: [
-    ["email", "organizationId", "status"],
-    ["organizationId", "status"],
-  ],
   oauthConsent: [["clientId", "userId"]],
-  ssoProvider: ["organizationId", "domain"],
-  subscription: ["stripeSubscriptionId", "stripeCustomerId", "referenceId"],
 };
 
 // Return map of unique, sortable, and reference fields