spacetimedb 2.0.3 → 2.1.0

package/src/sdk/table_cache.ts

@@ -12,7 +12,6 @@ import type {
   ReadonlyIndexes,
   ReadonlyRangedIndex,
   ReadonlyUniqueIndex,
-  UntypedIndex,
 } from '../lib/indexes.ts';
 import type { Bound } from '../server/range.ts';
 import type { Prettify } from '../lib/type_util.ts';
@@ -84,23 +83,27 @@ export class TableCacheImpl<
     this.tableDef = tableDef;
     this.rows = new Map();
     this.emitter = new EventEmitter();
-    // Build indexes
-    const indexesDef = this.tableDef.indexes || [];
-    for (const idx of indexesDef) {
-      // TODO: don't do this. See comment in `tableToSchema` in `schema.ts`
-      const idxDef = idx as UntypedIndex<
-        keyof TableDefForTableName<RemoteModule, TableName>['columns'] & string
-      >;
+    // Build index views from the resolved runtime index metadata.
+    //
+    // We intentionally use `resolvedIndexes` rather than `indexes`:
+    // - `indexes` is declarative table-level config (`IndexOpts`) used mainly for typing.
+    // - `resolvedIndexes` is the runtime shape (`UntypedIndex`) that includes both
+    //   field-level and explicit table-level indexes.
+    for (const idxDef of this.tableDef.resolvedIndexes) {
       const index = this.#makeReadonlyIndex(this.tableDef, idxDef);
+      // IMPORTANT: for duplicate accessor names, client cache uses assignment
+      // semantics and later entries overwrite earlier ones. This matches prior
+      // behavior and is intentionally different from server runtime merge logic.
       (this as any)[idxDef.name] = index;
     }
   }
 
   // TODO: this just scans the whole table; we should build proper index structures
   #makeReadonlyIndex<
-    I extends UntypedIndex<
-      keyof TableDefForTableName<RemoteModule, TableName>['columns'] & string
-    >,
+    I extends TableDefForTableName<
+      RemoteModule,
+      TableName
+    >['resolvedIndexes'][number],
   >(
     tableDef: TableDefForTableName<RemoteModule, TableName>,
     idx: I

package/src/sdk/websocket_decompress_adapter.ts

@@ -1,48 +1,55 @@
 import { decompress } from './decompress';
 import { resolveWS } from './ws';
 
-export class WebsocketDecompressAdapter {
-  onclose?: (...ev: any[]) => void;
-  onopen?: (...ev: any[]) => void;
-  onmessage?: (msg: { data: Uint8Array }) => void;
-  onerror?: (msg: ErrorEvent) => void;
-
-  #ws: WebSocket;
-
-  async #handleOnMessage(msg: MessageEvent) {
-    const buffer = new Uint8Array(msg.data);
-    let decompressed: Uint8Array;
-
-    if (buffer[0] === 0) {
-      decompressed = buffer.slice(1);
-    } else if (buffer[0] === 1) {
-      throw new Error(
-        'Brotli Compression not supported. Please use gzip or none compression in withCompression method on DbConnection.'
-      );
-    } else if (buffer[0] === 2) {
-      decompressed = await decompress(buffer.slice(1), 'gzip');
-    } else {
-      throw new Error(
-        'Unexpected Compression Algorithm. Please use `gzip` or `none`'
-      );
-    }
+export interface WebsocketAdapter {
+  send(msg: Uint8Array): void;
+  close(): void;
+
+  set onclose(handler: (ev: CloseEvent) => void);
+  set onopen(handler: () => void);
+  set onmessage(handler: (msg: { data: Uint8Array }) => void);
+  set onerror(handler: (msg: ErrorEvent) => void);
+}
 
-    this.onmessage?.({ data: decompressed });
+export class WebsocketDecompressAdapter implements WebsocketAdapter {
+  set onclose(handler: (ev: CloseEvent) => void) {
+    this.#ws.onclose = handler;
   }
-
-  #handleOnOpen(msg: any) {
-    this.onopen?.(msg);
+  set onopen(handler: () => void) {
+    this.#ws.onopen = handler;
   }
-
-  #handleOnError(msg: any) {
-    this.onerror?.(msg);
+  set onmessage(handler: (msg: { data: Uint8Array }) => void) {
+    this.#ws.onmessage = async (msg: MessageEvent<ArrayBuffer>) => {
+      const data = await this.#decompress(new Uint8Array(msg.data));
+      handler({ data });
+    };
+  }
+  set onerror(handler: (msg: ErrorEvent) => void) {
+    this.#ws.onerror = handler as (msg: Event) => void;
   }
 
-  #handleOnClose(msg: any) {
-    this.onclose?.(msg);
+  #ws: WebSocket;
+
+  async #decompress(buffer: Uint8Array): Promise<Uint8Array> {
+    const tag = buffer[0];
+    const data = buffer.subarray(1);
+    switch (tag) {
+      case 0:
+        return data;
+      case 1:
+        throw new Error(
+          'Brotli Compression not supported. Please use gzip or none compression in withCompression method on DbConnection.'
+        );
+      case 2:
+        return await decompress(data, 'gzip');
+      default:
+        throw new Error(
+          'Unexpected Compression Algorithm. Please use `gzip` or `none`'
+        );
+    }
   }
 
-  send(msg: any): void {
+  send(msg: Uint8Array): void {
     this.#ws.send(msg);
   }
 
@@ -51,16 +58,6 @@ export class WebsocketDecompressAdapter {
   }
 
   constructor(ws: WebSocket) {
-    this.onmessage = undefined;
-    this.onopen = undefined;
-    this.onmessage = undefined;
-    this.onerror = undefined;
-
-    ws.onmessage = this.#handleOnMessage.bind(this);
-    ws.onerror = this.#handleOnError.bind(this);
-    ws.onclose = this.#handleOnClose.bind(this);
-    ws.onopen = this.#handleOnOpen.bind(this);
-
     ws.binaryType = 'arraybuffer';
 
     this.#ws = ws;

package/src/sdk/websocket_test_adapter.ts

@@ -1,10 +1,11 @@
 import { BinaryReader, BinaryWriter } from '../';
 import { ClientMessage, ServerMessage } from './client_api/types';
+import type { WebsocketAdapter } from './websocket_decompress_adapter';
 
-class WebsocketTestAdapter {
+class WebsocketTestAdapter implements WebsocketAdapter {
   onclose: any;
   // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
-  onopen!: Function;
+  onopen!: () => void;
   onmessage: any;
   onerror: any;
 

package/src/server/index.ts

@@ -21,5 +21,6 @@ export { toCamelCase } from '../lib/util';
 export type { Uuid } from '../lib/uuid';
 export type { Random } from './rng';
 export type { ViewExport, ViewCtx, AnonymousViewCtx } from './views';
+export { Range, type Bound } from './range';
 
 import './polyfills'; // Ensure polyfills are loaded

package/src/server/runtime.ts

@@ -516,6 +516,7 @@ function makeTableView(
   ) as Table<any>;
 
   for (const indexDef of table.indexes) {
+    const accessorName = indexDef.accessorName!;
     const index_id = sys.index_id_from_name(indexDef.sourceName!);
 
     let column_ids: number[];
@@ -795,10 +796,13 @@ function makeTableView(
       } as RangedIndex<any, any>;
     }
 
-    if (Object.hasOwn(tableView, indexDef.accessorName!)) {
-      freeze(Object.assign(tableView[indexDef.accessorName!], index));
+    // IMPORTANT: duplicate accessor handling.
+    // When multiple raw indexes share the same accessor name, we merge index
+    // methods onto a single accessor object instead of throwing.
+    if (Object.hasOwn(tableView, accessorName)) {
+      freeze(Object.assign((tableView as any)[accessorName], index));
     } else {
-      tableView[indexDef.accessorName!] = freeze(index) as any;
+      (tableView as any)[accessorName] = freeze(index);
     }
   }
 

package/src/server/schema.test-d.ts

@@ -60,3 +60,40 @@ spacetimedb.init(ctx => {
   // @ts-expect-error update() is NOT allowed on non-PK unique indexes
   const _update = ctx.db.person.name2.update;
 });
+
+/**
+ * Regression coverage for the declared-vs-resolved index split:
+ * - declared table-level indexes must still produce typed accessors
+ * - field-level indexes must still produce typed accessors
+ * - non-indexed fields must not accidentally become index accessors
+ */
+const account = table(
+  {
+    indexes: [
+      {
+        accessor: 'byEmailAndOrg',
+        algorithm: 'btree',
+        columns: ['email', 'orgId'] as const,
+      },
+    ] as const,
+  },
+  {
+    accountId: t.u32(),
+    email: t.string().index('hash'),
+    orgId: t.u32(),
+    nickname: t.string(),
+  }
+);
+
+const spacetimedbIndexSplit = schema({ account });
+
+spacetimedbIndexSplit.init(ctx => {
+  // Explicit table-level index accessor from `table({ indexes: [...] })`.
+  ctx.db.account.byEmailAndOrg.filter(['a@example.com', 1]);
+
+  // Field-level index accessor derived from column metadata.
+  ctx.db.account.email.filter('a@example.com');
+
+  // @ts-expect-error `nickname` is not indexed, so no index accessor should exist.
+  const _nickname = ctx.db.account.nickname;
+});

package/src/server/view.test-d.ts

@@ -7,6 +7,7 @@ const person = table(
     name: 'person',
     indexes: [
       {
+        accessor: 'name_id_idx',
         name: 'name_id_idx',
         algorithm: 'btree',
         columns: ['name', 'id'] as const,
@@ -48,6 +49,7 @@ const order = table(
     name: 'order',
     indexes: [
       {
+        accessor: 'id_person_id',
         name: 'id_person_id', // We are adding this to make sure `person_id` still isn't considered indexed.
         algorithm: 'btree',
         columns: ['id', 'person_id'] as const,
@@ -159,6 +161,10 @@ spacetime.anonymousView({ name: 'v5', public: true }, arrayRetValue, ctx => {
     .where(row => row.id.eq(5))
     .leftSemijoin(ctx.from.order, (p, o) => p.name.eq(o.person_name))
     .build();
+  const _mixedScopeAndInJoinPredicate = ctx.from.person
+    // @ts-expect-error semijoin on(...) only supports one table scope for and/or clauses.
+    .leftSemijoin(ctx.from.order, (p, o) => p.id.eq(o.id).and(o.id.eq(5)))
+    .build();
   return ctx.from.person
     .where(row => row.id.eq(5))
     .leftSemijoin(ctx.from.order, (p, o) => p.id.eq(o.id))

package/src/tanstack/SpacetimeDBQueryClient.ts

@@ -96,6 +96,7 @@ export class SpacetimeDBQueryClient {
   setConnection(connection: SpacetimeConnection): void {
     this.connection = connection;
     this.processPendingQueries();
+    this.hydrateSubscriptions();
   }
 
   connect(queryClient: QueryClient): void {
@@ -289,6 +290,29 @@ export class SpacetimeDBQueryClient {
     }
   }
 
+  // subscribe to queries with SSR cached data but no active subscription
+  private hydrateSubscriptions(): void {
+    if (!this.connection || !this.queryClient) {
+      return;
+    }
+
+    for (const [querySql, { accessorName, whereExpr }] of queryRegistry) {
+      const queryKey = ['spacetimedb', accessorName, querySql] as const;
+      const keyStr = JSON.stringify(queryKey);
+
+      if (this.subscriptions.has(keyStr)) {
+        continue;
+      }
+      if (this.queryClient.getQueryData(queryKey) === undefined) {
+        continue;
+      }
+
+      this.setupSubscription(queryKey, accessorName, querySql, whereExpr).catch(
+        () => {}
+      );
+    }
+  }
+
   // clean up all subscriptions and disconnect
   disconnect(): void {
     if (this.cacheUnsubscribe) {