@rebasepro/client 0.14.0 → 0.14.1

package/dist/index.es.js

@@ -1,5 +1,5 @@
 import { DEFAULT_STORAGE_SOURCE_KEY, EntityReference, EntityRelation, GeoPoint, PUBLIC_STORAGE_PREFIX, RebaseApiError, RebaseApiError as RebaseApiError$1, RebaseClientError, RebaseClientError as RebaseClientError$1, Vector, isPublicStoragePath, toCanonicalOp } from "@rebasepro/types";
-import { COMPOSITE_ID_SEPARATOR, QueryBuilder, RebasePaginationError, and, buildCompositeId, collectAllPages, cond, or, paginateFind, resolveFindWindow, serializeFilter, serializeLogicalCondition, serializeOrderBy } from "@rebasepro/common";
+import { COMPOSITE_ID_SEPARATOR, QueryBuilder, RebasePaginationError, and, buildCompositeId, collectAllPages, cond, normalizeOrderBy, or, paginateFind, resolveFindWindow, serializeFilter, serializeLogicalCondition, serializeOrderBy } from "@rebasepro/common";
 import { toSnakeCase } from "@rebasepro/utils";
 //#region src/reviver.ts
 function rebaseReviver(_key, value) {
@@ -1277,9 +1277,15 @@ var SDKQueryBuilder = class {
 	}
 	/**
 	* Order the results by a specific column.
+	*
+	* Call it again to add a tie-breaker rather than replace the sort: keys
+	* apply in the order they were added, so
+	* `.orderBy("roles").orderBy("created_at", "desc")` sorts by role and
+	* shows the newest first within each one.
 	*/
 	orderBy(column, direction = "asc") {
-		this.params.orderBy = [column, direction];
+		const existing = normalizeOrderBy(this.params.orderBy) ?? [];
+		this.params.orderBy = [...existing, [column, direction]];
 		return this;
 	}
 	/**
@@ -1596,8 +1602,7 @@ function createCollectionClient(transport, slug, ws) {
 				logical: params?.logical,
 				limit: params?.limit,
 				offset: window.driverOffset,
-				orderBy: params?.orderBy?.[0],
-				order: params?.orderBy?.[1],
+				orderBy: normalizeOrderBy(params?.orderBy),
 				searchString: params?.searchString,
 				searchExplain: params?.searchExplain
 			}, (incomingRows) => {
@@ -4099,27 +4104,43 @@ function matchesParams(row, params) {
 * Sort in place, Postgres-style: nulls last ascending, first descending, with
 * the row id as a tiebreak so paging through an unsorted-but-equal run does
 * not shuffle rows between pages.
+*
+* The tiebreak runs *descending*, which is not a taste: every server-side sort
+* ends on `id DESC` — `FetchService.buildOrderExpressions` appends it to make
+* the ordering total, and the keyset cursor is built to match. This ran
+* ascending, so two rows sharing a sort value came back from the local overlay
+* in the opposite order to the server's, and {@link isLocallySortable} called
+* that page exactly reproducible while it was not.
 */
 function sortRows(rows, orderBy) {
-	if (!orderBy) return rows;
-	const [field, direction = "asc"] = orderBy;
-	const sign = direction === "desc" ? -1 : 1;
+	const keys = normalizeOrderBy(orderBy);
+	if (!keys) return rows;
 	return rows.sort((a, b) => {
-		const av = a[field];
-		const bv = b[field];
-		const aNull = isNullish(toComparable(av));
-		const bNull = isNullish(toComparable(bv));
-		if (aNull || bNull) {
-			if (aNull && bNull) return tiebreak(a, b);
-			return (aNull ? 1 : -1) * (direction === "desc" ? -1 : 1);
+		for (const [field, direction = "asc"] of keys) {
+			const cmp = compareOnKey(a, b, field, direction);
+			if (cmp !== 0) return cmp;
 		}
-		const cmp = compareValues(av, bv);
-		if (cmp === void 0 || cmp === 0) return tiebreak(a, b);
-		return cmp * sign;
+		return tiebreak(a, b);
 	});
 }
+/** One key's verdict: negative, positive, or 0 for "these two are equal here". */
+function compareOnKey(a, b, field, direction) {
+	const av = a[field];
+	const bv = b[field];
+	const aNull = isNullish(toComparable(av));
+	const bNull = isNullish(toComparable(bv));
+	if (aNull || bNull) {
+		if (aNull && bNull) return 0;
+		return (aNull ? 1 : -1) * (direction === "desc" ? -1 : 1);
+	}
+	const cmp = compareValues(av, bv);
+	if (cmp === void 0 || cmp === 0) return 0;
+	return cmp * (direction === "desc" ? -1 : 1);
+}
+/** The last word, and the server's: `id DESC`. */
 function tiebreak(a, b) {
-	return compareValues(a.id, b.id) ?? 0;
+	const cmp = compareValues(a.id, b.id);
+	return cmp === void 0 ? 0 : -cmp;
 }
 /**
 * Resolve `page`/`offset`/`limit` the way the server does.
@@ -4214,17 +4235,16 @@ function isExactlyEvaluable(params) {
 * comparator.
 */
 function isLocallySortable(rows, orderBy) {
-	if (!orderBy) return true;
-	const [field] = orderBy;
-	for (const row of rows) {
+	const keys = normalizeOrderBy(orderBy);
+	if (!keys) return true;
+	return keys.every(([field]) => rows.every((row) => {
 		const value = toComparable(row[field]);
-		if (isNullish(value)) continue;
-		if (typeof value === "number" || typeof value === "boolean") continue;
-		if (typeof value === "bigint") continue;
-		if (typeof value === "string" && value.trim() !== "" && !Number.isNaN(Number(value))) continue;
+		if (isNullish(value)) return true;
+		if (typeof value === "number" || typeof value === "boolean") return true;
+		if (typeof value === "bigint") return true;
+		if (typeof value === "string" && value.trim() !== "" && !Number.isNaN(Number(value))) return true;
 		return false;
-	}
-	return true;
+	}));
 }
 /** Run a full query — filter, sort, paginate — over a set of rows. */
 function runLocalQuery(rows, params) {