kitcn 0.32.2 → 0.33.0

package/dist/orm/aggregate-index/index.js

@@ -1,77 +1,8 @@
 import { t as DirectAggregate } from "../../runtime-B-8HKSIE.js";
 import { n as Columns } from "../../symbols-DDNAddkd.js";
 import { d as INTERNAL_CREATION_TIME_FIELD, f as PUBLIC_CREATED_AT_FIELD, m as usesSystemCreatedAtAlias } from "../../index-utils-DvK7P6Q1.js";
-import { Q as normalizeTemporalComparableValue, a as AGGREGATE_STATE_TABLE, c as getAggregateIndexDefinitions, d as COUNT_ERROR, ht as mapWithConcurrency, i as AGGREGATE_RANK_TREE_TABLE, l as getRankIndexDefinitions, m as createError, n as AGGREGATE_EXTREMA_TABLE, r as AGGREGATE_MEMBER_TABLE, s as rankAggregateName, t as AGGREGATE_BUCKET_TABLE, u as AGGREGATE_ERROR } from "../../schema-Bh7AmJwY.js";
+import { C as createError, _ as createOrmTransactionMemo, a as AGGREGATE_STATE_TABLE, b as COUNT_ERROR, c as getAggregateIndexDefinitions, d as flushOrmWriteBatch, f as isOrmWriteBatchOpen, h as createOrmWriteMemo, i as AGGREGATE_RANK_TREE_TABLE, l as getRankIndexDefinitions, n as AGGREGATE_EXTREMA_TABLE, r as AGGREGATE_MEMBER_TABLE, s as rankAggregateName, st as normalizeTemporalComparableValue, t as AGGREGATE_BUCKET_TABLE, u as enqueueOrmWriteBatch, wt as mapWithConcurrency, y as AGGREGATE_ERROR } from "../../schema-BF4P0ZjS.js";
 
-//#region src/orm/transaction-cache.ts
-/**
-* Per-transaction memo storage for the ORM.
-*
-* The ORM already has isolate-, execution-, statement- and row-scoped memos.
-* The lifetime it lacked is the one a hook needs: `prependWriteBarrier` is
-* built inside `createOrmDbLifecycle`, which `createOrm` runs at module scope,
-* so a flag in that closure lives as long as the isolate and would leak an
-* answer from one transaction into the next.
-*
-* Deliberately dependency-free, for the same reason as `write-fanout`:
-* `aggregate-index/runtime` is contractually unreachable from `orm/index`
-* (`import-graph.test.ts`), so importing `lifecycle` here to read one symbol
-* would drag the trigger runtime into the aggregate entry's bundle.
-* `Symbol.for` is registry-based, so re-declaring the key resolves to the same
-* symbol `lifecycle` installs.
-*/
-const ORMLIFECYCLE_INNER_DB = Symbol.for("kitcn:OrmLifecycleInnerDB");
-/**
-* The object whose identity stands in for "this transaction".
-*
-* Convex builds `ctx.db` fresh on every UDF invocation, so it can never be
-* shared by two transactions. `getOrmLifecycleInnerDb` cannot be used on its
-* own: the lifecycle refuses to wrap readers and returns a no-op wrapper for
-* schemas with no triggers and no aggregate indexes, so the inner-db symbol is
-* absent for every query and for most mutations. Resolving through it when it
-* is there, and falling back to the db itself when it is not, converges on the
-* same raw writer from the main scope, `skipRules`, `withoutTriggers` and the
-* scheduled workers.
-*
-* A nested `ctx.runMutation` shares the transaction but gets its own `ctx.db`,
-* so it starts a fresh memo. That direction only costs extra reads.
-*/
-const resolveTransactionAnchor = (db) => {
-	if (typeof db !== "object" || db === null) return;
-	const inner = db[ORMLIFECYCLE_INNER_DB];
-	return typeof inner === "object" && inner !== null ? inner : db;
-};
-/**
-* One memo namespace with transaction lifetime.
-*
-* The store is a `WeakMap` keyed on the anchor rather than a slot on the db,
-* because `createDatabase` promises not to mutate the `ctx.db` it was handed.
-* Entries die with the transaction's db object.
-*
-* Callers own staleness: only memoize a fact that nothing inside the
-* transaction can invalidate.
-*/
-const createOrmTransactionMemo = () => {
-	const byTransaction = /* @__PURE__ */ new WeakMap();
-	return {
-		get(db, key) {
-			const anchor = resolveTransactionAnchor(db);
-			return anchor ? byTransaction.get(anchor)?.get(key) : void 0;
-		},
-		set(db, key, value) {
-			const anchor = resolveTransactionAnchor(db);
-			if (!anchor) return;
-			const existing = byTransaction.get(anchor);
-			if (existing) {
-				existing.set(key, value);
-				return;
-			}
-			byTransaction.set(anchor, new Map([[key, value]]));
-		}
-	};
-};
-
-//#endregion
 //#region src/orm/aggregate-index/runtime.ts
 const UNDEFINED_SENTINEL = "__kitcnUndefined";
 const FLOAT64_SIGN_BIT = 1n << 63n;
@@ -801,6 +732,54 @@ const listBucketsByHash = async (db, tableName, indexName, keyHash) => await db.
 const getBucketByKey = async (db, tableName, indexName, keyParts) => {
 	return (await listBucketsByHash(db, tableName, indexName, serializeCountKeyParts(keyParts))).find((bucket) => deepEquals(bucket.keyParts, keyParts)) ?? null;
 };
+const bucketRowByKey = createOrmWriteMemo();
+const memberRowByDoc = createOrmWriteMemo();
+const aggregateRowMemoKey = (...parts) => parts.join("\0");
+const bucketMemoKey = (tableName, indexName, keyHash) => aggregateRowMemoKey(tableName, indexName, keyHash);
+/**
+* `kind` leads, because the member table stores a metric and a rank row for the
+* same document under index names the schema lets collide.
+*/
+const memberMemoKey = (tableName, indexName, docId) => aggregateRowMemoKey(AGGREGATE_STATE_KIND_METRIC, tableName, indexName, docId);
+/**
+* A stored row is the backend's object, and Convex's test backend hands out the
+* document it holds rather than a copy. One shallow clone of the row and of the
+* containers it owns makes the memo entry the memo's own, so an entry means the
+* same thing whatever the backend does with the document afterwards.
+*/
+const cloneStoredRow = (row) => {
+	const clone = { ...row };
+	for (const [field, value] of Object.entries(clone)) {
+		if (Array.isArray(value)) {
+			clone[field] = [...value];
+			continue;
+		}
+		if (typeof value === "object" && value !== null) clone[field] = { ...value };
+	}
+	return clone;
+};
+const rememberBucket = (db, memoKey, row) => {
+	bucketRowByKey.set(db, memoKey, { row: row === null ? null : cloneStoredRow(row) });
+};
+const rememberMember = (db, memoKey, row) => {
+	memberRowByDoc.set(db, memoKey, { row: row === null ? null : cloneStoredRow(row) });
+};
+/** `getBucketByKey` within the current write segment. Write path only. */
+const readBucketForWrite = async (db, tableName, indexName, keyParts, memoKey) => {
+	const memoized = bucketRowByKey.get(db, memoKey);
+	if (memoized) return memoized.row;
+	const bucket = await getBucketByKey(db, tableName, indexName, keyParts);
+	rememberBucket(db, memoKey, bucket);
+	return bucket;
+};
+/** `getMemberByDoc` within the current write segment. Write path only. */
+const readMemberForWrite = async (db, tableName, indexName, docId, memoKey) => {
+	const memoized = memberRowByDoc.get(db, memoKey);
+	if (memoized) return memoized.row;
+	const member = await getMemberByDoc(db, tableName, indexName, docId);
+	rememberMember(db, memoKey, member);
+	return member;
+};
 const listBucketsByHashPrefix = async (db, tableName, indexName, scan, limit) => await db.query(AGGREGATE_BUCKET_TABLE).withIndex("by_table_index_hash", (q) => {
 	const scoped = q.eq("tableKey", tableName).eq("indexName", indexName);
 	return (scan.after === void 0 ? scoped.gte("keyHash", scan.start) : scoped.gt("keyHash", scan.after)).lt("keyHash", scan.end);
@@ -814,34 +793,45 @@ const takeBucketsForIndex = async (db, tableName, indexName, limit) => await db.
 const takeExtremaForIndex = async (db, tableName, indexName, limit) => await db.query(AGGREGATE_EXTREMA_TABLE).withIndex("by_table_index", (q) => q.eq("tableKey", tableName).eq("indexName", indexName)).take(limit);
 const applyBucketDelta = async (db, tableName, indexName, keyParts, deltaCount, deltaSums, deltaNonNullCounts) => {
 	if (deltaCount === 0 && Object.keys(deltaSums).length === 0 && Object.keys(deltaNonNullCounts).length === 0) return;
-	const existing = await getBucketByKey(db, tableName, indexName, keyParts);
+	const keyHash = serializeCountKeyParts(keyParts);
+	const memoKey = bucketMemoKey(tableName, indexName, keyHash);
+	const existing = await readBucketForWrite(db, tableName, indexName, keyParts, memoKey);
 	const now = Date.now();
 	if (!existing) {
 		if (deltaCount < 0) return;
-		await db.insert(AGGREGATE_BUCKET_TABLE, {
+		const inserted = {
 			tableKey: tableName,
 			indexName,
-			keyHash: serializeCountKeyParts(keyParts),
+			keyHash,
 			keyParts,
 			count: deltaCount,
 			sumValues: deltaSums,
 			nonNullCountValues: deltaNonNullCounts,
 			updatedAt: now
+		};
+		const id = await db.insert(AGGREGATE_BUCKET_TABLE, inserted);
+		rememberBucket(db, memoKey, {
+			...inserted,
+			_id: id
 		});
 		return;
 	}
 	const nextCount = existing.count + deltaCount;
 	if (nextCount <= 0) {
 		await db.delete(AGGREGATE_BUCKET_TABLE, existing._id);
+		rememberBucket(db, memoKey, null);
 		return;
 	}
-	const nextSumValues = mergeSumValues(normalizeSumValues(existing.sumValues), deltaSums);
-	const nextNonNullCountValues = mergeCountValues(normalizeNonNullCountValues(existing.nonNullCountValues), deltaNonNullCounts);
-	await db.patch(AGGREGATE_BUCKET_TABLE, existing._id, {
+	const patch = {
 		count: nextCount,
-		sumValues: nextSumValues,
-		nonNullCountValues: nextNonNullCountValues,
+		sumValues: mergeSumValues(normalizeSumValues(existing.sumValues), deltaSums),
+		nonNullCountValues: mergeCountValues(normalizeNonNullCountValues(existing.nonNullCountValues), deltaNonNullCounts),
 		updatedAt: now
+	};
+	await db.patch(AGGREGATE_BUCKET_TABLE, existing._id, patch);
+	rememberBucket(db, memoKey, {
+		...existing,
+		...patch
 	});
 };
 const encodeNumberSortKey = (value) => {
@@ -926,6 +916,7 @@ const matchesRangePlanBucket = (options) => {
 	return true;
 };
 const readPlanBuckets = async (db, plan) => {
+	await flushOrmWriteBatch(db);
 	if (!plan.rangeConstraint) return (await mapWithConcurrency(plan.keyCandidates ?? buildCandidateKeys(plan.indexFields, plan.fieldValues), AGGREGATE_BUCKET_READ_CONCURRENCY, (keyParts) => getBucketByKey(db, plan.tableName, plan.indexName, keyParts))).filter((bucket) => bucket !== null);
 	const prefixCandidates = buildCandidateKeys(plan.rangeConstraint.prefixFields, plan.fieldValues);
 	const rangeFieldIndex = plan.indexFields.indexOf(plan.rangeConstraint.fieldName);
@@ -992,6 +983,7 @@ const getPlanBucketCacheKey = (plan) => serializeStable({
 	postFieldValues: sortFieldValueRecord(plan.postFieldValues)
 });
 const readPlanBucketsWithCache = async (db, plan, bucketCache) => {
+	await flushOrmWriteBatch(db);
 	if (!bucketCache) return await readPlanBuckets(db, plan);
 	const cacheKey = getPlanBucketCacheKey(plan);
 	const existing = bucketCache.get(cacheKey);
@@ -1053,6 +1045,7 @@ const readKeyExtrema = async (db, params) => {
 };
 const readExtremaFromBuckets = async (db, plan, bucketCache) => {
 	if (plan.metric.kind !== "min" && plan.metric.kind !== "max") throw new Error("readExtremaFromBuckets() requires a min/max aggregate plan.");
+	await flushOrmWriteBatch(db);
 	let selected = null;
 	const buckets = await readPlanBucketsWithCache(db, plan, bucketCache);
 	const metric = plan.metric;
@@ -1151,11 +1144,13 @@ const computeMembershipDelta = (existing, params) => {
 	const { tableName, indexName, docId, keyParts, metricValues } = params;
 	if (!keyParts || !metricValues) {
 		if (!existing) return {
+			docId,
 			buckets: [],
 			extrema: [],
 			member: { kind: "none" }
 		};
 		return {
+			docId,
 			buckets: [{
 				keyHash: serializeCountKeyParts(existing.keyParts),
 				keyParts: existing.keyParts,
@@ -1177,6 +1172,7 @@ const computeMembershipDelta = (existing, params) => {
 	const normalizedNextNonNullCountValues = normalizeNonNullCountValues(metricValues.nonNullCountValues);
 	const normalizedNextExtremaValues = normalizeExtremaValues(metricValues.extremaValues);
 	if (existing && existing.keyHash === keyHash && deepEquals(existing.keyParts, normalizedKeyParts) && deepEquals(normalizeSumValues(existing.sumValues), normalizedNextSumValues) && deepEquals(normalizeNonNullCountValues(existing.nonNullCountValues), normalizedNextNonNullCountValues) && deepEquals(normalizeExtremaValues(existing.extremaValues), normalizedNextExtremaValues)) return {
+		docId,
 		buckets: [],
 		extrema: [],
 		member: { kind: "none" }
@@ -1210,14 +1206,28 @@ const computeMembershipDelta = (existing, params) => {
 		extremaValues: normalizedNextExtremaValues,
 		updatedAt: now
 	};
+	if (existing) {
+		const { _id, ...priorFields } = existing;
+		return {
+			docId,
+			buckets,
+			extrema,
+			member: {
+				kind: "patch",
+				id: _id,
+				doc: memberFields,
+				post: {
+					...priorFields,
+					...memberFields
+				}
+			}
+		};
+	}
 	return {
+		docId,
 		buckets,
 		extrema,
-		member: existing ? {
-			kind: "patch",
-			id: existing._id,
-			doc: memberFields
-		} : {
+		member: {
 			kind: "insert",
 			doc: {
 				...memberFields,
@@ -1229,14 +1239,14 @@ const computeMembershipDelta = (existing, params) => {
 	};
 };
 const computeAggregateMembershipDelta = async (db, params) => {
-	return computeMembershipDelta(await getMemberByDoc(db, params.tableName, params.indexName, params.docId), params);
+	return computeMembershipDelta(await readMemberForWrite(db, params.tableName, params.indexName, params.docId, memberMemoKey(params.tableName, params.indexName, params.docId)), params);
 };
 /**
-* Write half of aggregate reconciliation. Folds bucket deltas by key tuple and
-* extrema deltas by (keyHash, field, value) so each storage document is read and
-* written once regardless of how many source documents contributed to it.
+* Folds bucket deltas by key tuple and extrema deltas by
+* (keyHash, field, value), so each storage document is read and written once
+* regardless of how many source documents contributed to it.
 */
-const flushAggregateMembershipDeltas = async (db, tableName, indexName, deltas) => {
+const foldStorageDeltas = (deltas) => {
 	const bucketDeltas = /* @__PURE__ */ new Map();
 	const extremaDeltas = /* @__PURE__ */ new Map();
 	for (const delta of deltas) {
@@ -1270,28 +1280,139 @@ const flushAggregateMembershipDeltas = async (db, tableName, indexName, deltas)
 			current.delta += entry.delta;
 		}
 	}
-	for (const bucket of bucketDeltas.values()) await applyBucketDelta(db, tableName, indexName, bucket.keyParts, bucket.deltaCount, bucket.deltaSums, bucket.deltaNonNullCounts);
-	for (const entry of extremaDeltas.values()) await applyExtremaDelta(db, tableName, indexName, entry.keyHash, entry.fieldName, entry.value, entry.delta);
+	return {
+		buckets: bucketDeltas,
+		extrema: extremaDeltas
+	};
+};
+/** Applies a fold to the bucket and extrema documents it names. */
+const applyFoldedStorageDeltas = async (db, tableName, indexName, folded) => {
+	for (const bucket of folded.buckets.values()) await applyBucketDelta(db, tableName, indexName, bucket.keyParts, bucket.deltaCount, bucket.deltaSums, bucket.deltaNonNullCounts);
+	for (const entry of folded.extrema.values()) await applyExtremaDelta(db, tableName, indexName, entry.keyHash, entry.fieldName, entry.value, entry.delta);
+};
+/**
+* One member row per source document. Nothing folds here — the member table
+* stores the per-document post-image the next reconciliation of that document
+* subtracts, so it is written eagerly even when the bucket write is deferred.
+*/
+const applyMemberWrites = async (db, tableName, indexName, deltas) => {
 	for (const delta of deltas) {
 		const member = delta.member;
+		if (member.kind === "none") continue;
+		const memoKey = memberMemoKey(tableName, indexName, delta.docId);
 		if (member.kind === "delete") {
 			await db.delete(AGGREGATE_MEMBER_TABLE, member.id);
+			rememberMember(db, memoKey, null);
 			continue;
 		}
 		if (member.kind === "patch") {
 			await db.patch(AGGREGATE_MEMBER_TABLE, member.id, member.doc);
+			rememberMember(db, memoKey, {
+				...member.post,
+				_id: member.id
+			});
 			continue;
 		}
-		if (member.kind === "insert") await db.insert(AGGREGATE_MEMBER_TABLE, member.doc);
+		const id = await db.insert(AGGREGATE_MEMBER_TABLE, member.doc);
+		rememberMember(db, memoKey, {
+			...member.doc,
+			_id: id
+		});
 	}
 };
 /**
-* Single-document reconciliation. Flushes eagerly so user code reading an
-* aggregate later in the same mutation sees its own writes.
+* Write half of aggregate reconciliation. Folds bucket deltas by key tuple and
+* extrema deltas by (keyHash, field, value) so each storage document is read and
+* written once regardless of how many source documents contributed to it.
+*/
+const flushAggregateMembershipDeltas = async (db, tableName, indexName, deltas) => {
+	await applyFoldedStorageDeltas(db, tableName, indexName, foldStorageDeltas(deltas));
+	await applyMemberWrites(db, tableName, indexName, deltas);
+};
+const PENDING_STORAGE_WRITES_KEY = "aggregateStorageWrites";
+/**
+* Bucket and extrema deltas the open write batch has not applied yet, keyed by
+* the index that owns them.
+*
+* Reconciliation runs once per document, so there is nothing for the fold to
+* collapse inside a single call. Holding the deltas until the statement ends is
+* what gives the fold something to fold: a 40-row statement over one key tuple
+* becomes one bucket read and one bucket write instead of forty of each.
+*/
+const pendingStorageWrites = createOrmTransactionMemo();
+/**
+* Grouped per index, never flat. `serializeCountKeyParts` is `JSON.stringify` of
+* the key tuple alone, so two indexes on different single string fields both
+* holding `"a"` produce the identical `keyHash`; a flat fold would write one
+* index's counts onto the other's bucket.
+*/
+const pendingIndexKey = (tableName, indexName) => `${tableName}\u0000${indexName}`;
+const getPendingStorageWrites = (db) => {
+	const existing = pendingStorageWrites.get(db, PENDING_STORAGE_WRITES_KEY);
+	if (existing) return existing;
+	const created = {
+		byIndex: /* @__PURE__ */ new Map(),
+		flush: async () => {
+			for (;;) {
+				const next = created.byIndex.entries().next();
+				if (next.done) return;
+				const [key, entry] = next.value;
+				created.byIndex.delete(key);
+				await applyFoldedStorageDeltas(db, entry.tableName, entry.indexName, foldStorageDeltas(entry.deltas));
+			}
+		}
+	};
+	pendingStorageWrites.set(db, PENDING_STORAGE_WRITES_KEY, created);
+	return created;
+};
+const isEmptyMembershipDelta = (delta) => delta.buckets.length === 0 && delta.extrema.length === 0 && delta.member.kind === "none";
+/**
+* Single-document reconciliation.
+*
+* The bucket and extrema writes always go on the transaction's write queue,
+* never straight to storage: `applyBucketDelta` writes an absolute count
+* computed from the row it just read, so two of them interleaving would be a
+* lost update, and routing every one of them through a single drain is what
+* keeps them serialized. Inside a mutation statement the queue is held to the
+* end of the statement, which is what lets the fold collapse a page of
+* documents into one write per key tuple; outside one it is drained
+* immediately, so a raw `ctx.db` write behaves exactly as it did before.
+*
+* The member row is written per document either way, because it is the
+* pre-image the next reconciliation of this document subtracts. Outside a
+* statement it is still written after the bucket, preserving the previous
+* order; inside one it necessarily lands first, and a flush that throws
+* part-way leaves the index needing a backfill — which a partially applied fold
+* would anyway, whichever order the two halves ran in.
+*
+* Deferral is invisible to aggregate readers: every bucket- and extrema-backed
+* read path drains the queue first, so user code reading a count later in the
+* same mutation — including from a trigger firing mid-statement — still sees
+* its own writes.
 */
 const reconcileAggregateMembership = async (db, params) => {
+	const { tableName, indexName } = params;
 	const delta = await computeAggregateMembershipDelta(db, params);
-	await flushAggregateMembershipDeltas(db, params.tableName, params.indexName, [delta]);
+	if (isEmptyMembershipDelta(delta)) return;
+	const pending = getPendingStorageWrites(db);
+	if (!enqueueOrmWriteBatch(db, pending.flush)) {
+		await flushAggregateMembershipDeltas(db, tableName, indexName, [delta]);
+		return;
+	}
+	const key = pendingIndexKey(tableName, indexName);
+	const entry = pending.byIndex.get(key);
+	if (entry) entry.deltas.push(delta);
+	else pending.byIndex.set(key, {
+		tableName,
+		indexName,
+		deltas: [delta]
+	});
+	if (isOrmWriteBatchOpen(db)) {
+		await applyMemberWrites(db, tableName, indexName, [delta]);
+		return;
+	}
+	await flushOrmWriteBatch(db);
+	await applyMemberWrites(db, tableName, indexName, [delta]);
 };
 const computeCountKeyParts = (doc, fields) => fields.map((field) => normalizeUndefined(doc[field]));
 const applyAggregateIndexesForChange = async (db, tableName, aggregateIndexes, change) => {
@@ -1361,6 +1482,7 @@ const assertAggregateIndexesWritable = async (db, tableName, metricIndexNames, r
 * writing anything.
 */
 const isIndexStateDrained = async (db, kind, tableName, indexName) => {
+	await flushOrmWriteBatch(db);
 	if (await db.query(AGGREGATE_MEMBER_TABLE).withIndex("by_kind_table_index", (q) => q.eq("kind", kind).eq("tableKey", tableName).eq("indexName", indexName)).first()) return false;
 	if (kind === AGGREGATE_STATE_KIND_RANK) return await db.query(AGGREGATE_RANK_TREE_TABLE).withIndex("by_aggregate_name", (q) => q.eq("aggregateName", rankAggregateName(tableName, indexName))).first() === null;
 	const [bucket, extrema] = await Promise.all([db.query(AGGREGATE_BUCKET_TABLE).withIndex("by_table_index", (q) => q.eq("tableKey", tableName).eq("indexName", indexName)).first(), db.query(AGGREGATE_EXTREMA_TABLE).withIndex("by_table_index", (q) => q.eq("tableKey", tableName).eq("indexName", indexName)).first()]);
@@ -1423,9 +1545,13 @@ const setCountStateError = async (db, tableName, indexName, error, kind = AGGREG
 * CLEARING write barrier keeps concurrent writers out of the index.
 */
 const clearCountIndexChunk = async (db, tableName, indexName, batchSize) => {
+	await flushOrmWriteBatch(db);
 	const members = await takeMembersForIndex(db, tableName, indexName, batchSize);
 	if (members.length > 0) {
-		for (const member of members) await db.delete(AGGREGATE_MEMBER_TABLE, member._id);
+		for (const member of members) {
+			await db.delete(AGGREGATE_MEMBER_TABLE, member._id);
+			rememberMember(db, memberMemoKey(member.tableKey, member.indexName, member.docId), null);
+		}
 		return {
 			done: false,
 			processed: members.length
@@ -1433,7 +1559,10 @@ const clearCountIndexChunk = async (db, tableName, indexName, batchSize) => {
 	}
 	const buckets = await takeBucketsForIndex(db, tableName, indexName, batchSize);
 	if (buckets.length > 0) {
-		for (const bucket of buckets) await db.delete(AGGREGATE_BUCKET_TABLE, bucket._id);
+		for (const bucket of buckets) {
+			await db.delete(AGGREGATE_BUCKET_TABLE, bucket._id);
+			rememberBucket(db, bucketMemoKey(bucket.tableKey, bucket.indexName, bucket.keyHash), null);
+		}
 		return {
 			done: false,
 			processed: buckets.length
@@ -1882,6 +2011,7 @@ function createCountBackfillHandlers(schema, getChunkRef) {
 		if (args.tableName && args.indexName) {
 			const tableName = args.tableName;
 			const indexName = args.indexName;
+			await flushOrmWriteBatch(ctx.db);
 			const [bucket, extrema, metricMember, rankMember] = await Promise.all([
 				ctx.db.query(AGGREGATE_BUCKET_TABLE).withIndex("by_table_index", (q) => q.eq("tableKey", tableName).eq("indexName", indexName)).first(),
 				ctx.db.query(AGGREGATE_EXTREMA_TABLE).withIndex("by_table_index", (q) => q.eq("tableKey", tableName).eq("indexName", indexName)).first(),

package/dist/orm/index.d.ts

@@ -1,5 +1,5 @@
-import { $n as TableName, $t as OrmLifecycleChange, An as ConvexCheckBuilder, At as UpdateSet, Bn as ConvexTextBuilder, Br as IsPrimaryKey, Bt as RelationsBuilderColumnBase, C as MigrationStep, Cn as ConvexVectorIndexConfig, Cr as not, Ct as OrderByClause, D as defineMigration, Dn as searchIndex, Dr as startsWith, Dt as ReturningAll, E as buildMigrationPlan, En as rankIndex, Er as or, Et as PredicateWhereIndexConfig, Fn as ConvexUniqueConstraintBuilderOn, Fr as ColumnBuilderTypeConfig, Ft as ExtractTablesFromSchema, Gn as Columns, Gt as TablesRelationalConfig, H as RlsMode, Hn as text, Hr as NotNull, In as ConvexUniqueConstraintConfig, Ir as ColumnBuilderWithTableName, It as ExtractTablesWithRelations, Jn as OrmSchemaExtensionTables, Jt as ConvexDeletionBuilder, Kt as defineRelations, Ln as check, Lr as ColumnDataType, Lt as ManyConfig, M as DatabaseWithQuery, Mn as ConvexForeignKeyBuilder, Mr as ColumnBuilder, Mt as VectorSearchProvider, N as OrmReader$1, Nn as ConvexForeignKeyConfig, Nr as ColumnBuilderBaseConfig, Nt as unsetToken, O as defineMigrationSet, On as uniqueIndex, Ot as ReturningResult, P as OrmWriter$1, Pn as ConvexUniqueConstraintBuilder, Pr as ColumnBuilderRuntimeConfig, Qn as OrmSchemaTriggers, Qt as DiscriminatorBuilderConfig, Rn as foreignKey, Rr as DrizzleEntity, Rt as OneConfig, S as MigrationStateMap, Sn as ConvexVectorIndexBuilderOn, Sr as ne, St as MutationRunMode, T as MigrationWriteMode, Tn as index, Tr as notInArray, Tt as PaginatedResult, U as EdgeMetadata, V as RlsContext, Vn as ConvexTextBuilderInitial, Vr as IsUnique, Vt as RelationsBuilderColumnConfig, W as extractRelationsConfig, Wn as Brand, Wt as TableRelationalConfig, Xn as OrmSchemaExtensions, Xt as ConvexTable, Yt as ConvexDeletionConfig, Zn as OrmSchemaRelations, Zt as ConvexTableWithColumns, _ as MigrationManifestEntry, _n as ConvexRankIndexBuilderOn, _r as isNotNull, _t as MutationExecutionMode, an as RlsPolicy, ar as UnaryExpression, at as BuildRelationResult, b as MigrationRunStatus, bn as ConvexSearchIndexConfig, br as lt, bt as MutationResult, cn as rlsPolicy, cr as contains, ct as DBQueryConfig, d as MigrationAppliedState, dn as rlsRole, dr as fieldRef, dt as InferInsertModel, en as OrmLifecycleOperation, er as BinaryExpression, f as MigrationDefinition, fn as ConvexAggregateIndexBuilder, fr as gt, ft as InferModelFromColumns, g as MigrationDriftIssue, gn as ConvexRankIndexBuilder, gr as isFieldReference, gt as MutationExecuteResult, h as MigrationDocContext, hn as ConvexIndexBuilderOn, hr as inArray, ht as MutationExecuteConfig, i as OrmMigrationCapability, in as discriminator, ir as LogicalExpression, it as BuildQueryResult, j as DatabaseWithMutations, jn as ConvexCheckConfig, jr as AnyColumn, jt as VectorQueryConfig, k as detectMigrationDrift, kn as vectorIndex, kr as SystemFields, kt as ReturningSelection, ln as RlsRole, lr as endsWith, lt as FilterOperators, m as MigrationDoc, mn as ConvexIndexBuilder, mr as ilike, mt as InsertValue, n as OrmCapabilities, nn as convexTable, nr as FieldReference, nt as AggregateFieldValue, on as RlsPolicyConfig, or as and, ot as CountConfig, p as MigrationDirection, pn as ConvexAggregateIndexBuilderOn, pr as gte, pt as InferSelectModel, qt as defineRelationsPart, r as OrmCapability, rn as deletion, rr as FilterExpression, rt as AggregateResult, sn as RlsPolicyToOption, sr as between, st as CountResult, t as OrmAggregateCapability, tn as TableConfig, tr as ExpressionVisitor, tt as AggregateConfig, un as RlsRoleConfig, ur as eq, ut as GetColumnData, v as MigrationMigrateOne, vn as ConvexSearchIndexBuilder, vr as isNull, vt as MutationPaginateConfig, w as MigrationTableName, wn as aggregateIndex, wr as notBetween, wt as OrderDirection, x as MigrationSet, xn as ConvexVectorIndexBuilder, xr as lte, xt as MutationReturning, y as MigrationPlan, yn as ConvexSearchIndexBuilderOn, yr as like, yt as MutationPaginatedResult, zn as unique, zr as HasDefault, zt as RelationsBuilder } from "../capabilities-BJm_VSDT.js";
-import { $ as OrmClientWithApi$1, A as ConvexDateMode, B as ConvexBytesBuilderInitial, C as ConvexNumberBuilderInitial, D as id, E as ConvexIdBuilderInitial, F as custom, G as ConvexBigIntBuilder, H as ConvexBooleanBuilder, I as json, J as CreateOrmOptions, K as ConvexBigIntBuilderInitial, L as objectOf, M as ConvexCustomBuilder, N as ConvexCustomBuilderInitial, O as ConvexDateBuilder, P as arrayOf, Q as OrmClientBase$1, R as unionOf, S as ConvexNumberBuilder, St as defineTriggers, T as ConvexIdBuilder, U as ConvexBooleanBuilderInitial, V as bytes, W as boolean, X as GenericOrmCtx$1, Y as GenericOrm$1, Z as OrmApiResult, _ as ConvexTimestampMode, _t as OrmBeforeResult, a as requireSchemaRelations, at as ScheduledMutationBatchArgs, b as ConvexTextEnumBuilderInitial, bt as OrmTriggerContext, c as TableConfigResult, ct as scheduledDeleteFactory, d as OrmNotFoundError, et as OrmFunctions, f as ConvexVectorBuilder, g as ConvexTimestampBuilderInitial, gt as defineSchemaExtension, h as ConvexTimestampBuilder, ht as SchemaExtension, i as getSchemaTriggers, it as createOrm, j as date, k as ConvexDateBuilderInitial, l as getTableColumns, m as vector, n as defineSchema, nt as OrmWriterCtx, o as asc, ot as scheduledMutationBatchFactory, p as ConvexVectorBuilderInitial, q as bigint, r as getSchemaRelations, rt as ResolveOrmSchema, s as desc, st as ScheduledDeleteArgs, t as WhereClauseResult, tt as OrmReaderCtx, u as getTableConfig, v as timestamp, vt as OrmTableTriggers, w as integer, x as textEnum, xt as OrmTriggers, y as ConvexTextEnumBuilder, yt as OrmTriggerChange, z as ConvexBytesBuilder } from "../where-clause-compiler-Dgf4lrO-.js";
+import { $n as TableName, $t as OrmLifecycleChange, An as ConvexCheckBuilder, At as UpdateSet, Bn as ConvexTextBuilder, Br as IsPrimaryKey, Bt as RelationsBuilderColumnBase, C as MigrationStep, Cn as ConvexVectorIndexConfig, Cr as not, Ct as OrderByClause, D as defineMigration, Dn as searchIndex, Dr as startsWith, Dt as ReturningAll, E as buildMigrationPlan, En as rankIndex, Er as or, Et as PredicateWhereIndexConfig, Fn as ConvexUniqueConstraintBuilderOn, Fr as ColumnBuilderTypeConfig, Ft as ExtractTablesFromSchema, Gn as Columns, Gt as TablesRelationalConfig, H as RlsMode, Hn as text, Hr as NotNull, In as ConvexUniqueConstraintConfig, Ir as ColumnBuilderWithTableName, It as ExtractTablesWithRelations, Jn as OrmSchemaExtensionTables, Jt as ConvexDeletionBuilder, Kt as defineRelations, Ln as check, Lr as ColumnDataType, Lt as ManyConfig, M as DatabaseWithQuery, Mn as ConvexForeignKeyBuilder, Mr as ColumnBuilder, Mt as VectorSearchProvider, N as OrmReader$1, Nn as ConvexForeignKeyConfig, Nr as ColumnBuilderBaseConfig, Nt as unsetToken, O as defineMigrationSet, On as uniqueIndex, Ot as ReturningResult, P as OrmWriter$1, Pn as ConvexUniqueConstraintBuilder, Pr as ColumnBuilderRuntimeConfig, Qn as OrmSchemaTriggers, Qt as DiscriminatorBuilderConfig, Rn as foreignKey, Rr as DrizzleEntity, Rt as OneConfig, S as MigrationStateMap, Sn as ConvexVectorIndexBuilderOn, Sr as ne, St as MutationRunMode, T as MigrationWriteMode, Tn as index, Tr as notInArray, Tt as PaginatedResult, U as EdgeMetadata, V as RlsContext, Vn as ConvexTextBuilderInitial, Vr as IsUnique, Vt as RelationsBuilderColumnConfig, W as extractRelationsConfig, Wn as Brand, Wt as TableRelationalConfig, Xn as OrmSchemaExtensions, Xt as ConvexTable, Yt as ConvexDeletionConfig, Zn as OrmSchemaRelations, Zt as ConvexTableWithColumns, _ as MigrationManifestEntry, _n as ConvexRankIndexBuilderOn, _r as isNotNull, _t as MutationExecutionMode, an as RlsPolicy, ar as UnaryExpression, at as BuildRelationResult, b as MigrationRunStatus, bn as ConvexSearchIndexConfig, br as lt, bt as MutationResult, cn as rlsPolicy, cr as contains, ct as DBQueryConfig, d as MigrationAppliedState, dn as rlsRole, dr as fieldRef, dt as InferInsertModel, en as OrmLifecycleOperation, er as BinaryExpression, f as MigrationDefinition, fn as ConvexAggregateIndexBuilder, fr as gt, ft as InferModelFromColumns, g as MigrationDriftIssue, gn as ConvexRankIndexBuilder, gr as isFieldReference, gt as MutationExecuteResult, h as MigrationDocContext, hn as ConvexIndexBuilderOn, hr as inArray, ht as MutationExecuteConfig, i as OrmMigrationCapability, in as discriminator, ir as LogicalExpression, it as BuildQueryResult, j as DatabaseWithMutations, jn as ConvexCheckConfig, jr as AnyColumn, jt as VectorQueryConfig, k as detectMigrationDrift, kn as vectorIndex, kr as SystemFields, kt as ReturningSelection, ln as RlsRole, lr as endsWith, lt as FilterOperators, m as MigrationDoc, mn as ConvexIndexBuilder, mr as ilike, mt as InsertValue, n as OrmCapabilities, nn as convexTable, nr as FieldReference, nt as AggregateFieldValue, on as RlsPolicyConfig, or as and, ot as CountConfig, p as MigrationDirection, pn as ConvexAggregateIndexBuilderOn, pr as gte, pt as InferSelectModel, qt as defineRelationsPart, r as OrmCapability, rn as deletion, rr as FilterExpression, rt as AggregateResult, sn as RlsPolicyToOption, sr as between, st as CountResult, t as OrmAggregateCapability, tn as TableConfig, tr as ExpressionVisitor, tt as AggregateConfig, un as RlsRoleConfig, ur as eq, ut as GetColumnData, v as MigrationMigrateOne, vn as ConvexSearchIndexBuilder, vr as isNull, vt as MutationPaginateConfig, w as MigrationTableName, wn as aggregateIndex, wr as notBetween, wt as OrderDirection, x as MigrationSet, xn as ConvexVectorIndexBuilder, xr as lte, xt as MutationReturning, y as MigrationPlan, yn as ConvexSearchIndexBuilderOn, yr as like, yt as MutationPaginatedResult, zn as unique, zr as HasDefault, zt as RelationsBuilder } from "../capabilities-Bxzoofl4.js";
+import { $ as OrmClientWithApi$1, A as ConvexDateMode, B as ConvexBytesBuilderInitial, C as ConvexNumberBuilderInitial, D as id, E as ConvexIdBuilderInitial, F as custom, G as ConvexBigIntBuilder, H as ConvexBooleanBuilder, I as json, J as CreateOrmOptions, K as ConvexBigIntBuilderInitial, L as objectOf, M as ConvexCustomBuilder, N as ConvexCustomBuilderInitial, O as ConvexDateBuilder, P as arrayOf, Q as OrmClientBase$1, R as unionOf, S as ConvexNumberBuilder, St as defineTriggers, T as ConvexIdBuilder, U as ConvexBooleanBuilderInitial, V as bytes, W as boolean, X as GenericOrmCtx$1, Y as GenericOrm$1, Z as OrmApiResult, _ as ConvexTimestampMode, _t as OrmBeforeResult, a as requireSchemaRelations, at as ScheduledMutationBatchArgs, b as ConvexTextEnumBuilderInitial, bt as OrmTriggerContext, c as TableConfigResult, ct as scheduledDeleteFactory, d as OrmNotFoundError, et as OrmFunctions, f as ConvexVectorBuilder, g as ConvexTimestampBuilderInitial, gt as defineSchemaExtension, h as ConvexTimestampBuilder, ht as SchemaExtension, i as getSchemaTriggers, it as createOrm, j as date, k as ConvexDateBuilderInitial, l as getTableColumns, m as vector, n as defineSchema, nt as OrmWriterCtx, o as asc, ot as scheduledMutationBatchFactory, p as ConvexVectorBuilderInitial, q as bigint, r as getSchemaRelations, rt as ResolveOrmSchema, s as desc, st as ScheduledDeleteArgs, t as WhereClauseResult, tt as OrmReaderCtx, u as getTableConfig, v as timestamp, vt as OrmTableTriggers, w as integer, x as textEnum, xt as OrmTriggers, y as ConvexTextEnumBuilder, yt as OrmTriggerChange, z as ConvexBytesBuilder } from "../where-clause-compiler-DrV6lQg0.js";
 import { i as pretendRequired, n as deprecated, r as pretend } from "../validators-0I-Ik1EN.js";
 import { a as QueryCtxWithPreferredOrmQueryTable, i as QueryCtxWithOrmQueryTable, n as LookupByIdResultByCtx, o as getByIdWithOrmQueryFallback, r as QueryCtxWithOptionalOrmQueryTable, t as DocByCtx } from "../query-context-BkNjkDCk.js";
 import { DefineSchemaOptions, GenericDatabaseReader, GenericDatabaseWriter, GenericSchema, SchemaDefinition } from "convex/server";