@convex-dev/better-auth 0.7.0-alpha.9 → 0.7.1

package/src/client/adapter.ts

@@ -1,34 +1,144 @@
 import { BetterAuth } from "./index";
-import { transformInput } from "../component/lib";
-import { createAdapter } from "better-auth/adapters";
+import {
+  AdapterDebugLogs,
+  CleanedWhere,
+  createAdapter,
+} from "better-auth/adapters";
 import {
   GenericActionCtx,
   GenericMutationCtx,
   GenericQueryCtx,
+  PaginationOptions,
+  PaginationResult,
 } from "convex/server";
+import { SetOptional } from "type-fest";
+
+const handlePagination = async (
+  next: ({
+    paginationOpts,
+  }: {
+    paginationOpts: PaginationOptions;
+  }) => Promise<
+    SetOptional<PaginationResult<any>, "page"> & { count?: number }
+  >,
+  { limit, numItems }: { limit?: number; numItems?: number } = {}
+) => {
+  const state: {
+    isDone: boolean;
+    cursor: string | null;
+    docs: any[];
+    count: number;
+  } = {
+    isDone: false,
+    cursor: null,
+    docs: [],
+    count: 0,
+  };
+  const onResult = (
+    result: SetOptional<PaginationResult<any>, "page"> & { count?: number }
+  ) => {
+    state.cursor =
+      result.pageStatus === "SplitRecommended" ||
+      result.pageStatus === "SplitRequired"
+        ? result.splitCursor ?? result.continueCursor
+        : result.continueCursor;
+    if (result.page) {
+      state.docs.push(...result.page);
+      state.isDone = (limit && state.docs.length >= limit) || result.isDone;
+      return;
+    }
+    // Update and delete only return a count
+    if (result.count) {
+      state.count += result.count;
+      state.isDone = (limit && state.count >= limit) || result.isDone;
+      return;
+    }
+    state.isDone = result.isDone;
+  };
+
+  do {
+    const result = await next({
+      paginationOpts: {
+        numItems: Math.min(
+          numItems ?? 200,
+          (limit ?? 200) - state.docs.length,
+          200
+        ),
+        cursor: state.cursor,
+      },
+    });
+    onResult(result);
+  } while (!state.isDone);
+  return state;
+};
 
-export const convexAdapter = <
-  Ctx extends
-    | GenericQueryCtx<any>
-    | GenericMutationCtx<any>
-    | GenericActionCtx<any>,
->(
-  ctx: Ctx,
-  component: BetterAuth
-) =>
-  createAdapter({
+type ConvexCleanedWhere = CleanedWhere & {
+  value: string | number | boolean | string[] | number[] | null;
+};
+
+const parseWhere = (where?: CleanedWhere[]): ConvexCleanedWhere[] => {
+  return where?.map((where) => {
+    if (where.value instanceof Date) {
+      return {
+        ...where,
+        value: where.value.getTime(),
+      };
+    }
+    return where;
+  }) as ConvexCleanedWhere[];
+};
+
+type GenericCtx =
+  | GenericQueryCtx<any>
+  | GenericMutationCtx<any>
+  | GenericActionCtx<any>;
+
+interface ConvexAdapterConfig {
+  /**
+   * Helps you debug issues with the adapter.
+   */
+  debugLogs?: AdapterDebugLogs;
+}
+export const convexAdapter = (
+  ctx: GenericCtx,
+  component: BetterAuth,
+  config: ConvexAdapterConfig = {}
+) => {
+  const { debugLogs } = config;
+  return createAdapter({
     config: {
       adapterId: "convex",
       adapterName: "Convex Adapter",
-      debugLogs: component.config.verbose ?? false,
+      debugLogs: component.config.verbose ?? debugLogs ?? false,
       disableIdGeneration: true,
+      supportsNumericIds: false,
+      usePlural: false,
+      mapKeysTransformOutput: {
+        _id: "id",
+      },
+      // With supportsDates: false, dates are stored as strings,
+      // we convert them to numbers here. This aligns with how
+      // Convex stores _creationTime, and avoids a breaking change.
+      supportsDates: false,
+      customTransformInput: ({ data, fieldAttributes }) => {
+        if (data && fieldAttributes.type === "date") {
+          return new Date(data).getTime();
+        }
+        return data;
+      },
+      customTransformOutput: ({ data, fieldAttributes }) => {
+        if (data && fieldAttributes.type === "date") {
+          return new Date(data).getTime();
+        }
+        return data;
+      },
     },
-    adapter: ({ schema }) => {
+    adapter: () => {
       return {
         id: "convex",
         create: async ({ model, data, select }): Promise<any> => {
           if (!("runMutation" in ctx)) {
-            throw new Error("ctx is not an action ctx");
+            throw new Error("ctx is not a mutation ctx");
           }
           if (select) {
             throw new Error("select is not supported");
@@ -39,223 +149,125 @@ export const convexAdapter = <
               : model === "session"
                 ? component.config.authFunctions.createSession
                 : component.component.lib.create;
-          return ctx.runMutation(createFn, {
-            input: { table: model, ...transformInput(model, data) },
+          return await ctx.runMutation(createFn, {
+            input: { model, data },
           });
         },
-        findOne: async ({ model, where }): Promise<any> => {
-          if (where.length === 1 && where[0].operator === "eq") {
-            const { value, field } = where[0];
-            const result = await ctx.runQuery(component.component.lib.getBy, {
-              table: model,
-              field,
-              unique:
-                field === "id" ? true : schema[model].fields[field].unique,
-              value: value instanceof Date ? value.getTime() : value,
-            });
-            return result;
-          }
-          if (
-            model === "account" &&
-            where.length === 2 &&
-            where[0].field === "accountId" &&
-            where[1].field === "providerId" &&
-            where[0].connector === "AND"
-          ) {
-            return ctx.runQuery(
-              component.component.lib.getAccountByAccountIdAndProviderId,
-              {
-                accountId: where[0].value as string,
-                providerId: where[1].value as string,
+        findOne: async (data): Promise<any> => {
+          if (data.where?.every((w) => w.connector === "OR")) {
+            for (const w of data.where) {
+              const result = await ctx.runQuery(
+                component.component.lib.findOne,
+                {
+                  ...data,
+                  where: parseWhere([w]),
+                }
+              );
+              if (result) {
+                return result;
               }
-            );
+            }
           }
-          throw new Error("where clause not supported");
+          return await ctx.runQuery(component.component.lib.findOne, {
+            ...data,
+            where: parseWhere(data.where),
+          });
         },
-        findMany: async ({
-          model,
-          where,
-          sortBy,
-          offset,
-          limit,
-        }): Promise<any[]> => {
-          if (offset) {
+        findMany: async (data): Promise<any[]> => {
+          if (data.offset) {
             throw new Error("offset not supported");
           }
-          if (
-            model === "jwks" &&
-            !where &&
-            (!sortBy ||
-              (sortBy?.field === "createdAt" && sortBy?.direction === "desc"))
-          ) {
-            return ctx.runQuery(component.component.lib.getJwks, { limit });
-          }
-          if (
-            where?.length !== 1 ||
-            (where[0].operator && where[0].operator !== "eq")
-          ) {
-            throw new Error("where clause not supported");
-          }
-          if (model === "verification" && where[0].field === "identifier") {
-            return ctx.runQuery(
-              component.component.lib.listVerificationsByIdentifier,
-              {
-                identifier: where[0].value as string,
-                sortBy,
-                limit,
-              }
-            );
+          if (data.where?.some((w) => w.connector === "OR")) {
+            throw new Error("OR connector not supported in findMany");
           }
-          if (model === "account" && where[0].field === "userId" && !sortBy) {
-            return ctx.runQuery(component.component.lib.getAccountsByUserId, {
-              userId: where[0].value as any,
-              limit,
-            });
+          const result = await handlePagination(
+            async ({ paginationOpts }) => {
+              return await ctx.runQuery(component.component.lib.findMany, {
+                ...data,
+                where: parseWhere(data.where),
+                paginationOpts,
+              });
+            },
+            { limit: data.limit }
+          );
+          return result.docs;
+        },
+        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");
           }
-          if (model === "session" && where[0].field === "userId" && !sortBy) {
-            return ctx.runQuery(component.component.lib.getSessionsByUserId, {
-              userId: where[0].value as any,
-              limit,
+          const result = await handlePagination(async ({ paginationOpts }) => {
+            return await ctx.runQuery(component.component.lib.findMany, {
+              ...data,
+              where: parseWhere(data.where),
+              paginationOpts,
             });
-          }
-          throw new Error("where clause not supported");
-        },
-        count: async ({ where }) => {
-          throw new Error("count not implemented");
-          // return 0;
+          });
+          return result.docs?.length ?? 0;
         },
-        update: async ({ model, where, update }): Promise<any> => {
+        update: async (data): Promise<any> => {
           if (!("runMutation" in ctx)) {
-            throw new Error("ctx is not an action ctx");
+            throw new Error("ctx is not a mutation ctx");
           }
-          if (where?.length === 1 && where[0].operator === "eq") {
-            const { value, field } = where[0];
+          if (data.where?.length === 1 && data.where[0].operator === "eq") {
             const updateFn =
-              model === "user"
+              data.model === "user"
                 ? component.config.authFunctions.updateUser
-                : component.component.lib.update;
+                : component.component.lib.updateOne;
             return ctx.runMutation(updateFn, {
               input: {
-                table: model as any,
-                where: {
-                  field,
-                  value: value instanceof Date ? value.getTime() : value,
-                },
-                value: transformInput(model, update as any),
+                model: data.model,
+                where: parseWhere(data.where),
+                update: data.update as any,
               },
             });
           }
           throw new Error("where clause not supported");
         },
-        delete: async ({ model, where }) => {
+        delete: async (data) => {
           if (!("runMutation" in ctx)) {
-            throw new Error("ctx is not an action ctx");
+            throw new Error("ctx is not a mutation ctx");
           }
-          if (where?.length === 1 && where[0].operator === "eq") {
-            const { field, value } = where[0];
-            const deleteFn =
-              model === "user"
-                ? component.config.authFunctions.deleteUser
-                : component.component.lib.deleteBy;
-            await ctx.runMutation(deleteFn, {
-              table: model,
-              field,
-              value: value instanceof Date ? value.getTime() : value,
-            });
-            return;
-          }
-          throw new Error("where clause not supported");
-          // return null
+          const deleteFn =
+            data.model === "user"
+              ? component.config.authFunctions.deleteUser
+              : component.component.lib.deleteOne;
+          await ctx.runMutation(deleteFn, {
+            model: data.model,
+            where: parseWhere(data.where),
+          });
+          return;
         },
-        deleteMany: async ({ model, where }) => {
-          if (!("runAction" in ctx)) {
-            throw new Error("ctx is not an action ctx");
-          }
-          if (
-            model === "verification" &&
-            where?.length === 1 &&
-            where[0].operator === "lt" &&
-            where[0].field === "expiresAt"
-          ) {
-            return ctx.runAction(
-              component.component.lib.deleteOldVerifications,
-              {
-                currentTimestamp: Date.now(),
-              }
-            );
+        deleteMany: async (data) => {
+          if (!("runMutation" in ctx)) {
+            throw new Error("ctx is not a mutation ctx");
           }
-          if (where?.length === 1 && where[0].field === "userId") {
-            return ctx.runAction(component.component.lib.deleteAllForUser, {
-              table: model,
-              userId: where[0].value as any,
+          const result = await handlePagination(async ({ paginationOpts }) => {
+            return await ctx.runMutation(component.component.lib.deleteMany, {
+              ...data,
+              where: parseWhere(data.where),
+              paginationOpts,
             });
-          }
-          if (
-            model === "session" &&
-            where?.length === 2 &&
-            where[0].operator === "eq" &&
-            where[0].connector === "AND" &&
-            where[0].field === "userId" &&
-            where[1].operator === "lte" &&
-            where[1].field === "expiresAt" &&
-            typeof where[1].value === "number"
-          ) {
-            return ctx.runMutation(
-              component.component.lib.deleteExpiredSessions,
-              {
-                userId: where[0].value as string,
-                expiresAt: where[1].value as number,
-              }
-            );
-          }
-          throw new Error("where clause not supported");
-          // return count;
+          });
+          return result.count;
         },
-        updateMany: async ({ model, where, update }) => {
+        updateMany: async (data) => {
           if (!("runMutation" in ctx)) {
             throw new Error("ctx is not an action ctx");
           }
-          if (
-            model === "twoFactor" &&
-            where?.length === 1 &&
-            where[0].operator === "eq" &&
-            where[0].field === "userId"
-          ) {
-            return ctx.runMutation(component.component.lib.updateTwoFactor, {
-              userId: where[0].value as string,
-              update: transformInput(model, update as any),
+          const result = await handlePagination(async ({ paginationOpts }) => {
+            return await ctx.runMutation(component.component.lib.updateMany, {
+              input: {
+                ...data,
+                where: parseWhere(data.where),
+                paginationOpts,
+              },
             });
-          }
-          if (
-            model === "account" &&
-            where?.length === 2 &&
-            where[0].operator === "eq" &&
-            where[0].connector === "AND" &&
-            where[0].field === "userId" &&
-            where[1].operator === "eq" &&
-            where[1].field === "providerId"
-          ) {
-            return ctx.runMutation(
-              component.component.lib.updateUserProviderAccounts,
-              {
-                userId: where[0].value as string,
-                providerId: where[1].value as string,
-                update: transformInput(model, update as any),
-              }
-            );
-          }
-          throw new Error("updateMany not implemented");
-          //return 0;
-          /*
-          const { model, where, update } = data;
-          const table = db[model];
-          const res = convertWhereClause(where, table, model);
-          res.forEach((record) => {
-            Object.assign(record, update);
           });
-          return res[0] || null;
-          */
+          return result.count;
         },
       };
     },
   });
+};

package/src/client/index.ts

@@ -16,33 +16,36 @@ import { type GenericId, Infer, v } from "convex/values";
 import type { api } from "../component/_generated/api";
 import schema from "../component/schema";
 import { convexAdapter } from "./adapter";
-import corsRouter from "./cors";
-import { getByArgsValidator, updateArgsInputValidator } from "../component/lib";
 import { betterAuth } from "better-auth";
 import { omit } from "convex-helpers";
 import { createCookieGetter } from "better-auth/cookies";
 import { fetchQuery } from "convex/nextjs";
 import { JWT_COOKIE_NAME } from "../plugins/convex";
-import { requireEnv } from "../util";
+import { requireEnv } from "../utils";
+import { partial } from "convex-helpers/validators";
+import { adapterArgsValidator, adapterWhereValidator } from "../component/lib";
+import { corsRouter } from "convex-helpers/server/cors";
 export { convexAdapter };
 
 const createUserFields = omit(schema.tables.user.validator.fields, ["userId"]);
 const createUserValidator = v.object(createUserFields);
 const createUserArgsValidator = v.object({
   input: v.object({
-    ...createUserFields,
-    table: v.literal("user"),
+    model: v.literal("user"),
+    data: v.object(createUserFields),
   }),
 });
 const updateUserArgsValidator = v.object({
-  input: updateArgsInputValidator("user"),
+  input: v.object({
+    model: v.literal("user"),
+    where: v.optional(v.array(adapterWhereValidator)),
+    update: v.object(partial(createUserFields)),
+  }),
 });
-const deleteUserArgsValidator = v.object(getByArgsValidator);
-
 const createSessionArgsValidator = v.object({
   input: v.object({
-    table: v.literal("session"),
-    ...schema.tables.session.validator.fields,
+    model: v.literal("session"),
+    data: v.object(schema.tables.session.validator.fields),
   }),
 });
 
@@ -61,7 +64,7 @@ export type AuthFunctions = {
   deleteUser: FunctionReference<
     "mutation",
     "internal",
-    Infer<typeof deleteUserArgsValidator>
+    Infer<typeof adapterArgsValidator>
   >;
   updateUser: FunctionReference<
     "mutation",
@@ -128,10 +131,14 @@ export class BetterAuth<UserId extends string = string> {
     if (!identity) {
       return null;
     }
-    const doc = await ctx.runQuery(this.component.lib.getBy, {
-      table: "user",
-      field: "userId",
-      value: identity.subject,
+    const doc = await ctx.runQuery(this.component.lib.findOne, {
+      model: "user",
+      where: [
+        {
+          field: "userId",
+          value: identity.subject,
+        },
+      ],
     });
     if (!doc) {
       return null;
@@ -182,35 +189,38 @@ export class BetterAuth<UserId extends string = string> {
       createUser: internalMutationGeneric({
         args: createUserArgsValidator,
         handler: async (ctx, args) => {
-          const userId = await opts.onCreateUser(ctx, args.input);
-          const input = { ...args.input, table: "user", userId };
+          const userId = await opts.onCreateUser(ctx, args.input.data);
           return ctx.runMutation(this.component.lib.create, {
-            input,
+            input: {
+              ...args.input,
+              data: { ...args.input.data, userId },
+            },
           });
         },
       }),
       deleteUser: internalMutationGeneric({
-        args: deleteUserArgsValidator,
+        args: adapterArgsValidator,
         handler: async (ctx, args) => {
-          const doc = await ctx.runMutation(this.component.lib.deleteBy, args);
-          if (opts.onDeleteUser) {
+          const doc = await ctx.runMutation(this.component.lib.deleteOne, args);
+          if (doc && opts.onDeleteUser) {
             await opts.onDeleteUser(ctx, doc.userId as UserId);
           }
+          return doc;
         },
       }),
       updateUser: internalMutationGeneric({
         args: updateUserArgsValidator,
         handler: async (ctx, args) => {
           const updatedUser = await ctx.runMutation(
-            this.component.lib.update,
-            args
+            this.component.lib.updateOne,
+            { input: args.input }
           );
           // Type narrowing
           if (!("emailVerified" in updatedUser)) {
             throw new Error("invalid user");
           }
           if (opts.onUpdateUser) {
-            await opts.onUpdateUser(ctx, omit(updatedUser, ["id"]));
+            await opts.onUpdateUser(ctx, omit(updatedUser, ["_id"]));
           }
           return updatedUser;
         },
@@ -218,14 +228,9 @@ export class BetterAuth<UserId extends string = string> {
       createSession: internalMutationGeneric({
         args: createSessionArgsValidator,
         handler: async (ctx, args) => {
-          const session = await ctx.runMutation(
-            this.component.lib.create,
-            args
-          );
-          // Type narrowing
-          if (!("ipAddress" in session)) {
-            throw new Error("invalid session");
-          }
+          const session = await ctx.runMutation(this.component.lib.create, {
+            input: args.input,
+          });
           await opts.onCreateSession?.(ctx, session);
           return session;
         },
@@ -283,50 +288,20 @@ export class BetterAuth<UserId extends string = string> {
 
       return;
     }
-
-    const trustedOrigins = [
-      ...(Array.isArray(betterAuthOptions.trustedOrigins)
-        ? betterAuthOptions.trustedOrigins
-        : [betterAuthOptions.trustedOrigins]),
-      betterAuthOptions.baseURL!,
-    ];
-    // The crossDomain plugin adds siteUrl to trustedOrigins
-    const trustedOriginsFromPlugins =
-      betterAuthOptions.plugins?.reduce((acc, plugin) => {
-        if (plugin.options?.trustedOrigins) {
-          acc.push(...plugin.options.trustedOrigins);
-        }
-        return acc;
-      }, [] as string[]) ?? [];
-
-    // Reuse trustedOrigins as default for allowedOrigins
-    const allowedOrigins = async (request: Request) => {
-      return (
-        await Promise.all(
-          [...trustedOrigins, ...trustedOriginsFromPlugins].map(
-            async (origin) => {
-              if (!origin) {
-                return [];
-              }
-              if (typeof origin === "function") {
-                return origin(request);
-              }
-              return [origin];
-            }
-          )
-        )
-      )
-        .flat()
-        .map((origin) =>
+    const cors = corsRouter(http, {
+      allowedOrigins: async (request) => {
+        const trustedOriginsOption =
+          (await createAuth({} as any).$context).options.trustedOrigins ?? [];
+        const trustedOrigins = Array.isArray(trustedOriginsOption)
+          ? trustedOriginsOption
+          : await trustedOriginsOption(request);
+        return trustedOrigins.map((origin) =>
           // Strip trailing wildcards, unsupported for allowedOrigins
           origin.endsWith("*") && origin.length > 1
             ? origin.slice(0, -1)
             : origin
         );
-    };
-
-    const cors = corsRouter(http, {
-      allowedOrigins,
+      },
       allowCredentials: true,
       allowedHeaders: ["Content-Type", "Better-Auth-Cookie"],
       exposedHeaders: ["Set-Better-Auth-Cookie"],