better-convex 0.5.8 → 0.6.0

package/dist/auth/index.js

@@ -1,13 +1,12 @@
-import { isRunMutationCtx } from "@convex-dev/better-auth/utils";
+import { a as partial, h as asyncMap, l as isQueryCtx, n as customCtx, r as customMutation, u as isRunMutationCtx } from "../customFunctions-C1okqCzL.js";
+import { C as stream, D as unsetToken, L as eq, S as mergedStream } from "../orm-Banm-XXb.js";
+import { convex } from "@convex-dev/better-auth/plugins";
 import { createAdapterFactory } from "better-auth/adapters";
 import { getAuthTables } from "better-auth/db";
-import { createFunctionHandle, internalActionGeneric, internalMutationGeneric, internalQueryGeneric, paginationOptsValidator } from "convex/server";
-import { asyncMap } from "convex-helpers";
-import { prop, sortBy, unique } from "remeda";
+import { ROUTABLE_HTTP_METHODS, createFunctionHandle, httpActionGeneric, httpRouter, internalActionGeneric, internalMutationGeneric, internalQueryGeneric, paginationOptsValidator } from "convex/server";
+import { prop, sortBy, uniqueBy } from "remeda";
 import { v } from "convex/values";
-import { partial } from "convex-helpers/validators";
 import { stripIndent } from "common-tags";
-import { mergedStream, stream } from "convex-helpers/server/stream";
 
 //#region src/auth/adapter-utils.ts
 const adapterWhereValidator = v.object({
@@ -209,9 +208,13 @@ const paginate = async (ctx, schema, betterAuthSchema, args) => {
 			page: []
 		};
 	}
+	const paginationLimit = args.paginationOpts.numItems ?? args.limit ?? 200;
+	const paginationMaxScan = Math.max(args.paginationOpts.maximumRowsRead ?? 0, paginationLimit + 1, 200);
 	const paginationOpts = {
-		...args.paginationOpts,
-		maximumRowsRead: Math.max((args.paginationOpts.numItems ?? 0) + 1, 200)
+		cursor: args.paginationOpts.cursor,
+		endCursor: args.paginationOpts.endCursor,
+		limit: paginationLimit,
+		maxScan: paginationMaxScan
 	};
 	const inWhere = args.where?.find((w) => w.operator === "in");
 	if (inWhere) {
@@ -281,134 +284,224 @@ const whereValidator = (schema, tableName) => v.object({
 	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("not_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())
 });
+const resolveSchemaTableName = (schema, betterAuthSchema, model) => {
+	if (schema.tables[model]) return model;
+	const modelConfig = betterAuthSchema?.[model];
+	if (modelConfig?.modelName && schema.tables[modelConfig.modelName]) return modelConfig.modelName;
+	for (const [key, value] of Object.entries(betterAuthSchema ?? {})) {
+		if (value?.modelName !== model) continue;
+		if (schema.tables[key]) return key;
+		if (schema.tables[value.modelName]) return value.modelName;
+	}
+};
+const resolveOrmTable = (ctx, schema, betterAuthSchema, model) => {
+	if (!ctx?.orm || typeof ctx.orm.insert !== "function" || typeof ctx.orm.update !== "function" || typeof ctx.orm.delete !== "function") return;
+	const tableName = resolveSchemaTableName(schema, betterAuthSchema, model);
+	if (!tableName) return;
+	const table = schema.tables[tableName];
+	if (!table || !table._id) return;
+	return {
+		table,
+		tableName
+	};
+};
+const normalizeUpdateForOrm = (update) => Object.fromEntries(Object.entries(update).map(([key, value]) => [key, value === void 0 ? unsetToken : value]));
+const ormInsert = async (ctx, table, data) => (await ctx.orm.insert(table).values(data).returning())[0];
+const ormUpdate = async (ctx, table, id, update) => (await ctx.orm.update(table).set(normalizeUpdateForOrm(update)).returning().where(eq(table._id, id)))[0];
+const ormDelete = async (ctx, table, id) => {
+	await ctx.orm.delete(table).where(eq(table._id, id));
+};
+const withBothIdFields = (doc) => {
+	const existingUnderscoreId = doc._id;
+	const existingId = doc.id;
+	const id = existingUnderscoreId ?? existingId;
+	if (!id) return doc;
+	return {
+		...doc,
+		_id: existingUnderscoreId ?? id,
+		id: existingId ?? id
+	};
+};
+const isPlainObject = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+const serializeDatesForConvex = (value) => {
+	if (value instanceof Date) return value.getTime();
+	if (Array.isArray(value)) {
+		let result;
+		for (let index = 0; index < value.length; index += 1) {
+			const entry = value[index];
+			const serialized = serializeDatesForConvex(entry);
+			if (serialized !== entry) {
+				if (!result) result = value.slice();
+				result[index] = serialized;
+			}
+		}
+		return result ?? value;
+	}
+	if (!isPlainObject(value)) return value;
+	let serialized;
+	for (const key in value) {
+		if (!Object.hasOwn(value, key)) continue;
+		const nested = value[key];
+		const encoded = serializeDatesForConvex(nested);
+		if (encoded !== nested) {
+			if (!serialized) serialized = { ...value };
+			serialized[key] = encoded;
+		}
+	}
+	return serialized ?? value;
+};
+const toConvexSafe = (value) => serializeDatesForConvex(value);
 const createHandler = async (ctx, args, schema, betterAuthSchema) => {
 	let data = args.input.data;
 	if (!args.skipBeforeHooks && args.beforeCreateHandle) {
-		const transformedData = await ctx.runMutation(args.beforeCreateHandle, {
+		const transformedData = await ctx.runMutation(args.beforeCreateHandle, serializeDatesForConvex({
 			data,
 			model: args.input.model
-		});
+		}));
 		if (transformedData !== void 0) data = transformedData;
 	}
 	await checkUniqueFields(ctx, schema, betterAuthSchema, args.input.model, data);
-	const id = await ctx.db.insert(args.input.model, data);
-	const doc = await ctx.db.get(id);
+	const ormTable = resolveOrmTable(ctx, schema, betterAuthSchema, args.input.model);
+	const doc = ormTable ? await ormInsert(ctx, ormTable.table, data) : await (async () => {
+		const id = await ctx.db.insert(args.input.model, data);
+		return 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, {
-		doc,
-		model: args.input.model
-	});
-	return result;
+	const normalizedDoc = ormTable ? withBothIdFields(doc) : doc;
+	const result = await selectFields(normalizedDoc, args.select);
+	if (args.onCreateHandle) {
+		const hookDoc = normalizedDoc;
+		await ctx.runMutation(args.onCreateHandle, serializeDatesForConvex({
+			doc: hookDoc,
+			model: args.input.model
+		}));
+	}
+	return toConvexSafe(result);
 };
-const findOneHandler = async (ctx, args, schema, betterAuthSchema) => await listOne(ctx, schema, betterAuthSchema, args);
-const findManyHandler = async (ctx, args, schema, betterAuthSchema) => await paginate(ctx, schema, betterAuthSchema, args);
+const findOneHandler = async (ctx, args, schema, betterAuthSchema) => toConvexSafe(await listOne(ctx, schema, betterAuthSchema, args));
+const findManyHandler = async (ctx, args, schema, betterAuthSchema) => toConvexSafe(await paginate(ctx, schema, betterAuthSchema, args));
 const updateOneHandler = async (ctx, args, schema, betterAuthSchema) => {
 	const doc = await listOne(ctx, schema, betterAuthSchema, args.input);
 	if (!doc) throw new Error(`Failed to update ${args.input.model}`);
 	let update = args.input.update;
 	if (args.beforeUpdateHandle) {
-		const transformedUpdate = await ctx.runMutation(args.beforeUpdateHandle, {
+		const transformedUpdate = await ctx.runMutation(args.beforeUpdateHandle, serializeDatesForConvex({
 			doc,
 			model: args.input.model,
 			update
-		});
+		}));
 		if (transformedUpdate !== void 0) update = transformedUpdate;
 	}
 	await checkUniqueFields(ctx, schema, betterAuthSchema, args.input.model, update, doc);
-	await ctx.db.patch(doc._id, update);
-	const updatedDoc = await ctx.db.get(doc._id);
+	const ormTable = resolveOrmTable(ctx, schema, betterAuthSchema, args.input.model);
+	const updatedDoc = ormTable ? await ormUpdate(ctx, ormTable.table, doc._id, update) : await (async () => {
+		await ctx.db.patch(doc._id, update);
+		return ctx.db.get(doc._id);
+	})();
 	if (!updatedDoc) throw new Error(`Failed to update ${args.input.model}`);
-	if (args.onUpdateHandle) await ctx.runMutation(args.onUpdateHandle, {
-		model: args.input.model,
-		newDoc: updatedDoc,
-		oldDoc: doc
-	});
-	return updatedDoc;
+	const normalizedUpdatedDoc = ormTable ? withBothIdFields(updatedDoc) : updatedDoc;
+	if (args.onUpdateHandle) {
+		const hookNewDoc = normalizedUpdatedDoc;
+		await ctx.runMutation(args.onUpdateHandle, serializeDatesForConvex({
+			model: args.input.model,
+			newDoc: hookNewDoc,
+			oldDoc: doc
+		}));
+	}
+	return toConvexSafe(normalizedUpdatedDoc);
 };
 const updateManyHandler = async (ctx, args, schema, betterAuthSchema) => {
 	const { page, ...result } = await paginate(ctx, schema, betterAuthSchema, {
 		...args.input,
 		paginationOpts: args.paginationOpts
 	});
+	const ormTable = resolveOrmTable(ctx, schema, betterAuthSchema, args.input.model);
 	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) => {
 			let update = args.input.update;
 			if (args.beforeUpdateHandle) {
-				const transformedUpdate = await ctx.runMutation(args.beforeUpdateHandle, {
+				const transformedUpdate = await ctx.runMutation(args.beforeUpdateHandle, serializeDatesForConvex({
 					doc,
 					model: args.input.model,
 					update
-				});
+				}));
 				if (transformedUpdate !== void 0) update = transformedUpdate;
 			}
 			await checkUniqueFields(ctx, schema, betterAuthSchema, args.input.model, update ?? {}, doc);
-			await ctx.db.patch(doc._id, update);
+			const newDoc = ormTable ? await ormUpdate(ctx, ormTable.table, doc._id, update ?? {}) : await (async () => {
+				await ctx.db.patch(doc._id, update);
+				return ctx.db.get(doc._id);
+			})();
 			if (args.onUpdateHandle) {
-				const newDoc = await ctx.db.get(doc._id);
-				await ctx.runMutation(args.onUpdateHandle, {
+				const hookNewDoc = ormTable ? withBothIdFields(newDoc) : newDoc;
+				await ctx.runMutation(args.onUpdateHandle, serializeDatesForConvex({
 					model: args.input.model,
-					newDoc,
+					newDoc: hookNewDoc,
 					oldDoc: doc
-				});
+				}));
 			}
 		});
 	}
-	return {
+	return toConvexSafe({
 		...result,
 		count: page.length,
 		ids: page.map((doc) => doc._id)
-	};
+	});
 };
 const deleteOneHandler = async (ctx, args, schema, betterAuthSchema) => {
 	const doc = await listOne(ctx, schema, betterAuthSchema, args.input);
 	if (!doc) return;
 	let hookDoc = doc;
 	if (!args.skipBeforeHooks && args.beforeDeleteHandle) {
-		const transformedDoc = await ctx.runMutation(args.beforeDeleteHandle, {
+		const transformedDoc = await ctx.runMutation(args.beforeDeleteHandle, serializeDatesForConvex({
 			doc,
 			model: args.input.model
-		});
+		}));
 		if (transformedDoc !== void 0) hookDoc = transformedDoc;
 	}
-	await ctx.db.delete(doc._id);
-	if (args.onDeleteHandle) await ctx.runMutation(args.onDeleteHandle, {
+	const ormTable = resolveOrmTable(ctx, schema, betterAuthSchema, args.input.model);
+	if (ormTable) await ormDelete(ctx, ormTable.table, doc._id);
+	else await ctx.db.delete(doc._id);
+	if (args.onDeleteHandle) await ctx.runMutation(args.onDeleteHandle, serializeDatesForConvex({
 		doc: hookDoc,
 		model: args.input.model
-	});
-	return hookDoc;
+	}));
+	return toConvexSafe(hookDoc);
 };
 const deleteManyHandler = async (ctx, args, schema, betterAuthSchema) => {
 	const { page, ...result } = await paginate(ctx, schema, betterAuthSchema, {
 		...args.input,
 		paginationOpts: args.paginationOpts
 	});
+	const ormTable = resolveOrmTable(ctx, schema, betterAuthSchema, args.input.model);
 	await asyncMap(page, async (doc) => {
 		let hookDoc = doc;
 		if (!args.skipBeforeHooks && args.beforeDeleteHandle) {
-			const transformedDoc = await ctx.runMutation(args.beforeDeleteHandle, {
+			const transformedDoc = await ctx.runMutation(args.beforeDeleteHandle, serializeDatesForConvex({
 				doc,
 				model: args.input.model
-			});
+			}));
 			if (transformedDoc !== void 0) hookDoc = transformedDoc;
 		}
-		await ctx.db.delete(doc._id);
-		if (args.onDeleteHandle) await ctx.runMutation(args.onDeleteHandle, {
+		if (ormTable) await ormDelete(ctx, ormTable.table, doc._id);
+		else await ctx.db.delete(doc._id);
+		if (args.onDeleteHandle) await ctx.runMutation(args.onDeleteHandle, serializeDatesForConvex({
 			doc: hookDoc,
 			model: args.input.model
-		});
+		}));
 	});
-	return {
+	return toConvexSafe({
 		...result,
 		count: page.length,
 		ids: page.map((doc) => doc._id)
-	};
+	});
 };
-const createApi = (schema, createAuth, options) => {
-	const betterAuthSchema = getAuthTables(createAuth({}).options);
-	const { internalMutation, skipValidation } = options ?? {};
-	const mutationBuilder = internalMutation ?? internalMutationGeneric;
+const createApi = (schema, getAuth, options) => {
+	const betterAuthSchema = getAuthTables(getAuth({}).options);
+	const { internalMutation, skipValidation, context } = options ?? {};
+	const mutationBuilderBase = internalMutation ?? internalMutationGeneric;
+	const mutationBuilder = context ? customMutation(mutationBuilderBase, customCtx(async (ctx) => await context?.(ctx) ?? ctx)) : mutationBuilderBase;
 	const anyInput = v.object({
 		data: v.any(),
 		model: v.string()
@@ -516,13 +609,13 @@ const createApi = (schema, createAuth, options) => {
 		getLatestJwks: internalActionGeneric({
 			args: {},
 			handler: async (ctx) => {
-				return createAuth(ctx).api.getLatestJwks();
+				return getAuth(ctx).api.getLatestJwks();
 			}
 		}),
 		rotateKeys: internalActionGeneric({
 			args: {},
 			handler: async (ctx) => {
-				return createAuth(ctx).api.rotateKeys();
+				return getAuth(ctx).api.rotateKeys();
 			}
 		})
 	};
@@ -569,6 +662,10 @@ const parseWhere = (where) => {
 		return w;
 	});
 };
+const uniqueDocs = (docs) => uniqueBy(docs, (doc) => {
+	if (doc && typeof doc === "object") return doc._id ?? doc.id ?? doc;
+	return doc;
+});
 const adapterConfig = {
 	adapterId: "convex",
 	adapterName: "Convex Adapter",
@@ -591,19 +688,36 @@ const adapterConfig = {
 		return data;
 	}
 };
-const httpAdapter = (ctx, { authFunctions, debugLogs, triggers }) => {
+const ORM_SCHEMA_OPTIONS = Symbol.for("better-convex:OrmSchemaOptions");
+const hasOrmSchemaMetadata = (schema) => !!schema && typeof schema === "object" && ORM_SCHEMA_OPTIONS in schema;
+const createAuthSchema = async ({ file, schema, tables }) => {
+	if (hasOrmSchemaMetadata(schema)) {
+		const { createSchemaOrm } = await import("../create-schema-orm-DplxTtYj.js");
+		return createSchemaOrm({
+			file,
+			tables
+		});
+	}
+	const { createSchema } = await import("../create-schema-DhWXOhnU.js");
+	return createSchema({
+		file,
+		tables
+	});
+};
+const httpAdapter = (ctx, { authFunctions, debugLogs, schema, triggers }) => {
 	return createAdapterFactory({
 		config: {
 			...adapterConfig,
 			debugLogs: debugLogs || false
 		},
 		adapter: ({ options }) => {
+			const getTriggers = (model) => triggers?.[model];
 			options.telemetry = { enabled: false };
 			return {
 				id: "convex",
 				options: { isRunMutationCtx: isRunMutationCtx(ctx) },
 				count: async (data) => {
-					if (data.where?.some((w) => w.connector === "OR")) return unique((await asyncMap(data.where, async (w) => handlePagination(async ({ paginationOpts }) => await ctx.runQuery(authFunctions.findMany, {
+					if (data.where?.some((w) => w.connector === "OR")) return uniqueDocs((await asyncMap(data.where, async (w) => handlePagination(async ({ paginationOpts }) => await ctx.runQuery(authFunctions.findMany, {
 						...data,
 						paginationOpts,
 						where: parseWhere(w)
@@ -616,8 +730,8 @@ const httpAdapter = (ctx, { authFunctions, debugLogs, triggers }) => {
 				},
 				create: async ({ data, model, select }) => {
 					if (!("runMutation" in ctx)) throw new Error("ctx is not a mutation ctx");
-					const onCreateHandle = authFunctions.onCreate && triggers?.[model]?.onCreate ? await createFunctionHandle(authFunctions.onCreate) : void 0;
-					const beforeCreateHandle = authFunctions.beforeCreate && triggers?.[model]?.beforeCreate ? await createFunctionHandle(authFunctions.beforeCreate) : void 0;
+					const onCreateHandle = authFunctions.onCreate && getTriggers(model)?.onCreate ? await createFunctionHandle(authFunctions.onCreate) : void 0;
+					const beforeCreateHandle = authFunctions.beforeCreate && getTriggers(model)?.beforeCreate ? await createFunctionHandle(authFunctions.beforeCreate) : void 0;
 					return await ctx.runMutation(authFunctions.create, {
 						beforeCreateHandle,
 						input: {
@@ -628,17 +742,15 @@ const httpAdapter = (ctx, { authFunctions, debugLogs, triggers }) => {
 						onCreateHandle
 					});
 				},
-				createSchema: async ({ file, tables }) => {
-					const { createSchema } = await import("../create-schema-B4CUvqik.js");
-					return createSchema({
-						file,
-						tables
-					});
-				},
+				createSchema: async ({ file, tables }) => createAuthSchema({
+					file,
+					schema,
+					tables
+				}),
 				delete: async (data) => {
 					if (!("runMutation" in ctx)) throw new Error("ctx is not a mutation ctx");
-					const onDeleteHandle = authFunctions.onDelete && triggers?.[data.model]?.onDelete ? await createFunctionHandle(authFunctions.onDelete) : void 0;
-					const beforeDeleteHandle = authFunctions.beforeDelete && triggers?.[data.model]?.beforeDelete ? await createFunctionHandle(authFunctions.beforeDelete) : void 0;
+					const onDeleteHandle = authFunctions.onDelete && getTriggers(data.model)?.onDelete ? await createFunctionHandle(authFunctions.onDelete) : void 0;
+					const beforeDeleteHandle = authFunctions.beforeDelete && getTriggers(data.model)?.beforeDelete ? await createFunctionHandle(authFunctions.beforeDelete) : void 0;
 					await ctx.runMutation(authFunctions.deleteOne, {
 						beforeDeleteHandle,
 						input: {
@@ -650,8 +762,8 @@ const httpAdapter = (ctx, { authFunctions, debugLogs, triggers }) => {
 				},
 				deleteMany: async (data) => {
 					if (!("runMutation" in ctx)) throw new Error("ctx is not a mutation ctx");
-					const onDeleteHandle = authFunctions.onDelete && triggers?.[data.model]?.onDelete ? await createFunctionHandle(authFunctions.onDelete) : void 0;
-					const beforeDeleteHandle = authFunctions.beforeDelete && triggers?.[data.model]?.beforeDelete ? await createFunctionHandle(authFunctions.beforeDelete) : void 0;
+					const onDeleteHandle = authFunctions.onDelete && getTriggers(data.model)?.onDelete ? await createFunctionHandle(authFunctions.onDelete) : void 0;
+					const beforeDeleteHandle = authFunctions.beforeDelete && getTriggers(data.model)?.beforeDelete ? await createFunctionHandle(authFunctions.beforeDelete) : void 0;
 					return (await handlePagination(async ({ paginationOpts }) => await ctx.runMutation(authFunctions.deleteMany, {
 						beforeDeleteHandle,
 						input: {
@@ -665,7 +777,7 @@ const httpAdapter = (ctx, { authFunctions, debugLogs, triggers }) => {
 				findMany: async (data) => {
 					if (data.offset) throw new Error("offset not supported");
 					if (data.where?.some((w) => w.connector === "OR")) {
-						const docs = unique((await asyncMap(data.where, async (w) => handlePagination(async ({ paginationOpts }) => await ctx.runQuery(authFunctions.findMany, {
+						const docs = uniqueDocs((await asyncMap(data.where, async (w) => handlePagination(async ({ paginationOpts }) => await ctx.runQuery(authFunctions.findMany, {
 							...data,
 							paginationOpts,
 							where: parseWhere(w)
@@ -703,8 +815,8 @@ const httpAdapter = (ctx, { authFunctions, debugLogs, triggers }) => {
 						}), { limit: 2 });
 						if (countResult.docs.length === 0) throw new Error(`No ${data.model} found matching criteria`);
 						if (countResult.docs.length > 1) throw new Error(`Multiple ${data.model} found matching criteria. Expected exactly 1.`);
-						const onUpdateHandle = authFunctions.onUpdate && triggers?.[data.model]?.onUpdate ? await createFunctionHandle(authFunctions.onUpdate) : void 0;
-						const beforeUpdateHandle = authFunctions.beforeUpdate && triggers?.[data.model]?.beforeUpdate ? await createFunctionHandle(authFunctions.beforeUpdate) : void 0;
+						const onUpdateHandle = authFunctions.onUpdate && getTriggers(data.model)?.onUpdate ? await createFunctionHandle(authFunctions.onUpdate) : void 0;
+						const beforeUpdateHandle = authFunctions.beforeUpdate && getTriggers(data.model)?.beforeUpdate ? await createFunctionHandle(authFunctions.beforeUpdate) : void 0;
 						return await ctx.runMutation(authFunctions.updateOne, {
 							beforeUpdateHandle,
 							input: {
@@ -719,8 +831,8 @@ const httpAdapter = (ctx, { authFunctions, debugLogs, triggers }) => {
 				},
 				updateMany: async (data) => {
 					if (!("runMutation" in ctx)) throw new Error("ctx is not a mutation ctx");
-					const onUpdateHandle = authFunctions.onUpdate && triggers?.[data.model]?.onUpdate ? await createFunctionHandle(authFunctions.onUpdate) : void 0;
-					const beforeUpdateHandle = authFunctions.beforeUpdate && triggers?.[data.model]?.beforeUpdate ? await createFunctionHandle(authFunctions.beforeUpdate) : void 0;
+					const onUpdateHandle = authFunctions.onUpdate && getTriggers(data.model)?.onUpdate ? await createFunctionHandle(authFunctions.onUpdate) : void 0;
+					const beforeUpdateHandle = authFunctions.beforeUpdate && getTriggers(data.model)?.beforeUpdate ? await createFunctionHandle(authFunctions.beforeUpdate) : void 0;
 					return (await handlePagination(async ({ paginationOpts }) => await ctx.runMutation(authFunctions.updateMany, {
 						beforeUpdateHandle,
 						input: {
@@ -735,20 +847,21 @@ const httpAdapter = (ctx, { authFunctions, debugLogs, triggers }) => {
 		}
 	});
 };
-const dbAdapter = (ctx, createAuthOptions, { authFunctions, debugLogs, schema, triggers }) => {
-	const betterAuthSchema = getAuthTables(createAuthOptions({}));
+const dbAdapter = (ctx, getAuthOptions, { authFunctions, debugLogs, schema, triggers }) => {
+	const betterAuthSchema = getAuthTables(getAuthOptions({}));
 	return createAdapterFactory({
 		config: {
 			...adapterConfig,
 			debugLogs: debugLogs || false
 		},
 		adapter: ({ options }) => {
+			const getTriggers = (model) => triggers?.[model];
 			options.telemetry = { enabled: false };
 			return {
 				id: "convex",
 				options: { isRunMutationCtx: isRunMutationCtx(ctx) },
 				count: async (data) => {
-					if (data.where?.some((w) => w.connector === "OR")) return unique((await asyncMap(data.where, async (w) => handlePagination(async ({ paginationOpts }) => await findManyHandler(ctx, {
+					if (data.where?.some((w) => w.connector === "OR")) return uniqueDocs((await asyncMap(data.where, async (w) => handlePagination(async ({ paginationOpts }) => await findManyHandler(ctx, {
 						...data,
 						paginationOpts,
 						where: parseWhere(w)
@@ -760,9 +873,9 @@ const dbAdapter = (ctx, createAuthOptions, { authFunctions, debugLogs, schema, t
 					}, schema, betterAuthSchema))).docs.length;
 				},
 				create: async ({ data, model, select }) => {
-					const onCreateHandle = authFunctions.onCreate && triggers?.[model]?.onCreate ? await createFunctionHandle(authFunctions.onCreate) : void 0;
+					const onCreateHandle = authFunctions.onCreate && getTriggers(model)?.onCreate ? await createFunctionHandle(authFunctions.onCreate) : void 0;
 					return await createHandler(ctx, {
-						beforeCreateHandle: authFunctions.beforeCreate && triggers?.[model]?.beforeCreate ? await createFunctionHandle(authFunctions.beforeCreate) : void 0,
+						beforeCreateHandle: authFunctions.beforeCreate && getTriggers(model)?.beforeCreate ? await createFunctionHandle(authFunctions.beforeCreate) : void 0,
 						input: {
 							data,
 							model
@@ -771,17 +884,15 @@ const dbAdapter = (ctx, createAuthOptions, { authFunctions, debugLogs, schema, t
 						onCreateHandle
 					}, schema, betterAuthSchema);
 				},
-				createSchema: async ({ file, tables }) => {
-					const { createSchema } = await import("../create-schema-B4CUvqik.js");
-					return createSchema({
-						file,
-						tables
-					});
-				},
+				createSchema: async ({ file, tables }) => createAuthSchema({
+					file,
+					schema,
+					tables
+				}),
 				delete: async (data) => {
-					const onDeleteHandle = authFunctions.onDelete && triggers?.[data.model]?.onDelete ? await createFunctionHandle(authFunctions.onDelete) : void 0;
+					const onDeleteHandle = authFunctions.onDelete && getTriggers(data.model)?.onDelete ? await createFunctionHandle(authFunctions.onDelete) : void 0;
 					await deleteOneHandler(ctx, {
-						beforeDeleteHandle: authFunctions.beforeDelete && triggers?.[data.model]?.beforeDelete ? await createFunctionHandle(authFunctions.beforeDelete) : void 0,
+						beforeDeleteHandle: authFunctions.beforeDelete && getTriggers(data.model)?.beforeDelete ? await createFunctionHandle(authFunctions.beforeDelete) : void 0,
 						input: {
 							model: data.model,
 							where: parseWhere(data.where)
@@ -790,8 +901,8 @@ const dbAdapter = (ctx, createAuthOptions, { authFunctions, debugLogs, schema, t
 					}, schema, betterAuthSchema);
 				},
 				deleteMany: async (data) => {
-					const onDeleteHandle = authFunctions.onDelete && triggers?.[data.model]?.onDelete ? await createFunctionHandle(authFunctions.onDelete) : void 0;
-					const beforeDeleteHandle = authFunctions.beforeDelete && triggers?.[data.model]?.beforeDelete ? await createFunctionHandle(authFunctions.beforeDelete) : void 0;
+					const onDeleteHandle = authFunctions.onDelete && getTriggers(data.model)?.onDelete ? await createFunctionHandle(authFunctions.onDelete) : void 0;
+					const beforeDeleteHandle = authFunctions.beforeDelete && getTriggers(data.model)?.beforeDelete ? await createFunctionHandle(authFunctions.beforeDelete) : void 0;
 					return (await handlePagination(async ({ paginationOpts }) => await deleteManyHandler(ctx, {
 						beforeDeleteHandle,
 						input: {
@@ -805,7 +916,7 @@ const dbAdapter = (ctx, createAuthOptions, { authFunctions, debugLogs, schema, t
 				findMany: async (data) => {
 					if (data.offset) throw new Error("offset not supported");
 					if (data.where?.some((w) => w.connector === "OR")) {
-						const docs = unique((await asyncMap(data.where, async (w) => handlePagination(async ({ paginationOpts }) => await findManyHandler(ctx, {
+						const docs = uniqueDocs((await asyncMap(data.where, async (w) => handlePagination(async ({ paginationOpts }) => await findManyHandler(ctx, {
 							...data,
 							paginationOpts,
 							where: parseWhere(w)
@@ -841,9 +952,9 @@ const dbAdapter = (ctx, createAuthOptions, { authFunctions, debugLogs, schema, t
 						}, schema, betterAuthSchema), { limit: 2 });
 						if (countResult.docs.length === 0) throw new Error(`No ${data.model} found matching criteria`);
 						if (countResult.docs.length > 1) throw new Error(`Multiple ${data.model} found matching criteria. Expected exactly 1.`);
-						const onUpdateHandle = authFunctions.onUpdate && triggers?.[data.model]?.onUpdate ? await createFunctionHandle(authFunctions.onUpdate) : void 0;
+						const onUpdateHandle = authFunctions.onUpdate && getTriggers(data.model)?.onUpdate ? await createFunctionHandle(authFunctions.onUpdate) : void 0;
 						return await updateOneHandler(ctx, {
-							beforeUpdateHandle: authFunctions.beforeUpdate && triggers?.[data.model]?.beforeUpdate ? await createFunctionHandle(authFunctions.beforeUpdate) : void 0,
+							beforeUpdateHandle: authFunctions.beforeUpdate && getTriggers(data.model)?.beforeUpdate ? await createFunctionHandle(authFunctions.beforeUpdate) : void 0,
 							input: {
 								model: data.model,
 								update: data.update,
@@ -855,8 +966,8 @@ const dbAdapter = (ctx, createAuthOptions, { authFunctions, debugLogs, schema, t
 					throw new Error("where clause not supported");
 				},
 				updateMany: async (data) => {
-					const onUpdateHandle = authFunctions.onUpdate && triggers?.[data.model]?.onUpdate ? await createFunctionHandle(authFunctions.onUpdate) : void 0;
-					const beforeUpdateHandle = authFunctions.beforeUpdate && triggers?.[data.model]?.beforeUpdate ? await createFunctionHandle(authFunctions.beforeUpdate) : void 0;
+					const onUpdateHandle = authFunctions.onUpdate && getTriggers(data.model)?.onUpdate ? await createFunctionHandle(authFunctions.onUpdate) : void 0;
+					const beforeUpdateHandle = authFunctions.beforeUpdate && getTriggers(data.model)?.beforeUpdate ? await createFunctionHandle(authFunctions.beforeUpdate) : void 0;
 					return (await handlePagination(async ({ paginationOpts }) => await updateManyHandler(ctx, {
 						beforeUpdateHandle,
 						input: {
@@ -877,24 +988,34 @@ const dbAdapter = (ctx, createAuthOptions, { authFunctions, debugLogs, schema, t
 const createClient = (config) => ({
 	authFunctions: config.authFunctions,
 	triggers: config.triggers,
-	adapter: (ctx, createAuthOptions) => dbAdapter(ctx, createAuthOptions, config),
-	httpAdapter: (ctx) => httpAdapter(ctx, config),
+	adapter: (ctx, getAuthOptions) => isQueryCtx(ctx) ? dbAdapter(ctx, getAuthOptions, config) : httpAdapter(ctx, config),
 	triggersApi: () => {
-		const mutationBuilder = config.internalMutation ?? internalMutationGeneric;
+		const mutationBuilderBase = config.internalMutation ?? internalMutationGeneric;
+		const hasMutationCtxTransforms = config.context !== void 0;
+		const transformMutationCtx = async (ctx) => await config.context?.(ctx) ?? ctx;
+		const mutationBuilder = hasMutationCtxTransforms ? customMutation(mutationBuilderBase, customCtx(async (ctx) => await transformMutationCtx(ctx))) : mutationBuilderBase;
+		const getTriggers = (model) => config.triggers?.[model];
+		const resolveTriggerCtx = async (ctx) => hasMutationCtxTransforms ? ctx : await transformMutationCtx(ctx);
 		return {
 			beforeCreate: mutationBuilder({
 				args: {
 					data: v.any(),
 					model: v.string()
 				},
-				handler: async (ctx, args) => await config?.triggers?.[args.model]?.beforeCreate?.(ctx, args.data) ?? args.data
+				handler: async (ctx, args) => {
+					const triggerCtx = await resolveTriggerCtx(ctx);
+					return await getTriggers(args.model)?.beforeCreate?.(triggerCtx, args.data) ?? args.data;
+				}
 			}),
 			beforeDelete: mutationBuilder({
 				args: {
 					doc: v.any(),
 					model: v.string()
 				},
-				handler: async (ctx, args) => await config?.triggers?.[args.model]?.beforeDelete?.(ctx, args.doc) ?? args.doc
+				handler: async (ctx, args) => {
+					const triggerCtx = await resolveTriggerCtx(ctx);
+					return await getTriggers(args.model)?.beforeDelete?.(triggerCtx, args.doc) ?? args.doc;
+				}
 			}),
 			beforeUpdate: mutationBuilder({
 				args: {
@@ -902,7 +1023,10 @@ const createClient = (config) => ({
 					model: v.string(),
 					update: v.any()
 				},
-				handler: async (ctx, args) => await config?.triggers?.[args.model]?.beforeUpdate?.(ctx, args.doc, args.update) ?? args.update
+				handler: async (ctx, args) => {
+					const triggerCtx = await resolveTriggerCtx(ctx);
+					return await getTriggers(args.model)?.beforeUpdate?.(triggerCtx, args.doc, args.update) ?? args.update;
+				}
 			}),
 			onCreate: mutationBuilder({
 				args: {
@@ -910,7 +1034,8 @@ const createClient = (config) => ({
 					model: v.string()
 				},
 				handler: async (ctx, args) => {
-					await config?.triggers?.[args.model]?.onCreate?.(ctx, args.doc);
+					const triggerCtx = await resolveTriggerCtx(ctx);
+					await getTriggers(args.model)?.onCreate?.(triggerCtx, args.doc);
 				}
 			}),
 			onDelete: mutationBuilder({
@@ -919,7 +1044,8 @@ const createClient = (config) => ({
 					model: v.string()
 				},
 				handler: async (ctx, args) => {
-					await config?.triggers?.[args.model]?.onDelete?.(ctx, args.doc);
+					const triggerCtx = await resolveTriggerCtx(ctx);
+					await getTriggers(args.model)?.onDelete?.(triggerCtx, args.doc);
 				}
 			}),
 			onUpdate: mutationBuilder({
@@ -929,7 +1055,8 @@ const createClient = (config) => ({
 					oldDoc: v.any()
 				},
 				handler: async (ctx, args) => {
-					await config?.triggers?.[args.model]?.onUpdate?.(ctx, args.newDoc, args.oldDoc);
+					const triggerCtx = await resolveTriggerCtx(ctx);
+					await getTriggers(args.model)?.onUpdate?.(triggerCtx, args.newDoc, args.oldDoc);
 				}
 			})
 		};
@@ -959,6 +1086,7 @@ const getSession = async (ctx, _sessionId) => {
 		if (!identity) return null;
 		sessionId = identity.sessionId;
 	}
+	if (!sessionId) return null;
 	return await ctx.db.get(sessionId);
 };
 const getHeaders = async (ctx, session) => {
@@ -984,18 +1112,18 @@ const getHeaders = async (ctx, session) => {
 *
 * const app = new Hono();
 * app.use('/api/*', cors({ origin: process.env.SITE_URL, credentials: true }));
-* app.use(authMiddleware(createAuth));
+* app.use(authMiddleware(getAuth));
 *
 * export default createHttpRouter(app, appRouter);
 * ```
 */
-function authMiddleware(createAuth, opts = {}) {
+function authMiddleware(getAuth, opts = {}) {
 	const basePath = opts.basePath ?? "/api/auth";
 	return async (c, next) => {
 		if (c.req.path === "/.well-known/openid-configuration") return c.redirect(`${process.env.CONVEX_SITE_URL}${basePath}/convex/.well-known/openid-configuration`);
 		if (c.req.path.startsWith(basePath)) {
 			if (opts.verbose) console.log("request headers", c.req.raw.headers);
-			const response = await createAuth(c.env).handler(c.req.raw);
+			const response = await getAuth(c.env).handler(c.req.raw);
 			if (opts.verbose) console.log("response headers", response.headers);
 			return response;
 		}
@@ -1004,4 +1132,326 @@ function authMiddleware(createAuth, opts = {}) {
 }
 
 //#endregion
-export { adapterArgsValidator, adapterConfig, adapterWhereValidator, authMiddleware, checkUniqueFields, createApi, createClient, createHandler, dbAdapter, deleteManyHandler, deleteOneHandler, findManyHandler, findOneHandler, getAuthUserId, getAuthUserIdentity, getHeaders, getSession, handlePagination, hasUniqueFields, httpAdapter, listOne, paginate, selectFields, updateManyHandler, updateOneHandler };
+//#region src/internal/upstream/server/cors.ts
+/** biome-ignore-all lint: vendored upstream helper source */
+/**
+* Vendored from upstream helper repository at commit c5e52c8.
+* Source path: packages/convex_helpers/server/cors.ts
+*/
+/**
+* This file defines a CorsHttpRouter class that extends Convex's HttpRouter.
+* It provides CORS (Cross-Origin Resource Sharing) support for HTTP routes.
+*
+* The CorsHttpRouter:
+* 1. Allows specifying allowed origins for CORS.
+* 2. Overrides the route method to add CORS headers to all non-OPTIONS requests.
+* 3. Automatically adds an OPTIONS route to handle CORS preflight requests.
+* 4. Uses the handleCors helper function to apply CORS headers consistently.
+*
+* This router simplifies the process of making Convex HTTP endpoints
+* accessible to web applications hosted on different domains while
+* maintaining proper CORS configuration.
+*/
+const DEFAULT_EXPOSED_HEADERS = ["Content-Range", "Accept-Ranges"];
+/**
+* Factory function to create a router that adds CORS support to routes.
+* @param allowedOrigins An array of allowed origins for CORS.
+* @returns A function to use instead of http.route when you want CORS.
+*/
+const corsRouter = (http, corsConfig) => {
+	const allowedExactMethodsByPath = /* @__PURE__ */ new Map();
+	const allowedPrefixMethodsByPath = /* @__PURE__ */ new Map();
+	return {
+		http,
+		route: (routeSpec) => {
+			const tempRouter = httpRouter();
+			tempRouter.exactRoutes = http.exactRoutes;
+			tempRouter.prefixRoutes = http.prefixRoutes;
+			const config = {
+				...corsConfig,
+				...routeSpec
+			};
+			const httpCorsHandler = handleCors({
+				originalHandler: routeSpec.handler,
+				allowedMethods: [routeSpec.method],
+				...config
+			});
+			/**
+			* Figure out what kind of route we're adding: exact or prefix and handle
+			* accordingly.
+			*/
+			if ("path" in routeSpec) {
+				let methods = allowedExactMethodsByPath.get(routeSpec.path);
+				if (!methods) {
+					methods = /* @__PURE__ */ new Set();
+					allowedExactMethodsByPath.set(routeSpec.path, methods);
+				}
+				methods.add(routeSpec.method);
+				tempRouter.route({
+					path: routeSpec.path,
+					method: routeSpec.method,
+					handler: httpCorsHandler
+				});
+				handleExactRoute(tempRouter, routeSpec, config, Array.from(methods));
+			} else {
+				let methods = allowedPrefixMethodsByPath.get(routeSpec.pathPrefix);
+				if (!methods) {
+					methods = /* @__PURE__ */ new Set();
+					allowedPrefixMethodsByPath.set(routeSpec.pathPrefix, methods);
+				}
+				methods.add(routeSpec.method);
+				tempRouter.route({
+					pathPrefix: routeSpec.pathPrefix,
+					method: routeSpec.method,
+					handler: httpCorsHandler
+				});
+				handlePrefixRoute(tempRouter, routeSpec, config, Array.from(methods));
+			}
+			/**
+			* Copy the routes from the temporary router to the main router.
+			*/
+			http.exactRoutes = new Map(tempRouter.exactRoutes);
+			http.prefixRoutes = new Map(tempRouter.prefixRoutes);
+		}
+	};
+};
+/**
+* Handles exact route matching and adds OPTIONS handler.
+* @param tempRouter Temporary router instance.
+* @param routeSpec Route specification for exact matching.
+*/
+function handleExactRoute(tempRouter, routeSpec, config, allowedMethods) {
+	const currentMethodsForPath = tempRouter.exactRoutes.get(routeSpec.path);
+	/**
+	* Add the OPTIONS handler for the given path
+	*/
+	const optionsHandler = createOptionsHandlerForMethods(allowedMethods, config);
+	currentMethodsForPath?.set("OPTIONS", optionsHandler);
+	tempRouter.exactRoutes.set(routeSpec.path, new Map(currentMethodsForPath));
+}
+/**
+* Handles prefix route matching and adds OPTIONS handler.
+* @param tempRouter Temporary router instance.
+* @param routeSpec Route specification for prefix matching.
+*/
+function handlePrefixRoute(tempRouter, routeSpec, config, allowedMethods) {
+	/**
+	* prefixRoutes is structured differently than exactRoutes. It's defined as
+	* a Map<string, Map<string, PublicHttpAction>> where the KEY is the
+	* METHOD and the VALUE is a map of paths and handlers.
+	*/
+	const optionsHandler = createOptionsHandlerForMethods(allowedMethods, config);
+	const optionsPrefixes = tempRouter.prefixRoutes.get("OPTIONS") || /* @__PURE__ */ new Map();
+	optionsPrefixes.set(routeSpec.pathPrefix, optionsHandler);
+	tempRouter.prefixRoutes.set("OPTIONS", optionsPrefixes);
+}
+/**
+* Creates an OPTIONS handler for the given HTTP methods.
+* @param methods Array of HTTP methods to be allowed.
+* @returns A CORS-enabled OPTIONS handler.
+*/
+function createOptionsHandlerForMethods(methods, config) {
+	return handleCors({
+		...config,
+		allowedMethods: methods
+	});
+}
+/**
+* handleCors() is a higher-order function that wraps a Convex HTTP action handler to add CORS support.
+* It allows for customization of allowed HTTP methods and origins for cross-origin requests.
+*
+* The function:
+* 1. Validates and normalizes the allowed HTTP methods.
+* 2. Generates appropriate CORS headers based on the provided configuration.
+* 3. Handles preflight OPTIONS requests automatically.
+* 4. Wraps the original handler to add CORS headers to its response.
+*
+* This helper simplifies the process of making Convex HTTP actions accessible
+* to web applications hosted on different domains.
+*/
+const SECONDS_IN_A_DAY = 3600 * 24;
+/**
+* Example CORS origins:
+* - "*" (allow all origins)
+* - "https://example.com" (allow a specific domain)
+* - "https://*.example.com" (allow all subdomains of example.com)
+* - "https://example1.com, https://example2.com" (allow multiple specific domains)
+* - "null" (allow requests from data URLs or local files)
+*/
+const handleCors = ({ originalHandler, allowedMethods = ["OPTIONS"], allowedOrigins = ["*"], allowedHeaders = ["Content-Type"], exposedHeaders = DEFAULT_EXPOSED_HEADERS, allowCredentials = false, browserCacheMaxAge = SECONDS_IN_A_DAY, enforceAllowOrigins = false, debug = false }) => {
+	const filteredMethods = Array.from(new Set(allowedMethods.map((method) => method.toUpperCase()))).filter((method) => ROUTABLE_HTTP_METHODS.includes(method));
+	if (filteredMethods.length === 0) throw new Error("No valid HTTP methods provided");
+	/**
+	* Ensure OPTIONS is not duplicated if it was passed in
+	* E.g. if allowedMethods = ["GET", "OPTIONS"]
+	*/
+	const allowMethods = filteredMethods.includes("OPTIONS") ? filteredMethods.join(", ") : [...filteredMethods].join(", ");
+	/**
+	* Build up the set of CORS headers
+	*/
+	const commonHeaders = { Vary: "Origin" };
+	if (allowCredentials) commonHeaders["Access-Control-Allow-Credentials"] = "true";
+	if (exposedHeaders.length > 0) commonHeaders["Access-Control-Expose-Headers"] = exposedHeaders.join(", ");
+	async function parseAllowedOrigins(request) {
+		return Array.isArray(allowedOrigins) ? allowedOrigins : await allowedOrigins(request);
+	}
+	async function isAllowedOrigin(request) {
+		const requestOrigin = request.headers.get("origin");
+		if (!requestOrigin) return false;
+		return (await parseAllowedOrigins(request)).some((allowed) => {
+			if (allowed === "*") return true;
+			if (allowed === requestOrigin) return true;
+			if (allowed.startsWith("*.")) {
+				const wildcardDomain = allowed.slice(1);
+				const rootDomain = allowed.slice(2);
+				try {
+					const url = new URL(requestOrigin);
+					return url.protocol === "https:" && (url.hostname.endsWith(wildcardDomain) || url.hostname === rootDomain);
+				} catch {
+					return false;
+				}
+			}
+			return false;
+		});
+	}
+	/**
+	* Return our modified HTTP action
+	*/
+	return httpActionGeneric(async (ctx, request) => {
+		if (debug) console.log("CORS request", {
+			path: request.url,
+			origin: request.headers.get("origin"),
+			headers: request.headers,
+			method: request.method,
+			body: request.body
+		});
+		const requestOrigin = request.headers.get("origin");
+		const parsedAllowedOrigins = await parseAllowedOrigins(request);
+		if (debug) console.log("allowed origins", parsedAllowedOrigins);
+		let allowOrigins = null;
+		if (parsedAllowedOrigins.includes("*") && requestOrigin && !allowCredentials) allowOrigins = requestOrigin;
+		else if (requestOrigin) {
+			if (await isAllowedOrigin(request)) allowOrigins = requestOrigin;
+		}
+		if (enforceAllowOrigins && !allowOrigins) {
+			console.error(`Request from origin ${requestOrigin} blocked, missing from allowed origins: ${parsedAllowedOrigins.join()}`);
+			return new Response(null, { status: 403 });
+		}
+		/**
+		* OPTIONS has no handler and just returns headers
+		*/
+		if (request.method === "OPTIONS") {
+			const responseHeaders = new Headers({
+				...commonHeaders,
+				...allowOrigins ? { "Access-Control-Allow-Origin": allowOrigins } : {},
+				"Access-Control-Allow-Methods": allowMethods,
+				"Access-Control-Allow-Headers": allowedHeaders.join(", "),
+				"Access-Control-Max-Age": browserCacheMaxAge.toString()
+			});
+			if (debug) console.log("CORS OPTIONS response headers", responseHeaders);
+			return new Response(null, {
+				status: 204,
+				headers: responseHeaders
+			});
+		}
+		/**
+		* If the method is not OPTIONS, it must pass a handler
+		*/
+		if (!originalHandler) throw new Error("No PublicHttpAction provider to CORS handler");
+		const originalResponse = await ("_handler" in originalHandler ? originalHandler["_handler"] : originalHandler)(ctx, request);
+		/**
+		* Second, get a copy of the original response's headers and add the
+		* allow origin header if it's allowed
+		*/
+		const newHeaders = new Headers(originalResponse.headers);
+		if (allowOrigins) newHeaders.set("Access-Control-Allow-Origin", allowOrigins);
+		/**
+		* Third, add or update our other CORS headers
+		*/
+		Object.entries(commonHeaders).forEach(([key, value]) => {
+			newHeaders.set(key, value);
+		});
+		if (debug) console.log("CORS response headers", newHeaders);
+		/**
+		* Fourth, return the modified Response.
+		* A Response object is immutable, so we create a new one to return here.
+		*/
+		return new Response(originalResponse.body, {
+			status: originalResponse.status,
+			statusText: originalResponse.statusText,
+			headers: newHeaders
+		});
+	});
+};
+
+//#endregion
+//#region src/auth/registerRoutes.ts
+/** biome-ignore-all lint/suspicious/noConsole: lib */
+const registerRoutes = (http, getAuth, opts = {}) => {
+	const staticAuth = getAuth({});
+	const path = staticAuth.options.basePath ?? "/api/auth";
+	const authRequestHandler = httpActionGeneric(async (ctx, request) => {
+		if (opts?.verbose) {
+			console.log("options.baseURL", staticAuth.options.baseURL);
+			console.log("request headers", request.headers);
+		}
+		const response = await getAuth(ctx).handler(request);
+		if (opts?.verbose) console.log("response headers", response.headers);
+		return response;
+	});
+	if (!http.lookup("/.well-known/openid-configuration", "GET")) http.route({
+		handler: httpActionGeneric(async () => {
+			const url = `${process.env.CONVEX_SITE_URL}${path}/convex/.well-known/openid-configuration`;
+			return Response.redirect(url);
+		}),
+		method: "GET",
+		path: "/.well-known/openid-configuration"
+	});
+	if (!opts.cors) {
+		http.route({
+			handler: authRequestHandler,
+			method: "GET",
+			pathPrefix: `${path}/`
+		});
+		http.route({
+			handler: authRequestHandler,
+			method: "POST",
+			pathPrefix: `${path}/`
+		});
+		return;
+	}
+	const corsOpts = typeof opts.cors === "boolean" ? {
+		allowedHeaders: [],
+		allowedOrigins: [],
+		exposedHeaders: []
+	} : opts.cors;
+	let trustedOriginsOption;
+	const cors = corsRouter(http, {
+		allowCredentials: true,
+		allowedHeaders: [
+			"Content-Type",
+			"Better-Auth-Cookie",
+			"Authorization"
+		].concat(corsOpts.allowedHeaders ?? []),
+		debug: opts?.verbose,
+		enforceAllowOrigins: false,
+		exposedHeaders: ["Set-Better-Auth-Cookie"].concat(corsOpts.exposedHeaders ?? []),
+		allowedOrigins: async (request) => {
+			trustedOriginsOption = trustedOriginsOption ?? (await staticAuth.$context).options.trustedOrigins ?? [];
+			return (Array.isArray(trustedOriginsOption) ? trustedOriginsOption : await trustedOriginsOption?.(request) ?? []).map((origin) => origin.endsWith("*") && origin.length > 1 ? origin.slice(0, -1) : origin).concat(corsOpts.allowedOrigins ?? []);
+		}
+	});
+	cors.route({
+		handler: authRequestHandler,
+		method: "GET",
+		pathPrefix: `${path}/`
+	});
+	cors.route({
+		handler: authRequestHandler,
+		method: "POST",
+		pathPrefix: `${path}/`
+	});
+};
+
+//#endregion
+export { adapterArgsValidator, adapterConfig, adapterWhereValidator, authMiddleware, checkUniqueFields, convex, createApi, createClient, createHandler, dbAdapter, deleteManyHandler, deleteOneHandler, findManyHandler, findOneHandler, getAuthUserId, getAuthUserIdentity, getHeaders, getSession, handlePagination, hasUniqueFields, httpAdapter, listOne, paginate, registerRoutes, selectFields, updateManyHandler, updateOneHandler };