Unifies server module library and client SDK for TypeScript (and fixes several bugs)

crates/bindings-typescript/examples/quickstart-chat/src/App.tsx

@@ -16,8 +16,9 @@ function App() {
   const [settingName, setSettingName] = useState(false);
   const [systemMessages, setSystemMessages] = useState([] as Message[]);
   const [newMessage, setNewMessage] = useState('');
-
   const conn = useSpacetimeDB<DbConnection>();
+
+  conn.setReducerFlags()
   const { identity, isActive: connected } = conn;
 
   // Subscribe to all messages in the chat

crates/bindings-typescript/src/server/indexes.ts → crates/bindings-typescript/src/lib/indexes.ts

@@ -1,7 +1,7 @@
 import type { RowType, UntypedTableDef } from './table';
 import type { ColumnMetadata, IndexTypes } from './type_builders';
 import type { CollapseTuple, Prettify } from './type_util';
-import { Range } from './range';
+import { Range } from '../server/range';
 import type { ColumnIsUnique } from './constraints';
 
 /**
@@ -56,30 +56,69 @@ export type Index<
   ? UniqueIndex<TableDef, I>
   : RangedIndex<TableDef, I>;
 
+/**
+ * A type representing a collection of read-only indexes defined on a table.
+ */
+export type ReadonlyIndexes<
+  TableDef extends UntypedTableDef,
+  I extends Record<string, UntypedIndex<keyof TableDef['columns'] & string>>,
+> = {
+  [k in keyof I]: ReadonlyIndex<TableDef, I[k]>;
+};
+
+/**
+ * A type representing a read-only database index, which can be either unique or ranged.
+ * This type only exposes read-only operations.
+ */
+export type ReadonlyIndex<
+  TableDef extends UntypedTableDef,
+  I extends UntypedIndex<keyof TableDef['columns'] & string>,
+> = I['unique'] extends true
+  ? ReadonlyUniqueIndex<TableDef, I>
+  : ReadonlyRangedIndex<TableDef, I>;
+
+/**
+ * A type representing a read-only unique index on a database table.
+ */
+export type ReadonlyUniqueIndex<
+  TableDef extends UntypedTableDef,
+  I extends UntypedIndex<keyof TableDef['columns'] & string>,
+> = {
+  find(colVal: IndexVal<TableDef, I>): RowType<TableDef> | null;
+};
+
 /**
  * A type representing a unique index on a database table.
  * Unique indexes enforce that the indexed columns contain unique values.
  */
 export type UniqueIndex<
   TableDef extends UntypedTableDef,
   I extends UntypedIndex<keyof TableDef['columns'] & string>,
-> = {
-  find(col_val: IndexVal<TableDef, I>): RowType<TableDef> | null;
-  delete(col_val: IndexVal<TableDef, I>): boolean;
-  update(col_val: RowType<TableDef>): RowType<TableDef>;
+> = ReadonlyUniqueIndex<TableDef, I> & {
+  delete(colVal: IndexVal<TableDef, I>): boolean;
+  update(colVal: RowType<TableDef>): RowType<TableDef>;
 };
 
 /**
- * A type representing a ranged index on a database table.
- * Ranged indexes allow for range queries on the indexed columns.
+ * A type representing a read-only ranged index on a database table. 
  */
-export type RangedIndex<
+export type ReadonlyRangedIndex<
   TableDef extends UntypedTableDef,
   I extends UntypedIndex<keyof TableDef['columns'] & string>,
 > = {
   filter(
     range: IndexScanRangeBounds<TableDef, I>
   ): IterableIterator<RowType<TableDef>>;
+};
+
+/**
+ * A type representing a ranged index on a database table.
+ * Ranged indexes allow for range queries on the indexed columns.
+ */
+export type RangedIndex<
+  TableDef extends UntypedTableDef,
+  I extends UntypedIndex<keyof TableDef['columns'] & string>,
+> = ReadonlyRangedIndex<TableDef, I> & {
   delete(range: IndexScanRangeBounds<TableDef, I>): number;
 };
 

crates/bindings-typescript/src/server/reducers.ts → crates/bindings-typescript/src/lib/reducers.ts

@@ -1,15 +1,17 @@
-import type { ProductType } from '../lib/algebraic_type';
-import Lifecycle from '../lib/autogen/lifecycle_type';
-import type RawReducerDefV9 from '../lib/autogen/raw_reducer_def_v_9_type';
-import type { ConnectionId } from '../lib/connection_id';
-import type { Identity } from '../lib/identity';
-import type { Timestamp } from '../lib/timestamp';
+import type { ProductType } from './algebraic_type';
+import Lifecycle from './autogen/lifecycle_type';
+import type RawReducerDefV9 from './autogen/raw_reducer_def_v_9_type';
+import type { ConnectionId } from './connection_id';
+import type { Identity } from './identity';
+import type { Timestamp } from './timestamp';
+import type { UntypedReducersDef } from '../sdk/reducers';
+import type { DbView } from '../server/db_view';
 import { MODULE_DEF, type UntypedSchemaDef } from './schema';
-import type { Table } from './table';
 import type {
   InferTypeOfRow,
   RowBuilder,
   RowObj,
+  StringBuilder,
   TypeBuilder,
 } from './type_builders';
 
@@ -58,13 +60,6 @@
   payload: ParamsAsObject<Params>
 ) => void | { tag: 'ok' } | { tag: 'err'; value: string };
 
-/**
- * A type representing the database view, mapping table names to their corresponding Table handles.
- */
-export type DbView<SchemaDef extends UntypedSchemaDef> = {
-  readonly [Tbl in SchemaDef['tables'][number] as Tbl['name']]: Table<Tbl>;
-};
-
 /**
  * Authentication information for the caller of a reducer.
  */
@@ -133,8 +128,9 @@
   fn: Reducer<any, any>,
   lifecycle?: RawReducerDefV9['lifecycle']
 ): void {
-  if (existingReducers.has(name))
+  if (existingReducers.has(name)) {
     throw new TypeError(`There is already a reducer with the name '${name}'`);
+  }
   existingReducers.add(name);
 
   const paramType: ProductType = {
@@ -263,3 +259,111 @@
 >(name: string, params: Params, fn: Reducer<S, Params>): void {
   pushReducer(name, params, fn, Lifecycle.OnDisconnect);
 }
+
+/**
+ * Represents a handle to a database reducer, including its name and argument type.
+ */
+export type ReducerSchema<
+  ReducerName extends string,
+  Params extends ParamsObj,
+> = {
+  /**
+   * The name of the reducer.
+   */
+  readonly reducerName: ReducerName;
+
+  /**
+   * The type of the parameters object expected by the reducer.
+   */
+  readonly paramsType: Params;
+
+  /**
+   * 
+   */
+  readonly paramsSpacetimeType: ProductType;
+
+  /**
+   * The {@link RawReducerDefV9} of the configured reducer.
+   */
+  readonly reducerDef: RawReducerDefV9;
+};
+
+class Reducers<ReducersDef extends UntypedReducersDef> {
+  /**
+   * Phantom type to track the reducers definition 
+   */
+  reducersType!: ReducersDef;
+}
+
+/**
+ * Helper type to convert an array of TableSchema into a schema definition
+ */
+type ReducersToSchema<T extends readonly ReducerSchema<any, any>[]> = {
+  reducers: {
+    /** @type {UntypedReducerDef} */
+    readonly [i in keyof T]: {
+      name: T[i]['reducerName'];
+      params: T[i]['paramsType'];
+      paramsSpacetimeType: T[i]['paramsSpacetimeType'];
+    };
+  };
+};
+
+/**
+ * Creates a schema from table definitions
+ * @param handles - Array of table handles created by table() function
+ * @returns ColumnBuilder representing the complete database schema
+ * @example
+ * ```ts
+ * const s = schema(
+ *   table({ name: 'user' }, userType),
+ *   table({ name: 'post' }, postType)
+ * );
+ * ```
+ */
+export function reducers<const H extends readonly ReducerSchema<any, any>[]>(
+  ...handles: H
+): Reducers<ReducersToSchema<H>>;
+
+/**
+ * Creates a schema from table definitions (array overload)
+ * @param handles - Array of table handles created by table() function
+ * @returns ColumnBuilder representing the complete database schema
+ */
+export function reducers<const H extends readonly ReducerSchema<any, any>[]>(
+  handles: H
+): Reducers<ReducersToSchema<H>>;
+
+export function reducers(
+  ...args:
+    | [readonly ReducerSchema<any, any>[]]
+    | readonly ReducerSchema<any, any>[]
+): Reducers<UntypedReducersDef> {
+  return new Reducers();
+}
+
+export function reducerSchema<
+  ReducerName extends string,
+  Params extends ParamsObj,
+>(
+  name: ReducerName,
+  params: Params
+): ReducerSchema<ReducerName, Params> {
+  const paramType: ProductType = {
+    elements: Object.entries(params).map(([n, c]) => ({
+      name: n,
+      algebraicType: c.algebraicType,
+    })),
+  };
+  return {
+    reducerName: name,
+    paramsType: params,
+    paramsSpacetimeType: paramType,
+    reducerDef: {
+      name,
+      params: paramType,
+      lifecycle: undefined,
+    },
+  };
+} 
+