@super-line/collections-cloudflare 0.2.0 → 0.3.0

package/CHANGELOG.md

@@ -3,6 +3,14 @@
 Generated from conventional commits by [git-cliff](https://git-cliff.org) —
 run `pnpm changelog` rather than editing by hand.
 
+## [collections-cloudflare-v0.3.0] — 2026-10-22
+
+### Features
+
+- **collections-cloudflare:** CountBy runs as one GROUP BY in the object's SQLite ([ec7b2b9])
+- **collections-cloudflare:** Count, and text order, like and has run in the object's SQLite ([73dd870])
+- **collections-cloudflare:** A remote rows snapshot may span every table of a store ([f26cc95])
+
 ## [collections-cloudflare-v0.2.0] — 2026-10-20
 
 ### Features

package/README.md

@@ -63,7 +63,7 @@ export class Store extends DurableObject<Env> {
     },
   })
   query(statements: Statement[], opts?: QueryOptions) { return this.sync.query(statements, opts) }
-  snapshot(table: string, limit: number) { return this.sync.snapshot(table, limit) }
+  snapshot(table: string | undefined, limit: number) { return this.sync.snapshot(table, limit) }
   get(table: string, id: string) { return this.sync.get(table, id) }
   changesSince(clock: number) { return this.sync.changesSince(clock) }
 }
@@ -95,7 +95,7 @@ export class Node extends createDurableNode((ctx, env, base) => {
 }
 ```
 
-A subscription must pin both `storeId` and `table` with `eq()`, and writes fail with `FORBIDDEN` — they go through the source's `query`. Dropping, renaming or altering a table, pruned deletes, a backlog over `maxPullChanges` or a reset source breaks that source's history: `onWipe` runs, and its subscribers resync. Store ids and table names must be colon-free. The source owns every `_sl_`-prefixed object in its SQLite.
+A subscription must pin `storeId` with `eq()` (and may pin `table`; without it the snapshot spans every table of the store), and writes fail with `FORBIDDEN` — they go through the source's `query`. Dropping, renaming or altering a table, pruned deletes, a backlog over `maxPullChanges` or a reset source breaks that source's history: `onWipe` runs, and its subscribers resync. Store ids and table names must be colon-free. The source owns every `_sl_`-prefixed object in its SQLite.
 
 - 📖 Guide: [Host a node on Cloudflare Durable Objects](https://super-line.dogar.biz/how-to/cloudflare-durable-objects)
 - 📖 Guide: [Serve another Durable Object's tables](https://super-line.dogar.biz/how-to/cloudflare-remote-rows)

package/dist/index.d.ts

@@ -47,7 +47,8 @@ interface SyncedSqlOptions {
 }
 interface SyncedSql {
     query(statements: Statement[], opts?: QueryOptions): Outcome;
-    snapshot(table: string, limit: number): RemoteRow[];
+    /** Rows of one table, or of every table when `table` is undefined, up to `limit` in all. */
+    snapshot(table: string | undefined, limit: number): RemoteRow[];
     get(table: string, id: string): RemoteRow | undefined;
     changesSince(clock: number): RemoteChanges;
 }
@@ -74,7 +75,7 @@ declare function syncedSql(ctx: DurableObjectState, opts?: SyncedSqlOptions): Sy
 type Awaitable<T> = T | Promise<T>;
 /** A source as the node reaches it: `syncedSql`'s reads, over RPC. A Durable Object stub satisfies it. */
 interface RemoteSource {
-    snapshot(table: string, limit: number): Awaitable<RemoteRow[]>;
+    snapshot(table: string | undefined, limit: number): Awaitable<RemoteRow[]>;
     get(table: string, id: string): Awaitable<RemoteRow | undefined>;
     changesSince(clock: number): Awaitable<RemoteChanges>;
 }
@@ -116,8 +117,8 @@ interface RemoteRowsStore extends SelfCollectionStore {
  * `changesSince` when a push skips a clock, carries no changes or comes from a new epoch. A store's feed starts at
  * its first subscribe, and every subscribe pulls first.
  *
- * A snapshot must pin `storeId` and `table` by equality (`VALIDATION` otherwise); the rest of the query runs on the
- * rows read. Changes carry no prior row, so the server sends a data-less delete to a subscriber the new row doesn't
+ * A snapshot must pin `storeId` by equality (`VALIDATION` otherwise) and may pin `table`; without it the read spans
+ * every table of the store. The rest of the query runs on the rows read. Changes carry no prior row, so the server sends a data-less delete to a subscriber the new row doesn't
  * match — unless its filter rules out the row's `storeId` or `table`, which never change for a key. Writes throw
  * `FORBIDDEN`: they go through the source's own path.
  *

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/index.ts
-import { SuperLineError as SuperLineError2, applyQuery as applyQuery2, isCrdtCollection, matchesFilter } from "@super-line/core";
+import { SuperLineError as SuperLineError2, applyQuery as applyQuery2, countValues, isCrdtCollection, matchesFilter } from "@super-line/core";
 
 // ../collections-sqlite/src/sql.ts
 import { DEGENERATE_DATA_COLUMN, planColumns } from "@super-line/core";
@@ -48,8 +48,26 @@ function resolveField(t, field) {
   if (col.kind === "json") return { at: "json", col: col.name, path: dot === -1 ? "$" : "$." + field.slice(dot + 1) };
   return dot === -1 ? { at: "scalar", col } : { at: "absent" };
 }
+var twoValued = (col, sql) => col.nullable || col.optional ? `COALESCE(${sql}, 0)` : sql;
 var TRUE = { sql: "1=1", params: [], exact: true };
 var FALSE = { sql: "1=0", params: [], exact: true };
+var elementSql = (value) => value === null ? { sql: `e.type = 'null'`, params: [] } : typeof value === "boolean" ? { sql: `e.type = '${value}'`, params: [] } : typeof value === "number" ? { sql: `e.type IN ('integer', 'real') AND e.value = ?`, params: [value] } : { sql: `e.type = 'text' AND e.value = ?`, params: [value] };
+function likeSql(pattern, ci) {
+  let out = "";
+  let exact = true;
+  for (const ch of pattern) {
+    if (ch === "%") out += ci ? "%" : "*";
+    else if (ch === "_") {
+      out += ci ? "%" : "*";
+      exact = false;
+    } else if (ci && ch.length === 1 && ch.charCodeAt(0) > 127) {
+      out += "_";
+      exact = false;
+    } else if (!ci && (ch === "*" || ch === "?" || ch === "[")) out += `[${ch}]`;
+    else out += ch;
+  }
+  return { pattern: out, exact };
+}
 function compileExpr(t, expr) {
   switch (expr.op) {
     case "and":
@@ -106,10 +124,9 @@ function compileExpr(t, expr) {
       const ref = resolveField(t, expr.field);
       if (ref.at === "absent") return FALSE;
       if (ref.at === "scalar") {
-        if (ref.col.kind === "real" && typeof expr.value === "number") {
-          return { sql: `COALESCE("${ref.col.name}" ${op} ?, 0)`, params: [expr.value], exact: true };
+        if (ref.col.kind === "real" && typeof expr.value === "number" || ref.col.kind === "text" && typeof expr.value === "string") {
+          return { sql: twoValued(ref.col, `"${ref.col.name}" ${op} ?`), params: [expr.value], exact: true };
         }
-        if (ref.col.kind === "text" && typeof expr.value === "string") return null;
         return FALSE;
       }
       if (typeof expr.value !== "number") return null;
@@ -124,7 +141,7 @@ function compileExpr(t, expr) {
         const parts = [];
         const params = [];
         if (usable.length > 0) {
-          parts.push(`COALESCE("${ref.col.name}" IN (${usable.map(() => "?").join(",")}), 0)`);
+          parts.push(twoValued(ref.col, `"${ref.col.name}" IN (${usable.map(() => "?").join(",")})`));
           params.push(...usable.map(norm));
         }
         if (expr.values.includes(null) && ref.col.nullable) parts.push(`"${ref.col.name}" IS NULL`);
@@ -137,15 +154,34 @@ function compileExpr(t, expr) {
         exact: false
       };
     }
-    default:
-      return null;
+    case "like":
+    case "ilike": {
+      const ref = resolveField(t, expr.field);
+      if (ref.at === "absent") return FALSE;
+      if (ref.at !== "scalar") return null;
+      if (ref.col.kind !== "text") return FALSE;
+      const p = likeSql(expr.pattern, expr.op === "ilike");
+      const sql = twoValued(ref.col, `"${ref.col.name}" ${expr.op === "ilike" ? "LIKE" : "GLOB"} ?`);
+      return { sql, params: [p.pattern], exact: p.exact };
+    }
+    case "has": {
+      if (expr.field.includes(".")) return null;
+      const ref = resolveField(t, expr.field);
+      if (ref.at !== "json") return FALSE;
+      const el = elementSql(expr.value);
+      return {
+        sql: `json_type("${ref.col}", ?) IS 'array' AND EXISTS (SELECT 1 FROM json_each("${t.name}"."${ref.col}", ?) AS e WHERE ${el.sql})`,
+        params: [ref.path, ref.path, ...el.params],
+        exact: true
+      };
+    }
   }
 }
 function compileOrder(t, orderBy) {
   const parts = [];
   for (const { field, dir } of orderBy) {
     const ref = resolveField(t, field);
-    if (ref.at !== "scalar" || ref.col.kind !== "real") return null;
+    if (ref.at !== "scalar" || ref.col.kind === "integer-bool") return null;
     parts.push(dir === "desc" ? `"${ref.col.name}" DESC NULLS FIRST` : `"${ref.col.name}" ASC NULLS LAST`);
   }
   return parts.join(", ");
@@ -168,6 +204,33 @@ function snapshotSql(t, query, maxParams = Infinity) {
   }
   return { sql, params, exact: true };
 }
+function countSql(t, filter, maxParams = Infinity) {
+  if (!filter) return { sql: `SELECT COUNT(*) AS n FROM "${t.name}"`, params: [] };
+  const where = compileExpr(t, filter);
+  if (!where?.exact || where.params.length > maxParams) return null;
+  return { sql: `SELECT COUNT(*) AS n FROM "${t.name}" WHERE ${where.sql}`, params: where.params };
+}
+function countBySql(t, field, filter, maxParams = Infinity) {
+  const where = filter ? compileExpr(t, filter) : TRUE;
+  if (field.includes(".") || !where?.exact || where.params.length + 2 > maxParams) return null;
+  const ref = resolveField(t, field);
+  if (ref.at === "absent") return { sql: `SELECT 0 AS n WHERE 0`, params: [], decode: () => ({ value: null, count: 0 }) };
+  if (ref.at === "scalar") {
+    const c = ref.col;
+    const missing = c.optional ? ` AND "${c.name}" IS NOT NULL` : "";
+    return {
+      sql: `SELECT "${c.name}" AS v, COUNT(*) AS n FROM "${t.name}" WHERE (${where.sql})${missing} GROUP BY "${c.name}"`,
+      params: where.params,
+      decode: (r) => ({ value: c.kind === "integer-bool" && r.v !== null ? r.v === 1 : r.v, count: r.n })
+    };
+  }
+  const kind = `CASE WHEN e.type IN ('integer', 'real') THEN 'number' ELSE e.type END`;
+  return {
+    sql: `SELECT k, v, COUNT(*) AS n FROM (SELECT DISTINCT f.rid, ${kind} AS k, e.value AS v FROM (SELECT "${t.plan.key}" AS rid, "${ref.col}" AS c FROM "${t.name}" WHERE ${where.sql}) AS f, json_each(f.c, ?) AS e WHERE json_type(f.c, ?) IS NOT 'object' AND e.type NOT IN ('object', 'array')) GROUP BY k, v`,
+    params: [...where.params, ref.path, ref.path],
+    decode: (r) => ({ value: r.k === "true" ? true : r.k === "false" ? false : r.v, count: r.n })
+  };
+}
 var rowMetaSql = (t, count) => `SELECT "${t.plan.key}" AS id, "_sl_created_at" AS c, "_sl_updated_at" AS u FROM "${t.name}" WHERE "${t.plan.key}" IN (${Array.from({ length: count }, () => "?").join(",")})`;
 var encode = (col, v) => {
   if (col.kind === "json") return v === void 0 ? null : JSON.stringify(v);
@@ -417,9 +480,13 @@ function syncedSql(ctx, opts = {}) {
     },
     snapshot(table, limit) {
       ensure();
-      const key = userTables().get(table);
-      if (key === void 0) return [];
-      return read(table, `SELECT ${key}, * FROM ${ident(table)} LIMIT ?`, limit);
+      const tables = userTables();
+      const out = [];
+      for (const [name, key] of table === void 0 ? tables : [[table, tables.get(table)]]) {
+        if (key === void 0 || out.length >= limit) continue;
+        out.push(...read(name, `SELECT ${key}, * FROM ${ident(name)} LIMIT ?`, limit - out.length));
+      }
+      return out;
     },
     get(table, id) {
       ensure();
@@ -509,8 +576,8 @@ function remoteRows(opts) {
       const parts = conjuncts(query.filter);
       const storeId = pinOf(parts, "storeId");
       const table = pinOf(parts, "table");
-      if (typeof storeId !== "string" || typeof table !== "string")
-        throw new SuperLineError("VALIDATION", `A ${collection} subscription must pin storeId and table with eq()`);
+      if (typeof storeId !== "string" || table !== void 0 && typeof table !== "string")
+        throw new SuperLineError("VALIDATION", `A ${collection} subscription must pin storeId with eq()`);
       await catchUp(storeId);
       const exact = !query.orderBy?.length && parts.every(isPin) && query.limit !== void 0;
       const limit = exact ? Math.min(snapshotLimit, (query.offset ?? 0) + (query.limit ?? 0)) : snapshotLimit;
@@ -581,6 +648,13 @@ function cloudflareCollections(storage, collections) {
     const r = rows(t.sql.get, id)[0];
     return r ? fromRow(t, r) : void 0;
   };
+  const snapshot = (n, query) => {
+    const t = table(n);
+    if (!t) return [];
+    const q = snapshotSql(t, query, MAX_PARAMS);
+    const found = rows(q.sql, ...q.params).map((r) => fromRow(t, r));
+    return q.exact ? found : applyQuery2(found, query);
+  };
   const listeners = /* @__PURE__ */ new Set();
   const emit = (changes) => {
     for (const c of changes) for (const cb of listeners) cb(c);
@@ -630,12 +704,18 @@ function cloudflareCollections(storage, collections) {
       emit(changes);
       return true;
     },
-    snapshot(n, query) {
+    snapshot,
+    count(n, filter) {
+      const t = table(n);
+      if (!t) return 0;
+      const q = countSql(t, filter, MAX_PARAMS);
+      return q ? rows(q.sql, ...q.params)[0].n : snapshot(n, { filter }).length;
+    },
+    countBy(n, field, filter) {
       const t = table(n);
       if (!t) return [];
-      const q = snapshotSql(t, query, MAX_PARAMS);
-      const found = rows(q.sql, ...q.params).map((r) => fromRow(t, r));
-      return q.exact ? found : applyQuery2(found, query);
+      const q = countBySql(t, field, filter, MAX_PARAMS);
+      return q ? rows(q.sql, ...q.params).map(q.decode) : countValues(snapshot(n, { filter }), field);
     },
     read(n, id) {
       const t = table(n);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@super-line/collections-cloudflare",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "type": "module",
   "description": "Durable Object SQLite CollectionStore backend for super-line — typed row collections stored in the object that is the node, with IR→SQL snapshot pushdown.",
   "license": "MIT",
@@ -45,11 +45,11 @@
     "zod": "^4.2.0"
   },
   "peerDependencies": {
-    "@super-line/core": ">=0.23.0 <1.0.0"
+    "@super-line/core": ">=0.24.0 <1.0.0"
   },
   "devDependencies": {
     "@cloudflare/workers-types": "^5.20261013.1",
-    "@super-line/core": "^0.23.0"
+    "@super-line/core": "^0.24.0"
   },
   "scripts": {
     "build": "tsup"