@spooky-sync/core 0.0.1-canary.128 → 0.0.1-canary.129

package/dist/index.d.ts

@@ -475,6 +475,15 @@ declare class DataModule<S extends SchemaStructure> {
    * `seen` dedupes within the batch.
    */
   private collectEmbeddedChildren;
+  /**
+   * Prepare a subquery-bearing row (preload / hydration) for the schemafull
+   * local store: replace an embedded FORWARD-relation object (`author = { id, … }`)
+   * with its RecordId so a `record<…>` field coerces, and DROP reverse-subquery
+   * ARRAYS (`comments = [ … ]`) since their rows are cached separately as their
+   * own bodies. A flat record — as the live `SELECT * FROM $ids` sync returns,
+   * with relations already RecordIds — passes through unchanged.
+   */
+  private flattenRelationsForStorage;
   /**
    * Instant-hydrate: ingest rows fetched one-shot from the remote (the query's own
    * surql run directly) so the query DISPLAYS immediately, while the full realtime

package/dist/index.js

@@ -2689,13 +2689,29 @@ var DataModule = class {
 				batch.push({
 					table,
 					op: "CREATE",
-					record: tableSchema ? cleanRecord(tableSchema.columns, child) : child,
+					record: this.flattenRelationsForStorage(child, tableSchema),
 					version: child._00_rv || 1
 				});
 			}
 		}
 	}
 	/**
+	* Prepare a subquery-bearing row (preload / hydration) for the schemafull
+	* local store: replace an embedded FORWARD-relation object (`author = { id, … }`)
+	* with its RecordId so a `record<…>` field coerces, and DROP reverse-subquery
+	* ARRAYS (`comments = [ … ]`) since their rows are cached separately as their
+	* own bodies. A flat record — as the live `SELECT * FROM $ids` sync returns,
+	* with relations already RecordIds — passes through unchanged.
+	*/
+	flattenRelationsForStorage(record, tableSchema) {
+		const isEmbeddedRecord = (v) => !!v && typeof v === "object" && !(v instanceof RecordId) && v.id instanceof RecordId;
+		const flat = {};
+		for (const [k, v] of Object.entries(record)) if (isEmbeddedRecord(v)) flat[k] = v.id;
+		else if (Array.isArray(v) && v.some(isEmbeddedRecord)) continue;
+		else flat[k] = v;
+		return tableSchema ? cleanRecord(tableSchema.columns, flat) : flat;
+	}
+	/**
 	* Instant-hydrate: ingest rows fetched one-shot from the remote (the query's own
 	* surql run directly) so the query DISPLAYS immediately, while the full realtime
 	* registration proceeds in the background. Ingests with versions (`_00_rv`) so the
@@ -2725,10 +2741,11 @@ var DataModule = class {
 	* (preload).
 	*/
 	async buildAndSaveCacheBatch(tableName, rows) {
+		const tableSchema = this.schema.tables.find((t) => t.name === tableName);
 		const batch = rows.map((record) => ({
 			table: tableName,
 			op: "CREATE",
-			record,
+			record: this.flattenRelationsForStorage(record, tableSchema),
 			version: record._00_rv || 1
 		}));
 		const seen = new Set(rows.map((r) => encodeRecordId(r.id)));
@@ -5101,8 +5118,8 @@ function parseBackendInfo(raw) {
 
 //#endregion
 //#region src/modules/devtools/index.ts
-const CORE_VERSION = "0.0.1-canary.128";
-const WASM_VERSION = "0.0.1-canary.128";
+const CORE_VERSION = "0.0.1-canary.129";
+const WASM_VERSION = "0.0.1-canary.129";
 const SURREAL_VERSION = "3.0.3";
 var DevToolsService = class {
 	eventsHistory = [];
@@ -7310,6 +7327,7 @@ var Sp00kyClient = class {
 			await this.streamProcessor.reset();
 			this.streamProcessor.setPermissions(extractSelectPermissions(this.config.schemaSurql));
 			this.cache.clearVersionLookups();
+			this.preloadedHashes.clear();
 		} finally {
 			reopen();
 		}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spooky-sync/core",
-  "version": "0.0.1-canary.128",
+  "version": "0.0.1-canary.129",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -59,8 +59,8 @@
     }
   },
   "dependencies": {
-    "@spooky-sync/query-builder": "0.0.1-canary.128",
-    "@spooky-sync/ssp-wasm": "0.0.1-canary.128",
+    "@spooky-sync/query-builder": "0.0.1-canary.129",
+    "@spooky-sync/ssp-wasm": "0.0.1-canary.129",
     "@sqlite.org/sqlite-wasm": "3.53.0-build1",
     "@surrealdb/wasm": "^3.0.3",
     "fast-json-patch": "^3.1.1",

package/src/modules/data/index.ts

@@ -739,15 +739,47 @@ export class DataModule<S extends SchemaStructure> {
         batch.push({
           table,
           op: 'CREATE',
-          record: (tableSchema
-            ? cleanRecord(tableSchema.columns, child)
-            : child) as RecordWithId,
+          // Flatten the child too: a nested comment carries its own embedded
+          // `author` object which the schemafull `record<user>` field would
+          // reject. (Its author is captured as a separate row by the recursion
+          // above.)
+          record: this.flattenRelationsForStorage(child, tableSchema),
           version: (child._00_rv as number) || 1,
         });
       }
     }
   }
 
+  /**
+   * Prepare a subquery-bearing row (preload / hydration) for the schemafull
+   * local store: replace an embedded FORWARD-relation object (`author = { id, … }`)
+   * with its RecordId so a `record<…>` field coerces, and DROP reverse-subquery
+   * ARRAYS (`comments = [ … ]`) since their rows are cached separately as their
+   * own bodies. A flat record — as the live `SELECT * FROM $ids` sync returns,
+   * with relations already RecordIds — passes through unchanged.
+   */
+  private flattenRelationsForStorage(
+    record: Record<string, any>,
+    tableSchema?: { columns: Record<string, any> }
+  ): RecordWithId {
+    const isEmbeddedRecord = (v: unknown): boolean =>
+      !!v &&
+      typeof v === 'object' &&
+      !(v instanceof RecordId) &&
+      (v as { id?: unknown }).id instanceof RecordId;
+    const flat: Record<string, any> = {};
+    for (const [k, v] of Object.entries(record)) {
+      if (isEmbeddedRecord(v)) {
+        flat[k] = (v as { id: unknown }).id;
+      } else if (Array.isArray(v) && v.some(isEmbeddedRecord)) {
+        continue;
+      } else {
+        flat[k] = v;
+      }
+    }
+    return (tableSchema ? cleanRecord(tableSchema.columns, flat) : flat) as RecordWithId;
+  }
+
   /**
    * Instant-hydrate: ingest rows fetched one-shot from the remote (the query's own
    * surql run directly) so the query DISPLAYS immediately, while the full realtime
@@ -792,10 +824,18 @@ export class DataModule<S extends SchemaStructure> {
     tableName: string,
     rows: RecordWithId[]
   ): Promise<void> {
+    const tableSchema = this.schema.tables.find((t) => t.name === tableName);
     const batch: CacheRecord[] = rows.map((record) => ({
       table: tableName,
       op: 'CREATE' as const,
-      record,
+      // Flatten embedded relations first: a preload/hydration row can carry a
+      // forward relation as a full nested OBJECT (`author = { id, … }`) and a
+      // reverse subquery as an array of objects (`comments = [ … ]`). The
+      // schemafull local field is `record<user>`, which rejects an object
+      // (`Couldn't coerce … found { id: …, username: … }`) and would throw the
+      // WHOLE batch. Store the parent with `author` as its RecordId and drop the
+      // subquery arrays — the children are cached as their own rows below.
+      record: this.flattenRelationsForStorage(record, tableSchema),
       version: (record._00_rv as number) || 1,
     }));
 

package/src/sp00ky.ts

@@ -589,6 +589,11 @@ export class Sp00kyClient<S extends SchemaStructure> {
       await this.streamProcessor.reset();
       this.streamProcessor.setPermissions(extractSelectPermissions(this.config.schemaSurql));
       this.cache.clearVersionLookups();
+      // Preload dedup is per-bucket: the `_00_preload` markers + cached rows it
+      // guards live in the local store we just swapped away from. Keeping the
+      // hashes would make `preload()` skip warming the NEW bucket (its store is
+      // empty), so every thread/comment prewarm silently no-ops after login.
+      this.preloadedHashes.clear();
     } finally {
       reopen();
     }