@spooky-sync/core 0.0.1-canary.241 → 0.0.1-canary.243

package/dist/index.js

@@ -1073,8 +1073,8 @@ function selfAllowlistedVariant(flag, userId) {
 
 //#endregion
 //#region src/modules/devtools/index.ts
-const CORE_VERSION = "0.0.1-canary.241";
-const WASM_VERSION = "0.0.1-canary.241";
+const CORE_VERSION = "0.0.1-canary.243";
+const WASM_VERSION = "0.0.1-canary.243";
 const SURREAL_VERSION = "3.0.3";
 var DevToolsService = class DevToolsService {
 	eventsHistory = [];
@@ -12473,7 +12473,7 @@ function createTabsCoordinator(config, s, host) {
 	return new TabsCoordinator({
 		tabId: s.tabId,
 		fingerprint: computeTabsFingerprint({
-			coreVersion: "0.0.1-canary.241",
+			coreVersion: "0.0.1-canary.243",
 			schemaHash: hash53(config.schemaSurql),
 			endpoint: config.database.endpoint ?? "",
 			namespace: config.database.namespace,

package/dist/sqlite-open.js

@@ -205,6 +205,15 @@ function reviveRow(json) {
 * than as text. `COALESCE` covers a row sharing none of the requested keys,
 * where the subquery yields NULL and `reviveRow` would throw.
 *
+* The one value `je.value` does NOT carry back is a TOP-LEVEL boolean. SQLite
+* has no boolean type, so `json_each` hands `true`/`false` out as the integers
+* 1/0 and `json_group_object` writes integers back. A projected row therefore
+* read `published: 1` where the same row read whole read `published: true`,
+* and every `=== true` in an app turned false the moment a screen painted from
+* the local cache. (A boolean NESTED in an object or array survives: those come
+* back as whole JSON documents, untouched.) `je.type` still knows what it was,
+* so the two boolean types are rebuilt as JSON literals on the way out.
+*
 * Deliberately unaliased, so the emitted statement keeps the exact shape the
 * callers already produce (`FROM "t" WHERE id IN (…)`).
 *
@@ -214,7 +223,7 @@ function reviveRow(json) {
 function projectedDataSql(fields, bind) {
 	const keys = ["id", ...fields];
 	for (const k of keys) bind.push(k);
-	return `COALESCE((SELECT json_group_object(je.key, je.value) FROM json_each(data) je WHERE je.key IN (${keys.map(() => "?").join(", ")})), '{}') AS data`;
+	return `COALESCE((SELECT json_group_object(je.key, CASE je.type WHEN 'true' THEN json('true') WHEN 'false' THEN json('false') ELSE je.value END) FROM json_each(data) je WHERE je.key IN (${keys.map(() => "?").join(", ")})), '{}') AS data`;
 }
 function project(row, fields) {
 	const out = {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spooky-sync/core",
-  "version": "0.0.1-canary.241",
+  "version": "0.0.1-canary.243",
   "type": "module",
   "sideEffects": false,
   "main": "./dist/index.js",
@@ -63,8 +63,8 @@
     }
   },
   "dependencies": {
-    "@spooky-sync/query-builder": "0.0.1-canary.241",
-    "@spooky-sync/ssp-wasm": "0.0.1-canary.241",
+    "@spooky-sync/query-builder": "0.0.1-canary.243",
+    "@spooky-sync/ssp-wasm": "0.0.1-canary.243",
     "@sqlite.org/sqlite-wasm": "3.53.0-build1",
     "@surrealdb/wasm": "^3.0.3",
     "blurhash": "^2.0.5",

package/src/services/database/sqlite-plan-sql.ts

@@ -99,6 +99,15 @@ export function reviveRow(json: string): Row {
  * than as text. `COALESCE` covers a row sharing none of the requested keys,
  * where the subquery yields NULL and `reviveRow` would throw.
  *
+ * The one value `je.value` does NOT carry back is a TOP-LEVEL boolean. SQLite
+ * has no boolean type, so `json_each` hands `true`/`false` out as the integers
+ * 1/0 and `json_group_object` writes integers back. A projected row therefore
+ * read `published: 1` where the same row read whole read `published: true`,
+ * and every `=== true` in an app turned false the moment a screen painted from
+ * the local cache. (A boolean NESTED in an object or array survives: those come
+ * back as whole JSON documents, untouched.) `je.type` still knows what it was,
+ * so the two boolean types are rebuilt as JSON literals on the way out.
+ *
  * Deliberately unaliased, so the emitted statement keeps the exact shape the
  * callers already produce (`FROM "t" WHERE id IN (…)`).
  *
@@ -109,8 +118,14 @@ export function projectedDataSql(fields: string[], bind: unknown[]): string {
   const keys = ['id', ...fields];
   for (const k of keys) bind.push(k);
   const placeholders = keys.map(() => '?').join(', ');
+  // `json('true')` / `json('false')` return JSON-subtyped values, so
+  // `json_group_object` embeds them as the literals `true` / `false` rather
+  // than as quoted text.
+  const value =
+    `CASE je.type WHEN 'true' THEN json('true') ` +
+    `WHEN 'false' THEN json('false') ELSE je.value END`;
   return (
-    `COALESCE((SELECT json_group_object(je.key, je.value) ` +
+    `COALESCE((SELECT json_group_object(je.key, ${value}) ` +
     `FROM json_each(data) je WHERE je.key IN (${placeholders})), '{}') AS data`
   );
 }

package/src/services/database/sqlite-projection.test.ts

@@ -12,7 +12,9 @@ import type { Row } from './cache-engine';
  * over it, which is what both engine paths did before. The traps it has to
  * clear are an ABSENT key (must stay absent, not become an explicit null — the
  * difference `json_object`/`json_extract` would have introduced), a STORED
- * null, nested objects/arrays, and the `{__u8}` tag that carries binary.
+ * null, nested objects/arrays, the `{__u8}` tag that carries binary, and a
+ * TOP-LEVEL boolean (SQLite has no boolean type, so an unguarded projection
+ * hands `true` back as the integer 1).
  */
 
 function makeDb(rows: Row[]) {
@@ -49,9 +51,10 @@ const FIXTURE: Row[] = [
   { id: 'game:2', white: null, pgn: 'heavy', sort_index: -3 }, // STORED null
   { id: 'game:3', pgn: 'heavy', sort_index: -4 }, // 'white' ABSENT
   { id: 'game:4', white: 'w', pgn: 'heavy', sort_index: -1, meta: { a: 1, b: [2, 3] } },
+  { id: 'game:5', white: 'w', pgn: 'heavy', sort_index: 0, rated: true, draw: false },
 ];
-const IDS = ['game:1', 'game:2', 'game:3', 'game:4'];
-const FIELDS = ['white', 'sort_index', 'meta'];
+const IDS = ['game:1', 'game:2', 'game:3', 'game:4', 'game:5'];
+const FIELDS = ['white', 'sort_index', 'meta', 'rated', 'draw'];
 
 describe('projectedDataSql against real SQLite', () => {
   it('is byte-identical to parse-then-project', () => {
@@ -91,6 +94,25 @@ describe('projectedDataSql against real SQLite', () => {
     for (const row of projectedRows(db, IDS, ['sort_index'])) expect(row.id).toBeTruthy();
   });
 
+  it('round-trips a top-level boolean as a boolean, not as 1/0', () => {
+    // The bug this guards: `json_each` yields SQLite integers for JSON booleans,
+    // so a projected row read `rated: 1` and every `row.rated === true` in a
+    // consuming app went false as soon as the screen painted from the cache.
+    // WhitePawn's /explore detail page read exactly that as "this collection was
+    // unpublished or deleted by its author".
+    const db = makeDb(FIXTURE);
+    const row = projectedRows(db, IDS, FIELDS).find((r) => r.id === 'game:5')!;
+    expect(row.rated).toBe(true);
+    expect(row.draw).toBe(false);
+  });
+
+  it('leaves a boolean nested in an object or array alone', () => {
+    const db = makeDb([{ id: 'game:7', flags: { on: true, off: false }, list: [true, false] }]);
+    const [row] = projectedRows(db, ['game:7'], ['flags', 'list']);
+    expect(row!.flags).toEqual({ on: true, off: false });
+    expect(row!.list).toEqual([true, false]);
+  });
+
   it('yields an empty object, not NULL, for a row sharing none of the keys', () => {
     // Without COALESCE the subquery returns NULL here and reviveRow throws.
     const db = makeDb([{ id: 'game:8', pgn: 'heavy' }]);