@rebasepro/client 0.14.1-canary.g7e666eb → 0.14.1

package/dist/offline-query.d.ts

@@ -38,6 +38,13 @@ export declare function matchesParams(row: Record<string, unknown>, params?: Fin
  * 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.
  */
 export declare function sortRows<M extends Record<string, unknown>>(rows: M[], orderBy?: OrderBySpec): M[];
 /**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rebasepro/client",
   "type": "module",
-  "version": "0.14.1-canary.g7e666eb",
+  "version": "0.14.1",
   "description": "HTTP SDK client for the Rebase custom backend",
   "funding": {
     "url": "https://github.com/sponsors/rebaseco"
@@ -29,9 +29,9 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@rebasepro/utils": "0.14.1-canary.g7e666eb",
-    "@rebasepro/common": "0.14.1-canary.g7e666eb",
-    "@rebasepro/types": "0.14.1-canary.g7e666eb"
+    "@rebasepro/common": "0.14.1",
+    "@rebasepro/utils": "0.14.1",
+    "@rebasepro/types": "0.14.1"
   },
   "devDependencies": {
     "@jest/globals": "^30.4.1",

package/src/offline-query.test.ts

@@ -158,9 +158,26 @@ describe("local query engine", () => {
             expect(sortRows([...rows], ["n", "desc"]).map((r) => r.id)).toEqual([2, 1, 3]);
         });
 
-        it("breaks ties on id so paging cannot shuffle equal rows between pages", () => {
-            const rows: Row[] = [{ id: "c", n: 1 }, { id: "a", n: 1 }, { id: "b", n: 1 }];
-            expect(sortRows(rows, ["n", "asc"]).map((r) => r.id)).toEqual(["a", "b", "c"]);
+        it("breaks ties on id descending, which is what the server orders by", () => {
+            // Not an arbitrary direction: `FetchService.buildOrderExpressions`
+            // appends `id DESC` to every sort it builds, and the keyset cursor
+            // is written to match it. Ascending here meant the overlay handed
+            // back tied rows in the opposite order to the network answer for
+            // the same query — while `isLocallySortable` reported the page as
+            // exactly reproducible.
+            const rows: Row[] = [{ id: "a", n: 1 }, { id: "c", n: 1 }, { id: "b", n: 1 }];
+            expect(sortRows(rows, ["n", "asc"]).map((r) => r.id)).toEqual(["c", "b", "a"]);
+            expect(sortRows(rows, ["n", "desc"]).map((r) => r.id)).toEqual(["c", "b", "a"]);
+        });
+
+        it("lets a later key decide before the id tiebreak does", () => {
+            const rows: Row[] = [
+                { id: 1, role: "admin", at: 2 },
+                { id: 2, role: "admin", at: 1 },
+                { id: 3, role: "user", at: 9 }
+            ];
+            expect(sortRows(rows, [["role", "asc"], ["at", "desc"]]).map((r) => r.id))
+                .toEqual([1, 2, 3]);
         });
 
         it("orders dates chronologically, not lexicographically", () => {

package/src/offline-query.ts

@@ -307,6 +307,13 @@ export function matchesParams(row: Record<string, unknown>, params?: FindParams)
  * 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.
  */
 export function sortRows<M extends Record<string, unknown>>(rows: M[], orderBy?: OrderBySpec): M[] {
     const keys = normalizeOrderBy(orderBy);
@@ -345,9 +352,10 @@ function compareOnKey(
     return cmp * (direction === "desc" ? -1 : 1);
 }
 
+/** The last word, and the server's: `id DESC`. */
 function tiebreak(a: Record<string, unknown>, b: Record<string, unknown>): number {
     const cmp = compareValues(a.id, b.id);
-    return cmp ?? 0;
+    return cmp === undefined ? 0 : -cmp;
 }
 
 /**