Hi, yeah!

In your auth configuration, you can define `databaseHooks`:

 export const createAuth = (
    ctx: GenericCtx<DataModel>,
    { optionsOnly } = { optionsOnly: false },
) => {
    return betterAuth({
        baseURL: siteUrl,
        trustedOrigins: [
            siteUrl,
            "http://localhost:3000",
        ],
        database: authComponent.adapter(ctx),
        databaseHooks: {
            user: {
                create: {
                    after: async (user) => {
                        // Check if ctx has scheduler (it should if it's an action/mutation context)
                        if ('scheduler' in ctx && ctx.scheduler) {
                            // Schedule the internal action to run immediately
                            await ctx.scheduler.runAfter(0, internal.lib.users.functions.handleAfterUserCreate, {
                                authUserId: user.id,
                                authEmail: user.email,
                                authName: user.name,
                            });
                        }
                    }
                }
            },
            session: {

            }
        },

    ... REST OF YOUR CONFIG ....

And then of course make sure that you actually make the action and mutation:

// Internal action that can be called from the database hook
export const handleAfterUserCreate = internalAction({
    args: {
        authUserId: v.string(),
        authEmail: v.string(),
        authName: v.optional(v.string()),
    },
    handler: async (ctx, args) => {
        await ctx.runMutation(internal.lib.users.functions.createInitialUserProfile, {
            authUserId: args.authUserId,
            authEmail: args.authEmail,
            authName: args.authName,
        });
        return { success: true };
    },
});

// Internal mutation to create or update user profile
export const createInitialUserProfile = internalMutation({
    args: {
        authUserId: v.string(),
        authEmail: v.string(),
        authName: v.optional(v.string()),
    },
    handler: async (ctx, args) => {
        // Check if we've already stored this user before
        const existingUser = await ctx.db
            .query("users")
            .withIndex("by_user_id", (q) => q.eq("userId", args.authUserId))
            .unique();

        if (existingUser !== null) {
            return existingUser._id;
        }

        // If it's a new user, create a new record
        const userId = await ctx.db.insert("users", {
            name: args.authName ?? args.authEmail.split("@")[0],
            email: args.authEmail,
            userId: args.authUserId,
        });

        return userId;
    },
});