More granular table traits

[onx2]

Description of Changes

This looks like a large diff but the real changes are just sdks/rust/src/lib.rs for traits and crates/codegen/src/rust.rs for the new codegen.

Refactored the Rust SDK table trait surface into composable capabilities and updated Rust codegen to match. Discord thread

Motivation

The granular traits are a useful type-system cleanup on their own, but the main motivation is to let downstream integration crates like bevy_stdb express callback capabilities more directly instead of routing them through broader semantic categories.

For example, bevy_stdb may want to support bindings like “forward only inserts from this subscribed view as Bevy messages” for a relation that is not semantically an EventTable. Today this can still be made to work with broader abstractions, so this is not primarily about enabling new runtime behavior. The value is mostly at compile time: more precise trait bounds, clearer downstream APIs, and better guarantees that a binding only requires the capabilities it actually uses.

Concretely, this makes it easier for integration crates to model things like insert-only or delete-only bindings for ordinary tables or views without conflating those behaviors with EventTable semantics.

Example:

// Current semantic shape:
plugin.add_event_table::<LogRow>(|reg, db| reg.bind(db.logs()));

// Potential capability-based shape:
plugin.add_insert_source::<CharacterRow>(|reg, db| reg.bind(db.characters_near_me()));
plugin.add_delete_source::<CharacterRow>(|reg, db| reg.bind(db.characters_near_me()));

Summary

• Added a shared TableLike trait for common table handle functionality:
  • Row
  • EventContext
  • count
  • iter
• Added capability traits:
  • WithInsert
  • WithDelete
  • WithUpdate
• Changed umbrella traits to compose those capabilities:
  • Table: TableLike + WithInsert + WithDelete
  • TableWithPrimaryKey: Table + WithUpdate
  • EventTable: TableLike + WithInsert
• Updated Rust binding codegen to emit separate impl blocks for:
  • TableLike
  • WithInsert
  • WithDelete
  • WithUpdate
  • plus empty umbrella impls for Table, TableWithPrimaryKey, and EventTable
• Updated generated-doc references for callback APIs
• Exported the new traits through both the Rust SDK public API and spacetimedb_sdk::__codegen so generated bindings can compile correctly

API and ABI breaking changes

Yes — this is an API-breaking change in the Rust SDK trait hierarchy.

Notable changes:

• insert callbacks are now provided via WithInsert
• delete callbacks are now provided via WithDelete
• update callbacks are now provided via WithUpdate
• generated Rust bindings now implement multiple capability traits instead of placing all methods in a single Table / EventTable impl block

Expected complexity level and risk

3/5

This is a moderate refactor because it changes the Rust SDK trait model, affects Rust code generation, and requires the generated binding surface and SDK re-export surface to stay in sync.

Main interaction points:

• sdks/rust/src/table.rs
• sdks/rust/src/lib.rs
• crates/codegen/src/rust.rs

Testing

• Ran cargo check --manifest-path /Users/onx2/Documents/projects/SpacetimeDB/sdks/rust/Cargo.toml
• Ran cargo test --manifest-path /Users/onx2/Documents/projects/SpacetimeDB/Cargo.toml -p spacetimedb-codegen test_codegen_rust
• Regenerated Rust client bindings using the workspace CLI and verified generated impls match the new trait structure
• Reviewer: regenerate a Rust client with the workspace CLI and confirm the generated bindings compile cleanly

[onx2]

This is the main change to functionality. I wanted to have access to specific traits so in bevy_stdb I can go from:

Before/after

fn bind_insert<TRow, TTable>(world: &World, table: &TTable)
where
    TRow: Send + Sync + Clone + InModule + 'static,
    RowEvent<TRow>: Send + Sync,
-   TTable: Table<
+   TTable: WithInsert<
            Row = TRow,
            EventContext = <<TRow as InModule>::Module as SpacetimeModule>::EventContext,
        >,
    TTable::EventContext: AbstractEventContext<Event = RowEvent<TRow>>,
{
    let sender = channel_sender::<InsertMessage<TRow>>(world);
    table.on_insert(move |ctx, row| {
        let _ = sender.send(InsertMessage {
            event: ctx.event().clone(),
            row: row.clone(),
        });
    });
}

[onx2]

Trait changes mean we need updated codegen too (breaking).

[onx2]

Do we need these empty impls? Maybe now Table can just be removed entirely?

[onx2]

Maybe this could have a better name? Its meant to be the common things all tables have.

[cloutiertyler]

I see the Discord thread, but could you expand on what the motivation for this is in the PR description? An example of what this enables would be helpful.

[onx2]

I see the Discord thread, but could you expand on what the motivation for this is in the PR description? An example of what this enables would be helpful.

Updated 😄