Add ctx.as.<namespace> for mounted submodules in typescript

Author: aasoni

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

@@ -98,6 +98,11 @@ export interface JwtClaims {
   readonly fullPayload: JsonObject;
 }
 
+export type AliasViews<SchemaDef extends UntypedSchemaDef> =
+  SchemaDef extends { namespaces: infer NS extends Record<string, UntypedSchemaDef> }
+    ? { readonly [K in keyof NS]: ReducerCtx<NS[K]> }
+    : {};
+
 /**
  * Reducer context parametrized by the inferred Schema
  */
@@ -113,4 +118,5 @@ export type ReducerCtx<SchemaDef extends UntypedSchemaDef> = Readonly<{
   newUuidV4(): Uuid;
   newUuidV7(): Uuid;
   random: Random;
+  as: AliasViews<SchemaDef>;
 }>;

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

@@ -30,6 +30,7 @@ import {
 import { callProcedure } from './procedures';
 import type { Reducers } from './reducers';
 import {
+  type AliasViews,
   type AuthCtx,
   type JsonObject,
   type JwtClaims,
@@ -195,18 +196,21 @@ export const ReducerCtxImpl = class ReducerCtx<
   timestamp: Timestamp;
   connectionId: ConnectionId | null;
   db: DbView<SchemaDef>;
+  as: AliasViews<SchemaDef>;
 
   constructor(
     sender: Identity,
     timestamp: Timestamp,
     connectionId: ConnectionId | null,
-    dbView: DbView<any>
+    dbView: DbView<any>,
+    asViews: object = {}
   ) {
     Object.seal(this);
     this.sender = sender;
     this.timestamp = timestamp;
     this.connectionId = connectionId;
     this.db = dbView as unknown as DbView<SchemaDef>;
+    this.as = asViews as AliasViews<SchemaDef>;
   }
 
   /** Reset the `ReducerCtx` to be used for a new transaction */
@@ -215,7 +219,8 @@ export const ReducerCtxImpl = class ReducerCtx<
     sender: Identity,
     timestamp: Timestamp,
     connectionId: ConnectionId | null,
-    dbView?: DbView<any>
+    dbView?: DbView<any>,
+    asViews?: object
   ) {
     me.sender = sender;
     me.timestamp = timestamp;
@@ -225,6 +230,9 @@ export const ReducerCtxImpl = class ReducerCtx<
     if (dbView !== undefined) {
       me.db = dbView;
     }
+    if (asViews !== undefined) {
+      me.as = asViews as AliasViews<any>;
+    }
   }
 
   get databaseIdentity() {
@@ -309,6 +317,7 @@ export const makeHooks = (schema: SchemaInner): ModuleHooks =>
 class ModuleHooksImpl implements ModuleHooks {
   #schema: SchemaInner;
   #dbView_: DbView<any> | undefined;
+  #consumerAs_: object | undefined;
   #reducerArgsDeserializers;
   #consumerReducerCount: number;
   #flatMounts: FlatMountDispatch[];
@@ -366,6 +375,13 @@ class ModuleHooksImpl implements ModuleHooks {
     ));
   }
 
+  get #consumerAs() {
+    return (this.#consumerAs_ ??= buildAliasCtxMap(
+      this.#reducerCtx,
+      this.#schema.mountedDispatchInfos
+    ));
+  }
+
   __describe_module__() {
     const writer = new BinaryWriter(128);
     RawModuleDef.serialize(
@@ -397,10 +413,12 @@ class ModuleHooksImpl implements ModuleHooks {
 
     let fn: ((...args: any[]) => any) | undefined;
     let dbView: DbView<any>;
+    let asViews: object;
 
     if (reducerId < this.#consumerReducerCount) {
       fn = this.#schema.reducers[reducerId];
       dbView = this.#dbView;
+      asViews = this.#consumerAs;
     } else {
       let offset = this.#consumerReducerCount;
       for (let i = 0; i < this.#flatMounts.length; i++) {
@@ -415,6 +433,7 @@ class ModuleHooksImpl implements ModuleHooks {
       if (fn === undefined) {
         throw new RangeError(`unknown reducerId ${reducerId}`);
       }
+      asViews = {};
     }
 
     const ctx = this.#reducerCtx;
@@ -423,7 +442,8 @@ class ModuleHooksImpl implements ModuleHooks {
       senderIdentity,
       new Timestamp(timestamp),
       ConnectionId.nullIfZero(new ConnectionId(connId)),
-      dbView!
+      dbView!,
+      asViews!
     );
     callUserFunction(fn, ctx, args);
   }
@@ -515,6 +535,36 @@ function buildDbViewForDispatch(dispatch: MountedDispatchInfo): object {
   return freeze(Object.fromEntries([...tableEntries, ...subNsEntries]));
 }
 
+function buildAliasCtx(
+  parent: InstanceType<typeof ReducerCtxImpl>,
+  dispatch: MountedDispatchInfo
+): object {
+  const nsDb = buildDbViewForDispatch(dispatch);
+  const subAs = buildAliasCtxMap(parent, dispatch.subDispatches);
+  return {
+    get sender() { return parent.sender; },
+    get databaseIdentity() { return parent.databaseIdentity; },
+    get identity() { return parent.identity; },
+    get timestamp() { return parent.timestamp; },
+    get connectionId() { return parent.connectionId; },
+    get senderAuth() { return parent.senderAuth; },
+    get random() { return parent.random; },
+    newUuidV4() { return parent.newUuidV4(); },
+    newUuidV7() { return parent.newUuidV7(); },
+    db: nsDb,
+    as: subAs,
+  };
+}
+
+function buildAliasCtxMap(
+  parent: InstanceType<typeof ReducerCtxImpl>,
+  dispatches: MountedDispatchInfo[]
+): object {
+  return freeze(
+    Object.fromEntries(dispatches.map(d => [d.namespace, buildAliasCtx(parent, d)]))
+  );
+}
+
 function makeTableView(
   typespace: Typespace,
   table: RawTableDefV10

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

@@ -0,0 +1,117 @@
+import { beforeAll, describe, expect, it, vi } from 'vitest';
+
+vi.mock(
+  'spacetime:sys@2.0',
+  () => ({
+    moduleHooks: Symbol('moduleHooks'),
+    table_id_from_name: () => 1,
+    index_id_from_name: () => 1,
+    row_iter_bsatn_close: () => {},
+  }),
+  { virtual: true }
+);
+
+vi.mock('spacetime:sys@2.1', () => ({}), { virtual: true });
+
+describe('ctx.as alias proxy', () => {
+  let schema: typeof import('../src/server/schema').schema;
+  let table: typeof import('../src/lib/table').table;
+  let t: typeof import('../src/lib/type_builders').t;
+  let moduleHooks: symbol;
+
+  beforeAll(async () => {
+    ({ schema } = await import('../src/server/schema'));
+    ({ table } = await import('../src/lib/table'));
+    ({ t } = await import('../src/lib/type_builders'));
+    ({ moduleHooks } = (await import('spacetime:sys@2.0')) as any);
+  });
+
+  it('ctx.as.<alias> provides a narrowed ctx with library db and delegating sender', async () => {
+    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 });
+
+    let capturedCtx: any;
+    const myReducer = consumer.reducer((ctx: any) => {
+      capturedCtx = ctx;
+    });
+
+    const hooks = (consumer as any)[moduleHooks]({ myReducer });
+    hooks.__call_reducer__(
+      0,
+      0n,
+      0n,
+      0n,
+      new DataView(new ArrayBuffer(0))
+    );
+
+    expect(capturedCtx.as).toBeDefined();
+    expect(capturedCtx.as.myauth).toBeDefined();
+    expect(capturedCtx.as.myauth.db).toBeDefined();
+    expect(capturedCtx.as.myauth.db.sessions).toBeDefined();
+    expect(capturedCtx.as.myauth.sender).toBe(capturedCtx.sender);
+    expect(capturedCtx.as.myauth.timestamp).toBe(capturedCtx.timestamp);
+  });
+
+  it('ctx.as is empty object when there are no mounts', async () => {
+    const players = table({ name: 'players' }, { id: t.u32().primaryKey() });
+    const consumer = schema({ players });
+
+    let capturedCtx: any;
+    const myReducer = consumer.reducer((ctx: any) => {
+      capturedCtx = ctx;
+    });
+
+    const hooks = (consumer as any)[moduleHooks]({ myReducer });
+    hooks.__call_reducer__(
+      0,
+      0n,
+      0n,
+      0n,
+      new DataView(new ArrayBuffer(0))
+    );
+
+    expect(capturedCtx.as).toBeDefined();
+    expect(Object.keys(capturedCtx.as)).toHaveLength(0);
+  });
+
+  it('ctx.as.<alias>.as carries nested sub-mount aliases', async () => {
+    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 });
+
+    let capturedCtx: any;
+    const myReducer = consumer.reducer((ctx: any) => {
+      capturedCtx = ctx;
+    });
+
+    const hooks = (consumer as any)[moduleHooks]({ myReducer });
+    hooks.__call_reducer__(
+      0,
+      0n,
+      0n,
+      0n,
+      new DataView(new ArrayBuffer(0))
+    );
+
+    expect(capturedCtx.as.myauth.as.baz).toBeDefined();
+    expect(capturedCtx.as.myauth.as.baz.db.bazTable).toBeDefined();
+    expect(capturedCtx.as.myauth.as.baz.sender).toBe(capturedCtx.sender);
+  });
+});