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

package/src/component/lib.ts

@@ -1,74 +1,34 @@
-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 { paginator } from "convex-helpers/server/pagination";
+import schema, { specialFields } from "../component/schema";
+import {
+  PaginationOptions,
+  paginationOptsValidator,
+  PaginationResult,
+} from "convex/server";
 import { partial } from "convex-helpers/validators";
+import { stream } from "convex-helpers/server/stream";
+import { mergedStream } from "convex-helpers/server/stream";
+import { stripIndent, stripIndents } from "common-tags";
 
-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 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 };
-};
-
-// 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;
-    }
-    return ctx.db.get(identity.sessionId as Id<"session">);
-  },
-});
-
-export const getByHelper = async (
-  ctx: QueryCtx,
-  args: {
-    table: string;
-    field: string;
-    value: any;
-    unique?: boolean;
-  }
-) => {
-  if (args.field === "id") {
-    return ctx.db.get(args.value);
-  }
-  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();
-};
-
-export const getByArgsValidator = {
-  table: v.string(),
+export const adapterWhereValidator = v.object({
   field: v.string(),
-  unique: v.optional(v.boolean()),
+  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(),
@@ -77,347 +37,693 @@ export const getByArgsValidator = {
     v.array(v.number()),
     v.null()
   ),
-};
+  connector: v.optional(v.union(v.literal("AND"), v.literal("OR"))),
+});
 
-// 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 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()),
+  offset: v.optional(v.number()),
+  unique: v.optional(v.boolean()),
 });
-export { getByQuery as getBy };
 
-export const create = mutation({
-  args: v.object({
-    input: v.union(
-      ...Object.values(schema.tables).map((table) =>
-        v.object({
-          table: v.string(),
-          ...table.validator.fields,
-        })
+const isUniqueField = (model: TableNames, field: string) => {
+  const fields = specialFields[model as keyof typeof specialFields];
+  if (!fields) {
+    return false;
+  }
+  return Object.entries(fields)
+    .filter(([, value]) => value.unique)
+    .map(([key]) => key)
+    .includes(field);
+};
+const hasUniqueFields = (model: TableNames, input: Record<string, any>) => {
+  for (const field of Object.keys(input)) {
+    if (isUniqueField(model, field)) {
+      return true;
+    }
+  }
+  return false;
+};
+
+const checkUniqueFields = async (
+  ctx: QueryCtx,
+  table: TableNames,
+  input: Record<string, any>,
+  doc?: Doc<any>
+) => {
+  if (!hasUniqueFields(table, input)) {
+    return;
+  }
+  for (const field of Object.keys(input)) {
+    if (!isUniqueField(table, field)) {
+      continue;
+    }
+    const existingDoc = await ctx.db
+      .query(table as any)
+      .withIndex(field as any, (q) =>
+        q.eq(field, input[field as keyof typeof input])
       )
-    ),
-  }),
-  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}`);
+      .unique();
+    if (existingDoc && existingDoc._id !== doc?._id) {
+      throw new Error(`${table} ${field} already exists`);
     }
-    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 findIndex = (args: {
+  model: string;
+  where?: {
+    field: string;
+    operator?:
+      | "lt"
+      | "lte"
+      | "gt"
+      | "gte"
+      | "eq"
+      | "in"
+      | "ne"
+      | "contains"
+      | "starts_with"
+      | "ends_with";
+    value: string | number | boolean | null | string[] | number[];
+    connector?: "AND" | "OR";
+  }[];
+  sortBy?: {
+    field: string;
+    direction: "asc" | "desc";
+  };
+}) => {
+  if (
+    (args.where?.length ?? 0) > 1 &&
+    args.where?.some((w) => w.connector === "OR")
+  ) {
+    throw new Error(
+      `OR connector not supported with multiple where statements in findIndex, split up the where statements before calling findIndex: ${JSON.stringify(args.where)}`
+    );
+  }
+  const where = args.where?.filter((w) => {
+    return (
+      (!w.operator ||
+        ["lt", "lte", "gt", "gte", "eq", "in"].includes(w.operator)) &&
+      w.field !== "id"
+    );
   });
+  if (!where?.length && !args.sortBy) {
+    return;
+  }
+  const lowerBounds =
+    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(where)}`
+    );
+  }
+  const upperBounds =
+    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(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(where)}`
+    );
+  }
+  const boundField = lowerBound?.field || upperBound?.field;
+  if (
+    boundField &&
+    where?.some(
+      (w) => w.field === boundField && w !== lowerBound && w !== upperBound
+    )
+  ) {
+    throw new Error(
+      `too many where clauses on the bound field: ${JSON.stringify(where)}`
+    );
+  }
+  const indexEqFields =
+    where
+      ?.filter((w) => !w.operator || w.operator === "eq")
+      .sort((a, b) => {
+        return a.field.localeCompare(b.field);
+      })
+      .map((w) => [w.field, w.value]) ?? [];
+  if (!indexEqFields?.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 indexFields = indexEqFields
+    .map(([field]) => field)
+    .concat(
+      boundField && boundField !== "createdAt"
+        ? `${indexEqFields.length ? "_" : ""}${boundField}`
+        : ""
+    )
+    .concat(
+      sortField && sortField !== "createdAt" && boundField !== sortField
+        ? `${indexEqFields.length || boundField ? "_" : ""}${sortField}`
+        : ""
+    )
+    .filter(Boolean);
+  if (!indexFields.length && !boundField && !sortField) {
+    return;
+  }
+  // Use the built in _creationTime index if bounding or sorting by createdAt
+  // with no other fields
+  const index = !indexFields.length
+    ? {
+        indexDescriptor: "by_creation_time",
+        fields: [],
+      }
+    : indexes.find(({ fields }) => {
+        const fieldsMatch = indexFields.every(
+          (field, idx) => field === fields[idx]
+        );
+        // If sorting by createdAt, no intermediate fields can be on the index
+        // as they may override the createdAt sort order.
+        const boundFieldMatch =
+          boundField === "createdAt" || sortField === "createdAt"
+            ? indexFields.length === fields.length
+            : true;
+        return fieldsMatch && boundFieldMatch;
+      });
+  if (!index) {
+    return { indexFields };
+  }
+  return {
+    index: {
+      indexDescriptor: index.indexDescriptor,
+      fields: [...index.fields, "_creationTime"],
+    },
+    boundField,
+    sortField,
+    values: {
+      eq: indexEqFields.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 updateArgsValidator = {
-  input: v.union(
-    updateArgsInputValidator("account"),
-    updateArgsInputValidator("session"),
-    updateArgsInputValidator("verification"),
-    updateArgsInputValidator("user")
-  ),
+const selectFields = <T extends TableNames, D extends Doc<T>>(
+  doc: D | null,
+  select?: string[]
+) => {
+  if (!doc) {
+    return null;
+  }
+  if (!select?.length) {
+    return doc;
+  }
+  return select.reduce((acc, field) => {
+    (acc as any)[field] = doc[field];
+    return acc;
+  }, {} as D);
 };
 
-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}`);
+// Manually filter an individual document by where clauses. This is used to
+// simplify queries that can only return 0 or 1 documents, or "in" clauses that
+// query multiple single documents in parallel.
+const filterByWhere = (
+  doc: Doc<any>,
+  where?: Infer<typeof adapterWhereValidator>[],
+  filterWhere?: (w: Infer<typeof adapterWhereValidator>) => any
+) => {
+  if (!doc) {
+    return false;
+  }
+  for (const w of where ?? []) {
+    if (filterWhere && !filterWhere(w)) {
+      continue;
     }
-    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}`);
+    const value = doc[w.field as keyof typeof doc] as Infer<
+      typeof adapterWhereValidator
+    >["value"];
+    const isLessThan = (val: typeof value, wVal: typeof w.value) => {
+      if (!wVal) {
+        return false;
+      }
+      if (!val) {
+        return true;
+      }
+      return val < wVal;
+    };
+    const isGreaterThan = (val: typeof value, wVal: typeof w.value) => {
+      if (!val) {
+        return false;
+      }
+      if (!wVal) {
+        return true;
+      }
+      return val > wVal;
+    };
+    switch (w.operator) {
+      case undefined:
+      case "eq": {
+        return value === w.value;
+      }
+      case "in": {
+        return Array.isArray(w.value) && (w.value as any[]).includes(value);
+      }
+      case "lt": {
+        return isLessThan(value, w.value);
+      }
+      case "lte": {
+        return value === w.value || isLessThan(value, w.value);
+      }
+      case "gt": {
+        return isGreaterThan(value, w.value);
+      }
+      case "gte": {
+        return value === w.value || isGreaterThan(value, w.value);
+      }
+      case "ne": {
+        return value !== w.value;
+      }
+      case "contains": {
+        return typeof value === "string" && value.includes(w.value as string);
+      }
+      case "starts_with": {
+        return typeof value === "string" && value.startsWith(w.value as string);
+      }
+      case "ends_with": {
+        return typeof value === "string" && value.endsWith(w.value as string);
+      }
     }
-    return transformOutput(updatedDoc, table);
-  },
-});
+  }
+  return true;
+};
 
-export const deleteBy = mutation({
-  args: getByArgsValidator,
-  handler: async (ctx, args) => {
-    const doc = await getByHelper(ctx, args);
-    if (!doc) {
-      return;
+const generateQuery = (
+  ctx: QueryCtx,
+  args: Infer<typeof adapterArgsValidator>
+) => {
+  const { index, values, boundField, indexFields } = findIndex(args) ?? {};
+  const query = stream(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 filteredQuery = orderedQuery.filterWith(async (doc) => {
+    if (!index && indexFields?.length) {
+      console.warn(
+        stripIndent`
+          Querying without an index on table "${args.model}".
+          This can cause performance issues, and may hit the document read limit.
+          To fix, add an index that begins with the following fields in order:
+          [${indexFields.join(", ")}]
+        `
+      );
+      return filterByWhere(doc, args.where);
     }
-    await ctx.db.delete(doc._id);
-    // onDeleteUser requires userId from the doc,
-    // so just return the whole thing
-    return doc;
-  },
-});
+    return filterByWhere(
+      doc,
+      args.where,
+      (w) =>
+        w.operator &&
+        ["contains", "starts_with", "ends_with", "ne"].includes(w.operator)
+    );
+  });
+  return filteredQuery;
+};
 
-// 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"));
-  },
-});
+// 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. Every response is a pagination result.
+const paginate = async (
+  ctx: QueryCtx,
+  args: Infer<typeof adapterArgsValidator> & {
+    paginationOpts: PaginationOptions;
+  }
+): Promise<PaginationResult<Doc<any>>> => {
+  if (args.offset) {
+    throw new Error(`offset not supported: ${JSON.stringify(args.offset)}`);
+  }
+  if (args.where?.some((w) => w.connector === "OR") && args.where?.length > 1) {
+    throw new Error(
+      `OR connector not supported with multiple where statements in paginate, split up the where statements before calling paginate: ${JSON.stringify(args.where)}`
+    );
+  }
+  if (
+    args.where?.some(
+      (w) =>
+        w.field === "id" && w.operator && !["eq", "in"].includes(w.operator)
+    )
+  ) {
+    throw new Error(
+      `id can only be used with eq or in operator: ${JSON.stringify(args.where)}`
+    );
+  }
+  // If any where clause is "eq" (or missing operator) on a unique field,
+  // we can only return a single document, so we get it and use any other
+  // where clauses as static filters.
+  const uniqueWhere = args.where?.find(
+    (w) =>
+      (!w.operator || w.operator === "eq") &&
+      (isUniqueField(args.model as TableNames, w.field) || w.field === "id")
+  );
+  if (uniqueWhere) {
+    const doc =
+      uniqueWhere.field === "id"
+        ? await ctx.db.get(uniqueWhere.value as Id<TableNames>)
+        : await ctx.db
+            .query(args.model as any)
+            .withIndex(uniqueWhere.field as any, (q) =>
+              q.eq(uniqueWhere.field, uniqueWhere.value)
+            )
+            .unique();
 
-export const getSessionsByUserId = query({
-  args: { userId: v.string(), limit: v.optional(v.number()) },
-  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"));
-  },
-});
+    if (filterByWhere(doc, args.where, (w) => w !== uniqueWhere)) {
+      return {
+        page: [selectFields(doc, args.select)].filter(Boolean),
+        isDone: true,
+        continueCursor: "",
+      };
+    }
+    return {
+      page: [],
+      isDone: true,
+      continueCursor: "",
+    };
+  }
 
-export const getJwks = query({
-  args: {
-    limit: v.optional(v.number()),
-  },
-  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"));
-  },
-});
+  const paginationOpts = {
+    ...args.paginationOpts,
+    // If maximumRowsRead is not at least 1 higher than numItems, bad cursors
+    // and incorrect paging will result (at least with convex-test).
+    maximumRowsRead: Math.max((args.paginationOpts.numItems ?? 0) + 1, 200),
+  };
 
-export const listVerificationsByIdentifier = query({
+  // Large queries using "in" clause will crash, but these are only currently
+  // possible with the organization plugin listing all members with a high
+  // limit. For cases like this we need to create proper convex queries in
+  // the component as an alternative to using Better Auth api's.
+  const inWhere = args.where?.find((w) => w.operator === "in");
+  if (inWhere) {
+    if (!Array.isArray(inWhere.value)) {
+      throw new Error("in clause value must be an array");
+    }
+    // For ids, just use asyncMap + .get()
+    if (inWhere.field === "id") {
+      const docs = await asyncMap(inWhere.value as any[], async (value) => {
+        return ctx.db.get(value as Id<TableNames>);
+      });
+      const filteredDocs = docs
+        .flatMap((doc) => doc || [])
+        .filter((doc) => filterByWhere(doc, args.where, (w) => w !== inWhere));
+
+      return {
+        page: filteredDocs.sort((a, b) => {
+          if (args.sortBy?.field === "createdAt") {
+            return args.sortBy.direction === "asc"
+              ? a._creationTime - b._creationTime
+              : b._creationTime - a._creationTime;
+          }
+          if (args.sortBy) {
+            const aValue = a[args.sortBy.field as keyof typeof a];
+            const bValue = b[args.sortBy.field as keyof typeof b];
+            if (aValue === bValue) {
+              return 0;
+            }
+            return args.sortBy.direction === "asc"
+              ? aValue > bValue
+                ? 1
+                : -1
+              : aValue > bValue
+                ? -1
+                : 1;
+          }
+          return 0;
+        }),
+        isDone: true,
+        continueCursor: "",
+      };
+    }
+    const streams = inWhere.value.map((value) => {
+      return generateQuery(ctx, {
+        ...args,
+        where: args.where?.map((w) => {
+          if (w === inWhere) {
+            return { ...w, operator: "eq", value };
+          }
+          return w;
+        }),
+      });
+    });
+    const result = await mergedStream(
+      streams,
+      [
+        args.sortBy?.field !== "createdAt" && args.sortBy?.field,
+        "_creationTime",
+      ].flatMap((f) => (f ? [f] : []))
+    )
+      .filterWith(async (doc) =>
+        filterByWhere(
+          doc,
+          args.where,
+          (w) =>
+            w.operator &&
+            ["contains", "starts_with", "ends_with", "ne"].includes(w.operator)
+        )
+      )
+      .paginate(paginationOpts);
+    return {
+      ...result,
+      page: result.page.map((doc) => selectFields(doc, args.select)),
+    };
+  }
+
+  const query = generateQuery(ctx, args);
+  const result = await query.paginate(paginationOpts);
+  return {
+    ...result,
+    page: result.page.map((doc) => selectFields(doc, args.select)),
+  };
+};
+
+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: {
-    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)),
+          data: v.object(table.validator.fields),
+        })
+      )
     ),
-    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}`);
+    await checkUniqueFields(
+      ctx,
+      args.input.model as TableNames,
+      args.input.data
+    );
+
+    const id = await ctx.db.insert(args.input.model as any, args.input.data);
+    const doc = await ctx.db.get(id);
+    if (!doc) {
+      throw new Error(`Failed to create ${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"));
+    return doc;
   },
 });
 
-export const deleteOldVerificationsPage = mutation({
-  args: {
-    currentTimestamp: v.number(),
-    paginationOpts: v.optional(paginationOptsValidator),
-  },
+export const findOne = query({
+  args: adapterArgsValidator,
   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 };
+    return await listOne(ctx, args);
   },
 });
 
-export const deleteOldVerifications = action({
+export const findMany = query({
   args: {
-    currentTimestamp: v.number(),
+    ...adapterArgsValidator.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,
-        },
-      });
-      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 await paginate(ctx, args);
   },
 });
 
-export const deleteExpiredSessions = mutation({
+export const updateOne = mutation({
   args: {
-    userId: v.string(),
-    expiresAt: v.number(),
-  },
-  handler: async (ctx, args) => {
-    const docs = await ctx.db
-      .query("session")
-      .withIndex("userId_expiresAt", (q) =>
-        q.eq("userId", args.userId).lt("expiresAt", args.expiresAt)
+    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(partial(table.validator.fields)),
+        })
       )
-      .collect();
-    await asyncMap(docs, async (doc) => {
-      await ctx.db.delete(doc._id);
-    });
-    return docs.length;
-  },
-});
-
-export const deleteAllForUserPage = mutation({
-  args: {
-    table: v.string(),
-    userId: v.string(),
-    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(args.table as any)
-      .withIndex("userId", (q) => q.eq("userId", args.userId))
-      .paginate(paginationOpts);
-    await asyncMap(page, async (doc) => {
-      await ctx.db.delete(doc._id);
-    });
-    return { ...result, count: page.length };
+    const doc = await listOne(ctx, args.input);
+    if (!doc) {
+      throw new Error(`Failed to update ${args.input.model}`);
+    }
+    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 deleteAllForUser = action({
+export const updateMany = mutation({
   args: {
-    table: v.string(),
-    userId: v.string(),
+    input: v.union(
+      ...Object.entries(schema.tables).map(([model, table]) =>
+        v.object({
+          ...adapterArgsValidator.fields,
+          model: v.literal(model),
+          where: v.optional(v.array(adapterWhereValidator)),
+          update: v.object(partial(table.validator.fields)),
+          paginationOpts: paginationOptsValidator,
+        })
+      )
+    ),
   },
   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,
-        },
+    const { page, ...result } = await paginate(ctx, args.input);
+    if (args.input.update) {
+      if (
+        hasUniqueFields(
+          args.input.model as TableNames,
+          args.input.update ?? {}
+        ) &&
+        page.length > 1
+      ) {
+        throw new Error(
+          `Attempted to set unique fields in multiple documents in ${args.input.model} with the same value. Fields: ${Object.keys(args.input.update ?? {}).join(", ")}`
+        );
+      }
+      await asyncMap(page, async (doc) => {
+        await checkUniqueFields(
+          ctx,
+          args.input.model as TableNames,
+          args.input.update ?? {},
+          doc
+        );
+        await ctx.db.patch(doc._id, args.input.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 getAccountByAccountIdAndProviderId = query({
-  args: { accountId: v.string(), providerId: v.string() },
+export const deleteOne = mutation({
+  args: adapterArgsValidator,
   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();
+    const doc = await listOne(ctx, args);
     if (!doc) {
       return;
     }
-    return transformOutput(doc, "account");
+    await ctx.db.delete(doc._id);
+    return doc;
   },
 });
 
-export const updateUserProviderAccounts = mutation({
+export const deleteMany = mutation({
   args: {
-    userId: v.string(),
-    providerId: v.string(),
-    update: v.object(partial(schema.tables.account.validator.fields)),
+    ...adapterArgsValidator.fields,
+    paginationOpts: paginationOptsValidator,
   },
   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;
-    }
-    await asyncMap(docs, async (doc) => {
-      await ctx.db.patch(doc._id, args.update);
+    const { page, ...result } = await paginate(ctx, args);
+    await asyncMap(page, async (doc) => {
+      await ctx.db.delete(doc._id);
     });
-    return docs.length;
+    return {
+      ...result,
+      count: page.length,
+    };
   },
 });
 
-export const updateTwoFactor = mutation({
-  args: {
-    userId: v.string(),
-    update: v.object(partial(schema.tables.twoFactor.validator.fields)),
-  },
-  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;
+// 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;
     }
-    await asyncMap(docs, async (doc) => {
-      await ctx.db.patch(doc._id, args.update);
-    });
-    return docs.length;
+    return ctx.db.get(identity.sessionId as Id<"session">);
   },
 });