hacky macro

Author: Shubham8287

crates/bindings-macro/src/lib.rs

@@ -132,6 +132,8 @@ mod sym {
     symbol!(update);
     symbol!(default);
     symbol!(event);
+    symbol!(outbox);
+    symbol!(on_result);
 
     symbol!(u8);
     symbol!(i8);

crates/bindings-macro/src/table.rs

@@ -22,6 +22,16 @@ pub(crate) struct TableArgs {
     accessor: Ident,
     indices: Vec<IndexArg>,
     event: Option<Span>,
+    outbox: Option<OutboxArg>,
+}
+
+/// Parsed from `outbox(remote_reducer_fn)` optionally followed by `on_result(local_reducer_fn)`.
+struct OutboxArg {
+    span: Span,
+    /// Path to the remote-side reducer function (used only for its name via `FnInfo::NAME`).
+    remote_reducer: Path,
+    /// Path to the local `on_result` reducer, if any.
+    on_result_reducer: Option<Path>,
 }
 
 enum TableAccess {
@@ -82,6 +92,7 @@ impl TableArgs {
         let mut name: Option<LitStr> = None;
         let mut indices = Vec::new();
         let mut event = None;
+        let mut outbox: Option<OutboxArg> = None;
         syn::meta::parser(|meta| {
             match_meta!(match meta {
                 sym::public => {
@@ -149,6 +160,30 @@ If you're migrating from SpacetimeDB 1.*, replace `name = {sym}` with `accessor
                     check_duplicate(&event, &meta)?;
                     event = Some(meta.path.span());
                 }
+                sym::outbox => {
+                    check_duplicate_msg(&outbox, &meta, "already specified outbox")?;
+                    outbox = Some(OutboxArg::parse_meta(meta)?);
+                }
+                sym::on_result => {
+                    // `on_result` must be specified alongside `outbox`.
+                    // We parse it here and attach it to the outbox arg below.
+                    let span = meta.path.span();
+                    let on_result_path = OutboxArg::parse_single_path_meta(meta)?;
+                    match &mut outbox {
+                        Some(ob) => {
+                            if ob.on_result_reducer.is_some() {
+                                return Err(syn::Error::new(span, "already specified on_result"));
+                            }
+                            ob.on_result_reducer = Some(on_result_path);
+                        }
+                        None => {
+                            return Err(syn::Error::new(
+                                span,
+                                "on_result requires outbox to be specified first: `outbox(remote_reducer), on_result(local_reducer)`",
+                            ))
+                        }
+                    }
+                }
             });
             Ok(())
         })
@@ -188,6 +223,7 @@ If you're migrating from SpacetimeDB 1.*, replace `name = {name_str_value:?}` wi
             indices,
             name,
             event,
+            outbox,
         })
     }
 }
@@ -231,6 +267,64 @@ impl ScheduledArg {
     }
 }
 
+impl OutboxArg {
+    /// Parse `outbox(remote_reducer_path)`.
+    ///
+    /// `on_result` is parsed separately via `parse_single_path_meta` and attached afterwards.
+    fn parse_meta(meta: ParseNestedMeta) -> syn::Result<Self> {
+        let span = meta.path.span();
+        let mut remote_reducer: Option<Path> = None;
+
+        meta.parse_nested_meta(|meta| {
+            if meta.input.peek(syn::Token![=]) || meta.input.peek(syn::token::Paren) {
+                Err(meta.error("outbox takes a single function path, e.g. `outbox(my_remote_reducer)`"))
+            } else {
+                check_duplicate_msg(
+                    &remote_reducer,
+                    &meta,
+                    "can only specify one remote reducer for outbox",
+                )?;
+                remote_reducer = Some(meta.path);
+                Ok(())
+            }
+        })?;
+
+        let remote_reducer = remote_reducer.ok_or_else(|| {
+            syn::Error::new(span, "outbox requires a remote reducer: `outbox(my_remote_reducer)`")
+        })?;
+
+        Ok(Self {
+            span,
+            remote_reducer,
+            on_result_reducer: None,
+        })
+    }
+
+    /// Parse `on_result(local_reducer_path)` and return the path.
+    fn parse_single_path_meta(meta: ParseNestedMeta) -> syn::Result<Path> {
+        let span = meta.path.span();
+        let mut result: Option<Path> = None;
+
+        meta.parse_nested_meta(|meta| {
+            if meta.input.peek(syn::Token![=]) || meta.input.peek(syn::token::Paren) {
+                Err(meta.error("on_result takes a single function path, e.g. `on_result(my_local_reducer)`"))
+            } else {
+                check_duplicate_msg(
+                    &result,
+                    &meta,
+                    "can only specify one on_result reducer",
+                )?;
+                result = Some(meta.path);
+                Ok(())
+            }
+        })?;
+
+        result.ok_or_else(|| {
+            syn::Error::new(span, "on_result requires a local reducer: `on_result(my_local_reducer)`")
+        })
+    }
+}
+
 impl IndexArg {
     fn parse_meta(meta: ParseNestedMeta) -> syn::Result<Self> {
         let mut accessor = None;

crates/bindings/src/rt.rs

@@ -533,6 +533,17 @@ impl<T: SpacetimeType> TableColumn for T {}
 /// Assert that the primary_key column of a scheduled table is a u64.
 pub const fn assert_scheduled_table_primary_key<T: ScheduledTablePrimaryKey>() {}
 
+/// Verify at compile time that a function has the correct signature for an outbox `on_result` reducer.
+///
+/// The reducer must accept `(OutboxRow, Result<(), String>)` as its user-supplied arguments:
+/// `fn on_result(ctx: &ReducerContext, request: OutboxRow, result: Result<(), String>)`
+pub const fn outbox_typecheck<'de, OutboxRow>(_x: impl Reducer<'de, (OutboxRow, Result<(), String>)>)
+where
+    OutboxRow: spacetimedb_lib::SpacetimeType + Serialize + Deserialize<'de>,
+{
+    core::mem::forget(_x);
+}
+
 mod sealed {
     pub trait Sealed {}
 }
@@ -763,6 +774,14 @@ pub fn register_table<T: Table>() {
 
         table.finish();
 
+        if let Some(outbox) = T::OUTBOX {
+            module.inner.add_outbox(
+                T::TABLE_NAME,
+                outbox.remote_reducer_name,
+                outbox.on_result_reducer_name,
+            );
+        }
+
         module.inner.add_explicit_names(T::explicit_names());
     })
 }

crates/bindings/src/table.rs

@@ -134,6 +134,7 @@ pub trait TableInternal: Sized {
     const SEQUENCES: &'static [u16];
     const SCHEDULE: Option<ScheduleDesc<'static>> = None;
     const IS_EVENT: bool = false;
+    const OUTBOX: Option<OutboxDesc<'static>> = None;
 
     /// Returns the ID of this table.
     fn table_id() -> TableId;
@@ -161,6 +162,14 @@ pub struct ScheduleDesc<'a> {
     pub scheduled_at_column: u16,
 }
 
+/// Describes the outbox configuration of a table, for inter-database communication.
+pub struct OutboxDesc<'a> {
+    /// The name of the remote reducer to invoke on the target database.
+    pub remote_reducer_name: &'a str,
+    /// The local reducer to call with the delivery result, if any.
+    pub on_result_reducer_name: Option<&'a str>,
+}
+
 #[derive(Debug, Clone)]
 pub struct ColumnDefault {
     pub col_id: u16,

crates/lib/src/db/raw_def/v10.rs

@@ -89,6 +89,13 @@ pub enum RawModuleDefV10Section {
 
     /// Names provided explicitly by the user that do not follow from the case conversion policy.
     ExplicitNames(ExplicitNames),
+
+    /// Outbox table definitions.
+    ///
+    /// Each entry marks a table as an outbox table for inter-database communication,
+    /// specifying the remote reducer to call and optionally a local callback reducer.
+    /// New variant — old modules simply omit this section; old servers skip it.
+    Outboxes(Vec<RawOutboxDefV10>),
 }
 
 #[derive(Debug, Clone, Copy, Default, SpacetimeType)]
@@ -264,6 +271,31 @@ pub struct RawColumnDefaultValueV10 {
     pub value: Box<[u8]>,
 }
 
+/// Marks a table as an outbox table for inter-database communication.
+///
+/// The table must have:
+/// - Col 0: `u64` with `#[primary_key] #[auto_inc]` — the row ID stored in `st_msg_id`.
+/// - Col 1: `Identity` (encoded as U256) — the target database identity.
+/// - Remaining cols: arguments forwarded verbatim to the remote reducer.
+///
+/// The `remote_reducer` is the name of the reducer to call on the target database.
+/// If `on_result_reducer` is set, that local reducer is called when delivery completes,
+/// with signature `fn on_result(ctx: &ReducerContext, request: OutboxRow, result: Result<(), String>)`.
+#[derive(Debug, Clone, SpacetimeType)]
+#[sats(crate = crate)]
+#[cfg_attr(feature = "test", derive(PartialEq, Eq, PartialOrd, Ord))]
+pub struct RawOutboxDefV10 {
+    /// The `source_name` of the outbox table (as given in `accessor = ...`).
+    pub table_name: RawIdentifier,
+
+    /// The name of the reducer to call on the target database.
+    pub remote_reducer: RawIdentifier,
+
+    /// The name of the local reducer to call with the delivery result.
+    /// If `None`, no callback is made after delivery.
+    pub on_result_reducer: Option<RawIdentifier>,
+}
+
 /// A reducer definition.
 #[derive(Debug, Clone, SpacetimeType)]
 #[sats(crate = crate)]
@@ -584,6 +616,14 @@ impl RawModuleDefV10 {
             .expect("Tables section must exist for tests")
     }
 
+    /// Get the outboxes section, if present.
+    pub fn outboxes(&self) -> Option<&Vec<RawOutboxDefV10>> {
+        self.sections.iter().find_map(|s| match s {
+            RawModuleDefV10Section::Outboxes(outboxes) => Some(outboxes),
+            _ => None,
+        })
+    }
+
     // Get the row-level security section, if present.
     pub fn row_level_security(&self) -> Option<&Vec<RawRowLevelSecurityDefV10>> {
         self.sections.iter().find_map(|s| match s {
@@ -785,6 +825,24 @@ impl RawModuleDefV10Builder {
         }
     }
 
+    /// Get mutable access to the outboxes section, creating it if missing.
+    fn outboxes_mut(&mut self) -> &mut Vec<RawOutboxDefV10> {
+        let idx = self
+            .module
+            .sections
+            .iter()
+            .position(|s| matches!(s, RawModuleDefV10Section::Outboxes(_)))
+            .unwrap_or_else(|| {
+                self.module.sections.push(RawModuleDefV10Section::Outboxes(Vec::new()));
+                self.module.sections.len() - 1
+            });
+
+        match &mut self.module.sections[idx] {
+            RawModuleDefV10Section::Outboxes(outboxes) => outboxes,
+            _ => unreachable!("Just ensured Outboxes section exists"),
+        }
+    }
+
     /// Get mutable access to the case conversion policy, creating it if missing.
     fn explicit_names_mut(&mut self) -> &mut ExplicitNames {
         let idx = self
@@ -1040,6 +1098,24 @@ impl RawModuleDefV10Builder {
         });
     }
 
+    /// Register an outbox table for inter-database communication.
+    ///
+    /// `table_name` is the `source_name` of the table (i.e. `accessor =` value).
+    /// `remote_reducer` is the reducer to call on the target database.
+    /// `on_result_reducer` is an optional local reducer called with the delivery result.
+    pub fn add_outbox(
+        &mut self,
+        table_name: impl Into<RawIdentifier>,
+        remote_reducer: impl Into<RawIdentifier>,
+        on_result_reducer: Option<impl Into<RawIdentifier>>,
+    ) {
+        self.outboxes_mut().push(RawOutboxDefV10 {
+            table_name: table_name.into(),
+            remote_reducer: remote_reducer.into(),
+            on_result_reducer: on_result_reducer.map(Into::into),
+        });
+    }
+
     /// Add a row-level security policy to the module.
     ///
     /// The `sql` expression should be a valid SQL expression that will be used to filter rows.