[release/v1.7.0]: Revert "ModuleDef and schema changes to support procedures (#3392)"

This reverts commit 0a6aa7c.

Author: bfops

Cargo.lock

@@ -42,11 +42,6 @@ spacetimedb
 │   ├── spacetimedb_primitives
 │   │   ├── bitflags
 │   │   ├── either
-│   │   ├── enum_as_inner
-│   │   │   ├── heck
-│   │   │   ├── proc_macro2 (*)
-│   │   │   ├── quote (*)
-│   │   │   └── syn (*)
 │   │   ├── itertools
 │   │   │   └── either
 │   │   └── nohash_hasher
@@ -55,7 +50,6 @@ spacetimedb
 │   └── spacetimedb_primitives
 │       ├── bitflags
 │       ├── either
-│       ├── enum_as_inner (*)
 │       ├── itertools
 │       │   └── either
 │       └── nohash_hasher
@@ -76,7 +70,11 @@ spacetimedb
 │   │       [build-dependencies]
 │   │       └── autocfg
 │   ├── derive_more (*)
-│   ├── enum_as_inner (*)
+│   ├── enum_as_inner
+│   │   ├── heck
+│   │   ├── proc_macro2 (*)
+│   │   ├── quote (*)
+│   │   └── syn (*)
 │   ├── hex
 │   ├── itertools (*)
 │   ├── spacetimedb_bindings_macro (*)

crates/bindings-csharp/Runtime/Internal/Autogen/RawMiscModuleExportV9.g.cs

@@ -23,7 +23,7 @@ use spacetimedb::host::module_host::ClientConnectedError;
 use spacetimedb::host::ReducerCallError;
 use spacetimedb::host::ReducerOutcome;
 use spacetimedb::host::UpdateDatabaseResult;
-use spacetimedb::host::{FunctionArgs, MigratePlanResult};
+use spacetimedb::host::{MigratePlanResult, ReducerArgs};
 use spacetimedb::identity::Identity;
 use spacetimedb::messages::control_db::{Database, HostType};
 use spacetimedb_client_api_messages::name::{
@@ -61,7 +61,7 @@ pub async fn call<S: ControlStateDelegate + NodeDelegate>(
     }
     let caller_identity = auth.claims.identity;
 
-    let args = FunctionArgs::Json(body);
+    let args = ReducerArgs::Json(body);
 
     let db_identity = name_or_identity.resolve(&worker_ctx).await?;
     let database = worker_ctx_find_database(&worker_ctx, &db_identity)

crates/bindings-csharp/Runtime/Internal/Autogen/RawProcedureDefV9.g.cs

@@ -12,7 +12,7 @@ use super::{message_handlers, ClientActorId, MessageHandleError};
 use crate::db::relational_db::RelationalDB;
 use crate::error::DBError;
 use crate::host::module_host::ClientConnectedError;
-use crate::host::{FunctionArgs, ModuleHost, NoSuchModule, ReducerCallError, ReducerCallResult};
+use crate::host::{ModuleHost, NoSuchModule, ReducerArgs, ReducerCallError, ReducerCallResult};
 use crate::messages::websocket::Subscribe;
 use crate::util::asyncify;
 use crate::util::prometheus_handle::IntGaugeExt;
@@ -809,7 +809,7 @@ impl ClientConnection {
     pub async fn call_reducer(
         &self,
         reducer: &str,
-        args: FunctionArgs,
+        args: ReducerArgs,
         request_id: RequestId,
         timer: Instant,
         flags: CallReducerFlags,

crates/bindings/tests/snapshots/deps__spacetimedb_bindings_dependencies.snap

@@ -2,7 +2,7 @@ use super::messages::{SubscriptionUpdateMessage, SwitchedServerMessage, ToProtoc
 use super::{ClientConnection, DataMessage, Protocol};
 use crate::energy::EnergyQuanta;
 use crate::host::module_host::{EventStatus, ModuleEvent, ModuleFunctionCall};
-use crate::host::{FunctionArgs, ReducerId};
+use crate::host::{ReducerArgs, ReducerId};
 use crate::identity::Identity;
 use crate::messages::websocket::{CallReducer, ClientMessage, OneOffQuery};
 use crate::worker_metrics::WORKER_METRICS;
@@ -36,14 +36,14 @@ pub async fn handle(client: &ClientConnection, message: DataMessage, timer: Inst
             let DeserializeWrapper(message) =
                 serde_json::from_str::<DeserializeWrapper<ClientMessage<Cow<str>>>>(&text)?;
             message.map_args(|s| {
-                FunctionArgs::Json(match s {
+                ReducerArgs::Json(match s {
                     Cow::Borrowed(s) => text.slice_ref(s),
                     Cow::Owned(string) => string.into(),
                 })
             })
         }
         DataMessage::Binary(message_buf) => bsatn::from_slice::<ClientMessage<&[u8]>>(&message_buf)?
-            .map_args(|b| FunctionArgs::Bsatn(message_buf.slice_ref(b))),
+            .map_args(|b| ReducerArgs::Bsatn(message_buf.slice_ref(b))),
     };
 
     let module = client.module();

crates/client-api/src/routes/database.rs

@@ -5,9 +5,10 @@ use derive_more::Display;
 use enum_map::Enum;
 use once_cell::sync::OnceCell;
 use spacetimedb_lib::bsatn;
-use spacetimedb_lib::de::{serde::SeedWrapper, DeserializeSeed};
+use spacetimedb_lib::de::serde::SeedWrapper;
+use spacetimedb_lib::de::DeserializeSeed;
 use spacetimedb_lib::ProductValue;
-use spacetimedb_schema::def::deserialize::{ArgsSeed, FunctionDef};
+use spacetimedb_schema::def::deserialize::ReducerArgsDeserializeSeed;
 
 mod disk_storage;
 mod host_controller;
@@ -30,37 +31,37 @@ pub use host_controller::{
 pub use module_host::{ModuleHost, NoSuchModule, ReducerCallError, UpdateDatabaseResult};
 pub use scheduler::Scheduler;
 
-/// Encoded arguments to a database function.
-///
-/// A database function is either a reducer or a procedure.
 #[derive(Debug)]
-pub enum FunctionArgs {
+pub enum ReducerArgs {
     Json(ByteString),
     Bsatn(Bytes),
     Nullary,
 }
 
-impl FunctionArgs {
-    fn into_tuple<Def: FunctionDef>(self, seed: ArgsSeed<'_, Def>) -> Result<ArgsTuple, InvalidFunctionArguments> {
-        self._into_tuple(seed).map_err(|err| InvalidFunctionArguments {
+impl ReducerArgs {
+    fn into_tuple(self, seed: ReducerArgsDeserializeSeed) -> Result<ArgsTuple, InvalidReducerArguments> {
+        self._into_tuple(seed).map_err(|err| InvalidReducerArguments {
             err,
-            function_name: seed.name().into(),
+            reducer: (*seed.reducer_def().name).into(),
         })
     }
-    fn _into_tuple<Def: FunctionDef>(self, seed: ArgsSeed<'_, Def>) -> anyhow::Result<ArgsTuple> {
+    fn _into_tuple(self, seed: ReducerArgsDeserializeSeed) -> anyhow::Result<ArgsTuple> {
         Ok(match self {
-            FunctionArgs::Json(json) => ArgsTuple {
+            ReducerArgs::Json(json) => ArgsTuple {
                 tuple: from_json_seed(&json, SeedWrapper(seed))?,
                 bsatn: OnceCell::new(),
                 json: OnceCell::with_value(json),
             },
-            FunctionArgs::Bsatn(bytes) => ArgsTuple {
+            ReducerArgs::Bsatn(bytes) => ArgsTuple {
                 tuple: seed.deserialize(bsatn::Deserializer::new(&mut &bytes[..]))?,
                 bsatn: OnceCell::with_value(bytes),
                 json: OnceCell::new(),
             },
-            FunctionArgs::Nullary => {
-                anyhow::ensure!(seed.params().elements.is_empty(), "failed to typecheck args");
+            ReducerArgs::Nullary => {
+                anyhow::ensure!(
+                    seed.reducer_def().params.elements.is_empty(),
+                    "failed to typecheck args"
+                );
                 ArgsTuple::nullary()
             }
         })
@@ -105,33 +106,14 @@ impl Default for ArgsTuple {
 // TODO(noa): replace imports from this module with imports straight from primitives.
 pub use spacetimedb_primitives::ReducerId;
 
-/// Inner error type for [`InvalidReducerArguments`] and [`InvalidProcedureArguments`].
 #[derive(thiserror::Error, Debug)]
-#[error("invalid arguments for function {function_name}: {err}")]
-pub struct InvalidFunctionArguments {
+#[error("invalid arguments for reducer {reducer}: {err}")]
+pub struct InvalidReducerArguments {
     #[source]
     err: anyhow::Error,
-    function_name: Box<str>,
+    reducer: Box<str>,
 }
 
-/// Newtype over [`InvalidFunctionArguments`] which renders with the word "reducer".
-#[derive(thiserror::Error, Debug)]
-#[error("invalid arguments for reducer {}: {}", .0.function_name, .0.err)]
-pub struct InvalidReducerArguments(
-    #[from]
-    #[source]
-    InvalidFunctionArguments,
-);
-
-/// Newtype over [`InvalidFunctionArguments`] which renders with the word "procedure".
-#[derive(thiserror::Error, Debug)]
-#[error("invalid arguments for procedure {}: {}", .0.function_name, .0.err)]
-pub struct InvalidProcedureArguments(
-    #[from]
-    #[source]
-    InvalidFunctionArguments,
-);
-
 fn from_json_seed<'de, T: serde::de::DeserializeSeed<'de>>(s: &'de str, seed: T) -> anyhow::Result<T::Value> {
     let mut de = serde_json::Deserializer::from_str(s);
     let mut track = serde_path_to_error::Track::new();

crates/core/src/client/client_connection.rs

@@ -1,6 +1,4 @@
-use super::{
-    ArgsTuple, FunctionArgs, InvalidReducerArguments, ReducerCallResult, ReducerId, ReducerOutcome, Scheduler,
-};
+use super::{ArgsTuple, InvalidReducerArguments, ReducerArgs, ReducerCallResult, ReducerId, ReducerOutcome, Scheduler};
 use crate::client::messages::{OneOffQueryResponseMessage, SerializableMessage};
 use crate::client::{ClientActorId, ClientConnectionSender};
 use crate::database_logger::{LogLevel, Record};
@@ -9,7 +7,6 @@ use crate::energy::EnergyQuanta;
 use crate::error::DBError;
 use crate::estimation::estimate_rows_scanned;
 use crate::hash::Hash;
-use crate::host::InvalidFunctionArguments;
 use crate::identity::Identity;
 use crate::messages::control_db::{Database, HostType};
 use crate::module_host_context::ModuleCreationContext;
@@ -50,7 +47,7 @@ use spacetimedb_primitives::TableId;
 use spacetimedb_query::compile_subscription;
 use spacetimedb_sats::ProductValue;
 use spacetimedb_schema::auto_migrate::{AutoMigrateError, MigrationPolicy};
-use spacetimedb_schema::def::deserialize::ArgsSeed;
+use spacetimedb_schema::def::deserialize::ReducerArgsDeserializeSeed;
 use spacetimedb_schema::def::{ModuleDef, ReducerDef, TableDef};
 use spacetimedb_schema::schema::{Schema, TableSchema};
 use spacetimedb_vm::relation::RelValue;
@@ -887,7 +884,7 @@ impl ModuleHost {
                     None,
                     reducer_id,
                     reducer_def,
-                    FunctionArgs::Nullary,
+                    ReducerArgs::Nullary,
                     inst,
                 )?;
 
@@ -982,10 +979,10 @@ impl ModuleHost {
                 log::error!(
                     "`call_identity_disconnected`: fallback transaction to delete from `st_client` failed: {err}"
                 );
-                InvalidReducerArguments(InvalidFunctionArguments {
+                InvalidReducerArguments {
                     err: err.into(),
-                    function_name: reducer_name.into(),
-                })
+                    reducer: reducer_name.into(),
+                }
                 .into()
             })
         };
@@ -1014,7 +1011,7 @@ impl ModuleHost {
                 None,
                 reducer_id,
                 reducer_def,
-                FunctionArgs::Nullary,
+                ReducerArgs::Nullary,
                 inst,
             );
 
@@ -1100,10 +1097,10 @@ impl ModuleHost {
         timer: Option<Instant>,
         reducer_id: ReducerId,
         reducer_def: &ReducerDef,
-        args: FunctionArgs,
+        args: ReducerArgs,
     ) -> Result<ReducerCallResult, ReducerCallError> {
-        let reducer_seed = ArgsSeed(self.info.module_def.typespace().with_type(reducer_def));
-        let args = args.into_tuple(reducer_seed).map_err(InvalidReducerArguments)?;
+        let reducer_seed = ReducerArgsDeserializeSeed(self.info.module_def.typespace().with_type(reducer_def));
+        let args = args.into_tuple(reducer_seed)?;
         let caller_connection_id = caller_connection_id.unwrap_or(ConnectionId::ZERO);
 
         Ok(self
@@ -1134,11 +1131,11 @@ impl ModuleHost {
         timer: Option<Instant>,
         reducer_id: ReducerId,
         reducer_def: &ReducerDef,
-        args: FunctionArgs,
+        args: ReducerArgs,
         module_instance: &mut Instance,
     ) -> Result<ReducerCallResult, ReducerCallError> {
-        let reducer_seed = ArgsSeed(self.info.module_def.typespace().with_type(reducer_def));
-        let args = args.into_tuple(reducer_seed).map_err(InvalidReducerArguments)?;
+        let reducer_seed = ReducerArgsDeserializeSeed(self.info.module_def.typespace().with_type(reducer_def));
+        let args = args.into_tuple(reducer_seed)?;
         let caller_connection_id = caller_connection_id.unwrap_or(ConnectionId::ZERO);
 
         Ok(module_instance.call_reducer(
@@ -1164,7 +1161,7 @@ impl ModuleHost {
         request_id: Option<RequestId>,
         timer: Option<Instant>,
         reducer_name: &str,
-        args: FunctionArgs,
+        args: ReducerArgs,
     ) -> Result<ReducerCallResult, ReducerCallError> {
         let res = async {
             let (reducer_id, reducer_def) = self
@@ -1243,12 +1240,10 @@ impl ModuleHost {
                     Ok(inst.call_reducer(Some(tx), params))
                 }
                 Ok(None) => Err(ReducerCallError::ScheduleReducerNotFound),
-                Err(err) => Err(ReducerCallError::Args(InvalidReducerArguments(
-                    InvalidFunctionArguments {
-                        err,
-                        function_name: REDUCER.into(),
-                    },
-                ))),
+                Err(err) => Err(ReducerCallError::Args(InvalidReducerArguments {
+                    err,
+                    reducer: REDUCER.into(),
+                })),
             }
         })
         .await?