kitcn 0.19.0 → 0.21.0

package/dist/aggregate/index.d.ts

@@ -1,4 +1,4 @@
-import { C as ConvexNumberBuilderInitial, E as ConvexIdBuilderInitial, N as ConvexCustomBuilderInitial, dn as ConvexTableWithColumns, tr as ConvexTextBuilderInitial } from "../where-clause-compiler-CmBz9CWA.js";
+import { C as ConvexNumberBuilderInitial, E as ConvexIdBuilderInitial, N as ConvexCustomBuilderInitial, dn as ConvexTableWithColumns, tr as ConvexTextBuilderInitial } from "../where-clause-compiler-B_H3oio5.js";
 import * as convex_values0 from "convex/values";
 import { GenericId, Infer, Value } from "convex/values";
 import { DocumentByName, GenericDataModel, GenericDatabaseReader, GenericDatabaseWriter, TableNamesInDataModel } from "convex/server";
@@ -229,6 +229,12 @@ declare class Aggregate<K extends Key, ID extends string, TNamespace extends Val
     maxNodeSize?: number;
     rootLazy?: boolean;
   }, TNamespace>): Promise<void>;
+  /**
+   * Deletes up to `limit` namespace trees without recreating them. Returns true
+   * once this aggregate owns no trees, so callers can drain every namespace
+   * across several mutations instead of walking them all in one.
+   */
+  deleteTrees(ctx: RunMutationCtx, limit: number): Promise<boolean>;
   makeRootLazy(ctx: RunMutationCtx, namespace: TNamespace): Promise<void>;
   paginateNamespaces(ctx: RunQueryCtx, cursor?: string, pageSize?: number): Promise<{
     cursor: string;

package/dist/aggregate/index.js

@@ -1,4 +1,4 @@
-import { n as TableAggregate$1, r as aggregateStorageTables, t as DirectAggregate$1 } from "../runtime-DmVSOe24.js";
+import { n as TableAggregate$1, r as aggregateStorageTables, t as DirectAggregate$1 } from "../runtime-6DJxpDfb.js";
 
 //#region src/aggregate/index.ts
 const wrapTriggerFactory = (methodName, factory) => ((...args) => {

package/dist/auth/client/index.js

@@ -24,28 +24,84 @@ const hasActiveSessionData = (session) => {
 	if (!session || typeof session !== "object") return false;
 	return Boolean(session.session);
 };
+const getSessionId = (sessionData) => {
+	if (!sessionData || typeof sessionData !== "object") return;
+	const session = sessionData.session;
+	if (!session || typeof session !== "object") return;
+	const id = session.id;
+	return typeof id === "string" ? id : void 0;
+};
+const isSameSession = (left, right) => {
+	if (left === right) return true;
+	const leftId = getSessionId(left);
+	return leftId !== void 0 && leftId === getSessionId(right);
+};
 const wait = (ms) => new Promise((resolve) => {
 	setTimeout(resolve, ms);
 });
-const readAuthResultData = (result) => {
-	if (!result || typeof result !== "object") return;
-	return result.data;
+const PERSISTED_TOKEN_RETRY_BASE_MS = 100;
+const PERSISTED_TOKEN_RETRY_MAX_MS = 2e3;
+const readAuthResult = (result) => {
+	if (!result || typeof result !== "object") return {
+		data: void 0,
+		errored: true
+	};
+	const { data, error } = result;
+	return {
+		data,
+		errored: Boolean(error)
+	};
 };
-const getSessionFromPersistedToken = async (authClient, token) => {
-	await wait(250);
+const fetchPersistedSession = async (authClient, token) => {
 	const getSession = authClient.getSession;
-	for (let attempt = 0; attempt < 10; attempt += 1) {
-		const data = readAuthResultData(authClient.$fetch ? await authClient.$fetch("/get-session", {
+	try {
+		return await (authClient.$fetch ? authClient.$fetch("/get-session", {
 			credentials: "omit",
 			headers: { Authorization: `Bearer ${token}` }
-		}) : await getSession?.({ fetchOptions: {
+		}) : getSession?.({ fetchOptions: {
 			credentials: "omit",
 			headers: { Authorization: `Bearer ${token}` }
 		} }));
-		if (data) return data;
-		if (attempt < 9) await wait(100);
+	} catch (error) {
+		return {
+			data: void 0,
+			error
+		};
+	}
+};
+const fetchPersistedSessionBeforeDeadline = async (authClient, token, deadline) => {
+	const remaining = deadline - Date.now();
+	if (remaining <= 0) return { status: "deadline" };
+	let timeoutId;
+	const deadlineResult = new Promise((resolve) => {
+		timeoutId = setTimeout(() => resolve({ status: "deadline" }), remaining);
+	});
+	try {
+		return await Promise.race([fetchPersistedSession(authClient, token).then((result) => ({
+			result,
+			status: "result"
+		})), deadlineResult]);
+	} finally {
+		if (timeoutId !== void 0) clearTimeout(timeoutId);
+	}
+};
+const getSessionFromPersistedToken = async (authClient, token, { deadline, shouldStop }) => {
+	for (let attempt = 0;; attempt += 1) {
+		if (attempt > 0) {
+			const remaining = deadline - Date.now();
+			if (remaining <= 0) return { status: "unknown" };
+			await wait(Math.min(PERSISTED_TOKEN_RETRY_BASE_MS * 3 ** (attempt - 1), PERSISTED_TOKEN_RETRY_MAX_MS, remaining));
+		}
+		if (shouldStop()) return { status: "unknown" };
+		const request = await fetchPersistedSessionBeforeDeadline(authClient, token, deadline);
+		if (request.status === "deadline") return { status: "unknown" };
+		const { data, errored } = readAuthResult(request.result);
+		if (data) return {
+			data,
+			status: "session"
+		};
+		if (!errored) return { status: "none" };
 	}
-	return null;
 };
 const syncSessionAtom = (authClient, sessionData) => {
 	const sessionAtom = authClient.$store?.atoms?.session;
@@ -107,6 +163,8 @@ function ConvexAuthProviderInner({ children, client, authClient, convexQueryClie
 	const sessionRef = useRef(session);
 	const isPendingRef = useRef(isPending);
 	const pendingTokenRef = useRef(null);
+	const restoredTokenRef = useRef(null);
+	const isMountedRef = useRef(false);
 	sessionRef.current = session;
 	isPendingRef.current = isPending;
 	const getCachedJwt = useCallback((minTimeRemainingMs = 0) => {
@@ -132,21 +190,41 @@ function ConvexAuthProviderInner({ children, client, authClient, convexQueryClie
 		isPending,
 		authStore
 	]);
+	useEffect(() => {
+		isMountedRef.current = true;
+		return () => {
+			isMountedRef.current = false;
+		};
+	}, []);
 	useEffect(() => {
 		if (hasActiveSessionData(session) || isPending || authStore.get("token")) return;
 		const persistedToken = readAuthSessionFallbackToken();
+		if (!persistedToken || restoredTokenRef.current === persistedToken || typeof authClient.getSession !== "function" && typeof authClient.$fetch !== "function") return;
+		restoredTokenRef.current = persistedToken;
 		const persistedSessionData = readAuthSessionFallbackData();
-		if (!persistedToken || typeof authClient.getSession !== "function" && typeof authClient.$fetch !== "function") return;
-		let cancelled = false;
+		const graceUntil = Date.now() + AUTH_SESSION_SYNC_GRACE_MS;
 		authStore.set("token", persistedToken);
 		authStore.set("expiresAt", decodeJwtExp(persistedToken));
-		authStore.set("sessionSyncGraceUntil", Date.now() + AUTH_SESSION_SYNC_GRACE_MS);
+		authStore.set("sessionSyncGraceUntil", graceUntil);
 		if (persistedSessionData) syncSessionAtom(authClient, persistedSessionData);
-		getSessionFromPersistedToken(authClient, persistedToken).then((result) => {
-			if (cancelled) return;
-			if (result) {
-				syncSessionAtom(authClient, result);
-				writeAuthSessionFallbackData(result);
+		const ownsToken = () => authStore.get("token") === persistedToken;
+		const shouldStop = () => !isMountedRef.current || !ownsToken();
+		getSessionFromPersistedToken(authClient, persistedToken, {
+			deadline: graceUntil,
+			shouldStop
+		}).then((outcome) => {
+			const hasCompetingSession = hasActiveSessionData(sessionRef.current) && !isSameSession(sessionRef.current, persistedSessionData);
+			if (!isMountedRef.current || !ownsToken() || hasCompetingSession) return;
+			if (outcome.status === "session") {
+				syncSessionAtom(authClient, outcome.data);
+				writeAuthSessionFallbackData(outcome.data);
+				return;
+			}
+			if (outcome.status === "unknown") {
+				if (persistedSessionData) clearSessionAtom(authClient);
+				authStore.set("token", null);
+				authStore.set("expiresAt", null);
+				authStore.set("sessionSyncGraceUntil", null);
 				return;
 			}
 			clearAuthSessionFallback();
@@ -154,17 +232,7 @@ function ConvexAuthProviderInner({ children, client, authClient, convexQueryClie
 			authStore.set("token", null);
 			authStore.set("expiresAt", null);
 			authStore.set("sessionSyncGraceUntil", null);
-		}).catch(() => {
-			if (cancelled) return;
-			clearAuthSessionFallback();
-			clearSessionAtom(authClient);
-			authStore.set("token", null);
-			authStore.set("expiresAt", null);
-			authStore.set("sessionSyncGraceUntil", null);
-		});
-		return () => {
-			cancelled = true;
-		};
+		}).catch(() => {});
 	}, [
 		session,
 		isPending,

package/dist/auth/generated/index.d.ts

@@ -1,2 +1,2 @@
-import { S as defineAuth, _ as GenericAuthBeforeResult, b as GenericAuthTriggerHandlers, g as BetterAuthOptionsWithoutDatabase, i as getGeneratedAuthDisabledReason, n as GeneratedAuthDisabledReasonKind, r as createDisabledAuthRuntime, t as AuthRuntime, v as GenericAuthDefinition, x as GenericAuthTriggers, y as GenericAuthTriggerChange } from "../../generated-contract-disabled-LOAfma7_.js";
+import { S as defineAuth, _ as GenericAuthBeforeResult, b as GenericAuthTriggerHandlers, g as BetterAuthOptionsWithoutDatabase, i as getGeneratedAuthDisabledReason, n as GeneratedAuthDisabledReasonKind, r as createDisabledAuthRuntime, t as AuthRuntime, v as GenericAuthDefinition, x as GenericAuthTriggers, y as GenericAuthTriggerChange } from "../../generated-contract-disabled-B-nmd7Ne.js";
 export { type AuthRuntime, BetterAuthOptionsWithoutDatabase, type GeneratedAuthDisabledReasonKind, GenericAuthBeforeResult, GenericAuthDefinition, GenericAuthTriggerChange, GenericAuthTriggerHandlers, GenericAuthTriggers, createDisabledAuthRuntime, defineAuth, getGeneratedAuthDisabledReason };

package/dist/auth/index.d.ts

@@ -1,7 +1,7 @@
 import { a as QueryCtxWithPreferredOrmQueryTable, n as LookupByIdResultByCtx, t as DocByCtx } from "../query-context-CNo9ffvI.js";
 import { t as GetAuth } from "../types-BCl8gfGy.js";
 import { t as GenericCtx } from "../context-utils-BBUtBqjN.js";
-import { S as defineAuth, _ as GenericAuthBeforeResult, a as AuthFunctions, b as GenericAuthTriggerHandlers, c as createApi, d as deleteOneHandler, f as findManyHandler, g as BetterAuthOptionsWithoutDatabase, h as updateOneHandler, i as getGeneratedAuthDisabledReason, l as createHandler, m as updateManyHandler, n as GeneratedAuthDisabledReasonKind, o as Triggers, p as findOneHandler, r as createDisabledAuthRuntime, s as createClient, t as AuthRuntime, u as deleteManyHandler, v as GenericAuthDefinition, x as GenericAuthTriggers, y as GenericAuthTriggerChange } from "../generated-contract-disabled-LOAfma7_.js";
+import { S as defineAuth, _ as GenericAuthBeforeResult, a as AuthFunctions, b as GenericAuthTriggerHandlers, c as createApi, d as deleteOneHandler, f as findManyHandler, g as BetterAuthOptionsWithoutDatabase, h as updateOneHandler, i as getGeneratedAuthDisabledReason, l as createHandler, m as updateManyHandler, n as GeneratedAuthDisabledReasonKind, o as Triggers, p as findOneHandler, r as createDisabledAuthRuntime, s as createClient, t as AuthRuntime, u as deleteManyHandler, v as GenericAuthDefinition, x as GenericAuthTriggers, y as GenericAuthTriggerChange } from "../generated-contract-disabled-B-nmd7Ne.js";
 import * as convex_values0 from "convex/values";
 import { Infer } from "convex/values";
 import { AuthConfig, DocumentByName, GenericDataModel, GenericMutationCtx, GenericQueryCtx, GenericSchema, PaginationOptions, PaginationResult, SchemaDefinition, TableNamesInDataModel } from "convex/server";
@@ -25,9 +25,11 @@ declare const handlePagination: (next: ({
 }) => Promise<SetOptional<PaginationResult<any>, "page"> & {
   count?: number;
 }>, {
+  countOnly,
   limit,
   numItems
 }?: {
+  countOnly?: boolean;
   limit?: number;
   numItems?: number;
 }) => Promise<{
@@ -66,7 +68,7 @@ declare const adapterConfig: {
     action: "create" | "update" | "findOne" | "findMany" | "updateMany" | "delete" | "deleteMany" | "consumeOne" | "incrementOne" | "count";
     model: string;
     schema: BetterAuthDBSchema;
-    options: BetterAuthOptions;
+    options: better_auth0.BetterAuthOptions;
   }) => any;
   customTransformOutput: ({
     data,
@@ -78,7 +80,7 @@ declare const adapterConfig: {
     select: string[];
     model: string;
     schema: BetterAuthDBSchema;
-    options: BetterAuthOptions;
+    options: better_auth0.BetterAuthOptions;
   }) => any;
 };
 declare const httpAdapter: <DataModel extends GenericDataModel, Schema extends SchemaDefinition<any, any>>(ctx: GenericCtx<DataModel>, {
@@ -89,16 +91,18 @@ declare const httpAdapter: <DataModel extends GenericDataModel, Schema extends S
   authFunctions: AuthFunctions;
   debugLogs?: DBAdapterDebugLogOption;
   schema?: Schema;
-}) => better_auth_adapters0.AdapterFactory<BetterAuthOptions>;
-declare const dbAdapter: <DataModel extends GenericDataModel, Schema extends SchemaDefinition<any, any>>(ctx: GenericCtx<DataModel>, getAuthOptions: (ctx: any) => BetterAuthOptions, {
+}) => better_auth_adapters0.AdapterFactory<better_auth0.BetterAuthOptions>;
+declare const dbAdapter: <DataModel extends GenericDataModel, Schema extends SchemaDefinition<any, any>>(ctx: GenericCtx<DataModel>, {
   authFunctions,
   debugLogs,
+  getBetterAuthSchema,
   schema
 }: {
-  authFunctions: AuthFunctions;
+  authFunctions: AuthFunctions; /** Ctx-free Better Auth table schema, memoized by the caller. */
+  getBetterAuthSchema: () => BetterAuthDBSchema;
   schema: Schema;
   debugLogs?: DBAdapterDebugLogOption;
-}) => better_auth_adapters0.AdapterFactory<BetterAuthOptions>;
+}) => better_auth_adapters0.AdapterFactory<better_auth0.BetterAuthOptions>;
 //#endregion
 //#region src/auth/adapter-utils.d.ts
 type AdapterPaginationOptions = PaginationOptions & {

package/dist/auth/index.js

@@ -4,12 +4,12 @@ import { i as defineAuth, n as createDisabledAuthRuntime, r as getGeneratedAuthD
 import { n as createGeneratedFunctionReference, o as isQueryCtx, s as isRunMutationCtx } from "../api-entry-N3nBOlI2.js";
 import { n as customCtx, r as customMutation } from "../customFunctions-DxEEO4Dq.js";
 import { o as mergedStream, s as stream, t as getByIdWithOrmQueryFallback, u as unsetToken, y as eq } from "../query-context-BzihIpnM.js";
-import { n as convex } from "../convex-plugin-BHVCqWTH.js";
+import { n as convex } from "../convex-plugin-D8B0oCFq.js";
 import { v } from "convex/values";
 import { internalActionGeneric, internalMutationGeneric, internalQueryGeneric, paginationOptsValidator } from "convex/server";
 import { createAdapterFactory } from "better-auth/adapters";
-import { getAuthTables } from "better-auth/db";
 import { prop, sortBy } from "remeda";
+import { getAuthTables } from "better-auth/db";
 import { stripIndent } from "common-tags";
 import { betterAuth } from "better-auth/minimal";
 
@@ -32,10 +32,34 @@ const adapterArgsValidator = v.object({
 	})),
 	where: v.optional(v.array(adapterWhereValidator))
 });
+const schemaViewsCache = /* @__PURE__ */ new WeakMap();
+const EMPTY_SCHEMA_VIEWS = {
+	modelNameToKey: /* @__PURE__ */ new Map(),
+	uniqueFields: /* @__PURE__ */ new Map()
+};
+const getSchemaViews = (betterAuthSchema) => {
+	if (!betterAuthSchema || typeof betterAuthSchema !== "object") return EMPTY_SCHEMA_VIEWS;
+	const cached = schemaViewsCache.get(betterAuthSchema);
+	if (cached) return cached;
+	const modelNameToKey = /* @__PURE__ */ new Map();
+	const uniqueFields = /* @__PURE__ */ new Map();
+	for (const [key, model] of Object.entries(betterAuthSchema)) {
+		if (model?.modelName && !modelNameToKey.has(model.modelName)) modelNameToKey.set(model.modelName, key);
+		const unique = /* @__PURE__ */ new Set();
+		for (const [field, attrs] of Object.entries(model?.fields ?? {})) if (attrs?.unique) unique.add(field);
+		uniqueFields.set(key, unique);
+	}
+	const views = {
+		modelNameToKey,
+		uniqueFields
+	};
+	schemaViewsCache.set(betterAuthSchema, views);
+	return views;
+};
 const isUniqueField = (betterAuthSchema, model, field) => {
-	const modelSchema = betterAuthSchema[Object.keys(betterAuthSchema).find((key) => betterAuthSchema[key].modelName === model) || model];
-	if (!modelSchema?.fields) return false;
-	return Object.entries(modelSchema.fields).filter(([, value]) => value.unique).map(([key]) => key).includes(field);
+	const { modelNameToKey, uniqueFields } = getSchemaViews(betterAuthSchema);
+	const betterAuthModel = modelNameToKey.get(model) ?? model;
+	return uniqueFields.get(betterAuthModel)?.has(field) ?? false;
 };
 const hasUniqueFields = (betterAuthSchema, model, input) => {
 	for (const field of Object.keys(input)) if (isUniqueField(betterAuthSchema, model, field)) return true;
@@ -482,8 +506,25 @@ const findManyHandler = async (ctx, args, schema, betterAuthSchema) => toConvexS
 const updateOneHandler = async (ctx, args, schema, betterAuthSchema) => {
 	const triggerCtx = args.triggerCtx ?? ctx;
 	const tableTriggers = args.tableTriggers;
-	const doc = await listOne(ctx, schema, betterAuthSchema, args.input);
+	const matches = [];
+	let cursor = null;
+	let isDone = false;
+	while (!isDone && matches.length < 2) {
+		const result = await paginate(ctx, schema, betterAuthSchema, {
+			...args.input,
+			paginationOpts: {
+				cursor,
+				numItems: 2 - matches.length
+			}
+		});
+		matches.push(...result.page);
+		isDone = result.isDone;
+		if (!isDone && result.continueCursor === cursor) throw new Error("Pagination made no forward progress");
+		cursor = result.continueCursor;
+	}
+	const doc = matches[0];
 	if (!doc) throw new Error(`Failed to update ${args.input.model}`);
+	if (matches.length > 1) throw new Error(`Multiple ${args.input.model} found matching criteria. Expected exactly 1.`);
 	const normalizedDoc = withBothIdFields(doc);
 	const update = stripUnsupportedAuthTimestamps(serializeDatesForConvex(await applyBeforeHook(args.input.model, "update", args.input.update, tableTriggers?.update?.before, triggerCtx)), schema, betterAuthSchema, args.input.model);
 	await checkUniqueFields(ctx, schema, betterAuthSchema, args.input.model, update, normalizedDoc);
@@ -590,9 +631,10 @@ const deleteManyHandler = async (ctx, args, schema, betterAuthSchema) => {
 	});
 };
 const createApi = (schema, getAuth, options) => {
-	const { internalMutation, validateInput = false, context, triggers } = options ?? {};
+	const { internalMutation, validateInput = false, context, getBetterAuthSchema: injectedBetterAuthSchema, triggers } = options ?? {};
 	let betterAuthSchema;
 	const getBetterAuthSchema = () => {
+		if (injectedBetterAuthSchema) return injectedBetterAuthSchema();
 		betterAuthSchema ??= getAuthTables(getAuth({}).options);
 		return betterAuthSchema;
 	};
@@ -749,7 +791,7 @@ const createApi = (schema, getAuth, options) => {
 //#endregion
 //#region src/auth/adapter.ts
 let didWarnExperimentalJoinsUnsupported = false;
-const handlePagination = async (next, { limit, numItems } = {}) => {
+const handlePagination = async (next, { countOnly, limit, numItems } = {}) => {
 	const state = {
 		count: 0,
 		cursor: null,
@@ -759,6 +801,11 @@ const handlePagination = async (next, { limit, numItems } = {}) => {
 	const onResult = (result) => {
 		state.cursor = result.continueCursor;
 		if (result.page) {
+			if (countOnly) {
+				state.count += result.page.length;
+				state.isDone = limit && state.count >= limit || result.isDone;
+				return;
+			}
 			state.docs.push(...result.page);
 			state.isDone = limit && state.docs.length >= limit || result.isDone;
 			return;
@@ -772,9 +819,10 @@ const handlePagination = async (next, { limit, numItems } = {}) => {
 	};
 	do {
 		const cursorBeforePage = state.cursor;
+		const consumed = countOnly ? state.count : state.docs.length;
 		const result = await next({ paginationOpts: {
 			cursor: state.cursor,
-			numItems: Math.min(numItems ?? 200, limit === void 0 ? Number.POSITIVE_INFINITY : limit - state.docs.length, 200)
+			numItems: Math.min(numItems ?? 200, limit === void 0 ? Number.POSITIVE_INFINITY : limit - consumed, 200)
 		} });
 		onResult(result);
 		const advanced = state.cursor !== cursorBeforePage;
@@ -901,7 +949,7 @@ const httpAdapter = (ctx, { authFunctions, debugLogs, schema }) => {
 						...data,
 						paginationOpts,
 						where: parseWhere(data.where)
-					}))).docs.length;
+					}), { countOnly: true })).count;
 				},
 				create: async ({ data, model, select }) => {
 					if (!("runMutation" in ctx)) throw new Error("ctx is not a mutation ctx");
@@ -990,20 +1038,11 @@ const httpAdapter = (ctx, { authFunctions, debugLogs, schema }) => {
 				update: async (data) => {
 					if (!("runMutation" in ctx)) throw new Error("ctx is not a mutation ctx");
 					if (!data.where?.length) return null;
-					if (data.where.every((w) => (w.operator === "eq" || w.operator === void 0) && w.connector !== "OR")) {
-						const countResult = await handlePagination(async ({ paginationOpts }) => await ctx.runQuery(authFunctions.findMany, {
-							model: data.model,
-							paginationOpts,
-							where: parseWhere(data.where)
-						}), { 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.`);
-						return await ctx.runMutation(authFunctions.updateOne, { input: {
-							model: data.model,
-							update: data.update,
-							where: parseWhere(data.where)
-						} });
-					}
+					if (data.where.every((w) => (w.operator === "eq" || w.operator === void 0) && w.connector !== "OR")) return await ctx.runMutation(authFunctions.updateOne, { input: {
+						model: data.model,
+						update: data.update,
+						where: parseWhere(data.where)
+					} });
 					throw new Error("where clause not supported");
 				},
 				updateMany: async (data) => {
@@ -1039,8 +1078,8 @@ const httpAdapter = (ctx, { authFunctions, debugLogs, schema }) => {
 		}
 	});
 };
-const dbAdapter = (ctx, getAuthOptions, { authFunctions, debugLogs, schema }) => {
-	const betterAuthSchema = getAuthTables(getAuthOptions({}));
+const dbAdapter = (ctx, { authFunctions, debugLogs, getBetterAuthSchema, schema }) => {
+	const betterAuthSchema = getBetterAuthSchema();
 	return createAdapterFactory({
 		config: {
 			...adapterConfig,
@@ -1079,7 +1118,7 @@ const dbAdapter = (ctx, getAuthOptions, { authFunctions, debugLogs, schema }) =>
 						...data,
 						paginationOpts,
 						where: parseWhere(data.where)
-					}, schema, betterAuthSchema))).docs.length;
+					}, schema, betterAuthSchema), { countOnly: true })).count;
 				},
 				create: async ({ data, model, select }) => {
 					if (!("runMutation" in ctx)) throw new Error("ctx is not a mutation ctx");
@@ -1167,13 +1206,6 @@ const dbAdapter = (ctx, getAuthOptions, { authFunctions, debugLogs, schema }) =>
 				update: async (data) => {
 					if (!data.where?.length) return null;
 					if (data.where.every((w) => (w.operator === "eq" || w.operator === void 0) && w.connector !== "OR")) {
-						const countResult = await handlePagination(async ({ paginationOpts }) => await findManyHandler(ctx, {
-							model: data.model,
-							paginationOpts,
-							where: parseWhere(data.where)
-						}, 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.`);
 						if (!("runMutation" in ctx)) throw new Error("ctx is not a mutation ctx");
 						return await ctx.runMutation(authFunctions.updateOne, { input: {
 							model: data.model,
@@ -1222,7 +1254,7 @@ const dbAdapter = (ctx, getAuthOptions, { authFunctions, debugLogs, schema }) =>
 const createClient = (config) => ({
 	authFunctions: config.authFunctions,
 	triggers: config.triggers,
-	adapter: (ctx, getAuthOptions) => isQueryCtx(ctx) ? dbAdapter(ctx, getAuthOptions, config) : httpAdapter(ctx, config)
+	adapter: (ctx) => isQueryCtx(ctx) ? dbAdapter(ctx, config) : httpAdapter(ctx, config)
 });
 
 //#endregion
@@ -1333,17 +1365,23 @@ const createAuthRuntime = (config) => {
 	const authDefinition = resolveGeneratedAuthDefinition(config.auth, getInvalidAuthDefinitionExportReason());
 	const authFunctions = resolveAuthFunctions(config.internal, config.moduleName);
 	const resolveRuntimeTriggers = (ctx) => authDefinition(ctx).triggers;
+	let betterAuthSchema;
+	const getBetterAuthSchema = () => {
+		betterAuthSchema ??= getAuthTables(withoutTriggers(authDefinition({})));
+		return betterAuthSchema;
+	};
 	const authClient = createClient({
 		authFunctions,
+		getBetterAuthSchema,
 		schema: config.schema,
 		...config.context ? { context: config.context } : {},
 		triggers: resolveRuntimeTriggers
 	});
-	const adapterGetAuthOptions = ((ctx) => withoutTriggers(authDefinition(ctx)));
-	const resolveAuthOptions = (ctx) => withDatabase(withAuthDefaults(withoutTriggers(authDefinition(ctx))), ctx, (_ctx) => authClient.adapter(_ctx, adapterGetAuthOptions));
+	const resolveAuthOptions = (ctx) => withDatabase(withAuthDefaults(withoutTriggers(authDefinition(ctx))), ctx, (_ctx) => authClient.adapter(_ctx));
 	const getAuth = (ctx) => betterAuth(resolveAuthOptions(ctx));
 	const decoratedAuthApi = decorateAuthRuntimeProcedures(createApi(config.schema, getAuth, {
 		...config.context ? { context: config.context } : {},
+		getBetterAuthSchema,
 		triggers: resolveRuntimeTriggers
 	}));
 	let staticAuth;

package/dist/auth/nextjs/index.js

@@ -1,4 +1,4 @@
-import { t as getToken } from "../../token-oA2EMtPA.js";
+import { t as getToken } from "../../token-xlpENMVn.js";
 import { n as defaultIsUnauthorized } from "../../error-Bvo7YEhk.js";
 import { t as createCallerFactory } from "../../caller-factory-DHywSoGZ.js";
 

package/dist/auth/start/server/index.js

@@ -1,4 +1,4 @@
-import { t as getToken } from "../../../token-oA2EMtPA.js";
+import { t as getToken } from "../../../token-xlpENMVn.js";
 import { stripIndent } from "common-tags";
 import { getRequestHeaders } from "@tanstack/react-start/server";
 import { ConvexHttpClient } from "convex/browser";

package/dist/cli.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { C as createSystemFields, S as TableName, _ as getSchemaRelations, a as generateMeta, b as OrmSchemaExtensions, d as loadBabelParser, f as loadClackPrompts, g as isColorEnabled, h as highlighter, i as resolveConfiguredBackend, l as createProjectJiti, m as loadEsbuild, n as withLocalCodegenEnv, o as getConvexConfig, p as loadDotenv, r as loadCliConfig, s as logger, t as getLocalBackendEnvVars, u as CRPC_BUILDER_STUB_SOURCE, v as Columns, x as RlsPolicies, y as EnableRLS } from "./local-env-DykABjCt.mjs";
+import { C as createSystemFields, S as TableName, _ as getSchemaRelations, a as generateMeta, b as OrmSchemaExtensions, d as loadBabelParser, f as loadClackPrompts, g as isColorEnabled, h as highlighter, i as resolveConfiguredBackend, l as createProjectJiti, m as loadEsbuild, n as withLocalCodegenEnv, o as getConvexConfig, p as loadDotenv, r as loadCliConfig, s as logger, t as getLocalBackendEnvVars, u as CRPC_BUILDER_STUB_SOURCE, v as Columns, x as RlsPolicies, y as EnableRLS } from "./local-env-yFKub75x.mjs";
 import { createRequire } from "node:module";
 import fs, { existsSync, readFileSync } from "node:fs";
 import path, { basename, delimiter, dirname, extname, isAbsolute, join, posix, relative, resolve } from "node:path";
@@ -12998,8 +12998,10 @@ async function runAggregatePruneFlow(params) {
 	if (result.exitCode !== 0) return result.exitCode;
 	const payload = parseBackendRunJson(result.stdout);
 	const pruned = typeof payload === "object" && payload !== null && !Array.isArray(payload) && typeof payload.pruned === "number" ? payload.pruned : 0;
+	const pruning = typeof payload === "object" && payload !== null && !Array.isArray(payload) && typeof payload.pruning === "number" ? payload.pruning : 0;
 	if (pruned > 0) logger.info(`aggregateBackfill pruned ${pruned} removed indexes`);
-	else logger.info("aggregateBackfill prune no-op");
+	else if (pruning === 0) logger.info("aggregateBackfill prune no-op");
+	if (pruning > 0) logger.info(`aggregateBackfill is clearing ${pruning} removed indexes in scheduled batches`);
 	return 0;
 }
 function slugifyMigrationName(name) {

package/dist/{convex-plugin-BHVCqWTH.js → convex-plugin-D8B0oCFq.js}

@@ -28,16 +28,26 @@ const parseAuthConfig = (authConfig, opts) => {
 	if (!isDataUriJwks && opts.jwks) console.warn("Static JWKS provided to Convex plugin, but not to auth config. This adds an unnecessary network request for token verification.");
 	return providerConfig;
 };
-const convex = (opts) => {
-	const jwtExpirationSeconds = opts.jwt?.expirationSeconds ?? opts.jwtExpirationSeconds ?? 900;
+const oidcProviderCache = /* @__PURE__ */ new Map();
+const getOidcProvider = (basePath) => {
+	const siteUrl = `${process.env.CONVEX_SITE_URL}`;
+	const key = `${siteUrl}|${basePath}`;
+	const cached = oidcProviderCache.get(key);
+	if (cached) return cached;
 	const oidcProvider$1 = oidcProvider({
 		loginPage: "/not-used",
 		metadata: {
-			issuer: `${process.env.CONVEX_SITE_URL}`,
-			jwks_uri: `${process.env.CONVEX_SITE_URL}${opts.options?.basePath ?? "/api/auth"}/convex/jwks`
+			issuer: siteUrl,
+			jwks_uri: `${siteUrl}${basePath}/convex/jwks`
 		},
 		__skipDeprecationWarning: true
 	});
+	oidcProviderCache.set(key, oidcProvider$1);
+	return oidcProvider$1;
+};
+const convex = (opts) => {
+	const jwtExpirationSeconds = opts.jwt?.expirationSeconds ?? opts.jwtExpirationSeconds ?? 900;
+	const oidcProvider = getOidcProvider(opts.options?.basePath ?? "/api/auth");
 	const providerConfig = parseAuthConfig(opts.authConfig, opts);
 	const jwtOptions = {
 		jwt: {
@@ -128,7 +138,7 @@ const convex = (opts) => {
 				})
 			}],
 			after: [
-				...normalizeAfterHooks(oidcProvider$1.hooks.after),
+				...normalizeAfterHooks(oidcProvider.hooks.after),
 				{
 					matcher: (ctx) => {
 						return Boolean(ctx.path?.startsWith("/sign-in") || ctx.path?.startsWith("/sign-up") || ctx.path?.startsWith("/callback") || ctx.path?.startsWith("/oauth2/callback") || ctx.path?.startsWith("/magic-link/verify") || ctx.path?.startsWith("/email-otp/verify-email") || ctx.path?.startsWith("/phone-number/verify") || ctx.path?.startsWith("/siwe/verify") || ctx.path?.startsWith("/update-session") || ctx.path?.startsWith("/get-session") && ctx.context.session);
@@ -167,7 +177,7 @@ const convex = (opts) => {
 				method: "GET",
 				metadata: { isAction: false }
 			}, async (ctx) => {
-				return await oidcProvider$1.endpoints.getOpenIdConfig({
+				return await oidcProvider.endpoints.getOpenIdConfig({
 					...ctx,
 					asResponse: false,
 					returnHeaders: false,

package/dist/{generated-contract-disabled-LOAfma7_.d.ts → generated-contract-disabled-B-nmd7Ne.d.ts}

@@ -1,9 +1,11 @@
 import { t as GetAuth } from "./types-BCl8gfGy.js";
 import { t as GenericCtx } from "./context-utils-BBUtBqjN.js";
 import * as convex_server0 from "convex/server";
-import { DocumentByName, FunctionReference, GenericDataModel, GenericMutationCtx, GenericSchema, SchemaDefinition, TableNamesInDataModel, internalMutationGeneric } from "convex/server";
+import { DocumentByName, FunctionReference, GenericDataModel, GenericMutationCtx, GenericSchema, PaginationResult, SchemaDefinition, TableNamesInDataModel, internalMutationGeneric } from "convex/server";
 import * as better_auth_adapters0 from "better-auth/adapters";
+import { BetterAuthDBSchema, getAuthTables } from "better-auth/db";
 import { BetterAuthOptions } from "better-auth/minimal";
+import * as better_auth0 from "better-auth";
 import { Auth } from "better-auth";
 
 //#region src/auth/define-auth.d.ts
@@ -101,7 +103,7 @@ declare const findManyHandler: (ctx: any, args: {
     field: string;
   };
   where?: any[];
-}, schema: Schema, betterAuthSchema: any) => Promise<convex_server0.PaginationResult<convex_server0.GenericDocument>>;
+}, schema: Schema, betterAuthSchema: any) => Promise<PaginationResult<convex_server0.GenericDocument>>;
 declare const updateOneHandler: (ctx: any, args: {
   input: {
     model: string;
@@ -155,6 +157,12 @@ declare const deleteManyHandler: (ctx: any, args: {
 declare const createApi: <Schema extends SchemaDefinition<any, any>, DataModel extends GenericDataModel = GenericDataModel, Ctx = unknown, TriggerCtx = Ctx, Auth = unknown>(schema: Schema, getAuth: GetAuth<Ctx, Auth>, options?: {
   internalMutation?: typeof internalMutationGeneric;
   context?: (ctx: any) => TriggerCtx | Promise<TriggerCtx>;
+  /**
+   * Ctx-free Better Auth table schema, memoized by the caller. Supplying it
+   * lets the runtime share one derivation with the db adapter instead of
+   * building a throwaway auth instance just to read `.options`.
+   */
+  getBetterAuthSchema?: () => ReturnType<typeof getAuthTables>;
   triggers?: GenericAuthTriggers<DataModel, Schema, TriggerCtx> | ((ctx: TriggerCtx) => GenericAuthTriggers<DataModel, Schema, TriggerCtx> | undefined); /** Validate input validators against auth table schemas. Defaults to false for smaller generated types. */
   validateInput?: boolean;
 }) => {
@@ -239,7 +247,7 @@ declare const createApi: <Schema extends SchemaDefinition<any, any>, DataModel e
       numItems: number;
       cursor: string | null;
     };
-  }, Promise<convex_server0.PaginationResult<convex_server0.GenericDocument>>>;
+  }, Promise<PaginationResult<convex_server0.GenericDocument>>>;
   findOne: convex_server0.RegisteredQuery<"internal", {
     join?: any;
     select?: string[] | undefined;
@@ -325,13 +333,18 @@ type Triggers<DataModel extends GenericDataModel, Schema extends SchemaDefinitio
 type TriggerResolver<DataModel extends GenericDataModel, Schema extends SchemaDefinition<any, any>, TriggerCtx extends GenericMutationCtx<DataModel> = GenericMutationCtx<DataModel>> = Triggers<DataModel, Schema, TriggerCtx> | ((ctx: TriggerCtx) => Triggers<DataModel, Schema, TriggerCtx> | undefined);
 declare const createClient: <DataModel extends GenericDataModel, Schema extends SchemaDefinition<GenericSchema, true>, TriggerCtx extends GenericMutationCtx<DataModel> = GenericMutationCtx<DataModel>>(config: {
   authFunctions: AuthFunctions;
+  /**
+   * Ctx-free Better Auth table schema, memoized by the caller. Resolved lazily
+   * on the first db-adapter construction, never at module scope.
+   */
+  getBetterAuthSchema: () => BetterAuthDBSchema;
   schema: Schema;
   context?: (ctx: GenericMutationCtx<DataModel>) => TriggerCtx | Promise<TriggerCtx>;
   triggers?: TriggerResolver<DataModel, Schema, TriggerCtx>;
 }) => {
   authFunctions: AuthFunctions;
   triggers: TriggerResolver<DataModel, Schema, TriggerCtx> | undefined;
-  adapter: (ctx: GenericCtx<DataModel>, getAuthOptions: (ctx: any) => BetterAuthOptions) => better_auth_adapters0.AdapterFactory<BetterAuthOptions>;
+  adapter: (ctx: GenericCtx<DataModel>) => better_auth_adapters0.AdapterFactory<better_auth0.BetterAuthOptions>;
 };
 //#endregion
 //#region src/auth/generated-contract-disabled.d.ts