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

package/dist/esm/component/lib.js

@@ -1,351 +1,528 @@
-import { action, mutation, query, } from "../component/_generated/server.js";
+import { mutation, query } from "../component/_generated/server.js";
 import { asyncMap } from "convex-helpers";
 import { v } from "convex/values";
-import { api } from "../component/_generated/api.js";
-import schema from "../component/schema.js";
-import { paginationOptsValidator } from "convex/server";
-import { paginator } from "convex-helpers/server/pagination";
+import schema, { specialFields } from "../component/schema.js";
+import { paginationOptsValidator, } from "convex/server";
 import { partial } from "convex-helpers/validators";
-export const transformInput = (model, data) => {
-    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 }, _model) => {
-    // Provide the expected id field, but it can be overwritten if
-    // the model has an id field
-    return { id: _id, ...data };
+import { stream } from "convex-helpers/server/stream";
+import { mergedStream } from "convex-helpers/server/stream";
+import { stripIndent } from "common-tags";
+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 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()),
+});
+const isUniqueField = (model, field) => {
+    const fields = specialFields[model];
+    if (!fields) {
+        return false;
+    }
+    return Object.entries(fields)
+        .filter(([, value]) => value.unique)
+        .map(([key]) => key)
+        .includes(field);
 };
-// 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 hasUniqueFields = (model, input) => {
+    for (const field of Object.keys(input)) {
+        if (isUniqueField(model, field)) {
+            return true;
         }
-        return ctx.db.get(identity.sessionId);
-    },
-});
-export const getByHelper = async (ctx, args) => {
-    if (args.field === "id") {
-        return ctx.db.get(args.value);
     }
-    const query = ctx.db
-        .query(args.table)
-        .withIndex(args.field, (q) => q.eq(args.field, args.value));
-    return args.unique ? await query.unique() : await query.first();
+    return false;
 };
-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()),
+const checkUniqueFields = async (ctx, table, input, doc) => {
+    if (!hasUniqueFields(table, input)) {
+        return;
+    }
+    for (const field of Object.keys(input)) {
+        if (!isUniqueField(table, field)) {
+            continue;
+        }
+        const existingDoc = await ctx.db
+            .query(table)
+            .withIndex(field, (q) => q.eq(field, input[field]))
+            .unique();
+        if (existingDoc && existingDoc._id !== doc?._id) {
+            throw new Error(`${table} ${field} already exists`);
+        }
+    }
 };
-// Generic functions
-export const getByQuery = query({
-    args: getByArgsValidator,
-    handler: async (ctx, args) => {
-        const doc = await getByHelper(ctx, args);
-        if (!doc) {
-            return;
+const findIndex = (args) => {
+    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][" 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: [],
         }
-        return transformOutput(doc, args.table);
-    },
-});
-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,
-        }))),
-    }),
-    handler: async (ctx, args) => {
-        const { table, ...input } = args.input;
-        const id = await ctx.db.insert(table, {
-            ...input,
+        : 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;
         });
-        const doc = await ctx.db.get(id);
-        if (!doc) {
-            throw new Error(`Failed to create ${table}`);
+    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 selectFields = (doc, select) => {
+    if (!doc) {
+        return null;
+    }
+    if (!select?.length) {
+        return doc;
+    }
+    return select.reduce((acc, field) => {
+        acc[field] = doc[field];
+        return acc;
+    }, {});
+};
+// 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, where, filterWhere) => {
+    if (!doc) {
+        return false;
+    }
+    for (const w of where ?? []) {
+        if (filterWhere && !filterWhere(w)) {
+            continue;
         }
-        return transformOutput(doc, table);
-    },
-});
-export const updateArgsInputValidator = (table) => {
-    return v.object({
-        table: v.literal(table),
-        where: v.object({ field: v.string(), value: getByArgsValidator.value }),
-        value: v.record(v.string(), v.any()),
-    });
+        const value = doc[w.field];
+        const isLessThan = (val, wVal) => {
+            if (!wVal) {
+                return false;
+            }
+            if (!val) {
+                return true;
+            }
+            return val < wVal;
+        };
+        const isGreaterThan = (val, wVal) => {
+            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.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);
+            }
+            case "starts_with": {
+                return typeof value === "string" && value.startsWith(w.value);
+            }
+            case "ends_with": {
+                return typeof value === "string" && value.endsWith(w.value);
+            }
+        }
+    }
+    return true;
 };
-const updateArgsValidator = {
-    input: v.union(updateArgsInputValidator("account"), updateArgsInputValidator("session"), updateArgsInputValidator("verification"), updateArgsInputValidator("user")),
+const generateQuery = (ctx, args) => {
+    const { index, values, boundField, indexFields } = findIndex(args) ?? {};
+    const query = stream(ctx.db, schema).query(args.model);
+    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) => {
+                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);
+        }
+        return filterByWhere(doc, args.where, (w) => w.operator &&
+            ["contains", "starts_with", "ends_with", "ne"].includes(w.operator));
+    });
+    return filteredQuery;
 };
-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)
-            : await getByHelper(ctx, { table, ...where });
-        if (!doc) {
-            throw new Error(`Failed to update ${table}`);
+// 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, args) => {
+    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, w.field) || w.field === "id"));
+    if (uniqueWhere) {
+        const doc = uniqueWhere.field === "id"
+            ? await ctx.db.get(uniqueWhere.value)
+            : await ctx.db
+                .query(args.model)
+                .withIndex(uniqueWhere.field, (q) => q.eq(uniqueWhere.field, uniqueWhere.value))
+                .unique();
+        if (filterByWhere(doc, args.where, (w) => w !== uniqueWhere)) {
+            return {
+                page: [selectFields(doc, args.select)].filter(Boolean),
+                isDone: true,
+                continueCursor: "",
+            };
         }
-        await ctx.db.patch(doc._id, value);
-        const updatedDoc = await ctx.db.get(doc._id);
-        if (!updatedDoc) {
-            throw new Error(`Failed to update ${table}`);
+        return {
+            page: [],
+            isDone: true,
+            continueCursor: "",
+        };
+    }
+    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),
+    };
+    // 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");
         }
-        return transformOutput(updatedDoc, table);
+        // For ids, just use asyncMap + .get()
+        if (inWhere.field === "id") {
+            const docs = await asyncMap(inWhere.value, async (value) => {
+                return ctx.db.get(value);
+            });
+            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];
+                        const bValue = b[args.sortBy.field];
+                        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, args) => {
+    return (await paginate(ctx, {
+        ...args,
+        paginationOpts: {
+            numItems: 1,
+            cursor: null,
+        },
+    })).page[0];
+};
+export const create = mutation({
+    args: {
+        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),
+        }))),
     },
-});
-export const deleteBy = mutation({
-    args: getByArgsValidator,
     handler: async (ctx, args) => {
-        const doc = await getByHelper(ctx, args);
+        await checkUniqueFields(ctx, args.input.model, args.input.data);
+        const id = await ctx.db.insert(args.input.model, 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()) },
+export const findOne = query({
+    args: adapterArgsValidator,
     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"));
+        return await listOne(ctx, args);
     },
 });
-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"));
-    },
-});
-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")),
-        })),
-        limit: v.optional(v.number()),
+        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)),
+        }))),
     },
     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, args.input.update, doc);
+        await ctx.db.patch(doc._id, args.input.update);
+        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(),
+        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 = await ctx.runMutation(api.lib.deleteOldVerificationsPage, {
-                currentTimestamp: args.currentTimestamp,
-                paginationOpts: {
-                    numItems: 500,
-                    cursor,
-                },
+        const { page, ...result } = await paginate(ctx, args.input);
+        if (args.input.update) {
+            if (hasUniqueFields(args.input.model, 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, args.input.update ?? {}, doc);
+                await ctx.db.patch(doc._id, args.input.update);
             });
-            count += result.count;
-            cursor =
-                result.pageStatus &&
-                    result.splitCursor &&
-                    ["SplitRecommended", "SplitRequired"].includes(result.pageStatus)
-                    ? result.splitCursor
-                    : result.continueCursor;
-            isDone = result.isDone;
-        } while (!isDone);
-        return count;
-    },
-});
-export const deleteExpiredSessions = 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))
-            .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,
+        }
+        return {
+            ...result,
+            count: page.length,
         };
-        const { page, ...result } = await paginator(ctx.db, schema)
-            .query(args.table)
-            .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 };
     },
 });
-export const deleteAllForUser = action({
-    args: {
-        table: v.string(),
-        userId: v.string(),
-    },
+export const deleteOne = mutation({
+    args: adapterArgsValidator,
     handler: async (ctx, args) => {
-        let count = 0;
-        let cursor = null;
-        let isDone = false;
-        do {
-            const result = 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;
-    },
-});
-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();
+        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);
     },
 });
 //# sourceMappingURL=lib.js.map