@rebasepro/client 0.14.1 → 0.14.2-canary.g27a129e

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rebasepro/client",
   "type": "module",
-  "version": "0.14.1",
+  "version": "0.14.2-canary.g27a129e",
   "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/common": "0.14.1",
-    "@rebasepro/utils": "0.14.1",
-    "@rebasepro/types": "0.14.1"
+    "@rebasepro/common": "0.14.2-canary.g27a129e",
+    "@rebasepro/types": "0.14.2-canary.g27a129e",
+    "@rebasepro/utils": "0.14.2-canary.g27a129e"
   },
   "devDependencies": {
     "@jest/globals": "^30.4.1",

package/src/offline-query.test.ts

@@ -326,6 +326,31 @@ describe("local query engine", () => {
             expect(isExactlyEvaluable({ where: { a: [["==", 1], ["<", "m"]] } } as never)).toBe(false);
             expect(isExactlyEvaluable({ where: { a: [["==", 1], ["!=", 2]] } } as never)).toBe(true);
         });
+
+        /**
+         * A dotted key reaches through a relation — `applications.status` asks
+         * about rows in another table. `matchesWhere` reads `row[field]` flat,
+         * so the key resolves to `undefined` on every cached row and the
+         * condition excludes all of them: a 200 with an empty list, which is
+         * indistinguishable from "nothing matched". The cache holds one
+         * collection and cannot answer a question about a second.
+         */
+        it("refuses a filter that reaches through a relation", () => {
+            expect(isExactlyEvaluable({
+                where: { "applications.status": ["in", ["applied"]] }
+            } as never)).toBe(false);
+            // The undotted sibling is unaffected.
+            expect(isExactlyEvaluable({ where: { status: ["in", ["applied"]] } } as never)).toBe(true);
+        });
+
+        it("finds a relation path inside an and/or group too", () => {
+            expect(isExactlyEvaluable({
+                logical: { type: "or", conditions: [
+                    { column: "a", operator: "==", value: 1 },
+                    { column: "applications.status", operator: "==", value: "applied" }
+                ] }
+            } as never)).toBe(false);
+        });
     });
 
     describe("isLocallySortable", () => {
@@ -360,6 +385,32 @@ describe("local query engine", () => {
         it("is vacuously true with no sort", () => {
             expect(isLocallySortable([{ id: 1, name: "a" }], undefined)).toBe(true);
         });
+
+        /**
+         * An aggregate over a relation is computed by the database and is not a
+         * field on the row, so every cached row reads `undefined` for it. To
+         * the null rule above that looks exactly like a column of nulls — which
+         * it would call reproducible, and then hand back rows in id order: a
+         * queue sorted by nothing at all, presented as the server's answer.
+         */
+        it("refuses an aggregate sort, in either spelling", () => {
+            const rows = [{ id: 1, name: "a" }, { id: 2, name: "b" }];
+            expect(isLocallySortable(rows, ["min(applications.created_at)", "asc"])).toBe(false);
+            expect(isLocallySortable(rows, ["count(applications)", "desc"])).toBe(false);
+            expect(isLocallySortable(
+                rows,
+                [{ relation: "applications", field: "created_at", agg: "min" }, "asc"]
+            )).toBe(false);
+        });
+
+        it("refuses a multi-key sort whose second key is an aggregate", () => {
+            // A sort the local side can only agree with down to its second
+            // column is one it disagrees with.
+            expect(isLocallySortable(
+                [{ id: 1, n: 1 }, { id: 2, n: 2 }],
+                [["n", "asc"], ["count(applications)", "desc"]]
+            )).toBe(false);
+        });
     });
 
     describe("primitives", () => {

package/src/offline-query.ts

@@ -6,7 +6,8 @@ import {
     FilterCondition,
     OrderBySpec,
     WhereFilterOp,
-    toCanonicalOp
+    toCanonicalOp,
+    parseRelationAggregateSort
 } from "@rebasepro/types";
 import { FindParams } from "./transport";
 import { normalizeOrderBy, resolveFindWindow } from "@rebasepro/common";
@@ -435,9 +436,34 @@ export function isExactlyEvaluable(params?: FindParams): boolean {
     if (params.vectorSearch) return false;
     if (whereOrders(params.where)) return false;
     if (logicalOrders(params.logical)) return false;
+    // A dotted key reaches through a relation — `applications.status` asks
+    // about rows in another table. `matchesWhere` reads `row[field]` flat, so
+    // the key resolves to `undefined` on every cached row and the condition
+    // excludes all of them: a 200 with an empty list, indistinguishable from
+    // "nothing matched". The cache holds one collection; it cannot answer a
+    // question about a second, so it must not claim to.
+    if (whereReachesThroughRelation(params.where)) return false;
+    if (logicalReachesThroughRelation(params.logical)) return false;
     return true;
 }
 
+/** Does any filter key reach outside this row — `applications.status`? */
+function whereReachesThroughRelation(where: FilterValues<string> | undefined): boolean {
+    return where ? Object.keys(where).some((field) => field.includes(".")) : false;
+}
+
+/** The same question, through an `and(...)`/`or(...)` tree. */
+function logicalReachesThroughRelation(
+    condition: LogicalCondition | FilterCondition | undefined,
+    depth = 0
+): boolean {
+    if (!condition || depth > 32) return false;
+    if ("type" in condition) {
+        return (condition.conditions ?? []).some((c) => logicalReachesThroughRelation(c, depth + 1));
+    }
+    return typeof condition.column === "string" && condition.column.includes(".");
+}
+
 /**
  * Would sorting `rows` locally reproduce the order the server would have sent?
  *
@@ -462,6 +488,12 @@ export function isLocallySortable(
 ): boolean {
     const keys = normalizeOrderBy(orderBy);
     if (!keys) return true;
+    // An aggregate over a relation is computed by the database and is not a
+    // field on the row, so every cached row reads `undefined` for it. That
+    // looks exactly like a column of nulls to the loop below, which would call
+    // the order reproducible and then hand back rows in id order — a queue
+    // sorted by nothing at all, presented as the server's answer.
+    if (keys.some(([field]) => parseRelationAggregateSort(field))) return false;
     // Every key has to be decidable, not just the first: a sort the local side
     // can only agree with down to its second column is one it disagrees with.
     return keys.every(([field]) => rows.every((row) => {

package/src/transport-baseurl.test.ts

@@ -30,8 +30,8 @@ describe("transport baseUrl resolution", () => {
     });
 
     it("follows the page, so a second hostname on the same app just works", () => {
-        setWindow("https://dadaki.apps.rebase.pro");
-        expect(createTransport({}).baseUrl).toBe("https://dadaki.apps.rebase.pro");
+        setWindow("https://dadaki.rebase.website");
+        expect(createTransport({}).baseUrl).toBe("https://dadaki.rebase.website");
         setWindow("https://dadaki.com");
         expect(createTransport({}).baseUrl).toBe("https://dadaki.com");
     });