@spooky-sync/core 0.0.1-canary.207 → 0.0.1-canary.208

package/dist/index.js

@@ -1,6 +1,6 @@
 import { a as renderOrderSql, c as serializeRow, i as projectedDataSql, l as resolveRelations, o as renderWhereSql, r as project, s as reviveRow, t as PROMOTION_OPEN_OPTIONS, u as stableKey } from "./sqlite-open.js";
 import { DateTime, Duration, RecordId, Surreal, Uuid, applyDiagnostics, createRemoteEngines } from "surrealdb";
-import { QueryBuilder, RecordId as RecordId$1, cyrb53 } from "@spooky-sync/query-builder";
+import { QueryBuilder, RecordId as RecordId$1, baseFieldOfParam, cyrb53 } from "@spooky-sync/query-builder";
 import pino from "pino";
 import { applyPatch } from "fast-json-patch";
 import init, { Sp00kyProcessor } from "@spooky-sync/ssp-wasm";
@@ -84,6 +84,10 @@ function cleanRecord(tableSchema, record) {
 	for (const [key, value] of Object.entries(record)) if (key === "id" || key.startsWith("_00_") || key in tableSchema) cleaned[key] = value;
 	return cleaned;
 }
+/**
+* Parse a RECORD's fields against the table schema. Anything the schema does not
+* know is dropped, which is what keeps a stray field out of a write.
+*/
 function parseParams(tableSchema, params) {
 	const parsedParams = {};
 	for (const [key, value] of Object.entries(params)) {
@@ -92,6 +96,26 @@ function parseParams(tableSchema, params) {
 	}
 	return parsedParams;
 }
+/**
+* Parse a QUERY's params. Unlike a record's fields, a param name is not always a
+* column: an `_or` branch binds under a synthetic `white__or0` (see
+* `orParamName` in @spooky-sync/query-builder), and the surql that references it
+* is already written. So resolve the column through the synthetic name, and keep
+* a param we cannot type rather than dropping it.
+*
+* Dropping was the bug: `parseParams` kept only column-named params, so every
+* `_or` query registered with `$or0`/`$or1` unbound and matched no rows at all,
+* silently (rowCount 0, errorCount 0).
+*/
+function parseQueryParams(tableSchema, params) {
+	const parsedParams = {};
+	for (const [key, value] of Object.entries(params)) {
+		if (value === void 0) continue;
+		const column = tableSchema[key] ?? tableSchema[baseFieldOfParam(key)];
+		parsedParams[key] = column ? parseValue(key, column, value) : value;
+	}
+	return parsedParams;
+}
 function parseValue(name, column, value) {
 	if (column.recordId) {
 		if (value instanceof RecordId$1) return value;
@@ -4735,7 +4759,7 @@ var DataModule = class DataModule {
 			...configRecord,
 			id: recordId,
 			plan,
-			params: parseParams(tableSchema.columns, configRecord.params),
+			params: parseQueryParams(tableSchema.columns, params ?? configRecord.params),
 			membershipKey
 		};
 		if (membershipKey && !config.remoteArray?.length) {
@@ -7414,8 +7438,8 @@ function selfAllowlistedVariant(flag, userId) {
 
 //#endregion
 //#region src/modules/devtools/index.ts
-const CORE_VERSION = "0.0.1-canary.207";
-const WASM_VERSION = "0.0.1-canary.207";
+const CORE_VERSION = "0.0.1-canary.208";
+const WASM_VERSION = "0.0.1-canary.208";
 const SURREAL_VERSION = "3.0.3";
 var DevToolsService = class DevToolsService {
 	eventsHistory = [];
@@ -12399,7 +12423,7 @@ var Sp00kyClient = class {
 		return new TabsCoordinator({
 			tabId,
 			fingerprint: computeTabsFingerprint({
-				coreVersion: "0.0.1-canary.207",
+				coreVersion: "0.0.1-canary.208",
 				schemaHash: hash53(this.config.schemaSurql),
 				endpoint: this.config.database.endpoint ?? "",
 				namespace: this.config.database.namespace,
@@ -12836,7 +12860,7 @@ var Sp00kyClient = class {
 	async initQuery(table, q, ttl) {
 		const tableSchema = this.config.schema.tables.find((t) => t.name === table);
 		if (!tableSchema) throw new Error(`Table ${table} not found`);
-		const params = parseParams(tableSchema.columns, q.selectQuery.vars ?? {});
+		const params = parseQueryParams(tableSchema.columns, q.selectQuery.vars ?? {});
 		const hash = await this.dataModule.query(table, q.selectQuery.query, params, ttl, q.selectQuery.plan);
 		if (!this.pendingQueryInits.has(hash)) {
 			const chain = this.finishQueryInit(hash, q, params).finally(() => {
@@ -12908,7 +12932,7 @@ var Sp00kyClient = class {
 		const tableName = q.tableName;
 		const tableSchema = this.config.schema.tables.find((t) => t.name === tableName);
 		if (!tableSchema) throw new Error(`Table ${tableName} not found`);
-		const params = parseParams(tableSchema.columns, q.selectQuery.vars ?? {});
+		const params = parseQueryParams(tableSchema.columns, q.selectQuery.vars ?? {});
 		const hashKey = String(q.hash);
 		const marker = await this.dataModule.getPreloadMarker(hashKey);
 		if (!marker) {

package/package.json

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

package/src/modules/data/index.ts

@@ -38,6 +38,7 @@ import {
   withRetry,
   surql,
   parseParams,
+  parseQueryParams,
   cleanRecord,
   extractTablePart,
   generateId,
@@ -2230,7 +2231,15 @@ export class DataModule<S extends SchemaStructure> {
       // In-memory only — carries the engine-neutral plan so non-SurrealQL local
       // engines materialize via `select(plan)` instead of parsing `surql`.
       plan,
-      params: parseParams(tableSchema.columns, configRecord.params),
+      // The CALLER's params, not the ones read back out of the local store: the
+      // store returns a RecordId as a plain `'table:id'` string, and
+      // `parseQueryParams` can only turn it back into a RecordId for a column
+      // the schema marks `recordId`. A union column (`string | record<x>`)
+      // codegens as a plain string, so its param stayed a string and the view
+      // compared a string against a record and matched nothing. The record id is
+      // the same query either way - `recordId` is the hash of surql + vars - so
+      // the in-memory value is the same one, with its types intact.
+      params: parseQueryParams(tableSchema.columns, params ?? configRecord.params),
       membershipKey,
     };
 

package/src/sp00ky.ts

@@ -52,7 +52,7 @@ import { AppReleaseModule, AppReleaseHandle } from './modules/app-release/index'
 import type { AppReleaseOptions } from './modules/app-release/index';
 import { LocalStoragePersistenceClient } from './services/persistence/localstorage';
 import { ANON_USER_ID, bucketIdForUser } from './modules/ref-tables';
-import { parseParams, encodeRecordId, parseDuration } from './utils/index';
+import { parseQueryParams, encodeRecordId, parseDuration } from './utils/index';
 import { SurrealDBPersistenceClient } from './services/persistence/surrealdb';
 import { ResilientPersistenceClient } from './services/persistence/resilient';
 import { detectSharedTabsSupport } from './services/tabs/support';
@@ -1358,7 +1358,7 @@ export class Sp00kyClient<S extends SchemaStructure> {
       throw new Error(`Table ${table} not found`);
     }
 
-    const params = parseParams(tableSchema.columns, q.selectQuery.vars ?? {});
+    const params = parseQueryParams(tableSchema.columns, q.selectQuery.vars ?? {});
     const hash = await this.dataModule.query(
       table,
       q.selectQuery.query,
@@ -1470,7 +1470,7 @@ export class Sp00kyClient<S extends SchemaStructure> {
     if (!tableSchema) {
       throw new Error(`Table ${tableName} not found`);
     }
-    const params = parseParams(tableSchema.columns, q.selectQuery.vars ?? {});
+    const params = parseQueryParams(tableSchema.columns, q.selectQuery.vars ?? {});
     const hashKey = String(q.hash);
 
     const marker = await this.dataModule.getPreloadMarker(hashKey);

package/src/utils/parser.test.ts

@@ -1,125 +1,54 @@
-import { describe, it, expect } from 'vitest';
-import { RecordId } from 'surrealdb';
-import { parseParams, cleanRecord } from './parser';
-
-describe('parseParams', () => {
-  it('passes through plain values unchanged', () => {
-    const schema = {
-      name: { type: 'string' as const, optional: false },
-      age: { type: 'number' as const, optional: false },
-    };
-    const result = parseParams(schema, { name: 'Alice', age: 30 });
-    expect(result).toEqual({ name: 'Alice', age: 30 });
-  });
-
-  it('converts string to RecordId for recordId columns', () => {
-    const schema = {
-      owner: { type: 'string' as const, optional: false, recordId: true },
-    };
-    const result = parseParams(schema, { owner: 'user:123' });
-    expect(result.owner).toBeInstanceOf(RecordId);
-    expect(result.owner.table.toString()).toBe('user');
-    expect(result.owner.id).toBe('123');
-  });
-
-  it('passes through existing RecordId for recordId columns', () => {
-    const schema = {
-      owner: { type: 'string' as const, optional: false, recordId: true },
-    };
-    const rid = new RecordId('user', '456');
-    const result = parseParams(schema, { owner: rid });
-    expect(result.owner).toBe(rid);
-  });
-
-  it('converts string to Date for dateTime columns', () => {
-    const schema = {
-      createdAt: { type: 'string' as const, optional: false, dateTime: true },
-    };
-    const result = parseParams(schema, { createdAt: '2024-01-01T00:00:00Z' });
-    expect(result.createdAt).toBeInstanceOf(Date);
-    expect(result.createdAt.toISOString()).toBe('2024-01-01T00:00:00.000Z');
-  });
-
-  it('converts number (timestamp) to Date for dateTime columns', () => {
-    const schema = {
-      createdAt: { type: 'string' as const, optional: false, dateTime: true },
-    };
-    const ts = 1704067200000; // 2024-01-01T00:00:00.000Z
-    const result = parseParams(schema, { createdAt: ts });
-    expect(result.createdAt).toBeInstanceOf(Date);
-    expect(result.createdAt.getTime()).toBe(ts);
-  });
-
-  it('passes through existing Date for dateTime columns', () => {
-    const schema = {
-      createdAt: { type: 'string' as const, optional: false, dateTime: true },
-    };
-    const date = new Date('2024-01-01');
-    const result = parseParams(schema, { createdAt: date });
-    expect(result.createdAt).toBe(date);
-  });
-
-  it('skips undefined values', () => {
-    const schema = {
-      name: { type: 'string' as const, optional: false },
-      age: { type: 'number' as const, optional: true },
-    };
-    const result = parseParams(schema, { name: 'Alice', age: undefined });
-    expect(result).toEqual({ name: 'Alice' });
-    expect('age' in result).toBe(false);
-  });
-
-  it('throws on invalid recordId value', () => {
-    const schema = {
-      owner: { type: 'string' as const, optional: false, recordId: true },
-    };
-    expect(() => parseParams(schema, { owner: 12345 })).toThrow('Invalid value for owner');
-  });
-
-  it('throws on invalid dateTime value', () => {
-    const schema = {
-      createdAt: { type: 'string' as const, optional: false, dateTime: true },
-    };
-    expect(() => parseParams(schema, { createdAt: true })).toThrow(
-      'Invalid value for createdAt'
-    );
+import { describe, expect, it } from 'vitest';
+import { RecordId } from '@spooky-sync/query-builder';
+import { parseParams, parseQueryParams } from './parser';
+
+const columns = {
+  white: { recordId: true },
+  black: { recordId: true },
+  owner: { recordId: true },
+  created_at: { dateTime: true },
+  result: {},
+} as any;
+
+describe('parseQueryParams', () => {
+  // The regression this exists for: an `_or` group binds under synthetic names,
+  // and dropping them left `(white = $white__or0 OR black = $black__or1)` with
+  // nothing bound, so every OR query registered and matched no rows at all.
+  it('keeps an _or branch param and types it through its field', () => {
+    const parsed = parseQueryParams(columns, {
+      owner: 'user:abc',
+      white__or0: 'player_name:PN_1',
+      black__or1: 'player_name:PN_1',
+    });
+
+    expect(Object.keys(parsed).sort()).toEqual(['black__or1', 'owner', 'white__or0']);
+    expect(parsed.white__or0).toBeInstanceOf(RecordId);
+    expect(String(parsed.white__or0)).toBe('player_name:PN_1');
+    expect(parsed.black__or1).toBeInstanceOf(RecordId);
+  });
+
+  it('passes a param it cannot resolve through untouched instead of dropping it', () => {
+    const parsed = parseQueryParams(columns, { in: 'anything', limit: 30 });
+    expect(parsed).toEqual({ in: 'anything', limit: 30 });
+  });
+
+  it('still types and keeps plain column params, and skips undefined', () => {
+    const parsed = parseQueryParams(columns, {
+      owner: 'user:abc',
+      created_at: '2026-01-01T00:00:00.000Z',
+      result: undefined,
+    });
+    expect(parsed.owner).toBeInstanceOf(RecordId);
+    expect(parsed.created_at).toBeInstanceOf(Date);
+    expect('result' in parsed).toBe(false);
   });
 });
 
-describe('cleanRecord', () => {
-  const tableSchema = {
-    name: { type: 'string' as const, optional: false },
-    age: { type: 'number' as const, optional: false },
-  };
-
-  it('keeps schema fields and strips non-schema fields', () => {
-    const record = { id: 'user:1', name: 'Alice', age: 30, _internal: true, computed_score: 99 };
-    const result = cleanRecord(tableSchema, record);
-    expect(result).toEqual({ id: 'user:1', name: 'Alice', age: 30 });
-  });
-
-  it('always preserves id even though it is not in schema', () => {
-    const record = { id: 'user:2', extra: 'gone' };
-    const result = cleanRecord(tableSchema, record);
-    expect(result).toEqual({ id: 'user:2' });
-  });
-
-  it('does not coerce or transform values', () => {
-    const date = new Date('2024-01-01');
-    const schema = { created: { type: 'string' as const, optional: false, dateTime: true } };
-    const record = { id: 'x:1', created: date };
-    const result = cleanRecord(schema, record);
-    expect(result.created).toBe(date);
-  });
-
-  it('returns only id when record has no schema fields', () => {
-    const record = { id: 'user:3', unknown1: 'a', unknown2: 'b' };
-    const result = cleanRecord(tableSchema, record);
-    expect(result).toEqual({ id: 'user:3' });
-  });
-
-  it('handles empty record', () => {
-    const result = cleanRecord(tableSchema, {});
-    expect(result).toEqual({});
+describe('parseParams', () => {
+  // Records keep the old behaviour: a field the schema does not know is dropped
+  // rather than written.
+  it('drops a field that is not a column', () => {
+    const parsed = parseParams(columns, { result: '1-0', nonsense: 'x', white__or0: 'y' });
+    expect(parsed).toEqual({ result: '1-0' });
   });
 });

package/src/utils/parser.ts

@@ -1,5 +1,5 @@
 import type { ColumnSchema} from '@spooky-sync/query-builder';
-import { RecordId } from '@spooky-sync/query-builder';
+import { RecordId, baseFieldOfParam } from '@spooky-sync/query-builder';
 import { parseRecordIdString } from './index';
 import { DateTime } from 'surrealdb';
 
@@ -16,6 +16,10 @@ export function cleanRecord(
   return cleaned;
 }
 
+/**
+ * Parse a RECORD's fields against the table schema. Anything the schema does not
+ * know is dropped, which is what keeps a stray field out of a write.
+ */
 export function parseParams(
   tableSchema: Record<string, ColumnSchema>,
   params: Record<string, any>
@@ -31,6 +35,31 @@ export function parseParams(
   return parsedParams;
 }
 
+/**
+ * Parse a QUERY's params. Unlike a record's fields, a param name is not always a
+ * column: an `_or` branch binds under a synthetic `white__or0` (see
+ * `orParamName` in @spooky-sync/query-builder), and the surql that references it
+ * is already written. So resolve the column through the synthetic name, and keep
+ * a param we cannot type rather than dropping it.
+ *
+ * Dropping was the bug: `parseParams` kept only column-named params, so every
+ * `_or` query registered with `$or0`/`$or1` unbound and matched no rows at all,
+ * silently (rowCount 0, errorCount 0).
+ */
+export function parseQueryParams(
+  tableSchema: Record<string, ColumnSchema>,
+  params: Record<string, any>
+) {
+  const parsedParams: Record<string, any> = {};
+  for (const [key, value] of Object.entries(params)) {
+    if (value === undefined) continue;
+    const column = tableSchema[key] ?? tableSchema[baseFieldOfParam(key)];
+    parsedParams[key] = column ? parseValue(key, column, value) : value;
+  }
+
+  return parsedParams;
+}
+
 function parseValue(name: string, column: ColumnSchema, value: any) {
   if (column.recordId) {
     if (value instanceof RecordId) return value;