Basic procedure calling

Author: coolreader18

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

@@ -0,0 +1,60 @@
+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, 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 = 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 });

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

@@ -0,0 +1,40 @@
+import { AlgebraicType, ProductType } from '../lib/algebraic_type';
+import BinaryReader from '../lib/binary_reader';
+import BinaryWriter from '../lib/binary_writer';
+import type { ConnectionId } from '../lib/connection_id';
+import { Identity } from '../lib/identity';
+import { PROCEDURES, type ProcedureCtx } from '../lib/procedures';
+import { MODULE_DEF, type UntypedSchemaDef } from '../lib/schema';
+import type { Timestamp } from '../lib/timestamp';
+import { sys } from './runtime';
+
+const { freeze } = Object;
+
+export function callProcedure(
+  id: number,
+  sender: Identity,
+  connectionId: ConnectionId | null,
+  timestamp: Timestamp,
+  argsBuf: Uint8Array
+): Uint8Array {
+  const { fn, paramsType, returnType, returnTypeBaseSize } = PROCEDURES[id];
+  const args = ProductType.deserializeValue(
+    new BinaryReader(argsBuf),
+    paramsType,
+    MODULE_DEF.typespace
+  );
+
+  const ctx: ProcedureCtx<UntypedSchemaDef> = freeze({
+    sender,
+    timestamp,
+    connectionId,
+    get identity() {
+      return new Identity(sys.identity().__identity__);
+    },
+  });
+
+  const ret = fn(ctx, args);
+  const retBuf = new BinaryWriter(returnTypeBaseSize);
+  AlgebraicType.serializeValue(retBuf, returnType, ret, MODULE_DEF.typespace);
+  return retBuf.getBuffer();
+}

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

@@ -1,6 +1,8 @@
 import { register_hooks } from 'spacetime:sys@1.0';
 import { register_hooks as register_hooks_v1_1 } from 'spacetime:sys@1.1';
-import { hooks, hooks_v1_1 } from './runtime';
+import { register_hooks as register_hooks_v1_2 } from 'spacetime:sys@1.2';
+import { hooks, hooks_v1_1, hooks_v1_2 } from './runtime';
 
 register_hooks(hooks);
 register_hooks_v1_1(hooks_v1_1);
+register_hooks_v1_2(hooks_v1_2);

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

@@ -1,54 +1,48 @@
-import { AlgebraicType } from '../lib/algebraic_type';
+import * as _syscalls1_0 from 'spacetime:sys@1.0';
+import * as _syscalls1_2 from 'spacetime:sys@1.2';
+
+import type { ModuleHooks, u16, u32 } from 'spacetime:sys@1.0';
+import { AlgebraicType, ProductType } from '../lib/algebraic_type';
 import RawModuleDef from '../lib/autogen/raw_module_def_type';
 import type RawModuleDefV9 from '../lib/autogen/raw_module_def_v_9_type';
 import type RawTableDefV9 from '../lib/autogen/raw_table_def_v_9_type';
 import type Typespace from '../lib/autogen/typespace_type';
-import { ConnectionId } from '../lib/connection_id';
-import { Identity } from '../lib/identity';
-import { Timestamp } from '../lib/timestamp';
 import BinaryReader from '../lib/binary_reader';
 import BinaryWriter from '../lib/binary_writer';
-import { SenderError, SpacetimeHostError } from './errors';
-import { Range, type Bound } from './range';
+import { ConnectionId } from '../lib/connection_id';
+import { Identity } from '../lib/identity';
 import {
   type Index,
   type IndexVal,
-  type UniqueIndex,
   type RangedIndex,
+  type UniqueIndex,
 } from '../lib/indexes';
-import { type RowType, type Table, type TableMethods } from '../lib/table';
+import { callProcedure } from './procedures';
 import {
-  type ReducerCtx,
   REDUCERS,
-  type JwtClaims,
   type AuthCtx,
   type JsonObject,
+  type JwtClaims,
+  type ReducerCtx,
 } from '../lib/reducers';
 import { MODULE_DEF } from '../lib/schema';
-
-import * as _syscalls from 'spacetime:sys@1.0';
-import type { u16, u32, ModuleHooks } from 'spacetime:sys@1.0';
-import type { DbView } from './db_view';
-import { toCamelCase } from '../lib/util';
+import { type RowType, type Table, type TableMethods } from '../lib/table';
+import { Timestamp } from '../lib/timestamp';
 import type { Infer } from '../lib/type_builders';
-import { bsatnBaseSize } from '../lib/util';
+import { bsatnBaseSize, toCamelCase } from '../lib/util';
 import {
   ANON_VIEWS,
   VIEWS,
   type AnonymousViewCtx,
   type ViewCtx,
 } from '../lib/views';
+import type { DbView } from './db_view';
+import { SenderError, SpacetimeHostError } from './errors';
+import { Range, type Bound } from './range';
 
 const { freeze } = Object;
 
-const sys: typeof _syscalls = freeze(
-  Object.fromEntries(
-    Object.entries(_syscalls).map(([name, syscall]) => [
-      name,
-      wrapSyscall(syscall),
-    ])
-  ) as typeof _syscalls
-);
+export const sys = freeze(wrapSyscalls(_syscalls1_0, _syscalls1_2));
 
 export function parseJsonObject(json: string): JsonObject {
   let value: unknown;
@@ -235,9 +229,9 @@ export const hooks_v1_1: import('spacetime:sys@1.1').ModuleHooks = {
       // at runtime
       db: getDbView(),
     });
-    const args = AlgebraicType.deserializeValue(
+    const args = ProductType.deserializeValue(
       new BinaryReader(argsBuf),
-      AlgebraicType.Product(params),
+      params,
       MODULE_DEF.typespace
     );
     const ret = fn(ctx, args);
@@ -253,9 +247,9 @@ export const hooks_v1_1: import('spacetime:sys@1.1').ModuleHooks = {
       // at runtime
       db: getDbView(),
     });
-    const args = AlgebraicType.deserializeValue(
+    const args = ProductType.deserializeValue(
       new BinaryReader(argsBuf),
-      AlgebraicType.Product(params),
+      params,
       MODULE_DEF.typespace
     );
     const ret = fn(ctx, args);
@@ -265,6 +259,18 @@ export const hooks_v1_1: import('spacetime:sys@1.1').ModuleHooks = {
   },
 };
 
+export const hooks_v1_2: import('spacetime:sys@1.2').ModuleHooks = {
+  __call_procedure__(id, sender, connection_id, timestamp, args) {
+    return callProcedure(
+      id,
+      new Identity(sender),
+      ConnectionId.nullIfZero(new ConnectionId(connection_id)),
+      new Timestamp(timestamp),
+      args
+    );
+  },
+};
+
 let DB_VIEW: DbView<any> | null = null;
 function getDbView() {
   DB_VIEW ??= makeDbView(MODULE_DEF);
@@ -587,6 +593,21 @@ class TableIterator implements IterableIterator<any, undefined> {
   }
 }
 
+type Intersections<Ts extends readonly any[]> = Ts extends [
+  infer T,
+  ...infer Rest,
+]
+  ? T & Intersections<Rest>
+  : unknown;
+
+function wrapSyscalls<
+  Modules extends Record<string, (...args: any[]) => any>[],
+>(...modules: Modules): Intersections<Modules> {
+  return Object.fromEntries(
+    modules.flatMap(Object.entries).map(([k, v]) => [k, wrapSyscall(v)])
+  ) as Intersections<Modules>;
+}
+
 function wrapSyscall<F extends (...args: any[]) => any>(
   func: F
 ): (...args: Parameters<F>) => ReturnType<F> {

crates/bindings-typescript/src/server/sys.d.ts

@@ -75,3 +75,17 @@ declare module 'spacetime:sys@1.1' {
 
   export function register_hooks(hooks: ModuleHooks);
 }
+
+declare module 'spacetime:sys@1.2' {
+  export type ModuleHooks = {
+    __call_procedure__(
+      id: u32,
+      sender: u256,
+      connection_id: u128,
+      timestamp: bigint,
+      args: Uint8Array
+    ): Uint8Array;
+  };
+
+  export function register_hooks(hooks: ModuleHooks);
+}

crates/core/src/error.rs

@@ -267,6 +267,8 @@ pub enum NodesError {
     BadColumn,
     #[error("can't perform operation; not inside transaction")]
     NotInTransaction,
+    #[error("can't perform operation; not inside anonymous transaction")]
+    NotInAnonTransaction,
     #[error("ABI call not allowed while holding open a transaction: {0}")]
     WouldBlockTransaction(AbiCall),
     #[error("table with name {0:?} already exists")]

crates/core/src/host/host_controller.rs

@@ -179,6 +179,7 @@ pub struct ProcedureCallResult {
     pub start_timestamp: Timestamp,
 }
 
+#[derive(Debug)]
 pub struct CallProcedureReturn {
     pub result: Result<ProcedureCallResult, ProcedureCallError>,
     pub tx_offset: Option<TransactionOffset>,