@convex-dev/better-auth 0.7.0-alpha.12 → 0.7.0-alpha.3

package/dist/commonjs/component/lib.js

@@ -1,380 +1,351 @@
-import { mutation, query } from "../component/_generated/server";
+import { action, mutation, query, } from "../component/_generated/server";
 import { asyncMap } from "convex-helpers";
 import { v } from "convex/values";
-import schema, { specialFields } from "../component/schema";
-import { paginationOptsValidator, } from "convex/server";
+import { api } from "../component/_generated/api";
+import schema from "../component/schema";
+import { paginationOptsValidator } from "convex/server";
 import { paginator } from "convex-helpers/server/pagination";
 import { partial } from "convex-helpers/validators";
-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()),
-    unique: v.optional(v.boolean()),
-});
-const getUniqueFields = (table, input) => {
-    const fields = specialFields[table];
-    if (!fields) {
-        return [];
-    }
-    return Object.entries(fields)
-        .filter(([key, value]) => value.unique && Object.keys(input).includes(key))
-        .map(([key]) => key);
-};
-const checkUniqueFields = async (ctx, table, input, doc) => {
-    const uniqueFields = getUniqueFields(table, input);
-    if (!uniqueFields.length) {
-        return;
-    }
-    for (const field of uniqueFields) {
-        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`);
-        }
-    }
-};
-const findIndex = async (args) => {
-    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][" 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}`);
-    }
+export const transformInput = (model, data) => {
     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,
-        },
+        ...Object.fromEntries(Object.entries(data).map(([key, value]) => {
+            if (value instanceof Date) {
+                return [key, value.getTime()];
+            }
+            return [key, value];
+        })),
     };
 };
-const selectFields = (doc, select) => {
-    if (!doc) {
-        return null;
-    }
-    if (!select?.length) {
-        return doc;
-    }
-    return select.reduce((acc, field) => {
-        acc[field] = doc[field];
-        return acc;
-    }, {});
+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 };
 };
-// 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, args) => {
-    // 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);
-        return {
-            page: [selectFields(doc, args.select)].filter(Boolean),
-            isDone: true,
-            continueCursor: "",
-        };
+// 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);
+    },
+});
+export const getByHelper = async (ctx, args) => {
+    if (args.field === "id") {
+        return ctx.db.get(args.value);
     }
-    const { index, values, boundField } = (await findIndex(args)) ?? {};
-    const query = paginator(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 result = await orderedQuery.paginate(args.paginationOpts);
-    return {
-        ...result,
-        page: result.page.map((doc) => selectFields(doc, args.select)),
-    };
+    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();
 };
-const listOne = async (ctx, args) => {
-    return (await paginate(ctx, {
-        ...args,
-        paginationOpts: {
-            numItems: 1,
-            cursor: null,
-        },
-    })).page[0];
+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()),
 };
+// 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 };
 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),
+    args: v.object({
+        input: v.union(...Object.values(schema.tables).map((table) => v.object({
+            table: v.string(),
+            ...table.validator.fields,
         }))),
-    },
+    }),
     handler: async (ctx, args) => {
-        await checkUniqueFields(ctx, args.input.model, args.input.data);
-        const id = await ctx.db.insert(args.input.model, args.input.data);
+        const { table, ...input } = args.input;
+        const id = await ctx.db.insert(table, {
+            ...input,
+        });
         const doc = await ctx.db.get(id);
         if (!doc) {
-            throw new Error(`Failed to create ${args.input.model}`);
+            throw new Error(`Failed to create ${table}`);
+        }
+        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 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)
+            : await getByHelper(ctx, { table, ...where });
+        if (!doc) {
+            throw new Error(`Failed to update ${table}`);
+        }
+        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 transformOutput(updatedDoc, table);
+    },
+});
+export const deleteBy = mutation({
+    args: getByArgsValidator,
+    handler: async (ctx, args) => {
+        const doc = await getByHelper(ctx, args);
+        if (!doc) {
+            return;
         }
+        await ctx.db.delete(doc._id);
+        // onDeleteUser requires userId from the doc,
+        // so just return the whole thing
         return doc;
     },
 });
-export const findOne = query({
-    args: adapterArgsValidator,
+// Single purpose functions
+export const getAccountsByUserId = query({
+    args: { userId: v.string(), limit: v.optional(v.number()) },
     handler: async (ctx, args) => {
-        return await listOne(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 findMany = query({
+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({
     args: {
-        ...adapterArgsValidator.fields,
-        paginationOpts: paginationOptsValidator,
+        limit: v.optional(v.number()),
     },
     handler: async (ctx, args) => {
-        return await paginate(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"));
     },
 });
-export const updateOne = mutation({
+export const listVerificationsByIdentifier = query({
     args: {
-        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,
-            ]))),
-        }))),
+        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()),
     },
     handler: async (ctx, args) => {
-        const doc = await listOne(ctx, args.input);
-        if (!doc) {
-            throw new Error(`Failed to update ${args.input.model}`);
+        if (args.sortBy && args.sortBy.field !== "createdAt") {
+            throw new Error(`Unsupported sortBy field: ${args.sortBy.field}`);
         }
-        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;
+        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 updateMany = mutation({
+export const deleteOldVerificationsPage = mutation({
     args: {
-        ...adapterArgsValidator.fields,
-        update: v.optional(v.object(partial(schema.tables.user.validator.fields))),
-        paginationOpts: paginationOptsValidator,
+        currentTimestamp: v.number(),
+        paginationOpts: v.optional(paginationOptsValidator),
     },
     handler: async (ctx, args) => {
-        const { page, ...result } = await paginate(ctx, args);
-        if (args.update) {
-            const uniqueFields = getUniqueFields(args.model, 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, args.update ?? {}, doc);
-                await ctx.db.patch(doc._id, args.update);
-            });
-        }
-        return {
-            ...result,
-            count: page.length,
+        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 };
     },
 });
-export const deleteOne = mutation({
-    args: adapterArgsValidator,
+export const deleteOldVerifications = action({
+    args: {
+        currentTimestamp: v.number(),
+    },
     handler: async (ctx, args) => {
-        const doc = await listOne(ctx, args);
-        if (!doc) {
-            return;
-        }
-        await ctx.db.delete(doc._id);
-        return doc;
+        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,
+                },
+            });
+            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 deleteMany = mutation({
+export const deleteExpiredSessions = mutation({
     args: {
-        ...adapterArgsValidator.fields,
-        paginationOpts: paginationOptsValidator,
+        userId: v.string(),
+        expiresAt: v.number(),
     },
     handler: async (ctx, args) => {
-        const { page, ...result } = await paginate(ctx, args);
-        await asyncMap(page, async (doc) => {
+        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 {
-            ...result,
-            count: page.length,
+        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)
+            .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 };
     },
 });
-// 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;
+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 = 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();
+        if (!doc) {
+            return;
         }
-        return ctx.db.get(identity.sessionId);
+        return transformOutput(doc, "account");
     },
 });
-// TODO: rewrite functions below here to be dynamic
-export const getIn = query({
-    args: adapterArgsValidator,
+export const updateUserProviderAccounts = mutation({
+    args: {
+        userId: v.string(),
+        providerId: v.string(),
+        update: v.object(partial(schema.tables.account.validator.fields)),
+    },
     handler: async (ctx, args) => {
-        const where = args.where?.[0];
-        if (!where || where.operator !== "in" || args.where?.length !== 1) {
-            throw new Error("where must be a single in clause");
+        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;
         }
-        return (await asyncMap(where.value, async (value) => {
-            if (where.field === "id") {
-                return [await ctx.db.get(value)];
-            }
-            const query = ctx.db
-                .query(args.model)
-                .withIndex(where.field, (q) => q.eq(where.field, value));
-            if (args.limit) {
-                return await query.take(args.limit);
-            }
-            return await query.collect();
-        }))
-            .flat()
-            .filter(Boolean);
+        await asyncMap(docs, async (doc) => {
+            await ctx.db.patch(doc._id, args.update);
+        });
+        return docs.length;
     },
 });
-export const deleteIn = mutation({
+export const updateTwoFactor = mutation({
     args: {
-        input: v.union(v.object({
-            table: v.literal("session"),
-            field: v.literal("token"),
-            values: v.array(v.string()),
-        })),
+        userId: v.string(),
+        update: v.object(partial(schema.tables.twoFactor.validator.fields)),
     },
     handler: async (ctx, args) => {
-        const { table, field, values } = args.input;
-        const docs = await asyncMap(values, async (value) => {
-            const doc = await ctx.db
-                .query(table)
-                .withIndex(field, (q) => q.eq(field, value))
-                .unique();
-            if (!doc) {
-                return;
-            }
-            await ctx.db.delete(doc._id);
-            return doc;
+        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);
         });
-        return docs.filter(Boolean).length;
+        return docs.length;
     },
 });
 //# sourceMappingURL=lib.js.map