wip

Author: coolreader18

crates/bindings-typescript/src/sdk/db_connection_impl.ts

@@ -55,6 +55,7 @@ import type {
 import type { ClientDbView } from './db_view.ts';
 import type { UntypedTableDef } from '../lib/table.ts';
 import { toCamelCase, toPascalCase } from '../lib/util.ts';
+import type { ProceduresView } from './procedures.ts';
 
 export {
   DbConnectionBuilder,
@@ -137,13 +138,20 @@ export class DbConnectionImpl<RemoteModule extends UntypedRemoteModule>
    */
   setReducerFlags: SetReducerFlags<RemoteModule>;
 
+  /**
+   * The accessor field to access the reducers in the database and associated
+   * callback functions.
+   */
+  procedures: ProceduresView<RemoteModule>;
+
   /**
    * The `ConnectionId` of the connection to to the database.
    */
   connectionId: ConnectionId = ConnectionId.random();
 
   // These fields are meant to be strictly private.
   #queryId = 0;
+  #requestId = 0;
   #emitter: EventEmitter<ConnectionEvent>;
   #reducerEmitter: EventEmitter<string, ReducerEventCallback<RemoteModule>> =
     new EventEmitter();
@@ -198,6 +206,7 @@ export class DbConnectionImpl<RemoteModule extends UntypedRemoteModule>
     this.db = this.#makeDbView(remoteModule);
     this.reducers = this.#makeReducers(remoteModule);
     this.setReducerFlags = this.#makeSetReducerFlags(remoteModule);
+    this.procedures = this.#makeProcedures(remoteModule);
 
     this.wsPromise = createWSFn({
       url,
@@ -237,6 +246,8 @@ export class DbConnectionImpl<RemoteModule extends UntypedRemoteModule>
     return queryId;
   };
 
+  #getNextRequestId = () => this.#requestId++;
+
   #makeDbView(def: RemoteModule): ClientDbView<RemoteModule> {
     const view = Object.create(null) as ClientDbView<RemoteModule>;
 
@@ -310,6 +321,45 @@ export class DbConnectionImpl<RemoteModule extends UntypedRemoteModule>
     return out;
   }
 
+  #makeProcedures(def: RemoteModule): ProceduresView<RemoteModule> {
+    const out: Record<string, unknown> = {};
+
+    for (const reducer of def.reducers) {
+      const key = toCamelCase(reducer.name);
+
+      (out as any)[key] = (params: InferTypeOfRow<typeof reducer.params>) => {
+        this.callReducerWithParams(
+          reducer.name,
+          reducer.paramsType,
+          params,
+          flags
+        );
+      };
+
+      const onReducerEventKey = `on${toPascalCase(reducer.name)}`;
+      (out as any)[onReducerEventKey] = (
+        callback: ReducerEventCallback<
+          RemoteModule,
+          InferTypeOfRow<typeof reducer.params>
+        >
+      ) => {
+        this.onReducer(reducer.name, callback);
+      };
+
+      const offReducerEventKey = `removeOn${toPascalCase(reducer.name)}`;
+      (out as any)[offReducerEventKey] = (
+        callback: ReducerEventCallback<
+          RemoteModule,
+          InferTypeOfRow<typeof reducer.params>
+        >
+      ) => {
+        this.offReducer(reducer.name, callback);
+      };
+    }
+
+    return out as ReducersView<RemoteModule>;
+  }
+
   #makeEventContext(
     event: Event<
       ReducerEventInfo<
@@ -916,6 +966,43 @@ export class DbConnectionImpl<RemoteModule extends UntypedRemoteModule>
     this.callReducer(reducerName, argsBuffer, flags);
   }
 
+  /**
+   * Call a reducer on your SpacetimeDB module.
+   *
+   * @param procedureName The name of the reducer to call
+   * @param argsBuffer The arguments to pass to the reducer
+   */
+  callProcedure(procedureName: string, argsBuffer: Uint8Array): void {
+    const message = ClientMessage.CallProcedure({
+      procedure: procedureName,
+      args: argsBuffer,
+      // The TypeScript SDK doesn't currently track `request_id`s,
+      // so always use 0.
+      requestId: 0,
+      // reserved for future use - 0 is the only valid value
+      flags: 0,
+    });
+    this.#sendMessage(message);
+  }
+
+  /**
+   * Call a reducer on your SpacetimeDB module with typed arguments.
+   * @param reducerSchema The schema of the reducer to call
+   * @param callReducerFlags The flags for the reducer call
+   * @param params The arguments to pass to the reducer
+   */
+  callProcedureWithParams(
+    procedureName: string,
+    paramsType: ProductType,
+    params: object,
+    flags: CallReducerFlags
+  ) {
+    const writer = new BinaryWriter(1024);
+    ProductType.serializeValue(writer, paramsType, params);
+    const argsBuffer = writer.getBuffer();
+    this.callProcedure(procedureName, argsBuffer, flags);
+  }
+
   /**
    * Close the current connection.
    *

crates/bindings-typescript/src/sdk/event_context.ts

@@ -30,6 +30,13 @@ export interface ReducerEventContextInterface<
   >;
 }
 
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+export interface ProcedureEventContextInterface<
+  RemoteModule extends UntypedRemoteModule,
+> extends DbContext<RemoteModule> {
+  /** No event is provided */
+}
+
 // eslint-disable-next-line @typescript-eslint/no-empty-object-type
 export interface SubscriptionEventContextInterface<
   RemoteModule extends UntypedRemoteModule,

crates/bindings-typescript/src/sdk/procedures.ts

@@ -0,0 +1,46 @@
+import type { AlgebraicType, ProductType } from '../lib/algebraic_type';
+import type { ParamsObj } from '../lib/reducers';
+import type { CoerceRow } from '../lib/table';
+import type { Infer, InferTypeOfRow, TypeBuilder } from '../lib/type_builders';
+import type { CamelCase } from '../lib/type_util';
+import type { ProcedureEventContextInterface } from './event_context';
+import type { UntypedRemoteModule } from './spacetime_module';
+
+export type ProcedureEventPromise<
+  RemoteModule extends UntypedRemoteModule,
+  ProcedureReturn,
+> = Promise<
+  [ctx: ProcedureEventContextInterface<RemoteModule>, result: ProcedureReturn]
+>;
+
+// Utility: detect 'any'
+type IfAny<T, Y, N> = 0 extends 1 & T ? Y : N;
+
+// Loose shape that allows all three families even when key names are unknown
+type ProceduresViewLoose = {
+  // call: camelCase(name)
+  [k: string]: (params: any) => ProcedureEventPromise<any, any>;
+};
+
+export type ProceduresView<RemoteModule> = IfAny<
+  RemoteModule,
+  ProceduresViewLoose,
+  RemoteModule extends UntypedRemoteModule
+    ? // x: camelCase(name)
+      {
+        [K in RemoteModule['procedures'][number] as CamelCase<
+          K['accessorName']
+        >]: (
+          params: InferTypeOfRow<K['params']>
+        ) => ProcedureEventPromise<RemoteModule, Infer<K['returnType']>>;
+      }
+    : never
+>;
+
+export type UntypedProcedureDef = {
+  name: string;
+  accessorName: string;
+  params: CoerceRow<ParamsObj>;
+  paramsType: ProductType;
+  returnType: TypeBuilder<any, any>;
+};

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

@@ -9,6 +9,7 @@ import type {
   ReducerEventContextInterface,
   SubscriptionEventContextInterface,
 } from './event_context';
+import type { UntypedProcedureDef } from './procedures';
 
 export type ReducerEventCallback<
   RemoteModule extends UntypedRemoteModule,
@@ -81,8 +82,10 @@ export type UntypedReducerDef = {
   paramsType: ProductType;
 };
 
+// TODO: rename to FunctionsDef
 export type UntypedReducersDef = {
   reducers: readonly UntypedReducerDef[];
+  procedures: readonly UntypedProcedureDef[];
 };
 
 export type SetReducerFlags<R extends UntypedReducersDef> = {