kitcn 0.27.4 → 0.28.0

package/dist/auth/index.js

@@ -1,11 +1,11 @@
 import { n as asyncMap } from "../upstream-BCgGZX6q.js";
 import { r as partial } from "../validators-CIoUYCqO.js";
-import { i as defineAuth, n as createDisabledAuthRuntime, r as getGeneratedAuthDisabledReason, t as DEFAULT_AUTH_DEFINITION_PATH } from "../generated-contract-disabled-CZa0iyV0.js";
+import { i as defineAuth, n as createDisabledAuthRuntime, r as getGeneratedAuthDisabledReason, t as DEFAULT_AUTH_DEFINITION_PATH } from "../generated-contract-disabled-_1Mjg9pW.js";
 import { n as createGeneratedFunctionReference, o as isQueryCtx, s as isRunMutationCtx } from "../api-entry-CkDpGYVg.js";
 import { n as customCtx, r as customMutation } from "../customFunctions-ivbc6-_g.js";
 import { l as eq } from "../filter-expression-Dydt8wS0.js";
 import { o as mergedStream, s as stream, t as getByIdWithOrmQueryFallback, u as unsetToken } from "../query-context-DOm5Xm3H.js";
-import { n as convex } from "../convex-plugin-DfOhBU9g.js";
+import { n as convex } from "../convex-plugin-Dic0l-k8.js";
 import { v } from "convex/values";
 import { internalActionGeneric, internalMutationGeneric, internalQueryGeneric, paginationOptsValidator } from "convex/server";
 import { createAdapterFactory } from "better-auth/adapters";
@@ -36,7 +36,8 @@ const adapterArgsValidator = v.object({
 const schemaViewsCache = /* @__PURE__ */ new WeakMap();
 const EMPTY_SCHEMA_VIEWS = {
 	modelNameToKey: /* @__PURE__ */ new Map(),
-	uniqueFields: /* @__PURE__ */ new Map()
+	uniqueFields: /* @__PURE__ */ new Map(),
+	uniqueIndexes: /* @__PURE__ */ new Map()
 };
 const getSchemaViews = (betterAuthSchema) => {
 	if (!betterAuthSchema || typeof betterAuthSchema !== "object") return EMPTY_SCHEMA_VIEWS;
@@ -44,15 +45,20 @@ const getSchemaViews = (betterAuthSchema) => {
 	if (cached) return cached;
 	const modelNameToKey = /* @__PURE__ */ new Map();
 	const uniqueFields = /* @__PURE__ */ new Map();
+	const uniqueIndexes = /* @__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);
+		for (const [field, attrs] of Object.entries(model?.fields ?? {})) if (attrs?.unique) unique.add(attrs.fieldName ?? field);
 		uniqueFields.set(key, unique);
+		uniqueIndexes.set(key, (model?.indexes ?? []).filter((index) => index.unique).map((index) => index.fields.map((field) => {
+			return (model?.fields?.[field])?.fieldName ?? field;
+		})));
 	}
 	const views = {
 		modelNameToKey,
-		uniqueFields
+		uniqueFields,
+		uniqueIndexes
 	};
 	schemaViewsCache.set(betterAuthSchema, views);
 	return views;
@@ -62,9 +68,15 @@ const isUniqueField = (betterAuthSchema, model, field) => {
 	const betterAuthModel = modelNameToKey.get(model) ?? model;
 	return uniqueFields.get(betterAuthModel)?.has(field) ?? false;
 };
+const getUniqueIndexes = (betterAuthSchema, model) => {
+	const { modelNameToKey, uniqueIndexes } = getSchemaViews(betterAuthSchema);
+	const betterAuthModel = modelNameToKey.get(model) ?? model;
+	return uniqueIndexes.get(betterAuthModel) ?? [];
+};
 const hasUniqueFields = (betterAuthSchema, model, input) => {
 	for (const field of Object.keys(input)) if (isUniqueField(betterAuthSchema, model, field)) return true;
-	return false;
+	const inputFields = new Set(Object.keys(input));
+	return getUniqueIndexes(betterAuthSchema, model).some((fields) => fields.some((field) => inputFields.has(field)));
 };
 const findIndex = (schema, args) => {
 	if ((args.where?.length ?? 0) > 1 && args.where?.some((w) => w.connector === "OR")) throw new Error(`OR connector not supported with multiple where statements in findIndex, split up the where statements before calling findIndex: ${JSON.stringify(args.where)}`);
@@ -136,6 +148,25 @@ const checkUniqueFields = async (ctx, schema, betterAuthSchema, table, input, do
 		const existingDoc = await ctx.db.query(table).withIndex(index.indexDescriptor, (q) => q.eq(field, input[field])).unique();
 		if (existingDoc && existingDoc._id !== doc?._id) throw new Error(`${table} ${field} already exists`);
 	}
+	const nextDoc = {
+		...doc,
+		...input
+	};
+	for (const uniqueIndex of getUniqueIndexes(betterAuthSchema, table)) {
+		if (uniqueIndex.length === 1 && isUniqueField(betterAuthSchema, table, uniqueIndex[0]) || doc && !uniqueIndex.some((field) => field in input) || !uniqueIndex.every((field) => field in nextDoc)) continue;
+		const fields = [...uniqueIndex];
+		const tableSchema = schema.tables[table];
+		let indexes = [];
+		if (tableSchema) indexes = tableSchema[" indexes"] ? tableSchema[" indexes"]() : tableSchema.export().indexes;
+		const index = indexes.find(({ fields: indexFields }) => fields.length === indexFields.length && fields.every((field, index) => field === indexFields[index]));
+		if (!index) throw new Error(`No index found for ${table} ${fields.join(", ")}`);
+		const existingDoc = await ctx.db.query(table).withIndex(index.indexDescriptor, (q) => {
+			let query = q;
+			for (const field of fields) query = query.eq(field, nextDoc[field]);
+			return query;
+		}).unique();
+		if (existingDoc && existingDoc._id !== doc?._id) throw new Error(`${table} ${uniqueIndex.join(", ")} already exists`);
+	}
 };
 const selectFields = (doc, select) => {
 	if (!doc) return null;
@@ -557,6 +588,32 @@ const updateOneHandler = async (ctx, args, schema, betterAuthSchema) => {
 	}, triggerCtx);
 	return toConvexSafe(normalizedUpdatedDoc);
 };
+const incrementOneHandler = async (ctx, args, schema, betterAuthSchema) => {
+	const doc = await listOne(ctx, schema, betterAuthSchema, args.input);
+	if (!doc) return null;
+	const normalizedDoc = withBothIdFields(doc);
+	const update = { ...args.input.set };
+	for (const [field, delta] of Object.entries(args.input.increment)) {
+		const current = normalizedDoc[field];
+		if (typeof current !== "number") throw new Error(`Cannot increment non-numeric field ${field}`);
+		update[field] = current + delta;
+	}
+	const id = getDocId$1(normalizedDoc);
+	if (!id) throw new Error(`Cannot increment ${args.input.model} without an id`);
+	return updateOneHandler(ctx, {
+		input: {
+			model: args.input.model,
+			update,
+			where: [{
+				field: "_id",
+				operator: "eq",
+				value: id
+			}]
+		},
+		tableTriggers: args.tableTriggers,
+		triggerCtx: args.triggerCtx
+	}, schema, betterAuthSchema);
+};
 const updateManyHandler = async (ctx, args, schema, betterAuthSchema) => {
 	const triggerCtx = args.triggerCtx ?? ctx;
 	const tableTriggers = args.tableTriggers;
@@ -565,26 +622,23 @@ const updateManyHandler = async (ctx, args, schema, betterAuthSchema) => {
 		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) => {
-			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);
-			const hookNewDoc = serializeDatesForConvex(withBothIdFields(ormTable ? await ormUpdate(ctx, ormTable.table, normalizedDoc._id, update ?? {}) : await (async () => {
-				await ctx.db.patch(normalizedDoc._id, update);
-				return ctx.db.get(normalizedDoc._id);
-			})()));
-			const hookOldDoc = serializeDatesForConvex(normalizedDoc);
-			const id = getDocId$1(hookNewDoc);
-			await tableTriggers?.update?.after?.(hookNewDoc, triggerCtx);
-			await tableTriggers?.change?.({
-				id,
-				newDoc: hookNewDoc,
-				oldDoc: hookOldDoc,
-				operation: "update"
-			}, triggerCtx);
-		});
+	if (args.input.update) for (const doc of page) {
+		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);
+		const hookNewDoc = serializeDatesForConvex(withBothIdFields(ormTable ? await ormUpdate(ctx, ormTable.table, normalizedDoc._id, update ?? {}) : await (async () => {
+			await ctx.db.patch(normalizedDoc._id, update);
+			return ctx.db.get(normalizedDoc._id);
+		})()));
+		const hookOldDoc = serializeDatesForConvex(normalizedDoc);
+		const id = getDocId$1(hookNewDoc);
+		await tableTriggers?.update?.after?.(hookNewDoc, triggerCtx);
+		await tableTriggers?.change?.({
+			id,
+			newDoc: hookNewDoc,
+			oldDoc: hookOldDoc,
+			operation: "update"
+		}, triggerCtx);
 	}
 	return toConvexSafe({
 		...result,
@@ -592,7 +646,7 @@ const updateManyHandler = async (ctx, args, schema, betterAuthSchema) => {
 		ids: page.map((doc) => withBothIdFields(doc)._id)
 	});
 };
-const deleteOneHandler = async (ctx, args, schema, betterAuthSchema) => {
+const deleteOneWithStoredDoc = async (ctx, args, schema, betterAuthSchema) => {
 	const triggerCtx = args.triggerCtx ?? ctx;
 	const tableTriggers = args.tableTriggers;
 	const doc = await listOne(ctx, schema, betterAuthSchema, args.input);
@@ -610,7 +664,16 @@ const deleteOneHandler = async (ctx, args, schema, betterAuthSchema) => {
 		oldDoc: hookDoc,
 		operation: "delete"
 	}, triggerCtx);
-	return toConvexSafe(withBothIdFields(hookDoc));
+	return {
+		hookDoc: toConvexSafe(withBothIdFields(hookDoc)),
+		storedDoc: toConvexSafe(withBothIdFields(normalizedDoc))
+	};
+};
+const deleteOneHandler = async (ctx, args, schema, betterAuthSchema) => {
+	return (await deleteOneWithStoredDoc(ctx, args, schema, betterAuthSchema))?.hookDoc;
+};
+const consumeOneHandler = async (ctx, args, schema, betterAuthSchema) => {
+	return (await deleteOneWithStoredDoc(ctx, args, schema, betterAuthSchema))?.storedDoc ?? null;
 };
 const deleteManyHandler = async (ctx, args, schema, betterAuthSchema) => {
 	const triggerCtx = args.triggerCtx ?? ctx;
@@ -691,7 +754,24 @@ const createApi = (schema, getAuth, options) => {
 			where: v.optional(v.array(whereValidator(schema, tableName)))
 		});
 	})) : anyInputWithUpdate;
+	const incrementInput = v.object({
+		increment: v.record(v.string(), v.number()),
+		model: modelValidator,
+		set: v.optional(v.record(v.string(), v.any())),
+		where: v.optional(v.array(adapterWhereValidator))
+	});
 	return {
+		consumeOne: mutationBuilder({
+			args: { input: deleteInput },
+			handler: async (ctx, args) => {
+				const triggerCtx = ctx;
+				return consumeOneHandler(ctx, {
+					input: args.input,
+					tableTriggers: resolveTableTriggers(args.input.model, triggerCtx),
+					triggerCtx
+				}, schema, getBetterAuthSchema());
+			}
+		}),
 		create: mutationBuilder({
 			args: {
 				input: createInput,
@@ -763,6 +843,17 @@ const createApi = (schema, getAuth, options) => {
 				return getAuth(ctx).api.getLatestJwks();
 			}
 		}),
+		incrementOne: mutationBuilder({
+			args: { input: incrementInput },
+			handler: async (ctx, args) => {
+				const triggerCtx = ctx;
+				return incrementOneHandler(ctx, {
+					input: args.input,
+					tableTriggers: resolveTableTriggers(args.input.model, triggerCtx),
+					triggerCtx
+				}, schema, getBetterAuthSchema());
+			}
+		}),
 		rotateKeys: internalActionGeneric({
 			args: {},
 			handler: async (ctx) => {
@@ -800,7 +891,21 @@ const createApi = (schema, getAuth, options) => {
 
 //#endregion
 //#region src/auth/adapter.ts
-let didWarnExperimentalJoinsUnsupported = false;
+let didWarnJoinsUnsupported = false;
+const disableUnsupportedJoins = (options) => {
+	if (!options.advanced?.database?.joins) return;
+	options.advanced = {
+		...options.advanced,
+		database: {
+			...options.advanced.database,
+			joins: false
+		}
+	};
+	if (!didWarnJoinsUnsupported) {
+		didWarnJoinsUnsupported = true;
+		console.warn("[kitcn] Better Auth advanced.database.joins is not supported by the Convex adapter yet. Forcing advanced.database.joins = false.");
+	}
+};
 const handlePagination = async (next, { countOnly, limit, numItems } = {}) => {
 	const state = {
 		count: 0,
@@ -908,13 +1013,13 @@ const ORM_SCHEMA_OPTIONS = Symbol.for("kitcn: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-C3y6GLwQ.js");
+		const { createSchemaOrm } = await import("../create-schema-orm-HcJzGCxj.js");
 		return createSchemaOrm({
 			file,
 			tables
 		});
 	}
-	const { createSchema } = await import("../create-schema-DqhLA_UF.js");
+	const { createSchema } = await import("../create-schema-ojI-OH_9.js");
 	return createSchema({
 		file,
 		tables
@@ -928,16 +1033,7 @@ const httpAdapter = (ctx, { authFunctions, debugLogs, schema }) => {
 		},
 		adapter: ({ options }) => {
 			options.telemetry = { enabled: false };
-			if (options.experimental?.joins) {
-				options.experimental = {
-					...options.experimental,
-					joins: false
-				};
-				if (!didWarnExperimentalJoinsUnsupported) {
-					didWarnExperimentalJoinsUnsupported = true;
-					console.warn("[kitcn] Better Auth experimental.joins is not supported by the Convex adapter yet. Forcing experimental.joins = false.");
-				}
-			}
+			disableUnsupportedJoins(options);
 			const collectIdsForOrWhere = async (data) => {
 				return dedupeDocsById((await asyncMap(data.where, async (w) => handlePagination(async ({ paginationOpts }) => await ctx.runQuery(authFunctions.findMany, {
 					model: data.model,
@@ -961,6 +1057,13 @@ const httpAdapter = (ctx, { authFunctions, debugLogs, schema }) => {
 						where: parseWhere(data.where)
 					}), { countOnly: true })).count;
 				},
+				consumeOne: async (data) => {
+					if (!("runMutation" in ctx)) throw new Error("ctx is not a mutation ctx");
+					return await ctx.runMutation(authFunctions.consumeOne, { input: {
+						model: data.model,
+						where: parseWhere(data.where)
+					} });
+				},
 				create: async ({ data, model, select }) => {
 					if (!("runMutation" in ctx)) throw new Error("ctx is not a mutation ctx");
 					return await ctx.runMutation(authFunctions.create, {
@@ -1045,6 +1148,15 @@ const httpAdapter = (ctx, { authFunctions, debugLogs, schema }) => {
 						where: parsedWhere
 					});
 				},
+				incrementOne: async (data) => {
+					if (!("runMutation" in ctx)) throw new Error("ctx is not a mutation ctx");
+					const { set, ...input } = data;
+					return await ctx.runMutation(authFunctions.incrementOne, { input: {
+						...input,
+						...set === void 0 ? {} : { set },
+						where: parseWhere(data.where)
+					} });
+				},
 				update: async (data) => {
 					if (!("runMutation" in ctx)) throw new Error("ctx is not a mutation ctx");
 					if (!data.where?.length) return null;
@@ -1097,16 +1209,7 @@ const dbAdapter = (ctx, { authFunctions, debugLogs, getBetterAuthSchema, schema
 		},
 		adapter: ({ options }) => {
 			options.telemetry = { enabled: false };
-			if (options.experimental?.joins) {
-				options.experimental = {
-					...options.experimental,
-					joins: false
-				};
-				if (!didWarnExperimentalJoinsUnsupported) {
-					didWarnExperimentalJoinsUnsupported = true;
-					console.warn("[kitcn] Better Auth experimental.joins is not supported by the Convex adapter yet. Forcing experimental.joins = false.");
-				}
-			}
+			disableUnsupportedJoins(options);
 			const collectIdsForOrWhere = async (data) => {
 				return dedupeDocsById((await asyncMap(data.where, async (w) => handlePagination(async ({ paginationOpts }) => await findManyHandler(ctx, {
 					model: data.model,
@@ -1130,6 +1233,13 @@ const dbAdapter = (ctx, { authFunctions, debugLogs, getBetterAuthSchema, schema
 						where: parseWhere(data.where)
 					}, schema, betterAuthSchema), { countOnly: true })).count;
 				},
+				consumeOne: async (data) => {
+					if (!("runMutation" in ctx)) throw new Error("ctx is not a mutation ctx");
+					return await ctx.runMutation(authFunctions.consumeOne, { input: {
+						model: data.model,
+						where: parseWhere(data.where)
+					} });
+				},
 				create: async ({ data, model, select }) => {
 					if (!("runMutation" in ctx)) throw new Error("ctx is not a mutation ctx");
 					return await ctx.runMutation(authFunctions.create, {
@@ -1213,6 +1323,15 @@ const dbAdapter = (ctx, { authFunctions, debugLogs, getBetterAuthSchema, schema
 						where: parseWhere(data.where)
 					}, schema, betterAuthSchema);
 				},
+				incrementOne: async (data) => {
+					if (!("runMutation" in ctx)) throw new Error("ctx is not a mutation ctx");
+					const { set, ...input } = data;
+					return await ctx.runMutation(authFunctions.incrementOne, { input: {
+						...input,
+						...set === void 0 ? {} : { set },
+						where: parseWhere(data.where)
+					} });
+				},
 				update: async (data) => {
 					if (!data.where?.length) return null;
 					if (data.where.every((w) => (w.operator === "eq" || w.operator === void 0) && w.connector !== "OR")) {
@@ -1333,12 +1452,14 @@ const createLazyAuthProxy = (resolve) => new Proxy({}, { get(_target, prop, rece
 	return typeof value === "function" ? value.bind(auth) : value;
 } });
 const AUTH_RUNTIME_PROCEDURE_TYPES = {
+	consumeOne: "mutation",
 	create: "mutation",
 	deleteMany: "mutation",
 	deleteOne: "mutation",
 	findMany: "query",
 	findOne: "query",
 	getLatestJwks: "action",
+	incrementOne: "mutation",
 	rotateKeys: "action",
 	updateMany: "mutation",
 	updateOne: "mutation"
@@ -1347,11 +1468,13 @@ const createGeneratedInternalFunctionReference = (name) => createGeneratedFuncti
 const resolveAuthFunctions = (internal, moduleName) => {
 	const existing = internal?.[moduleName] ?? {};
 	return {
+		consumeOne: existing.consumeOne ?? createGeneratedInternalFunctionReference(`${moduleName}:consumeOne`),
 		create: existing.create ?? createGeneratedInternalFunctionReference(`${moduleName}:create`),
 		deleteMany: existing.deleteMany ?? createGeneratedInternalFunctionReference(`${moduleName}:deleteMany`),
 		deleteOne: existing.deleteOne ?? createGeneratedInternalFunctionReference(`${moduleName}:deleteOne`),
 		findMany: existing.findMany ?? createGeneratedInternalFunctionReference(`${moduleName}:findMany`),
 		findOne: existing.findOne ?? createGeneratedInternalFunctionReference(`${moduleName}:findOne`),
+		incrementOne: existing.incrementOne ?? createGeneratedInternalFunctionReference(`${moduleName}:incrementOne`),
 		updateMany: existing.updateMany ?? createGeneratedInternalFunctionReference(`${moduleName}:updateMany`),
 		updateOne: existing.updateOne ?? createGeneratedInternalFunctionReference(`${moduleName}:updateOne`)
 	};
@@ -1486,4 +1609,4 @@ const getHeaders = async (ctx, session) => {
 };
 
 //#endregion
-export { adapterArgsValidator, adapterConfig, adapterWhereValidator, checkUniqueFields, convex, createApi, createAuthRuntime, createClient, createDisabledAuthRuntime, createHandler, dbAdapter, defineAuth, deleteManyHandler, deleteOneHandler, findManyHandler, findOneHandler, getAuthUserId, getAuthUserIdentity, getGeneratedAuthDisabledReason, getHeaders, getInvalidAuthDefinitionExportReason, getSession, getSessionNetworkSignals, handlePagination, hasUniqueFields, httpAdapter, listOne, paginate, resolveGeneratedAuthDefinition, selectFields, updateManyHandler, updateOneHandler };
+export { adapterArgsValidator, adapterConfig, adapterWhereValidator, checkUniqueFields, consumeOneHandler, convex, createApi, createAuthRuntime, createClient, createDisabledAuthRuntime, createHandler, dbAdapter, defineAuth, deleteManyHandler, deleteOneHandler, findManyHandler, findOneHandler, getAuthUserId, getAuthUserIdentity, getGeneratedAuthDisabledReason, getHeaders, getInvalidAuthDefinitionExportReason, getSession, getSessionNetworkSignals, handlePagination, hasUniqueFields, httpAdapter, incrementOneHandler, listOne, paginate, resolveGeneratedAuthDefinition, selectFields, updateManyHandler, updateOneHandler };

package/dist/auth/nextjs/index.js

@@ -1,4 +1,4 @@
-import { t as getToken } from "../../token-DcV_0fkF.js";
+import { t as getToken } from "../../token-B0NKKxqP.js";
 import { n as defaultIsUnauthorized } from "../../error-CMLeCadS.js";
 import { t as createCallerFactory } from "../../caller-factory-D4pz5GcZ.js";
 

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

@@ -1,4 +1,4 @@
-import { t as getToken } from "../../../token-DcV_0fkF.js";
+import { t as getToken } from "../../../token-B0NKKxqP.js";
 import { n as defaultIsUnauthorized } from "../../../error-CMLeCadS.js";
 import { t as createCallerFactory } from "../../../caller-factory-D4pz5GcZ.js";
 import { stripIndent } from "common-tags";

package/dist/{capabilities-CLCYgRdY.d.ts → capabilities-DkfnnNp7.d.ts}

@@ -2896,6 +2896,24 @@ declare class GelRelationalQuery<TSchema extends TablesRelationalConfig, TTableC
   rls?: RlsContext | undefined, relationLoading?: {
     concurrency?: number;
   } | undefined, vectorSearchProvider?: VectorSearchProvider | undefined, configuredIndex?: PredicateWhereIndexConfig<TTableConfig> | undefined, countIndexReadiness?: Map<string, Promise<void>>);
+  /**
+   * Relation counts for a document the caller is already holding.
+   *
+   * `returning({ _count })` runs inside the mutation that just wrote the row,
+   * so resolving it through `execute()` spends one `db.get` re-reading a
+   * document that is already in the transaction's write set. The count engine
+   * only ever reads the counted edges' source fields off its parent, and the
+   * caller's document carries all of them, so the root read is pure waste.
+   * Everything else `execute()` would have done to that row — the select-plan
+   * assertion and the RLS select filter — still runs here.
+   *
+   * Reached through the static accessor below rather than exposed on the instance:
+   * `GelRelationalQuery` is the declared return type of the public query
+   * builders, so an instance method would land in every user's autocomplete.
+   */
+  private _countRelationsForHeldRow;
+  /** @internal Accessor for `returning({ _count })`; see `returning-count.ts`. */
+  static countRelationsForHeldRow(query: GelRelationalQuery<any, any, any>, row: Record<string, unknown>, countSelection: Record<string, unknown>): Promise<Record<string, number>>;
   /**
    * The aggregate-index runtime, registered at `createOrm()`.
    *

package/dist/cli.mjs

@@ -2321,8 +2321,8 @@ const SUPPORTED_CONCAVE_CLI_VERSION = "0.0.1-alpha.14";
 const SUPPORTED_CONVEX_VERSION = "1.44.0";
 const SUPPORTED_CONVEX_MIN_VERSION = "1.42";
 const SUPPORTED_CONVEX_MIN_TYPE_VERSION = "1.42.3";
-const SUPPORTED_BETTER_AUTH_VERSION = "1.6.18";
-const SUPPORTED_BETTER_AUTH_MIN_VERSION = "1.6.11";
+const SUPPORTED_BETTER_AUTH_VERSION = "1.7.1";
+const SUPPORTED_BETTER_AUTH_MIN_VERSION = "1.7.0";
 const SUPPORTED_HONO_VERSION = "4.12.9";
 const SUPPORTED_OPENTELEMETRY_API_VERSION = "1.9.0";
 const SUPPORTED_TANSTACK_REACT_QUERY_VERSION = "5.95.2";
@@ -2412,6 +2412,7 @@ const SUPPORTED_DEPENDENCY_VERSIONS = {
 };
 const PINNED_CONVEX_INSTALL_SPEC = `convex@${SUPPORTED_DEPENDENCY_VERSIONS.convex.exact}`;
 const BETTER_AUTH_INSTALL_SPEC = `better-auth@${SUPPORTED_DEPENDENCY_VERSIONS.betterAuth.exact}`;
+const BETTER_AUTH_EXPO_INSTALL_SPEC = `@better-auth/expo@${SUPPORTED_DEPENDENCY_VERSIONS.betterAuth.exact}`;
 const PINNED_HONO_INSTALL_SPEC = `hono@${SUPPORTED_DEPENDENCY_VERSIONS.hono.exact}`;
 const OPENTELEMETRY_API_INSTALL_SPEC = `@opentelemetry/api@${SUPPORTED_DEPENDENCY_VERSIONS.opentelemetryApi.exact}`;
 const PINNED_TANSTACK_REACT_QUERY_INSTALL_SPEC = `@tanstack/react-query@${SUPPORTED_DEPENDENCY_VERSIONS.tanstackReactQuery.exact}`;
@@ -5916,8 +5917,20 @@ const mergedIndexFields$1 = (tables) => Object.fromEntries(Object.entries(tables
 		if (resolved.length === index.length) indexes.push(resolved);
 		return indexes;
 	}, []) || [];
-	const specialFieldIndexes = Object.keys(specialFields$1(tables)[key] || {}).filter((index) => !manualIndexes.some((m) => Array.isArray(m) ? m[0] === index : m === index));
-	return [key, manualIndexes.concat(specialFieldIndexes)];
+	const declaredIndexes = (table.indexes ?? []).reduce((indexes, index) => {
+		const resolved = index.fields.map((fieldKey) => resolveIndexField(fieldKey)).filter((fieldName) => fieldName !== null);
+		if (resolved.length === index.fields.length) indexes.push(resolved.length === 1 ? resolved[0] : resolved);
+		return indexes;
+	}, []);
+	const explicitIndexes = manualIndexes.concat(declaredIndexes);
+	const specialFieldIndexes = Object.keys(specialFields$1(tables)[key] || {}).filter((index) => !explicitIndexes.some((m) => Array.isArray(m) ? m[0] === index : m === index));
+	const seen = /* @__PURE__ */ new Set();
+	return [key, explicitIndexes.concat(specialFieldIndexes).filter((index) => {
+		const key = (Array.isArray(index) ? index : [index]).join("\0");
+		if (seen.has(key)) return false;
+		seen.add(key);
+		return true;
+	})];
 }));
 const createSchema = async ({ exportName = "tables", file, regenerateCommand, tables }) => {
 	const path = await import(Buffer.from("cGF0aA==", "base64").toString());
@@ -5948,7 +5961,7 @@ export const ${exportName} = {
 			}[type];
 		}
 		const indexes = mergedIndexFields$1(tables)[tableKey]?.map((index) => {
-			const indexArray = Array.isArray(index) ? index.sort() : [index];
+			const indexArray = Array.isArray(index) ? index : [index];
 			return `.index("${indexArray.join("_")}", ${JSON.stringify(indexArray)})`;
 		}) || [];
 		const schema = `${modelName}: defineTable({
@@ -5999,8 +6012,20 @@ const mergedIndexFields = (tables) => Object.fromEntries(Object.entries(tables).
 		if (resolved.length === index.length) indexes.push(resolved);
 		return indexes;
 	}, []) || [];
-	const specialFieldIndexes = Object.entries(tableSpecialFields).filter(([, fieldMeta]) => fieldMeta.unique !== true).map(([fieldName]) => fieldName).filter((index) => !manualIndexes.some((m) => Array.isArray(m) ? m[0] === index : m === index));
-	return [key, manualIndexes.concat(specialFieldIndexes)];
+	const declaredIndexes = (table.indexes ?? []).reduce((indexes, index) => {
+		const resolved = index.fields.map((fieldKey) => resolveIndexField(fieldKey)).filter((fieldName) => fieldName !== null);
+		if (resolved.length === index.fields.length) indexes.push(resolved.length === 1 ? resolved[0] : resolved);
+		return indexes;
+	}, []);
+	const explicitIndexes = manualIndexes.concat(declaredIndexes);
+	const specialFieldIndexes = Object.entries(tableSpecialFields).filter(([, fieldMeta]) => fieldMeta.unique !== true).map(([fieldName]) => fieldName).filter((index) => !explicitIndexes.some((m) => Array.isArray(m) ? m[0] === index : m === index));
+	const seen = /* @__PURE__ */ new Set();
+	return [key, explicitIndexes.concat(specialFieldIndexes).filter((index) => {
+		const key = (Array.isArray(index) ? index : [index]).join("\0");
+		if (seen.has(key)) return false;
+		seen.add(key);
+		return true;
+	})];
 }));
 const VALID_IDENTIFIER_REGEX = /^[$A-Z_][0-9A-Z_$]*$/i;
 const LEADING_DIGIT_REGEX = /^[0-9]/;
@@ -6152,11 +6177,19 @@ const renderSchemaOrmFile = async ({ extensionKey, exportName, file, mode, regen
 			return `    ${key}: ${expression},`;
 		});
 		const indexes = mergedIndexFields(tables)[entry.key]?.map((indexSpec) => {
-			const indexArray = Array.isArray(indexSpec) ? [...indexSpec].sort() : [indexSpec];
+			const indexArray = Array.isArray(indexSpec) ? indexSpec : [indexSpec];
 			const indexName = indexArray.join("_");
-			state.ormImports.add("index");
+			const indexFactory = (entry.table.indexes ?? []).some((index) => {
+				if (!index.unique) return false;
+				const resolvedFields = index.fields.map((fieldKey) => {
+					const field = entry.table.fields[fieldKey];
+					return field ? field.fieldName ?? fieldKey : null;
+				}).filter((fieldName) => fieldName !== null);
+				return resolvedFields.length === index.fields.length && resolvedFields.join("\0") === indexArray.join("\0");
+			}) ? "uniqueIndex" : "index";
+			state.ormImports.add(indexFactory);
 			const fieldsCall = indexArray.map((fieldName) => renderPropertyAccess(entry.varName, fieldName)).join(", ");
-			return `index(${JSON.stringify(indexName)}).on(${fieldsCall})`;
+			return `${indexFactory}(${JSON.stringify(indexName)}).on(${fieldsCall})`;
 		}) || [];
 		const extraConfig = indexes.length > 0 ? `,\n  (${entry.varName}) => [\n    ${indexes.join(",\n    ")},\n  ]` : "";
 		tableBlocks.push(`export const ${entry.varName} = convexTable(\n  ${JSON.stringify(entry.modelName)},\n  {\n${fieldLines.join("\n")}\n  }${extraConfig}\n);`);
@@ -6430,7 +6463,6 @@ const AUTH_ENV_FIELDS = [
 		schema: "z.string().optional()"
 	}
 ];
-const BETTER_AUTH_EXPO_INSTALL_SPEC = "@better-auth/expo@1.6.18";
 const EXPO_SECURE_STORE_INSTALL_SPEC = "expo-secure-store@~55.0.8";
 const EXPO_NETWORK_INSTALL_SPEC = "expo-network@~55.0.8";
 const AUTH_FILES = [