spacetimedb 2.0.2 → 2.0.4

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/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,

package/src/tanstack/SpacetimeDBQueryClient.ts

@@ -4,13 +4,15 @@ import type {
   QueryFunction,
 } from '@tanstack/react-query';
 import {
+  type Query,
+  toSql,
   type BooleanExpr,
   evaluateBooleanExpr,
   getQueryAccessorName,
   getQueryWhereClause,
 } from '../lib/query';
 
-type QueryInput = { toSql(): string } & Record<string, any>;
+type QueryInput = Query<any>;
 
 const queryRegistry = new Map<
   string,
@@ -51,7 +53,7 @@ export function spacetimeDBQuery(
   const query = queryOrSkip;
   const accessorName = getQueryAccessorName(query);
   const whereExpr = getQueryWhereClause(query);
-  const querySql = query.toSql();
+  const querySql = toSql(query);
 
   queryRegistry.set(querySql, { accessorName, whereExpr });
 
@@ -94,6 +96,7 @@ export class SpacetimeDBQueryClient {
   setConnection(connection: SpacetimeConnection): void {
     this.connection = connection;
     this.processPendingQueries();
+    this.hydrateSubscriptions();
   }
 
   connect(queryClient: QueryClient): void {
@@ -287,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) {

package/src/tanstack/hooks.ts

@@ -6,6 +6,7 @@ import type {
   UseSuspenseQueryResult,
 } from '@tanstack/react-query';
 import type { UntypedTableDef, RowType } from '../lib/table';
+import type { Query } from '../lib/query';
 import { spacetimeDBQuery } from './SpacetimeDBQueryClient';
 
 export type UseSpacetimeDBQueryResult<T> = [
@@ -29,7 +30,7 @@ export type UseSpacetimeDBSuspenseQueryResult<T> = [
 //   useSpacetimeDBQuery(tables.user.where(r => r.online.eq(true)))
 //   useSpacetimeDBQuery(condition ? tables.user : 'skip')
 export function useSpacetimeDBQuery<TableDef extends UntypedTableDef>(
-  queryOrSkip: ({ toSql(): string } & Record<string, any>) | 'skip',
+  queryOrSkip: Query<TableDef> | 'skip',
   // any useQuery option (e.g. enabled, refetchInterval, select, placeholderData),
   // except queryKey, queryFn, and meta (managed internally)
   options?: Omit<
@@ -60,7 +61,7 @@ export function useSpacetimeDBQuery<TableDef extends UntypedTableDef>(
 // until data is ready, a parent <Suspense fallback={…}> handles the loading UI.
 // does not support 'skip' because useSuspenseQuery must always resolve
 export function useSpacetimeDBSuspenseQuery<TableDef extends UntypedTableDef>(
-  query: { toSql(): string } & Record<string, any>,
+  query: Query<TableDef>,
   options?: Omit<
     UseSuspenseQueryOptions<
       RowType<TableDef>[],