kitcn 0.20.0 → 0.22.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-BGBNBNit.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";

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

@@ -1,5 +1,5 @@
 'use client';
-import { r as AuthStore } from "../../auth-store-47WTg13B.js";
+import { r as AuthStore } from "../../auth-store-DHEk0ARa.js";
 import { ConvexReactClient } from "convex/react";
 import { ReactNode } from "react";
 import * as react_jsx_runtime0 from "react/jsx-runtime";

package/dist/auth/client/index.js

@@ -1,5 +1,5 @@
 'use client';
-import { A as CRPCClientError, C as decodeJwtExp, D as readAuthSessionFallbackToken, E as readAuthSessionFallbackData, O as writeAuthSessionFallbackData, T as clearAuthSessionFallback, d as isSessionSyncGraceActive, g as useAuthValue, h as useAuthStore, j as defaultIsUnauthorized, n as AuthProvider, o as ConvexProviderWithAuth$1, s as FetchAccessTokenContext, t as AUTH_SESSION_SYNC_GRACE_MS } from "../../auth-store-BHk8eMnX.js";
+import { A as CRPCClientError, C as decodeJwtExp, D as readAuthSessionFallbackToken, E as readAuthSessionFallbackData, O as writeAuthSessionFallbackData, T as clearAuthSessionFallback, d as isSessionSyncGraceActive, g as useAuthValue, h as useAuthStore, j as defaultIsUnauthorized, n as AuthProvider, o as ConvexProviderWithAuth$1, s as FetchAccessTokenContext, t as AUTH_SESSION_SYNC_GRACE_MS } from "../../auth-store-BnsWs1xd.js";
 import { useConvexAuth } from "convex/react";
 import { useCallback, useEffect, useMemo, useRef } from "react";
 import { jsx } from "react/jsx-runtime";
@@ -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-BbPCefQM.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-BbPCefQM.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 & {
@@ -109,30 +113,30 @@ declare const adapterWhereValidator: convex_values0.VObject<{
   mode?: "sensitive" | "insensitive" | undefined;
   connector?: "AND" | "OR" | undefined;
   operator?: "lt" | "lte" | "gt" | "gte" | "eq" | "in" | "not_in" | "ne" | "contains" | "starts_with" | "ends_with" | undefined;
-  field: string;
   value: string | number | boolean | string[] | number[] | null;
+  field: string;
 }, {
   connector: convex_values0.VUnion<"AND" | "OR" | undefined, [convex_values0.VLiteral<"AND", "required">, convex_values0.VLiteral<"OR", "required">], "optional", never>;
   field: convex_values0.VString<string, "required">;
   mode: convex_values0.VUnion<"sensitive" | "insensitive" | undefined, [convex_values0.VLiteral<"sensitive", "required">, convex_values0.VLiteral<"insensitive", "required">], "optional", never>;
   operator: convex_values0.VUnion<"lt" | "lte" | "gt" | "gte" | "eq" | "in" | "not_in" | "ne" | "contains" | "starts_with" | "ends_with" | undefined, [convex_values0.VLiteral<"lt", "required">, convex_values0.VLiteral<"lte", "required">, convex_values0.VLiteral<"gt", "required">, convex_values0.VLiteral<"gte", "required">, convex_values0.VLiteral<"eq", "required">, convex_values0.VLiteral<"in", "required">, convex_values0.VLiteral<"not_in", "required">, convex_values0.VLiteral<"ne", "required">, convex_values0.VLiteral<"contains", "required">, convex_values0.VLiteral<"starts_with", "required">, convex_values0.VLiteral<"ends_with", "required">], "optional", never>;
   value: convex_values0.VUnion<string | number | boolean | string[] | number[] | null, [convex_values0.VString<string, "required">, convex_values0.VFloat64<number, "required">, convex_values0.VBoolean<boolean, "required">, convex_values0.VArray<string[], convex_values0.VString<string, "required">, "required">, convex_values0.VArray<number[], convex_values0.VFloat64<number, "required">, "required">, convex_values0.VNull<null, "required">], "required", never>;
-}, "required", "mode" | "connector" | "field" | "operator" | "value">;
+}, "required", "mode" | "value" | "connector" | "field" | "operator">;
 declare const adapterArgsValidator: convex_values0.VObject<{
-  limit?: number | undefined;
-  offset?: number | undefined;
   select?: string[] | undefined;
-  sortBy?: {
-    field: string;
-    direction: "asc" | "desc";
-  } | undefined;
   where?: {
     mode?: "sensitive" | "insensitive" | undefined;
     connector?: "AND" | "OR" | undefined;
     operator?: "lt" | "lte" | "gt" | "gte" | "eq" | "in" | "not_in" | "ne" | "contains" | "starts_with" | "ends_with" | undefined;
-    field: string;
     value: string | number | boolean | string[] | number[] | null;
+    field: string;
   }[] | undefined;
+  limit?: number | undefined;
+  offset?: number | undefined;
+  sortBy?: {
+    field: string;
+    direction: "asc" | "desc";
+  } | undefined;
   model: string;
 }, {
   limit: convex_values0.VFloat64<number | undefined, "optional">;
@@ -150,22 +154,22 @@ declare const adapterArgsValidator: convex_values0.VObject<{
     mode?: "sensitive" | "insensitive" | undefined;
     connector?: "AND" | "OR" | undefined;
     operator?: "lt" | "lte" | "gt" | "gte" | "eq" | "in" | "not_in" | "ne" | "contains" | "starts_with" | "ends_with" | undefined;
-    field: string;
     value: string | number | boolean | string[] | number[] | null;
+    field: string;
   }[] | undefined, convex_values0.VObject<{
     mode?: "sensitive" | "insensitive" | undefined;
     connector?: "AND" | "OR" | undefined;
     operator?: "lt" | "lte" | "gt" | "gte" | "eq" | "in" | "not_in" | "ne" | "contains" | "starts_with" | "ends_with" | undefined;
-    field: string;
     value: string | number | boolean | string[] | number[] | null;
+    field: string;
   }, {
     connector: convex_values0.VUnion<"AND" | "OR" | undefined, [convex_values0.VLiteral<"AND", "required">, convex_values0.VLiteral<"OR", "required">], "optional", never>;
     field: convex_values0.VString<string, "required">;
     mode: convex_values0.VUnion<"sensitive" | "insensitive" | undefined, [convex_values0.VLiteral<"sensitive", "required">, convex_values0.VLiteral<"insensitive", "required">], "optional", never>;
     operator: convex_values0.VUnion<"lt" | "lte" | "gt" | "gte" | "eq" | "in" | "not_in" | "ne" | "contains" | "starts_with" | "ends_with" | undefined, [convex_values0.VLiteral<"lt", "required">, convex_values0.VLiteral<"lte", "required">, convex_values0.VLiteral<"gt", "required">, convex_values0.VLiteral<"gte", "required">, convex_values0.VLiteral<"eq", "required">, convex_values0.VLiteral<"in", "required">, convex_values0.VLiteral<"not_in", "required">, convex_values0.VLiteral<"ne", "required">, convex_values0.VLiteral<"contains", "required">, convex_values0.VLiteral<"starts_with", "required">, convex_values0.VLiteral<"ends_with", "required">], "optional", never>;
     value: convex_values0.VUnion<string | number | boolean | string[] | number[] | null, [convex_values0.VString<string, "required">, convex_values0.VFloat64<number, "required">, convex_values0.VBoolean<boolean, "required">, convex_values0.VArray<string[], convex_values0.VString<string, "required">, "required">, convex_values0.VArray<number[], convex_values0.VFloat64<number, "required">, "required">, convex_values0.VNull<null, "required">], "required", never>;
-  }, "required", "mode" | "connector" | "field" | "operator" | "value">, "optional">;
-}, "required", "limit" | "model" | "offset" | "select" | "sortBy" | "where" | "sortBy.field" | "sortBy.direction">;
+  }, "required", "mode" | "value" | "connector" | "field" | "operator">, "optional">;
+}, "required", "model" | "select" | "where" | "limit" | "offset" | "sortBy" | "sortBy.field" | "sortBy.direction">;
 declare const hasUniqueFields: (betterAuthSchema: BetterAuthDBSchema, model: string, input: Record<string, any>) => boolean;
 declare const checkUniqueFields: <Schema extends SchemaDefinition<any, any>>(ctx: GenericQueryCtx<GenericDataModel>, schema: Schema, betterAuthSchema: BetterAuthDBSchema, table: string, input: Record<string, any>, doc?: Record<string, any>) => Promise<void>;
 declare const selectFields: <T extends TableNamesInDataModel<GenericDataModel>, D extends DocumentByName<GenericDataModel, T>>(doc: D | null, select?: string[]) => D | null;

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/{auth-store-BHk8eMnX.js → auth-store-BnsWs1xd.js}

@@ -216,7 +216,8 @@ const { AuthProvider, useAuthStore, useAuthState, useAuthValue } = createAtomSto
 	expiresAt: null,
 	isLoading: true,
 	isAuthenticated: false,
-	sessionSyncGraceUntil: null
+	sessionSyncGraceUntil: null,
+	authEpoch: 0
 }, {
 	name: "auth",
 	suppressWarnings: true

package/dist/{auth-store-47WTg13B.d.ts → auth-store-DHEk0ARa.d.ts}

@@ -49,6 +49,12 @@ type AuthStoreState = {
   isLoading: boolean; /** Auth state (synced from useConvexAuth for class methods) */
   isAuthenticated: boolean; /** Grace window for freshly seeded auth tokens while session sync catches up */
   sessionSyncGraceUntil: number | null;
+  /**
+   * Account generation, advanced on every identity transition. Client state
+   * that only makes sense inside one account's result set — paginated cursor
+   * chains — keys on it so it is rebuilt instead of reused across accounts.
+   */
+  authEpoch: number;
 };
 declare const AUTH_SESSION_SYNC_GRACE_MS = 10000;
 declare const isSessionSyncGraceActive: (sessionSyncGraceUntil: number | null) => boolean;
@@ -63,6 +69,7 @@ declare const AuthProvider: react.FC<jotai_x0.ProviderProps<{
     isLoading: boolean;
     isAuthenticated: boolean;
     sessionSyncGraceUntil: number | null;
+    authEpoch: number;
   }>>, useAuthStore: jotai_x0.UseStoreApi<AuthStoreState, object>, useAuthState: <K extends keyof AuthStoreState>(key: K, options?: string | jotai_x0.UseAtomOptions) => ({
     onMutationUnauthorized: jotai_x0.SimpleWritableAtom<() => void>;
     onQueryUnauthorized: jotai_x0.SimpleWritableAtom<(info: {
@@ -74,6 +81,7 @@ declare const AuthProvider: react.FC<jotai_x0.ProviderProps<{
     isLoading: jotai_x0.SimpleWritableAtom<boolean>;
     isAuthenticated: jotai_x0.SimpleWritableAtom<boolean>;
     sessionSyncGraceUntil: jotai_x0.SimpleWritableAtom<number | null>;
+    authEpoch: jotai_x0.SimpleWritableAtom<number>;
   } & object)[K] extends jotai_vanilla0.WritableAtom<infer V, infer A extends unknown[], infer R> ? [V, (...args: A) => R] : never, useAuthValue: <K extends keyof AuthStoreState, S = (({
     onMutationUnauthorized: jotai_x0.SimpleWritableAtom<() => void>;
     onQueryUnauthorized: jotai_x0.SimpleWritableAtom<(info: {
@@ -85,6 +93,7 @@ declare const AuthProvider: react.FC<jotai_x0.ProviderProps<{
     isLoading: jotai_x0.SimpleWritableAtom<boolean>;
     isAuthenticated: jotai_x0.SimpleWritableAtom<boolean>;
     sessionSyncGraceUntil: jotai_x0.SimpleWritableAtom<number | null>;
+    authEpoch: jotai_x0.SimpleWritableAtom<number>;
   } & object)[K] extends jotai_vanilla0.Atom<infer V> ? V : never)>(key: K, options?: ({
     selector?: ((v: ({
       onMutationUnauthorized: jotai_x0.SimpleWritableAtom<() => void>;
@@ -97,6 +106,7 @@ declare const AuthProvider: react.FC<jotai_x0.ProviderProps<{
       isLoading: jotai_x0.SimpleWritableAtom<boolean>;
       isAuthenticated: jotai_x0.SimpleWritableAtom<boolean>;
       sessionSyncGraceUntil: jotai_x0.SimpleWritableAtom<number | null>;
+      authEpoch: jotai_x0.SimpleWritableAtom<number>;
     } & object)[K] extends jotai_vanilla0.Atom<infer V_1> ? V_1 : never, prevSelectorOutput?: S | undefined) => S) | undefined;
     equalityFn?: ((prev: S, next: S) => boolean) | undefined;
   } & jotai_x0.UseAtomOptions) | undefined, deps?: unknown[]) => S;