[TS] Implement basic procedure calling (#3649)

# Description of Changes

Implements `__call_procedure__` in the TS bindings and host.

# Expected complexity level and risk

2

# Testing

<!-- Describe any testing you've done, and any testing you'd like your
reviewers to do,
so that you're confident that all the changes work as expected! -->

- [ ] <!-- maybe a test you want to do -->
- [ ] <!-- maybe a test you want a reviewer to do, so they can check it
off when they're satisfied. -->

Author: coolreader18

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

@@ -0,0 +1,64 @@
+import { AlgebraicType, ProductType } from '../lib/algebraic_type';
+import type { ConnectionId } from '../lib/connection_id';
+import type { Identity } from '../lib/identity';
+import type { Timestamp } from '../lib/timestamp';
+import type { ParamsObj } from './reducers';
+import {
+  MODULE_DEF,
+  registerTypesRecursively,
+  type UntypedSchemaDef,
+} from './schema';
+import type { Infer, InferTypeOfRow, TypeBuilder } from './type_builders';
+import { bsatnBaseSize } from './util';
+
+export type ProcedureFn<
+  S extends UntypedSchemaDef,
+  Params extends ParamsObj,
+  Ret extends TypeBuilder<any, any>,
+> = (ctx: ProcedureCtx<S>, args: InferTypeOfRow<Params>) => Infer<Ret>;
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export interface ProcedureCtx<S extends UntypedSchemaDef> {
+  readonly sender: Identity;
+  readonly identity: Identity;
+  readonly timestamp: Timestamp;
+  readonly connectionId: ConnectionId | null;
+}
+
+export function procedure<
+  S extends UntypedSchemaDef,
+  Params extends ParamsObj,
+  Ret extends TypeBuilder<any, any>,
+>(name: string, params: Params, ret: Ret, fn: ProcedureFn<S, Params, Ret>) {
+  const paramsType: ProductType = {
+    elements: Object.entries(params).map(([n, c]) => ({
+      name: n,
+      algebraicType:
+        'typeBuilder' in c ? c.typeBuilder.algebraicType : c.algebraicType,
+    })),
+  };
+  const returnType = registerTypesRecursively(ret).algebraicType;
+
+  MODULE_DEF.miscExports.push({
+    tag: 'Procedure',
+    value: {
+      name,
+      params: paramsType,
+      returnType,
+    },
+  });
+
+  PROCEDURES.push({
+    fn,
+    paramsType,
+    returnType,
+    returnTypeBaseSize: bsatnBaseSize(MODULE_DEF.typespace, returnType),
+  });
+}
+
+export const PROCEDURES: Array<{
+  fn: ProcedureFn<any, any, any>;
+  paramsType: ProductType;
+  returnType: AlgebraicType;
+  returnTypeBaseSize: number;
+}> = [];

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

@@ -47,6 +47,7 @@ import {
 } from './views';
 import RawIndexDefV9 from './autogen/raw_index_def_v_9_type';
 import type { IndexOpts } from './indexes';
+import { procedure, type ProcedureFn } from './procedures';
 
 export type TableNamesOf<S extends UntypedSchemaDef> =
   S['tables'][number]['name'];
@@ -547,6 +548,32 @@ class Schema<S extends UntypedSchemaDef> {
   //   }
   // }
 
+  procedure<Params extends ParamsObj, Ret extends TypeBuilder<any, any>>(
+    name: string,
+    params: Params,
+    ret: Ret,
+    fn: ProcedureFn<S, Params, Ret>
+  ): ProcedureFn<S, Params, Ret>;
+  procedure<Ret extends TypeBuilder<any, any>>(
+    name: string,
+    ret: Ret,
+    fn: ProcedureFn<S, {}, Ret>
+  ): ProcedureFn<S, {}, Ret>;
+  procedure<Params extends ParamsObj, Ret extends TypeBuilder<any, any>>(
+    name: string,
+    paramsOrRet: Ret | Params,
+    retOrFn: ProcedureFn<S, {}, Ret> | Ret,
+    maybeFn?: ProcedureFn<S, Params, Ret>
+  ): ProcedureFn<S, Params, Ret> {
+    if (typeof retOrFn === 'function') {
+      procedure(name, {}, paramsOrRet as Ret, retOrFn);
+      return retOrFn;
+    } else {
+      procedure(name, paramsOrRet as Params, retOrFn, maybeFn!);
+      return maybeFn!;
+    }
+  }
+
   clientVisibilityFilter = {
     sql(filter: string): void {
       MODULE_DEF.rowLevelSecurity.push({ sql: filter });