spacetimedb 2.0.4 → 2.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spacetimedb",
-  "version": "2.0.4",
+  "version": "2.1.0",
   "description": "API and ABI bindings for the SpacetimeDB TypeScript module library",
   "homepage": "https://github.com/clockworklabs/SpacetimeDB#readme",
   "bugs": {

package/src/lib/algebraic_type.ts

@@ -535,7 +535,11 @@ const view = reader.view;
 ${ty.elements
   .map(({ name, algebraicType: { tag } }) =>
     tag in primitiveJSName
-      ? `\
+      ? tag === 'Bool'
+        ? `\
+result.${name} = view.getUint8(reader.offset) !== 0;
+reader.offset += 1;`
+        : `\
 result.${name} = view.get${primitiveJSName[tag as JSPrimitives]}(reader.offset, ${primitiveSizes[tag] > 1 ? 'true' : ''});
 reader.offset += ${primitiveSizes[tag]};`
       : `result.${name} = reader.read${tag}();`

package/src/lib/query.ts

@@ -348,7 +348,8 @@ function createRowExpr<TableDef extends TypedTableDef>(
       columnBuilder.typeBuilder.algebraicType as InferSpacetimeTypeOfColumn<
         TableDef,
         typeof columnName
-      >
+      >,
+      columnBuilder.columnMetadata.name
     );
     row[columnName] = Object.freeze(column);
   }
@@ -438,7 +439,10 @@ export class ColumnExpression<
   ColumnName extends ColumnNames<TableDef>,
 > {
   readonly type = 'column' as const;
+  // This is the column accessor
   readonly column: ColumnName;
+  // The name of the column in the database.
+  readonly columnName: string;
   readonly table: TableDef['sourceName'];
   // phantom: actual runtime value is undefined
   readonly tsValueType?: RowType<TableDef>[ColumnName];
@@ -447,10 +451,12 @@ export class ColumnExpression<
   constructor(
     table: TableDef['sourceName'],
     column: ColumnName,
-    spacetimeType: InferSpacetimeTypeOfColumn<TableDef, ColumnName>
+    spacetimeType: InferSpacetimeTypeOfColumn<TableDef, ColumnName>,
+    columnName?: string
   ) {
     this.table = table;
     this.column = column;
+    this.columnName = columnName || column;
     this.spacetimeType = spacetimeType;
   }
 
@@ -710,15 +716,38 @@ type BooleanExprData<Table extends TypedTableDef> = (
   _tableType?: Table;
 };
 
+type AndOrMixedTableScopeError = {
+  readonly 'Cannot combine predicates from different table scopes with and/or. In semijoin on(...), keep only the join equality and move extra predicates to .where(...).': never;
+};
+
+type RequireSameAndOrTable<
+  Expected extends TypedTableDef,
+  Actual extends TypedTableDef,
+> = [Expected] extends [Actual]
+  ? [Actual] extends [Expected]
+    ? unknown
+    : AndOrMixedTableScopeError
+  : AndOrMixedTableScopeError;
+
 export class BooleanExpr<Table extends TypedTableDef> {
   constructor(readonly data: BooleanExprData<Table>) {}
 
-  and(other: BooleanExpr<Table>): BooleanExpr<Table> {
-    return new BooleanExpr({ type: 'and', clauses: [this.data, other.data] });
+  and<OtherTable extends TypedTableDef>(
+    other: BooleanExpr<OtherTable> & RequireSameAndOrTable<Table, OtherTable>
+  ): BooleanExpr<Table> {
+    return new BooleanExpr({
+      type: 'and',
+      clauses: [this.data, other.data as BooleanExprData<Table>],
+    });
   }
 
-  or(other: BooleanExpr<Table>): BooleanExpr<Table> {
-    return new BooleanExpr({ type: 'or', clauses: [this.data, other.data] });
+  or<OtherTable extends TypedTableDef>(
+    other: BooleanExpr<OtherTable> & RequireSameAndOrTable<Table, OtherTable>
+  ): BooleanExpr<Table> {
+    return new BooleanExpr({
+      type: 'or',
+      clauses: [this.data, other.data as BooleanExprData<Table>],
+    });
   }
 
   not(): BooleanExpr<Table> {
@@ -732,28 +761,40 @@ export function not<T extends TypedTableDef>(
   return new BooleanExpr({ type: 'not', clause: clause.data });
 }
 
-export function and<T extends TypedTableDef>(
-  ...clauses: readonly [BooleanExpr<T>, BooleanExpr<T>, ...BooleanExpr<T>[]]
-): BooleanExpr<T> {
+export function and<
+  Table extends TypedTableDef,
+  OtherTable extends TypedTableDef,
+>(
+  first: BooleanExpr<Table>,
+  second: BooleanExpr<OtherTable> & RequireSameAndOrTable<Table, OtherTable>,
+  ...rest: readonly BooleanExpr<Table>[]
+): BooleanExpr<Table> {
+  const clauses = [first, second, ...rest];
   return new BooleanExpr({
     type: 'and',
     clauses: clauses.map(c => c.data) as [
-      BooleanExprData<T>,
-      BooleanExprData<T>,
-      ...BooleanExprData<T>[],
+      BooleanExprData<Table>,
+      BooleanExprData<Table>,
+      ...BooleanExprData<Table>[],
     ],
   });
 }
 
-export function or<T extends TypedTableDef>(
-  ...clauses: readonly [BooleanExpr<T>, BooleanExpr<T>, ...BooleanExpr<T>[]]
-): BooleanExpr<T> {
+export function or<
+  Table extends TypedTableDef,
+  OtherTable extends TypedTableDef,
+>(
+  first: BooleanExpr<Table>,
+  second: BooleanExpr<OtherTable> & RequireSameAndOrTable<Table, OtherTable>,
+  ...rest: readonly BooleanExpr<Table>[]
+): BooleanExpr<Table> {
+  const clauses = [first, second, ...rest];
   return new BooleanExpr({
     type: 'or',
     clauses: clauses.map(c => c.data) as [
-      BooleanExprData<T>,
-      BooleanExprData<T>,
-      ...BooleanExprData<T>[],
+      BooleanExprData<Table>,
+      BooleanExprData<Table>,
+      ...BooleanExprData<Table>[],
     ],
   });
 }
@@ -803,7 +844,7 @@ function valueExprToSql<Table extends TypedTableDef>(
     return literalValueToSql(expr.value);
   }
   const table = tableAlias ?? expr.table;
-  return `${quoteIdentifier(table)}.${quoteIdentifier(expr.column)}`;
+  return `${quoteIdentifier(table)}.${quoteIdentifier(expr.columnName)}`;
 }
 
 function literalValueToSql(value: unknown): string {

package/src/lib/table.ts

@@ -239,7 +239,12 @@ export type ReadonlyTable<TableDef extends UntypedTableDef> = Prettify<
 >;
 
 export interface ReadonlyTableMethods<TableDef extends UntypedTableDef> {
-  /** Returns the number of rows in the TX state. */
+  /**
+   * Returns the number of rows in this table.
+   *
+   * This reads datastore metadata, so it runs in constant time.
+   * It also takes into account modifications by the current transaction.
+   */
   count(): bigint;
 
   /** Iterate over all rows in the TX state. Rust Iterator<Item=Row> → TS IterableIterator<Row>. */

package/src/react/useTable.ts

@@ -104,6 +104,8 @@ export function useTable<TableDef extends UntypedTableDef>(
         ) as Prettify<UseTableRowType>[])
       : (Array.from(table.iter()) as Prettify<UseTableRowType>[]);
     return [result, subscribeApplied];
+    // TODO: investigating refactoring so that this is no longer necessary, as we have had genuine bugs with missed deps.
+    // See https://github.com/clockworklabs/SpacetimeDB/pull/4580.
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [connectionState, accessorName, querySql, subscribeApplied]);
 
@@ -205,11 +207,14 @@ export function useTable<TableDef extends UntypedTableDef>(
         table.removeOnUpdate?.(onUpdate);
       };
     },
+    // TODO: investigating refactoring so that this is no longer necessary, as we have had genuine bugs with missed deps.
+    // See https://github.com/clockworklabs/SpacetimeDB/pull/4580.
     // eslint-disable-next-line react-hooks/exhaustive-deps
     [
       connectionState,
       accessorName,
       querySql,
+      computeSnapshot,
       callbacks?.onDelete,
       callbacks?.onInsert,
       callbacks?.onUpdate,

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/view.test-d.ts

@@ -161,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))