@convex-dev/better-auth 0.7.0-alpha.1 → 0.7.0-alpha.11

package/src/component/lib.ts

@@ -1,423 +1,532 @@
-import {
-  action,
-  mutation,
-  query,
-  QueryCtx,
-} from "../component/_generated/server";
+import { mutation, query, QueryCtx } from "../component/_generated/server";
 import { asyncMap } from "convex-helpers";
-import { v } from "convex/values";
-import { api } from "../component/_generated/api";
+import { Infer, v } from "convex/values";
 import { Doc, Id, TableNames } from "../component/_generated/dataModel";
-import schema from "../component/schema";
-import { paginationOptsValidator, PaginationResult } from "convex/server";
+import schema, { specialFields } from "../component/schema";
+import {
+  PaginationOptions,
+  paginationOptsValidator,
+  PaginationResult,
+} from "convex/server";
 import { paginator } from "convex-helpers/server/pagination";
 import { partial } from "convex-helpers/validators";
 
-export const transformInput = (model: string, data: Record<string, any>) => {
-  return {
-    ...Object.fromEntries(
-      Object.entries(data).map(([key, value]) => {
-        if (value instanceof Date) {
-          return [key, value.getTime()];
-        }
-        return [key, value];
-      })
-    ),
-  };
-};
+export const adapterWhereValidator = v.object({
+  field: v.string(),
+  operator: v.optional(
+    v.union(
+      v.literal("lt"),
+      v.literal("lte"),
+      v.literal("gt"),
+      v.literal("gte"),
+      v.literal("eq"),
+      v.literal("in"),
+      v.literal("ne"),
+      v.literal("contains"),
+      v.literal("starts_with"),
+      v.literal("ends_with")
+    )
+  ),
+  value: v.union(
+    v.string(),
+    v.number(),
+    v.boolean(),
+    v.array(v.string()),
+    v.array(v.number()),
+    v.null()
+  ),
+  connector: v.optional(v.union(v.literal("AND"), v.literal("OR"))),
+});
 
-export const transformOutput = (
-  { _id, _creationTime, ...data }: Doc<TableNames>,
-  _model: string
-) => {
-  // Provide the expected id field, but it can be overwritten if
-  // the model has an id field
-  return { id: _id, ...data };
+export const adapterArgsValidator = v.object({
+  model: v.string(),
+  where: v.optional(v.array(adapterWhereValidator)),
+  sortBy: v.optional(
+    v.object({
+      field: v.string(),
+      direction: v.union(v.literal("asc"), v.literal("desc")),
+    })
+  ),
+  select: v.optional(v.array(v.string())),
+  limit: v.optional(v.number()),
+  unique: v.optional(v.boolean()),
+});
+
+const getUniqueFields = (table: TableNames, input: Record<string, any>) => {
+  const fields = specialFields[table as keyof typeof specialFields];
+  if (!fields) {
+    return [];
+  }
+  return Object.entries(fields)
+    .filter(
+      ([key, value]) =>
+        value.unique && Object.keys(input).includes(key as keyof typeof input)
+    )
+    .map(([key]) => key);
 };
 
-// Get the session via sessionId in jwt claims
-export const getCurrentSession = query({
-  args: {},
-  handler: async (ctx) => {
-    const identity = await ctx.auth.getUserIdentity();
-    if (!identity) {
-      return null;
+const checkUniqueFields = async (
+  ctx: QueryCtx,
+  table: TableNames,
+  input: Record<string, any>,
+  doc?: Doc<any>
+) => {
+  const uniqueFields = getUniqueFields(table, input);
+  if (!uniqueFields.length) {
+    return;
+  }
+  for (const field of uniqueFields) {
+    const existingDoc = await ctx.db
+      .query(table as any)
+      .withIndex(field as any, (q) =>
+        q.eq(field, input[field as keyof typeof input])
+      )
+      .unique();
+    if (existingDoc && existingDoc._id !== doc?._id) {
+      throw new Error(`${table} ${field} already exists`);
     }
-    return ctx.db.get(identity.sessionId as Id<"session">);
-  },
-});
+  }
+};
 
-export const getByHelper = async (
-  ctx: QueryCtx,
-  args: {
-    table: string;
+const findIndex = async (args: {
+  model: string;
+  where?: {
     field: string;
+    operator?: string;
     value: any;
-    unique?: boolean;
+    connector?: "AND" | "OR";
+  }[];
+  sortBy?: {
+    field: string;
+    direction: "asc" | "desc";
+  };
+}) => {
+  if (!args.where && !args.sortBy) {
+    return;
+  }
+  if (args.where?.some((w) => w.field === "id")) {
+    throw new Error("id is not a valid index field");
   }
+  if (args.where?.some((w) => w.connector && w.connector !== "AND")) {
+    throw new Error(
+      `OR connector not supported: ${JSON.stringify(args.where)}`
+    );
+  }
+  if (
+    args.where?.some(
+      (w) =>
+        w.operator &&
+        !["lt", "lte", "gt", "gte", "eq", "in"].includes(w.operator)
+    )
+  ) {
+    throw new Error(
+      `where clause not supported: ${JSON.stringify(args.where)}`
+    );
+  }
+  const lowerBounds =
+    args.where?.filter((w) => w.operator === "lt" || w.operator === "lte") ??
+    [];
+  if (lowerBounds.length > 1) {
+    throw new Error(
+      `cannot have more than one lower bound where clause: ${JSON.stringify(args.where)}`
+    );
+  }
+  const upperBounds =
+    args.where?.filter((w) => w.operator === "gt" || w.operator === "gte") ??
+    [];
+  if (upperBounds.length > 1) {
+    throw new Error(
+      `cannot have more than one upper bound where clause: ${JSON.stringify(args.where)}`
+    );
+  }
+  const lowerBound = lowerBounds[0];
+  const upperBound = upperBounds[0];
+  if (lowerBound && upperBound && lowerBound.field !== upperBound.field) {
+    throw new Error(
+      `lower bound and upper bound must have the same field: ${JSON.stringify(args.where)}`
+    );
+  }
+  const boundField = lowerBound?.field || upperBound?.field;
+  if (
+    boundField &&
+    args.where?.some(
+      (w) => w.field === boundField && w !== lowerBound && w !== upperBound
+    )
+  ) {
+    throw new Error(
+      `too many where clauses on the bound field: ${JSON.stringify(args.where)}`
+    );
+  }
+  const indexFields =
+    args.where
+      ?.filter((w) => !w.operator || w.operator === "eq")
+      .sort((a, b) => {
+        return a.field.localeCompare(b.field);
+      })
+      .map((w) => [w.field, w.value]) ?? [];
+  if (!indexFields?.length && !boundField && !args.sortBy) {
+    return;
+  }
+  const indexes =
+    schema.tables[args.model as keyof typeof schema.tables][" indexes"]();
+  const sortField = args.sortBy?.field;
+
+  // We internally use _creationTime in place of Better Auth's createdAt
+  const indexName = indexFields
+    .map(([field]) => field)
+    .join("_")
+    .concat(
+      boundField && boundField !== "createdAt"
+        ? `${indexFields.length ? "_" : ""}${boundField}`
+        : ""
+    )
+    .concat(
+      sortField && sortField !== "createdAt" && boundField !== sortField
+        ? `${indexFields.length || boundField ? "_" : ""}${sortField}`
+        : ""
+    );
+  if (!indexName && !boundField && !sortField) {
+    return;
+  }
+  // Use the built in creationTime index if bounding or sorting by createdAt
+  // with no other fields
+  const index = !indexName
+    ? {
+        indexDescriptor: "by_creation_time",
+        fields: [],
+      }
+    : indexes.find(({ indexDescriptor }) => {
+        return boundField === "createdAt" || sortField === "createdAt"
+          ? indexDescriptor === indexName
+          : indexDescriptor.startsWith(indexName);
+      });
+  if (!index) {
+    throw new Error(`Index ${indexName} not found for table ${args.model}`);
+  }
+  return {
+    index: {
+      indexDescriptor: index.indexDescriptor,
+      fields: [...index.fields, "_creationTime"],
+    },
+    boundField,
+    sortField,
+    values: {
+      eq: indexFields.map(([, value]) => value),
+      lt: lowerBound?.operator === "lt" ? lowerBound.value : undefined,
+      lte: lowerBound?.operator === "lte" ? lowerBound.value : undefined,
+      gt: upperBound?.operator === "gt" ? upperBound.value : undefined,
+      gte: upperBound?.operator === "gte" ? upperBound.value : undefined,
+    },
+  };
+};
+
+const selectFields = <T extends TableNames, D extends Doc<T>>(
+  doc: D | null,
+  select?: string[]
 ) => {
-  if (args.field === "id") {
-    return ctx.db.get(args.value);
+  if (!doc) {
+    return null;
+  }
+  if (!select?.length) {
+    return doc;
   }
-  const query = ctx.db
-    .query(args.table as any)
-    .withIndex(args.field as any, (q) => q.eq(args.field, args.value));
-  return args.unique ? await query.unique() : await query.first();
+  return select.reduce((acc, field) => {
+    (acc as any)[field] = doc[field];
+    return acc;
+  }, {} as D);
 };
 
-export const getByArgsValidator = {
-  table: v.string(),
-  field: v.string(),
-  unique: v.optional(v.boolean()),
-  value: v.union(
-    v.string(),
-    v.number(),
-    v.boolean(),
-    v.array(v.string()),
-    v.array(v.number()),
-    v.null()
-  ),
+// This is the core function for reading from the database, it parses and
+// validates where conditions, selects indexes, and allows the caller to
+// optionally paginate as needed.
+const paginate = async (
+  ctx: QueryCtx,
+  args: Infer<typeof adapterArgsValidator> & {
+    paginationOpts: PaginationOptions;
+  }
+): Promise<PaginationResult<Doc<any>>> => {
+  // If any index is id, we can only return a single document
+  const idWhere = args.where?.find((w) => w.field === "id");
+  if (idWhere) {
+    const doc = await ctx.db.get(idWhere.value as Id<TableNames>);
+    return {
+      page: [selectFields(doc, args.select)].filter(Boolean),
+      isDone: true,
+      continueCursor: "",
+    };
+  }
+  const { index, values, boundField } = (await findIndex(args)) ?? {};
+  const query = paginator(ctx.db, schema).query(args.model as any);
+  const hasValues =
+    values?.eq?.length ||
+    values?.lt ||
+    values?.lte ||
+    values?.gt ||
+    values?.gte;
+  const indexedQuery =
+    index && index.indexDescriptor !== "by_creation_time"
+      ? query.withIndex(
+          index.indexDescriptor,
+          hasValues
+            ? (q: any) => {
+                for (const [idx, value] of (values?.eq ?? []).entries()) {
+                  q = q.eq(index.fields[idx], value);
+                }
+                if (values?.lt) {
+                  q = q.lt(boundField, values.lt);
+                }
+                if (values?.lte) {
+                  q = q.lte(boundField, values.lte);
+                }
+                if (values?.gt) {
+                  q = q.gt(boundField, values.gt);
+                }
+                if (values?.gte) {
+                  q = q.gte(boundField, values.gte);
+                }
+                return q;
+              }
+            : undefined
+        )
+      : query;
+
+  const orderedQuery = args.sortBy
+    ? indexedQuery.order(args.sortBy.direction === "asc" ? "asc" : "desc")
+    : indexedQuery;
+  const result = await orderedQuery.paginate(args.paginationOpts);
+  return {
+    ...result,
+    page: result.page.map((doc) => selectFields(doc, args.select)),
+  };
 };
 
-// Generic functions
-export const getByQuery = query({
-  args: getByArgsValidator,
-  handler: async (ctx, args) => {
-    const doc = await getByHelper(ctx, args);
-    if (!doc) {
-      return;
-    }
-    return transformOutput(doc, args.table);
-  },
-});
-export { getByQuery as getBy };
+const listOne = async (
+  ctx: QueryCtx,
+  args: Infer<typeof adapterArgsValidator>
+): Promise<Doc<any> | null> => {
+  return (
+    await paginate(ctx, {
+      ...args,
+      paginationOpts: {
+        numItems: 1,
+        cursor: null,
+      },
+    })
+  ).page[0];
+};
 
 export const create = mutation({
-  args: v.object({
+  args: {
     input: v.union(
-      ...Object.values(schema.tables).map((table) =>
+      ...Object.entries(schema.tables).map(([model, table]) =>
         v.object({
-          table: v.string(),
-          ...table.validator.fields,
+          model: v.literal(model),
+          where: v.optional(v.array(adapterWhereValidator)),
+          data: v.object(table.validator.fields),
         })
       )
     ),
-  }),
-  handler: async (ctx, args) => {
-    const { table, ...input } = args.input;
-    const id = await ctx.db.insert(table as any, {
-      ...input,
-    });
-    const doc = await ctx.db.get(id);
-    if (!doc) {
-      throw new Error(`Failed to create ${table}`);
-    }
-    return transformOutput(doc, table);
   },
-});
-
-export const updateArgsInputValidator = <T extends TableNames>(table: T) => {
-  return v.object({
-    table: v.literal(table),
-    where: v.object({ field: v.string(), value: getByArgsValidator.value }),
-    value: v.record(v.string(), v.any()),
-  });
-};
-
-const updateArgsValidator = {
-  input: v.union(
-    updateArgsInputValidator("account"),
-    updateArgsInputValidator("session"),
-    updateArgsInputValidator("verification"),
-    updateArgsInputValidator("user")
-  ),
-};
-
-export const update = mutation({
-  args: updateArgsValidator,
   handler: async (ctx, args) => {
-    const { table, where, value } = args.input;
-    const doc =
-      where.field === "id"
-        ? await ctx.db.get(where.value as Id<any>)
-        : await getByHelper(ctx, { table, ...where });
-    if (!doc) {
-      throw new Error(`Failed to update ${table}`);
-    }
-    await ctx.db.patch(doc._id, value as any);
-    const updatedDoc = await ctx.db.get(doc._id);
-    if (!updatedDoc) {
-      throw new Error(`Failed to update ${table}`);
-    }
-    return transformOutput(updatedDoc, table);
-  },
-});
+    await checkUniqueFields(
+      ctx,
+      args.input.model as TableNames,
+      args.input.data
+    );
 
-export const deleteBy = mutation({
-  args: getByArgsValidator,
-  handler: async (ctx, args) => {
-    const doc = await getByHelper(ctx, args);
+    const id = await ctx.db.insert(args.input.model as any, args.input.data);
+    const doc = await ctx.db.get(id);
     if (!doc) {
-      return;
+      throw new Error(`Failed to create ${args.input.model}`);
     }
-    await ctx.db.delete(doc._id);
-    // onDeleteUser requires userId from the doc,
-    // so just return the whole thing
     return doc;
   },
 });
 
-// Single purpose functions
-export const getAccountsByUserId = query({
-  args: { userId: v.string(), limit: v.optional(v.number()) },
-  handler: async (ctx, args) => {
-    const query = ctx.db
-      .query("account")
-      .withIndex("userId", (q) => q.eq("userId", args.userId));
-    const docs = args.limit
-      ? await query.take(args.limit)
-      : await query.collect();
-    return docs.map((doc) => transformOutput(doc, "account"));
-  },
-});
-
-export const getSessionsByUserId = query({
-  args: { userId: v.string(), limit: v.optional(v.number()) },
+export const findOne = query({
+  args: adapterArgsValidator,
   handler: async (ctx, args) => {
-    const query = ctx.db
-      .query("session")
-      .withIndex("userId", (q) => q.eq("userId", args.userId));
-    const docs = args.limit
-      ? await query.take(args.limit)
-      : await query.collect();
-    return docs.map((doc) => transformOutput(doc, "session"));
+    return await listOne(ctx, args);
   },
 });
 
-export const getJwks = query({
+export const findMany = query({
   args: {
-    limit: v.optional(v.number()),
+    ...adapterArgsValidator.fields,
+    paginationOpts: paginationOptsValidator,
   },
   handler: async (ctx, args) => {
-    const query = ctx.db.query("jwks");
-    const docs = args.limit
-      ? await query.take(args.limit)
-      : await query.collect();
-    return docs.map((doc) => transformOutput(doc, "jwks"));
+    return await paginate(ctx, args);
   },
 });
 
-export const listVerificationsByIdentifier = query({
+export const updateOne = mutation({
   args: {
-    identifier: v.string(),
-    sortBy: v.optional(
-      v.object({
-        field: v.string(),
-        direction: v.union(v.literal("asc"), v.literal("desc")),
-      })
+    input: v.union(
+      ...Object.entries(schema.tables).map(([model, table]) =>
+        v.object({
+          model: v.literal(model),
+          where: v.optional(v.array(adapterWhereValidator)),
+          update: v.object(
+            Object.fromEntries(
+              Object.entries(table.validator.fields).map(([key, value]) => [
+                key,
+                value.isOptional === "required" ? v.optional(value) : value,
+              ])
+            )
+          ),
+        })
+      )
     ),
-    limit: v.optional(v.number()),
   },
   handler: async (ctx, args) => {
-    if (args.sortBy && args.sortBy.field !== "createdAt") {
-      throw new Error(`Unsupported sortBy field: ${args.sortBy.field}`);
+    const doc = await listOne(ctx, args.input);
+    if (!doc) {
+      throw new Error(`Failed to update ${args.input.model}`);
     }
-    const query = ctx.db
-      .query("verification")
-      .withIndex("identifier", (q) => q.eq("identifier", args.identifier))
-      .order(
-        args.sortBy?.field === "createdAt" && args.sortBy?.direction
-          ? args.sortBy.direction
-          : "asc"
-      );
-    const docs = args.limit
-      ? await query.take(args.limit)
-      : await query.collect();
-    return docs.map((doc) => transformOutput(doc, "verification"));
-  },
-});
-
-export const deleteOldVerificationsPage = mutation({
-  args: {
-    currentTimestamp: v.number(),
-    paginationOpts: v.optional(paginationOptsValidator),
-  },
-  handler: async (ctx, args) => {
-    const paginationOpts = args.paginationOpts ?? {
-      numItems: 500,
-      cursor: null,
-    };
-    const { page, ...result } = await paginator(ctx.db, schema)
-      .query("verification")
-      .withIndex("expiresAt", (q) => q.lt("expiresAt", args.currentTimestamp))
-      .paginate(paginationOpts);
-    await asyncMap(page, async (doc) => {
-      await ctx.db.delete(doc._id);
-    });
-    return { ...result, count: page.length };
+    await checkUniqueFields(
+      ctx,
+      args.input.model as TableNames,
+      args.input.update,
+      doc
+    );
+    await ctx.db.patch(doc._id, args.input.update as any);
+    const updatedDoc = await ctx.db.get(doc._id);
+    if (!updatedDoc) {
+      throw new Error(`Failed to update ${args.input.model}`);
+    }
+    return updatedDoc;
   },
 });
 
-export const deleteOldVerifications = action({
+export const updateMany = mutation({
   args: {
-    currentTimestamp: v.number(),
+    ...adapterArgsValidator.fields,
+    update: v.optional(v.object(partial(schema.tables.user.validator.fields))),
+    paginationOpts: paginationOptsValidator,
   },
   handler: async (ctx, args) => {
-    let count = 0;
-    let cursor = null;
-    let isDone = false;
-    do {
-      const result: Omit<PaginationResult<Doc<"verification">>, "page"> & {
-        count: number;
-      } = await ctx.runMutation(api.lib.deleteOldVerificationsPage, {
-        currentTimestamp: args.currentTimestamp,
-        paginationOpts: {
-          numItems: 500,
-          cursor,
-        },
+    const { page, ...result } = await paginate(ctx, args);
+    if (args.update) {
+      const uniqueFields = getUniqueFields(
+        args.model as TableNames,
+        args.update ?? {}
+      );
+      if (uniqueFields.length && page.length > 1) {
+        throw new Error(
+          `Attempted to set unique fields in multiple documents in ${args.model} with the same value. Fields: ${uniqueFields.join(", ")}`
+        );
+      }
+      await asyncMap(page, async (doc) => {
+        await checkUniqueFields(
+          ctx,
+          args.model as TableNames,
+          args.update ?? {},
+          doc
+        );
+        await ctx.db.patch(doc._id, args.update as any);
       });
-      count += result.count;
-      cursor =
-        result.pageStatus &&
-        result.splitCursor &&
-        ["SplitRecommended", "SplitRequired"].includes(result.pageStatus)
-          ? result.splitCursor
-          : result.continueCursor;
-      isDone = result.isDone;
-    } while (!isDone);
-    return count;
+    }
+    return {
+      ...result,
+      count: page.length,
+    };
   },
 });
 
-export const deleteExpiredSessions = mutation({
-  args: {
-    userId: v.string(),
-    expiresAt: v.number(),
-  },
+export const deleteOne = mutation({
+  args: adapterArgsValidator,
   handler: async (ctx, args) => {
-    const docs = await ctx.db
-      .query("session")
-      .withIndex("userId_expiresAt", (q) =>
-        q.eq("userId", args.userId).lt("expiresAt", args.expiresAt)
-      )
-      .collect();
-    await asyncMap(docs, async (doc) => {
-      await ctx.db.delete(doc._id);
-    });
-    return docs.length;
+    const doc = await listOne(ctx, args);
+    if (!doc) {
+      return;
+    }
+    await ctx.db.delete(doc._id);
+    return doc;
   },
 });
 
-export const deleteAllForUserPage = mutation({
+export const deleteMany = mutation({
   args: {
-    table: v.string(),
-    userId: v.string(),
-    paginationOpts: v.optional(paginationOptsValidator),
+    ...adapterArgsValidator.fields,
+    paginationOpts: paginationOptsValidator,
   },
   handler: async (ctx, args) => {
-    const paginationOpts = args.paginationOpts ?? {
-      numItems: 500,
-      cursor: null,
-    };
-    const { page, ...result } = await paginator(ctx.db, schema)
-      .query(args.table as any)
-      .withIndex("userId", (q) => q.eq("userId", args.userId))
-      .paginate(paginationOpts);
+    const { page, ...result } = await paginate(ctx, args);
     await asyncMap(page, async (doc) => {
       await ctx.db.delete(doc._id);
     });
-    return { ...result, count: page.length };
-  },
-});
-
-export const deleteAllForUser = action({
-  args: {
-    table: v.string(),
-    userId: v.string(),
-  },
-  handler: async (ctx, args) => {
-    let count = 0;
-    let cursor = null;
-    let isDone = false;
-    do {
-      const result: Omit<PaginationResult<Doc<"session">>, "page"> & {
-        count: number;
-      } = await ctx.runMutation(api.lib.deleteAllForUserPage, {
-        table: args.table,
-        userId: args.userId,
-        paginationOpts: {
-          numItems: 500,
-          cursor,
-        },
-      });
-      count += result.count;
-      cursor =
-        result.pageStatus &&
-        result.splitCursor &&
-        ["SplitRecommended", "SplitRequired"].includes(result.pageStatus)
-          ? result.splitCursor
-          : result.continueCursor;
-      isDone = result.isDone;
-    } while (!isDone);
-    return count;
+    return {
+      ...result,
+      count: page.length,
+    };
   },
 });
 
-export const getAccountByAccountIdAndProviderId = query({
-  args: { accountId: v.string(), providerId: v.string() },
-  handler: async (ctx, args) => {
-    const doc = await ctx.db
-      .query("account")
-      .withIndex("providerId_accountId", (q) =>
-        q.eq("providerId", args.providerId).eq("accountId", args.accountId)
-      )
-      .unique();
-    if (!doc) {
-      return;
+// Get the session via sessionId in jwt claims
+// TODO: this needs a refresh, subquery only necessary for actions
+export const getCurrentSession = query({
+  args: {},
+  handler: async (ctx) => {
+    const identity = await ctx.auth.getUserIdentity();
+    if (!identity) {
+      return null;
     }
-    return transformOutput(doc, "account");
+    return ctx.db.get(identity.sessionId as Id<"session">);
   },
 });
 
-export const updateUserProviderAccounts = mutation({
-  args: {
-    userId: v.string(),
-    providerId: v.string(),
-    update: v.object(partial(schema.tables.account.validator.fields)),
-  },
+// TODO: rewrite functions below here to be dynamic
+
+export const getIn = query({
+  args: adapterArgsValidator,
   handler: async (ctx, args) => {
-    const docs = await ctx.db
-      .query("account")
-      .withIndex("userId_providerId", (q) =>
-        q.eq("userId", args.userId).eq("providerId", args.providerId)
-      )
-      .collect();
-    if (docs.length === 0) {
-      return 0;
+    const where = args.where?.[0];
+    if (!where || where.operator !== "in" || args.where?.length !== 1) {
+      throw new Error("where must be a single in clause");
     }
-    await asyncMap(docs, async (doc) => {
-      await ctx.db.patch(doc._id, args.update);
-    });
-    return docs.length;
+    return (
+      await asyncMap(where.value as any[], async (value) => {
+        if (where.field === "id") {
+          return [await ctx.db.get(value as Id<TableNames>)];
+        }
+        const query = ctx.db
+          .query(args.model as any)
+          .withIndex(where.field as any, (q) => q.eq(where.field, value));
+        if (args.limit) {
+          return await query.take(args.limit);
+        }
+        return await query.collect();
+      })
+    )
+      .flat()
+      .filter(Boolean);
   },
 });
 
-export const updateTwoFactor = mutation({
+export const deleteIn = mutation({
   args: {
-    userId: v.string(),
-    update: v.object(partial(schema.tables.twoFactor.validator.fields)),
+    input: v.union(
+      v.object({
+        table: v.literal("session"),
+        field: v.literal("token"),
+        values: v.array(v.string()),
+      })
+    ),
   },
   handler: async (ctx, args) => {
-    const docs = await ctx.db
-      .query("twoFactor")
-      .withIndex("userId", (q) => q.eq("userId", args.userId))
-      .collect();
-    if (docs.length === 0) {
-      return 0;
-    }
-    await asyncMap(docs, async (doc) => {
-      await ctx.db.patch(doc._id, args.update);
+    const { table, field, values } = args.input;
+    const docs = await asyncMap(values, async (value) => {
+      const doc = await ctx.db
+        .query(table)
+        .withIndex(field as any, (q) => q.eq(field, value))
+        .unique();
+      if (!doc) {
+        return;
+      }
+      await ctx.db.delete(doc._id);
+      return doc;
     });
-    return docs.length;
+    return docs.filter(Boolean).length;
   },
 });