@spooky-sync/core 0.0.1-canary.239 → 0.0.1-canary.240

package/dist/index.js

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

package/dist/sqlite-open.js

@@ -46,6 +46,7 @@ async function resolveOne(parents, relation, fetcher, depth, path) {
 	for (const parent of parents) {
 		const key = parentKeyOf(parent);
 		if (key == null) continue;
+		if (isOne && !looksLikeRecordId(key)) continue;
 		const k = stableKey(key);
 		if (!keySet.has(k)) keySet.set(k, key);
 	}
@@ -72,10 +73,28 @@ async function resolveOne(parents, relation, fetcher, depth, path) {
 		let bucket = key == null ? [] : grouped.get(stableKey(key)) ?? [];
 		if (relation.orderBy && relation.orderBy.length > 0) bucket = sortRows(bucket, relation.orderBy);
 		if (relation.limit !== void 0) bucket = bucket.slice(0, relation.limit);
-		parent[relation.alias] = isOne ? bucket[0] ?? null : bucket;
+		if (isOne) {
+			const raw = parent[relation.alias];
+			const keepRaw = relation.alias === relation.foreignKeyField && raw != null && !looksLikeRecordId(raw);
+			parent[relation.alias] = bucket[0] ?? (keepRaw ? raw : null);
+		} else parent[relation.alias] = bucket;
 	}
 }
 /**
+* Whether a correlation value can address a record: a RecordId (duck-typed) or
+* a `table:id` string. Anything else (a plain display string, a number) cannot
+* be the target of a to-one relation and is skipped rather than fetched.
+*/
+function looksLikeRecordId(value) {
+	if (value == null) return false;
+	if (typeof value === "string") return /^[A-Za-z_][A-Za-z0-9_]*:.+/.test(value);
+	if (typeof value === "object") {
+		const rid = value;
+		return rid.tb !== void 0 && rid.id !== void 0;
+	}
+	return false;
+}
+/**
 * Stable grouping key for a correlation value. A `RecordId` (duck-typed to
 * avoid a hard surrealdb dependency here) and its `table:id` string form must
 * collapse to the same key so a parent FK stored either way matches the child.

package/package.json

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

package/src/services/database/relation-resolver.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect } from 'vitest';
 import type { RelationPlan, WhereNode } from '@spooky-sync/query-builder';
-import { resolveRelations, sortRows, stableKey } from './relation-resolver';
+import { looksLikeRecordId, resolveRelations, sortRows, stableKey } from './relation-resolver';
 import {
   RelationCycleError,
   type RelationFetch,
@@ -411,3 +411,57 @@ describe('resolveRelations — property: batched == naive over random trees', ()
     }
   });
 });
+
+describe('to-one relations over a `string | record` column', () => {
+  const rel = (alias: string, fk: string): RelationPlan => ({
+    table: 'player_name',
+    alias,
+    cardinality: 'one',
+    foreignKeyField: fk,
+  });
+
+  it('keeps a legacy plain string when the alias is the foreign-key column', async () => {
+    const store = new MemStore({
+      player_name: [{ id: 'player_name:PN_1', name: 'Magnus' }],
+    });
+    const rows: Row[] = [
+      { id: 'game:1', white: 'player_name:PN_1' },
+      { id: 'game:2', white: 'Hikaru' }, // pre-normalization row: not a link
+      { id: 'game:3', white: 'player_name:PN_gone' }, // dangling link
+    ];
+    await resolveRelations(rows, [rel('white', 'white')], store);
+    expect(rows[0].white).toEqual({ id: 'player_name:PN_1', name: 'Magnus' });
+    expect(rows[1].white).toBe('Hikaru');
+    // A dangling LINK is null, like SurrealQL's `(SELECT …)[0] AS white`.
+    expect(rows[2].white).toBeNull();
+  });
+
+  it('never sends a non-record value as a correlation key', async () => {
+    const seen: unknown[][] = [];
+    const store: RowFetcher = {
+      fetchRelation: async (req) => {
+        seen.push(req.keys);
+        return [];
+      },
+    };
+    const rows: Row[] = [{ id: 'game:1', white: 'Hikaru' }, { id: 'game:2', white: 'player_name:PN_2' }];
+    await resolveRelations(rows, [rel('white', 'white')], store);
+    expect(seen).toEqual([['player_name:PN_2']]);
+  });
+
+  it('nulls a distinct alias when nothing resolves', async () => {
+    const store = new MemStore({ player_name: [] });
+    const rows: Row[] = [{ id: 'game:1', white: 'player_name:PN_gone' }];
+    await resolveRelations(rows, [rel('whiteRow', 'white')], store);
+    expect(rows[0].whiteRow).toBeNull();
+    expect(rows[0].white).toBe('player_name:PN_gone');
+  });
+
+  it('looksLikeRecordId accepts table:id strings and RecordId shapes only', () => {
+    expect(looksLikeRecordId('player_name:PN_1')).toBe(true);
+    expect(looksLikeRecordId({ tb: 'player_name', id: 'PN_1' })).toBe(true);
+    expect(looksLikeRecordId('Magnus')).toBe(false);
+    expect(looksLikeRecordId(42)).toBe(false);
+    expect(looksLikeRecordId(null)).toBe(false);
+  });
+});