Use a class for ReducerCtx (#3958)

# Description of Changes

#3538 added a `uuid_counter` field to ReducerCtx, which has no need to
be public. Implementing ReducerCtx as a class allows us to encapsulate
better, and lets us enumerate exactly the data that it needs to hold so
that the runtime could possibly optimize it.

# Expected complexity level and risk

1: straightforward switch

# Testing

- [x] Automated testing is sufficient.

Author: coolreader18

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

@@ -119,8 +119,6 @@ export type ReducerCtx<SchemaDef extends UntypedSchemaDef> = Readonly<{
   identity: Identity;
   timestamp: Timestamp;
   connectionId: ConnectionId | null;
-  // **Note:** must be 0..=u32::MAX
-  counter_uuid: { value: number };
   db: DbView<SchemaDef>;
   senderAuth: AuthCtx;
   newUuidV4(): Uuid;

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

@@ -12,7 +12,7 @@ import { MODULE_DEF, type UntypedSchemaDef } from '../lib/schema';
 import { Timestamp } from '../lib/timestamp';
 import { Uuid } from '../lib/uuid';
 import { httpClient } from './http_internal';
-import { callUserFunction, makeReducerCtx, sys } from './runtime';
+import { callUserFunction, ReducerCtxImpl, sys } from './runtime';
 
 const { freeze } = Object;
 
@@ -45,8 +45,10 @@ export function callProcedure(
         const timestamp = sys.procedure_start_mut_tx();
 
         try {
-          const ctx: TransactionCtx<UntypedSchemaDef> = freeze(
-            makeReducerCtx(sender, new Timestamp(timestamp), connectionId)
+          const ctx: TransactionCtx<UntypedSchemaDef> = new ReducerCtxImpl(
+            sender,
+            new Timestamp(timestamp),
+            connectionId
           );
           return body(ctx);
         } catch (e) {

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

@@ -27,6 +27,7 @@ import {
   type JsonObject,
   type JwtClaims,
   type ReducerCtx,
+  type ReducerCtx as IReducerCtx,
 } from '../lib/reducers';
 import {
   MODULE_DEF,
@@ -185,45 +186,66 @@ class AuthCtxImpl implements AuthCtx {
   }
 }
 
-export const makeReducerCtx = (
-  sender: Identity,
-  timestamp: Timestamp,
-  connectionId: ConnectionId | null
-): ReducerCtx<UntypedSchemaDef> => {
-  return {
-    sender,
-    get identity() {
-      return new Identity(sys.identity().__identity__);
-    },
-    timestamp,
-    connectionId,
-    db: getDbView(),
-    senderAuth: AuthCtxImpl.fromSystemTables(connectionId, sender),
-    counter_uuid: { value: Number(0) },
-
-    /**
-     * Create a new random {@link Uuid} `v4` using the {@link crypto} RNG.
-     *
-     * WARN: Until we use a spacetime RNG this make calls non-deterministic.
-     */
-    newUuidV4(): Uuid {
-      // TODO: Use a spacetime RNG when available
-      const bytes = crypto.getRandomValues(new Uint8Array(16));
-      return Uuid.fromRandomBytesV4(bytes);
-    },
+// Using a class expression rather than declaration keeps the class out of the
+// type namespace, so that `ReducerCtx` still refers to the interface.
+export const ReducerCtxImpl = class ReducerCtx<
+  SchemaDef extends UntypedSchemaDef,
+> implements IReducerCtx<SchemaDef>
+{
+  #identity: Identity | undefined;
+  #senderAuth: AuthCtx | undefined;
+  #uuidCounter: { value: number } | undefined;
+  sender: Identity;
+  timestamp: Timestamp;
+  connectionId: ConnectionId | null;
+  db: DbView<SchemaDef>;
 
-    /**
-     * Create a new sortable {@link Uuid} `v7` using the {@link crypto} RNG, counter,
-     * and the timestamp.
-     *
-     * WARN: Until we use a spacetime RNG this make calls non-deterministic.
-     */
-    newUuidV7(): Uuid {
-      // TODO: Use a spacetime RNG when available
-      const bytes = crypto.getRandomValues(new Uint8Array(4));
-      return Uuid.fromCounterV7(this.counter_uuid, this.timestamp, bytes);
-    },
-  };
+  constructor(
+    sender: Identity,
+    timestamp: Timestamp,
+    connectionId: ConnectionId | null
+  ) {
+    Object.seal(this);
+    this.sender = sender;
+    this.timestamp = timestamp;
+    this.connectionId = connectionId;
+    this.db = getDbView();
+  }
+
+  get identity() {
+    return (this.#identity ??= new Identity(sys.identity().__identity__));
+  }
+
+  get senderAuth() {
+    return (this.#senderAuth ??= AuthCtxImpl.fromSystemTables(
+      this.connectionId,
+      this.sender
+    ));
+  }
+
+  /**
+   * Create a new random {@link Uuid} `v4` using the {@link crypto} RNG.
+   *
+   * WARN: Until we use a spacetime RNG this make calls non-deterministic.
+   */
+  newUuidV4(): Uuid {
+    // TODO: Use a spacetime RNG when available
+    const bytes = crypto.getRandomValues(new Uint8Array(16));
+    return Uuid.fromRandomBytesV4(bytes);
+  }
+
+  /**
+   * Create a new sortable {@link Uuid} `v7` using the {@link crypto} RNG, counter,
+   * and the timestamp.
+   *
+   * WARN: Until we use a spacetime RNG this make calls non-deterministic.
+   */
+  newUuidV7(): Uuid {
+    // TODO: Use a spacetime RNG when available
+    const bytes = crypto.getRandomValues(new Uint8Array(4));
+    const counter = (this.#uuidCounter ??= { value: 0 });
+    return Uuid.fromCounterV7(counter, this.timestamp, bytes);
+  }
 };
 
 /**
@@ -257,12 +279,10 @@ export const hooks: ModuleHooks = {
       MODULE_DEF.typespace
     );
     const senderIdentity = new Identity(sender);
-    const ctx: ReducerCtx<any> = freeze(
-      makeReducerCtx(
-        senderIdentity,
-        new Timestamp(timestamp),
-        ConnectionId.nullIfZero(new ConnectionId(connId))
-      )
+    const ctx: ReducerCtx<any> = new ReducerCtxImpl(
+      senderIdentity,
+      new Timestamp(timestamp),
+      ConnectionId.nullIfZero(new ConnectionId(connId))
     );
     try {
       return callUserFunction(REDUCERS[reducerId], ctx, args) ?? { tag: 'ok' };