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

package/dist/commonjs/client/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/client/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,IAAI,IAAI,UAAU,EACvB,KAAK,mBAAmB,EACxB,KAAK,MAAM,EACX,KAAK,iBAAiB,EACtB,gBAAgB,EAChB,KAAK,gBAAgB,EACrB,kBAAkB,EAClB,KAAK,eAAe,EACpB,KAAK,UAAU,EAIhB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,EAAK,MAAM,eAAe,CAAC;AACzD,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,6BAA6B,CAAC;AACvD,OAAO,MAAM,MAAM,qBAAqB,CAAC;AACzC,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAC1C,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAOzC,OAAO,EAAE,oBAAoB,EAAyB,MAAM,kBAAkB,CAAC;AAK/E,OAAO,EAAE,aAAa,EAAE,CAAC;AAOzB,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uRAA6B,CAAC;AACvD,QAAA,MAAM,6BAA6B;;;;;;;;;;;;;+EAejC,CAAC;AAOH,QAAA,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4jBAM3B,CAAC;AACH,QAAA,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4TAK9B,CAAC;AAEH,MAAM,MAAM,aAAa,CAAC,CAAC,SAAS,mBAAmB,IAAI,iBAAiB,CAC1E,UAAU,EACV,UAAU,GAAG,QAAQ,EACrB,CAAC,CACF,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,UAAU,EAAE,iBAAiB,CAC3B,UAAU,EACV,UAAU,EACV,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAC5C,CAAC;IACF,UAAU,EAAE,iBAAiB,CAC3B,UAAU,EACV,UAAU,EACV,KAAK,CAAC,OAAO,oBAAoB,CAAC,CACnC,CAAC;IACF,UAAU,EAAE,iBAAiB,CAC3B,UAAU,EACV,UAAU,EACV,KAAK,CAAC,OAAO,uBAAuB,CAAC,CACtC,CAAC;IACF,aAAa,EAAE,iBAAiB,CAC9B,UAAU,EACV,UAAU,EACV,KAAK,CAAC,OAAO,0BAA0B,CAAC,CACzC,CAAC;CACH,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,eAAe,EAAE,iBAAiB,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;CACvD,CAAC;AAEF,qBAAa,UAAU,CAAC,MAAM,SAAS,MAAM,GAAG,MAAM;IAE3C,SAAS,EAAE,MAAM,CAAC,OAAO,GAAG,CAAC;IAC7B,MAAM,EAAE;QACb,aAAa,EAAE,aAAa,CAAC;QAC7B,mBAAmB,CAAC,EAAE,mBAAmB,CAAC;QAC1C,OAAO,CAAC,EAAE,OAAO,CAAC;KACnB;gBALM,SAAS,EAAE,MAAM,CAAC,OAAO,GAAG,CAAC,EAC7B,MAAM,EAAE;QACb,aAAa,EAAE,aAAa,CAAC;QAC7B,mBAAmB,CAAC,EAAE,mBAAmB,CAAC;QAC1C,OAAO,CAAC,EAAE,OAAO,CAAC;KACnB;IAGG,eAAe,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI;IAarC,UAAU,CAAC,GAAG,EAAE,WAAW,GAAG;QAAE,IAAI,EAAE,UAAU,CAAA;KAAE;IASlD,aAAa,CAAC,GAAG,EAAE,WAAW,GAAG;QAAE,IAAI,EAAE,UAAU,CAAA;KAAE;IASrD,WAAW,CAAC,GAAG,EAAE,WAAW,GAAG;QAAE,IAAI,EAAE,UAAU,CAAA;KAAE;;;;;;;;;;;;;;;;;;;;;IA6BnD,oBAAoB,CACxB,UAAU,EAAE,CAAC,GAAG,EAAE,gBAAgB,CAAC,GAAG,CAAC,KAAK,UAAU,CAAC,OAAO,UAAU,CAAC;IAQrE,kBAAkB,CACtB,GAAG,EAAE,kBAAkB,CAAC,gBAAgB,CAAC,EACzC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,IAAI,CACZ,OAAO,CAAC,KAAK,CAAC,OAAO,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,EACnD,QAAQ,CACT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAWG,iBAAiB,CACrB,GAAG,EAAE,eAAe,CAAC,gBAAgB,CAAC,EACtC,QAAQ,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;IAiBlB,mBAAmB,CAAC,SAAS,SAAS,gBAAgB,EAAE,IAAI,EAAE;QAC5D,YAAY,EAAE,CACZ,GAAG,EAAE,kBAAkB,CAAC,SAAS,CAAC,EAClC,IAAI,EAAE,KAAK,CAAC,OAAO,mBAAmB,CAAC,KACpC,OAAO,CAAC,MAAM,CAAC,CAAC;QACrB,YAAY,CAAC,EAAE,CACb,GAAG,EAAE,kBAAkB,CAAC,SAAS,CAAC,EAClC,EAAE,EAAE,MAAM,KACP,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;QAC1B,YAAY,CAAC,EAAE,CACb,GAAG,EAAE,kBAAkB,CAAC,SAAS,CAAC,EAClC,IAAI,EAAE,KAAK,CAAC,OAAO,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,KAC7C,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;QAC1B,eAAe,CAAC,EAAE,CAChB,GAAG,EAAE,kBAAkB,CAAC,SAAS,CAAC,EAClC,OAAO,EAAE,KAAK,CAAC,OAAO,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,KACnD,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;KAC3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA8DD,cAAc,CACZ,IAAI,EAAE,UAAU,EAChB,UAAU,EAAE,CAAC,GAAG,EAAE,gBAAgB,CAAC,GAAG,CAAC,KAAK,UAAU,CAAC,OAAO,UAAU,CAAC,EACzE,IAAI,GAAE;QACJ,IAAI,CAAC,EACD,OAAO,GACP;YAEE,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;YAC1B,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;YAC1B,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;SAC3B,CAAC;KACF;CA0FT;AAID,MAAM,MAAM,WAAW,GAAG;IACxB,QAAQ,EAAE,eAAe,CAAC,gBAAgB,CAAC,CAAC,UAAU,CAAC,CAAC;CACzD,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,QAAQ,EAAE,eAAe,CAAC,gBAAgB,CAAC,CAAC,UAAU,CAAC,CAAC;IACxD,WAAW,EAAE,kBAAkB,CAAC,gBAAgB,CAAC,CAAC,aAAa,CAAC,CAAC;CAClE,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,EAAE,eAAe,CAAC,gBAAgB,CAAC,CAAC,UAAU,CAAC,CAAC;IACxD,WAAW,EAAE,kBAAkB,CAAC,gBAAgB,CAAC,CAAC,aAAa,CAAC,CAAC;IACjE,SAAS,EAAE,gBAAgB,CAAC,gBAAgB,CAAC,CAAC,WAAW,CAAC,CAAC;CAC5D,CAAC;AAEF,MAAM,MAAM,MAAM,GAAG,WAAW,GAAG,cAAc,GAAG,YAAY,CAAC;AAEjE,MAAM,MAAM,SAAS,CAAC,CAAC,IACrB,CAAC,SAAS,SAAS,CAAC,MAAM,EAAE,CAAC,GACzB,MAAM,GACN,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,EAAE,GACnB,SAAS,CAAC,CAAC,CAAC,EAAE,GACd,CAAC,SAAS,WAAW,GACnB,WAAW,GACX,CAAC,SAAS,MAAM,GACd;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAAE,GACnC,CAAC,CAAC;AAEd,MAAM,MAAM,MAAM,CAAC,GAAG,IAAI,MAAM,CAAC;KAC9B,GAAG,IAAI,MAAM,GAAG,GAAG,GAAG,CAAC,GAAG,CAAC,SAAS,iBAAiB,CACpD,MAAM,KAAK,EACX,QAAQ,EACR,MAAM,KAAK,EACX,MAAM,WAAW,EACjB,MAAM,cAAc,CACrB,GACG,iBAAiB,CACf,KAAK,EACL,UAAU,EACV,SAAS,CAAC,KAAK,CAAC,EAChB,SAAS,CAAC,WAAW,CAAC,EACtB,cAAc,CACf,GACD,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;CACrB,CAAC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/client/index.ts"],"names":[],"mappings":"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"}

package/dist/commonjs/client/index.js

@@ -1,257 +1,384 @@
-import { httpActionGeneric, internalMutationGeneric, queryGeneric, } from "convex/server";
+import { httpActionGeneric, internalMutationGeneric, mutationGeneric, paginationOptsValidator, queryGeneric, } from "convex/server";
 import { v } from "convex/values";
-import schema from "../component/schema";
 import { convexAdapter } from "./adapter";
-import { omit } from "convex-helpers";
-import { createCookieGetter } from "better-auth/cookies";
-import { fetchQuery } from "convex/nextjs";
-import { JWT_COOKIE_NAME } from "../plugins/convex";
+import { asyncMap } from "convex-helpers";
 import { requireEnv } from "../utils";
-import { parse, partial } from "convex-helpers/validators";
-import { adapterArgsValidator, adapterWhereValidator } from "../component/lib";
+import { partial } from "convex-helpers/validators";
+import { adapterWhereValidator, checkUniqueFields, hasUniqueFields, listOne, paginate, selectFields, } from "./adapterUtils";
 import { corsRouter } from "convex-helpers/server/cors";
 import { version as convexVersion } from "convex";
 import semver from "semver";
+import { getAuthTables } from "better-auth/db";
 export { convexAdapter };
 if (semver.lt(convexVersion, "1.25.0")) {
     throw new Error("Convex version must be at least 1.25.0");
 }
-const createUserFields = omit(schema.tables.user.validator.fields, ["userId"]);
-const createUserValidator = v.object(createUserFields);
-const createPermissiveArgsValidator = v.object({
-    input: v.object({
-        model: v.literal("user"),
-        data: v.record(v.string(), v.union(v.string(), v.number(), v.boolean(), v.array(v.string()), v.array(v.number()), v.null())),
-    }),
+const whereValidator = (schema, tableName) => v.object({
+    field: v.union(...Object.keys(schema.tables[tableName].validator.fields).map((field) => v.literal(field)), v.literal("id")),
+    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"))),
 });
-const createUserArgsValidator = v.object({
-    input: v.object({
-        model: v.literal("user"),
-        data: v.object(createUserFields),
-    }),
-});
-const updateUserArgsValidator = v.object({
-    input: v.object({
-        model: v.literal("user"),
-        where: v.optional(v.array(adapterWhereValidator)),
-        update: v.object(partial(createUserFields)),
-    }),
-});
-const createSessionArgsValidator = v.object({
-    input: v.object({
-        model: v.literal("session"),
-        data: v.object(schema.tables.session.validator.fields),
-    }),
-});
-export class BetterAuth {
-    component;
-    config;
-    constructor(component, config) {
-        this.component = component;
-        this.config = config;
-    }
-    async isAuthenticated(token) {
-        if (!this.config.publicAuthFunctions?.isAuthenticated) {
-            throw new Error("isAuthenticated function not found. It must be a named export in convex/auth.ts");
-        }
-        return fetchQuery(this.config.publicAuthFunctions.isAuthenticated, {}, { token: token ?? undefined });
-    }
-    async getHeaders(ctx) {
-        const session = await ctx.runQuery(this.component.lib.getCurrentSession);
-        return new Headers({
-            ...(session?.token ? { authorization: `Bearer ${session.token}` } : {}),
-            ...(session?.ipAddress ? { "x-forwarded-for": session.ipAddress } : {}),
-        });
-    }
-    // TODO: use the proper id type for auth functions
-    async getAuthUserId(ctx) {
-        const identity = await ctx.auth.getUserIdentity();
-        if (!identity) {
-            return null;
-        }
-        return identity.subject;
-    }
-    // Convenience function for getting the Better Auth user
-    async getAuthUser(ctx) {
+export const createApi = (schema, createAuth) => {
+    const betterAuthSchema = getAuthTables(createAuth({}).options);
+    return {
+        create: mutationGeneric({
+            args: {
+                input: v.union(...Object.entries(schema.tables).map(([model, table]) => v.object({
+                    model: v.literal(model),
+                    data: v.object(table.validator.fields),
+                }))),
+                select: v.optional(v.array(v.string())),
+                onCreateHandle: v.optional(v.string()),
+            },
+            handler: async (ctx, args) => {
+                await checkUniqueFields(ctx, schema, betterAuthSchema, 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) {
+                    throw new Error(`Failed to create ${args.input.model}`);
+                }
+                const result = selectFields(doc, args.select);
+                if (args.onCreateHandle) {
+                    await ctx.runMutation(args.onCreateHandle, {
+                        model: args.input.model,
+                        doc,
+                    });
+                }
+                return result;
+            },
+        }),
+        findOne: queryGeneric({
+            args: {
+                model: v.union(...Object.keys(schema.tables).map((model) => v.literal(model))),
+                where: v.optional(v.array(adapterWhereValidator)),
+                select: v.optional(v.array(v.string())),
+            },
+            handler: async (ctx, args) => {
+                return await listOne(ctx, schema, betterAuthSchema, args);
+            },
+        }),
+        findMany: queryGeneric({
+            args: {
+                model: v.union(...Object.keys(schema.tables).map((model) => v.literal(model))),
+                where: v.optional(v.array(adapterWhereValidator)),
+                limit: v.optional(v.number()),
+                sortBy: v.optional(v.object({
+                    direction: v.union(v.literal("asc"), v.literal("desc")),
+                    field: v.string(),
+                })),
+                offset: v.optional(v.number()),
+                paginationOpts: paginationOptsValidator,
+            },
+            handler: async (ctx, args) => {
+                return await paginate(ctx, schema, betterAuthSchema, args);
+            },
+        }),
+        updateOne: mutationGeneric({
+            args: {
+                input: v.union(...Object.entries(schema.tables).map(([tableName, table]) => {
+                    const fields = partial(table.validator.fields);
+                    return v.object({
+                        model: v.literal(tableName),
+                        update: v.object(fields),
+                        where: v.optional(v.array(whereValidator(schema, tableName))),
+                    });
+                })),
+                onUpdateHandle: v.optional(v.string()),
+            },
+            handler: async (ctx, args) => {
+                const doc = await listOne(ctx, schema, betterAuthSchema, args.input);
+                if (!doc) {
+                    throw new Error(`Failed to update ${args.input.model}`);
+                }
+                await checkUniqueFields(ctx, schema, betterAuthSchema, 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}`);
+                }
+                if (args.onUpdateHandle) {
+                    await ctx.runMutation(args.onUpdateHandle, {
+                        input: {
+                            model: args.input.model,
+                            oldDoc: doc,
+                            newDoc: updatedDoc,
+                        },
+                    });
+                }
+                return updatedDoc;
+            },
+        }),
+        updateMany: mutationGeneric({
+            args: {
+                input: v.union(...Object.entries(schema.tables).map(([tableName, table]) => {
+                    const fields = partial(table.validator.fields);
+                    return v.object({
+                        model: v.literal(tableName),
+                        update: v.object(fields),
+                        where: v.optional(v.array(whereValidator(schema, tableName))),
+                    });
+                })),
+                paginationOpts: paginationOptsValidator,
+                onUpdateHandle: v.optional(v.string()),
+            },
+            handler: async (ctx, args) => {
+                const { page, ...result } = await paginate(ctx, schema, betterAuthSchema, {
+                    ...args.input,
+                    paginationOpts: args.paginationOpts,
+                });
+                if (args.input.update) {
+                    if (hasUniqueFields(betterAuthSchema, 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, schema, betterAuthSchema, args.input.model, args.input.update ?? {}, doc);
+                        await ctx.db.patch(doc._id, args.input.update);
+                        if (args.onUpdateHandle) {
+                            await ctx.runMutation(args.onUpdateHandle, {
+                                model: args.input.model,
+                                oldDoc: doc,
+                                newDoc: await ctx.db.get(doc._id),
+                            });
+                        }
+                    });
+                }
+                return {
+                    ...result,
+                    count: page.length,
+                    ids: page.map((doc) => doc._id),
+                };
+            },
+        }),
+        deleteOne: mutationGeneric({
+            args: {
+                input: v.union(...Object.keys(schema.tables).map((tableName) => {
+                    return v.object({
+                        model: v.literal(tableName),
+                        where: v.optional(v.array(whereValidator(schema, tableName))),
+                    });
+                })),
+                onDeleteHandle: v.optional(v.string()),
+            },
+            handler: async (ctx, args) => {
+                const doc = await listOne(ctx, schema, betterAuthSchema, args.input);
+                if (!doc) {
+                    return;
+                }
+                await ctx.db.delete(doc._id);
+                if (args.onDeleteHandle) {
+                    await ctx.runMutation(args.onDeleteHandle, { model: args.input.model, doc });
+                }
+                return doc;
+            },
+        }),
+        deleteMany: mutationGeneric({
+            args: {
+                input: v.union(...Object.keys(schema.tables).map((tableName) => {
+                    return v.object({
+                        model: v.literal(tableName),
+                        where: v.optional(v.array(whereValidator(schema, tableName))),
+                    });
+                })),
+                paginationOpts: paginationOptsValidator,
+                onDeleteHandle: v.optional(v.string()),
+            },
+            handler: async (ctx, args) => {
+                const { page, ...result } = await paginate(ctx, schema, betterAuthSchema, {
+                    ...args.input,
+                    paginationOpts: args.paginationOpts,
+                });
+                await asyncMap(page, async (doc) => {
+                    if (args.onDeleteHandle) {
+                        await ctx.runMutation(args.onDeleteHandle, {
+                            model: args.input.model,
+                            doc,
+                        });
+                    }
+                    await ctx.db.delete(doc._id);
+                });
+                return {
+                    ...result,
+                    count: page.length,
+                    ids: page.map((doc) => doc._id),
+                };
+            },
+        }),
+    };
+};
+export const createClient = (component, config) => {
+    const safeGetAuthUser = async (ctx) => {
         const identity = await ctx.auth.getUserIdentity();
         if (!identity) {
-            return null;
+            return;
         }
-        const doc = await ctx.runQuery(this.component.lib.findOne, {
+        const doc = (await ctx.runQuery(component.adapter.findOne, {
             model: "user",
             where: [
                 {
-                    field: "userId",
+                    field: "id",
                     value: identity.subject,
                 },
             ],
-        });
+        }));
         if (!doc) {
-            return null;
-        }
-        // Type narrowing
-        if (!("emailVerified" in doc)) {
-            throw new Error("invalid user");
-        }
-        return omit(doc, ["_id", "_creationTime"]);
-    }
-    async getIdTokenCookieName(createAuth) {
-        const auth = createAuth({});
-        const createCookie = createCookieGetter(auth.options);
-        const cookie = createCookie(JWT_COOKIE_NAME);
-        return cookie.name;
-    }
-    async updateUserMetadata(ctx, userId, metadata) {
-        return ctx.runMutation(this.component.lib.updateOne, {
-            input: {
-                model: "user",
-                where: [{ field: "userId", value: userId }],
-                update: metadata,
-            },
-        });
-    }
-    async getUserByUsername(ctx, username) {
-        const user = await ctx.runQuery(this.component.lib.findOne, {
-            model: "user",
-            where: [{ field: "username", value: username }],
-        });
-        if (!user) {
-            return null;
+            return;
         }
-        return omit(user, ["_id", "_creationTime"]);
-    }
-    createAuthFunctions(opts) {
-        return {
-            isAuthenticated: queryGeneric({
-                args: v.object({}),
-                handler: async (ctx) => {
-                    const identity = await ctx.auth.getUserIdentity();
-                    return identity !== null;
+        return doc;
+    };
+    return {
+        component,
+        adapter: (ctx) => convexAdapter(ctx, component, config),
+        getHeaders: async (ctx) => {
+            const identity = await ctx.auth.getUserIdentity();
+            if (!identity) {
+                return;
+            }
+            const session = await ctx.runQuery(component.adapter.findOne, {
+                model: "session",
+                where: [
+                    {
+                        field: "userId",
+                        value: identity.subject,
+                    },
+                ],
+            });
+            return new Headers({
+                ...(session?.token ? { authorization: `Bearer ${session.token}` } : {}),
+                ...(session?.ipAddress
+                    ? { "x-forwarded-for": session.ipAddress }
+                    : {}),
+            });
+        },
+        safeGetAuthUser,
+        getAuthUser: async (ctx) => {
+            const user = await safeGetAuthUser(ctx);
+            if (!user) {
+                throw new Error("Unauthenticated");
+            }
+            return user;
+        },
+        // Replaces 0.7 behavior of returning a new user id from
+        // onCreateUser
+        setUserId: async (ctx, authId, userId) => {
+            await ctx.runMutation(component.adapter.updateOne, {
+                input: {
+                    model: "user",
+                    where: [{ field: "id", value: authId }],
+                    update: { userId },
                 },
-            }),
-            createUser: internalMutationGeneric({
-                args: createPermissiveArgsValidator,
-                handler: async (ctx, args) => {
-                    const userId = await opts.onCreateUser(ctx, args.input.data);
-                    const parsedArgs = parse(createUserArgsValidator, args);
-                    return ctx.runMutation(this.component.lib.create, {
-                        input: {
-                            ...parsedArgs.input,
-                            data: { ...parsedArgs.input.data, userId },
-                        },
-                    });
+            });
+        },
+        triggersApi: () => ({
+            onCreate: internalMutationGeneric({
+                args: {
+                    doc: v.any(),
+                    model: v.string(),
                 },
-            }),
-            deleteUser: internalMutationGeneric({
-                args: adapterArgsValidator,
                 handler: async (ctx, args) => {
-                    const doc = await ctx.runMutation(this.component.lib.deleteOne, args);
-                    if (doc && opts.onDeleteUser) {
-                        await opts.onDeleteUser(ctx, doc.userId);
-                    }
-                    return doc;
+                    await config?.triggers?.[args.model]?.onCreate?.(ctx, args.doc);
                 },
             }),
-            updateUser: internalMutationGeneric({
-                args: updateUserArgsValidator,
+            onUpdate: internalMutationGeneric({
+                args: {
+                    oldDoc: v.any(),
+                    newDoc: v.any(),
+                    model: v.string(),
+                },
                 handler: async (ctx, args) => {
-                    const updatedUser = await ctx.runMutation(this.component.lib.updateOne, { input: args.input });
-                    // Type narrowing
-                    if (!("emailVerified" in updatedUser)) {
-                        throw new Error("invalid user");
-                    }
-                    if (opts.onUpdateUser) {
-                        await opts.onUpdateUser(ctx, omit(updatedUser, ["_id"]));
-                    }
-                    return updatedUser;
+                    await config?.triggers?.[args.model]?.onUpdate?.(ctx, args.oldDoc, args.newDoc);
                 },
             }),
-            createSession: internalMutationGeneric({
-                args: createSessionArgsValidator,
+            onDelete: internalMutationGeneric({
+                args: {
+                    doc: v.any(),
+                    model: v.string(),
+                },
                 handler: async (ctx, args) => {
-                    const session = await ctx.runMutation(this.component.lib.create, {
-                        input: args.input,
-                    });
-                    await opts.onCreateSession?.(ctx, session);
-                    return session;
+                    await config?.triggers?.[args.model]?.onDelete?.(ctx, args.doc);
                 },
             }),
-        };
-    }
-    registerRoutes(http, createAuth, opts = {}) {
-        const betterAuthOptions = createAuth({}).options;
-        const path = betterAuthOptions.basePath ?? "/api/auth";
-        const authRequestHandler = httpActionGeneric(async (ctx, request) => {
-            if (this.config.verbose) {
-                console.log("options.baseURL", betterAuthOptions.baseURL);
-                console.log("request headers", request.headers);
+        }),
+        registerRoutes: (http, createAuth, opts = {}) => {
+            const authDummy = createAuth({});
+            const path = authDummy.options.basePath ?? "/api/auth";
+            const authRequestHandler = httpActionGeneric(async (ctx, request) => {
+                if (config?.verbose) {
+                    console.log("options.baseURL", authDummy.options.baseURL);
+                    console.log("request headers", request.headers);
+                }
+                const auth = createAuth(ctx);
+                const response = await auth.handler(request);
+                if (config?.verbose) {
+                    console.log("response headers", response.headers);
+                }
+                return response;
+            });
+            const wellKnown = http.lookup("/.well-known/openid-configuration", "GET");
+            // If registerRoutes is used multiple times, this may already be defined
+            if (!wellKnown) {
+                // Redirect root well-known to api well-known
+                http.route({
+                    path: "/.well-known/openid-configuration",
+                    method: "GET",
+                    handler: httpActionGeneric(async () => {
+                        const url = `${requireEnv("CONVEX_SITE_URL")}${path}/convex/.well-known/openid-configuration`;
+                        return Response.redirect(url);
+                    }),
+                });
             }
-            const auth = createAuth(ctx);
-            const response = await auth.handler(request);
-            if (this.config?.verbose) {
-                console.log("response headers", response.headers);
+            if (!opts.cors) {
+                http.route({
+                    pathPrefix: `${path}/`,
+                    method: "GET",
+                    handler: authRequestHandler,
+                });
+                http.route({
+                    pathPrefix: `${path}/`,
+                    method: "POST",
+                    handler: authRequestHandler,
+                });
+                return;
             }
-            return response;
-        });
-        const wellKnown = http.lookup("/.well-known/openid-configuration", "GET");
-        // If registerRoutes is used multiple times, this may already be defined
-        if (!wellKnown) {
-            // Redirect root well-known to api well-known
-            http.route({
-                path: "/.well-known/openid-configuration",
-                method: "GET",
-                handler: httpActionGeneric(async () => {
-                    const url = `${requireEnv("CONVEX_SITE_URL")}${path}/convex/.well-known/openid-configuration`;
-                    return Response.redirect(url);
-                }),
+            const corsOpts = typeof opts.cors === "boolean"
+                ? { allowedOrigins: [], allowedHeaders: [], exposedHeaders: [] }
+                : opts.cors;
+            let trustedOriginsOption;
+            const cors = corsRouter(http, {
+                allowedOrigins: async (request) => {
+                    trustedOriginsOption =
+                        trustedOriginsOption ??
+                            (await authDummy.$context).options.trustedOrigins ??
+                            [];
+                    const trustedOrigins = Array.isArray(trustedOriginsOption)
+                        ? trustedOriginsOption
+                        : await trustedOriginsOption(request);
+                    return trustedOrigins
+                        .map((origin) => 
+                    // Strip trailing wildcards, unsupported for allowedOrigins
+                    origin.endsWith("*") && origin.length > 1
+                        ? origin.slice(0, -1)
+                        : origin)
+                        .concat(corsOpts.allowedOrigins ?? []);
+                },
+                allowCredentials: true,
+                allowedHeaders: ["Content-Type", "Better-Auth-Cookie"].concat(corsOpts.allowedHeaders ?? []),
+                exposedHeaders: ["Set-Better-Auth-Cookie"].concat(corsOpts.exposedHeaders ?? []),
+                debug: config?.verbose,
+                enforceAllowOrigins: false,
             });
-        }
-        if (!opts.cors) {
-            http.route({
+            cors.route({
                 pathPrefix: `${path}/`,
                 method: "GET",
                 handler: authRequestHandler,
             });
-            http.route({
+            cors.route({
                 pathPrefix: `${path}/`,
                 method: "POST",
                 handler: authRequestHandler,
             });
-            return;
-        }
-        const corsOpts = typeof opts.cors === "boolean"
-            ? { allowedOrigins: [], allowedHeaders: [], exposedHeaders: [] }
-            : opts.cors;
-        const cors = corsRouter(http, {
-            allowedOrigins: async (request) => {
-                const trustedOriginsOption = (await createAuth({}).$context).options.trustedOrigins ?? [];
-                const trustedOrigins = Array.isArray(trustedOriginsOption)
-                    ? trustedOriginsOption
-                    : await trustedOriginsOption(request);
-                return trustedOrigins
-                    .map((origin) => 
-                // Strip trailing wildcards, unsupported for allowedOrigins
-                origin.endsWith("*") && origin.length > 1
-                    ? origin.slice(0, -1)
-                    : origin)
-                    .concat(corsOpts.allowedOrigins ?? []);
-            },
-            allowCredentials: true,
-            allowedHeaders: ["Content-Type", "Better-Auth-Cookie"].concat(corsOpts.allowedHeaders ?? []),
-            exposedHeaders: ["Set-Better-Auth-Cookie"].concat(corsOpts.exposedHeaders ?? []),
-            debug: this.config?.verbose,
-            enforceAllowOrigins: false,
-        });
-        cors.route({
-            pathPrefix: `${path}/`,
-            method: "GET",
-            handler: authRequestHandler,
-        });
-        cors.route({
-            pathPrefix: `${path}/`,
-            method: "POST",
-            handler: authRequestHandler,
-        });
-    }
-}
+        },
+    };
+};
 //# sourceMappingURL=index.js.map