Add ctx.db.<namespace>

Author: aasoni

crates/bindings-typescript/src/lib/schema.ts

@@ -52,6 +52,7 @@ export type TableNamesOf<S extends UntypedSchemaDef> = Values<
  */
 export type UntypedSchemaDef = {
   tables: Record<string, UntypedTableDef>;
+  namespaces?: Record<string, UntypedSchemaDef>;
 };
 
 /**

crates/bindings-typescript/src/server/db_view.ts

@@ -9,7 +9,9 @@ export type ReadonlyDbView<SchemaDef extends UntypedSchemaDef> = {
   readonly [Tbl in Values<
     SchemaDef['tables']
   > as Tbl['accessorName']]: ReadonlyTable<Tbl>;
-};
+} & (SchemaDef extends { namespaces: infer NS extends Record<string, UntypedSchemaDef> }
+  ? { readonly [K in keyof NS]: ReadonlyDbView<NS[K]> }
+  : {});
 
 /**
  * A type representing the database view, mapping table names to their corresponding Table handles.
@@ -18,4 +20,6 @@ export type DbView<SchemaDef extends UntypedSchemaDef> = {
   readonly [Tbl in Values<
     SchemaDef['tables']
   > as Tbl['accessorName']]: Table<Tbl>;
-};
+} & (SchemaDef extends { namespaces: infer NS extends Record<string, UntypedSchemaDef> }
+  ? { readonly [K in keyof NS]: DbView<NS[K]> }
+  : {});

crates/bindings-typescript/src/server/runtime.ts

@@ -40,7 +40,7 @@ import { type RowType, type Table, type TableMethods } from '../lib/table';
 import { hasOwn } from '../lib/util';
 import { type AnonymousViewCtx, type ViewCtx } from './views';
 import { isRowTypedQuery, makeQueryBuilder, toSql } from './query';
-import type { DbView } from './db_view';
+import type { DbView, ReadonlyDbView } from './db_view';
 import { getErrorConstructor, SenderError } from './errors';
 import { Range, type Bound } from './range';
 import { makeRandom, type Random } from './rng';
@@ -206,7 +206,7 @@ export const ReducerCtxImpl = class ReducerCtx<
     this.sender = sender;
     this.timestamp = timestamp;
     this.connectionId = connectionId;
-    this.db = dbView;
+    this.db = dbView as unknown as DbView<SchemaDef>;
   }
 
   /** Reset the `ReducerCtx` to be used for a new transaction */
@@ -330,14 +330,19 @@ class ModuleHooksImpl implements ModuleHooks {
   }
 
   get #dbView() {
-    return (this.#dbView_ ??= freeze(
-      Object.fromEntries(
-        Object.values(this.#schema.schemaType.tables).map(table => [
-          table.accessorName,
-          makeTableView(this.#schema.typespace, table.tableDef),
-        ])
-      )
-    ));
+    if (this.#dbView_ !== undefined) return this.#dbView_;
+    const rootTables = Object.values(this.#schema.schemaType.tables).map(
+      table => [
+        table.accessorName,
+        makeTableView(this.#schema.typespace, table.tableDef),
+      ]
+    );
+    const mountNs = this.#schema.mountedDispatchInfos.map(dispatch => [
+      dispatch.namespace,
+      buildDbViewForDispatch(dispatch),
+    ]);
+    this.#dbView_ = freeze(Object.fromEntries([...rootTables, ...mountNs])) as DbView<any>;
+    return this.#dbView_;
   }
 
   #getMountDbView(mountIdx: number): DbView<any> {
@@ -348,7 +353,7 @@ class ModuleHooksImpl implements ModuleHooks {
           accessorName,
           makeTableView(m.typespace, tableDef),
         ])
-      )
+      ) as DbView<any>
     ));
   }
 
@@ -436,7 +441,7 @@ class ModuleHooksImpl implements ModuleHooks {
       // this is the non-readonly DbView, but the typing for the user will be
       // the readonly one, and if they do call mutating functions it will fail
       // at runtime
-      db: this.#dbView,
+      db: this.#dbView as ReadonlyDbView<any>,
       from: makeQueryBuilder(moduleCtx.schemaType),
     });
     const args = deserializeParams(new BinaryReader(argsBuf));
@@ -460,7 +465,7 @@ class ModuleHooksImpl implements ModuleHooks {
       // this is the non-readonly DbView, but the typing for the user will be
       // the readonly one, and if they do call mutating functions it will fail
       // at runtime
-      db: this.#dbView,
+      db: this.#dbView as ReadonlyDbView<any>,
       from: makeQueryBuilder(moduleCtx.schemaType),
     });
     const args = deserializeParams(new BinaryReader(argsBuf));
@@ -490,14 +495,26 @@ class ModuleHooksImpl implements ModuleHooks {
       ConnectionId.nullIfZero(new ConnectionId(connection_id)),
       new Timestamp(timestamp),
       args,
-      () => this.#dbView
+      () => this.#dbView as DbView<any>
     );
   }
 }
 
 const BINARY_WRITER = new BinaryWriter(0);
 const BINARY_READER = new BinaryReader(new Uint8Array());
 
+function buildDbViewForDispatch(dispatch: MountedDispatchInfo): object {
+  const tableEntries = dispatch.tables.map(({ accessorName, tableDef }) => [
+    accessorName,
+    makeTableView(dispatch.typespace, tableDef),
+  ]);
+  const subNsEntries = dispatch.subDispatches.map(sub => [
+    sub.namespace,
+    buildDbViewForDispatch(sub),
+  ]);
+  return freeze(Object.fromEntries([...tableEntries, ...subNsEntries]));
+}
+
 function makeTableView(
   typespace: Typespace,
   table: RawTableDefV10

crates/bindings-typescript/src/server/schema.ts

@@ -50,6 +50,7 @@ import {
 import type { UntypedTableDef } from '../lib/table';
 
 export type MountedDispatchInfo = {
+  namespace: string;
   reducerFns: Reducers;
   reducerDefs: RawReducerDefV10[];
   typespace: Typespace;
@@ -216,6 +217,7 @@ export class Schema<S extends UntypedSchemaDef> implements ModuleDefaultExport {
     return {
       rawDef,
       dispatch: {
+        namespace: '',
         reducerFns: [...this.#ctx.reducers],
         reducerDefs: [...this.#ctx.moduleDef.reducers],
         typespace: this.#ctx.moduleDef.typespace,
@@ -622,6 +624,19 @@ type ExtractTableEntries<H extends Record<string, SchemaEntry>> = {
   >;
 };
 
+type ExtractMountSchemas<H extends Record<string, SchemaEntry>> = {
+  [K in keyof H as H[K] extends { default: Schema<any> }
+    ? K
+    : never]: H[K] extends { default: Schema<infer S extends UntypedSchemaDef> }
+    ? S
+    : never;
+};
+
+type SchemaDefForEntries<H extends Record<string, SchemaEntry>> =
+  TablesToSchema<ExtractTableEntries<H>> & {
+    namespaces: ExtractMountSchemas<H>;
+  };
+
 function isUntypedTableSchema(x: unknown): x is UntypedTableSchema {
   return typeof x === 'object' && x !== null && hasOwn(x, 'tableDef');
 }
@@ -666,8 +681,8 @@ function registerModuleExports(
 export function schema<const H extends Record<string, SchemaEntry>>(
   entries: H,
   moduleSettings?: ModuleSettings
-): Schema<TablesToSchema<ExtractTableEntries<H>>> {
-  const ctx = new SchemaInner<TablesToSchema<ExtractTableEntries<H>>>(ctx => {
+): Schema<SchemaDefForEntries<H>> {
+  const ctx = new SchemaInner<SchemaDefForEntries<H>>(ctx => {
     // Apply module settings.
     if (moduleSettings?.CASE_CONVERSION_POLICY != null) {
       ctx.setCaseConversionPolicy(moduleSettings.CASE_CONVERSION_POLICY);
@@ -682,6 +697,7 @@ export function schema<const H extends Record<string, SchemaEntry>>(
       }
       if (isMountedModuleNamespace(entry)) {
         const { rawDef, dispatch } = entry.default.buildMountForDispatch(entry);
+        dispatch.namespace = accName;
         ctx.addMount({ namespace: accName, module: rawDef });
         ctx.mountedDispatchInfos.push(dispatch);
         continue;
@@ -728,7 +744,7 @@ export function schema<const H extends Record<string, SchemaEntry>>(
         });
       }
     }
-    return { tables: tableSchemas } as TablesToSchema<ExtractTableEntries<H>>;
+    return { tables: tableSchemas } as SchemaDefForEntries<H>;
   });
 
   return new Schema(ctx);
@@ -758,7 +774,7 @@ export function merge(
     default: Schema<any>;
   };
   const tables: Record<string, UntypedTableDef> = {};
-  for (const td of Object.values(libSchema.schemaType.tables)) {
+  for (const td of Object.values(libSchema.schemaType.tables) as UntypedTableDef[]) {
     tables[td.accessorName] = td;
   }
   return { ...tables, ...(namedExports as Record<string, ModuleExport>) };

crates/bindings-typescript/src/server/views.ts

@@ -186,7 +186,7 @@ export function registerView<
   }
 
   (anon ? ctx.anonViews : ctx.views).push({
-    fn,
+    fn: fn as unknown as ViewFn<any, any, any>,
     deserializeParams: ProductType.makeDeserializer(paramType, typespace),
     serializeReturn: AlgebraicType.makeSerializer(returnType, typespace),
     returnTypeBaseSize: bsatnBaseSize(typespace, returnType),

crates/bindings-typescript/tests/schema_mounts.test.ts

@@ -262,4 +262,43 @@ describe('schema mounts', () => {
     expect(reducerNames).toContain('authReducer');
     expect(reducerNames).toContain('utilReducer');
   });
+
+  it('mountedDispatchInfos carry namespace and nested namespace dispatches propagate', () => {
+    const sessions = table(
+      { name: 'sessions' },
+      { id: t.u64().primaryKey().autoInc() }
+    );
+    const authSchema = schema({ sessions });
+    const authLib = { default: authSchema };
+
+    const players = table({ name: 'players' }, { id: t.u32().primaryKey() });
+    const consumer = schema({ players, myauth: authLib });
+
+    const infos = consumer.mountedDispatchInfos;
+    expect(infos).toHaveLength(1);
+    expect(infos[0].namespace).toBe('myauth');
+    expect(infos[0].tables[0].accessorName).toBe('sessions');
+  });
+
+  it('nested mounts carry their own namespace on subDispatches', () => {
+    const bazTable = table({ name: 'baz_items' }, { id: t.u32().primaryKey() });
+    const bazSchema = schema({ bazTable });
+    const bazLib = { default: bazSchema };
+
+    const sessions = table(
+      { name: 'sessions' },
+      { id: t.u64().primaryKey().autoInc() }
+    );
+    const authSchema = schema({ sessions, baz: bazLib });
+    const authLib = { default: authSchema };
+
+    const players = table({ name: 'players' }, { id: t.u32().primaryKey() });
+    const consumer = schema({ players, myauth: authLib });
+
+    const authInfo = consumer.mountedDispatchInfos[0];
+    expect(authInfo.namespace).toBe('myauth');
+    expect(authInfo.subDispatches).toHaveLength(1);
+    expect(authInfo.subDispatches[0].namespace).toBe('baz');
+    expect(authInfo.subDispatches[0].tables[0].accessorName).toBe('bazTable');
+  });
 });