PublicArchive/SpacetimeDB
2
0
Fork 0
mirror of https://github.com/clockworklabs/SpacetimeDB.git synced 2026-05-12 18:57:51 -04:00
Code Issues Packages Projects Releases Wiki Activity
Files
bfops/debug-changes
SpacetimeDB/crates/codegen/tests/snapshots/codegen__codegen_rust.snap
T
Shubham Mishra 2560846f22 Rust: client query builder (#4003) 
# Description of Changes
Client Query builder for rust, as per proposal -
https://github.com/clockworklabs/SpacetimeDBPrivate/pull/2356.

1. Pach moves query builder to its separate crate, so that it can be
shared between module and sdk.
2. Implements `TypedSubscriptionBuilder` in `sdks/rust` as mentioned in
proposal
3. Modify codegen to extend types to support query builder as mentioned
in proposal
4. a test

# API and ABI breaking changes
NA, additive changes.

# Expected complexity level and risk
2

# Testing
Added a test.

---------

Signed-off-by: Shubham Mishra <shivam828787@gmail.com>
Co-authored-by: joshua-spacetime <josh@clockworklabs.io>
2026-01-22 15:37:22 +00:00

5805 lines
195 KiB
Plaintext
Raw Permalink Blame History

---
source: crates/codegen/tests/codegen.rs
assertion_line: 37
expression: outfiles
---
"add_player_reducer.rs" = '''
// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
#![allow(unused, clippy::all)]
use spacetimedb_sdk::__codegen::{
self as __sdk,
__lib,
__sats,
__ws,
};
#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
#[sats(crate = __lib)]
pub(super) struct AddPlayerArgs {
pub name: String,
}
impl From<AddPlayerArgs> for super::Reducer {
fn from(args: AddPlayerArgs) -> Self {
Self::AddPlayer {
name: args.name,
}
}
}
impl __sdk::InModule for AddPlayerArgs {
type Module = super::RemoteModule;
}
pub struct AddPlayerCallbackId(__sdk::CallbackId);
#[allow(non_camel_case_types)]
/// Extension trait for access to the reducer `add_player`.
///
/// Implemented for [`super::RemoteReducers`].
pub trait add_player {
/// Request that the remote module invoke the reducer `add_player` to run as soon as possible.
///
/// This method returns immediately, and errors only if we are unable to send the request.
/// The reducer will run asynchronously in the future,
/// and its status can be observed by listening for [`Self::on_add_player`] callbacks.
fn add_player(&self, name: String,
) -> __sdk::Result<()>;
/// Register a callback to run whenever we are notified of an invocation of the reducer `add_player`.
///
/// Callbacks should inspect the [`__sdk::ReducerEvent`] contained in the [`super::ReducerEventContext`]
/// to determine the reducer's status.
///
/// The returned [`AddPlayerCallbackId`] can be passed to [`Self::remove_on_add_player`]
/// to cancel the callback.
fn on_add_player(&self, callback: impl FnMut(&super::ReducerEventContext, &String, ) + Send + 'static) -> AddPlayerCallbackId;
/// Cancel a callback previously registered by [`Self::on_add_player`],
/// causing it not to run in the future.
fn remove_on_add_player(&self, callback: AddPlayerCallbackId);
}
impl add_player for super::RemoteReducers {
fn add_player(&self, name: String,
) -> __sdk::Result<()> {
self.imp.call_reducer("add_player", AddPlayerArgs { name, })
}
fn on_add_player(
&self,
mut callback: impl FnMut(&super::ReducerEventContext, &String, ) + Send + 'static,
) -> AddPlayerCallbackId {
AddPlayerCallbackId(self.imp.on_reducer(
"add_player",
Box::new(move |ctx: &super::ReducerEventContext| {
#[allow(irrefutable_let_patterns)]
let super::ReducerEventContext {
event: __sdk::ReducerEvent {
reducer: super::Reducer::AddPlayer {
name,
},
..
},
..
} = ctx else { unreachable!() };
callback(ctx, name, )
}),
))
}
fn remove_on_add_player(&self, callback: AddPlayerCallbackId) {
self.imp.remove_on_reducer("add_player", callback.0)
}
}
#[allow(non_camel_case_types)]
#[doc(hidden)]
/// Extension trait for setting the call-flags for the reducer `add_player`.
///
/// Implemented for [`super::SetReducerFlags`].
///
/// This type is currently unstable and may be removed without a major version bump.
pub trait set_flags_for_add_player {
/// Set the call-reducer flags for the reducer `add_player` to `flags`.
///
/// This type is currently unstable and may be removed without a major version bump.
fn add_player(&self, flags: __ws::CallReducerFlags);
}
impl set_flags_for_add_player for super::SetReducerFlags {
fn add_player(&self, flags: __ws::CallReducerFlags) {
self.imp.set_call_reducer_flags("add_player", flags);
}
}
'''
"add_private_reducer.rs" = '''
// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
#![allow(unused, clippy::all)]
use spacetimedb_sdk::__codegen::{
self as __sdk,
__lib,
__sats,
__ws,
};
#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
#[sats(crate = __lib)]
pub(super) struct AddPrivateArgs {
pub name: String,
}
impl From<AddPrivateArgs> for super::Reducer {
fn from(args: AddPrivateArgs) -> Self {
Self::AddPrivate {
name: args.name,
}
}
}
impl __sdk::InModule for AddPrivateArgs {
type Module = super::RemoteModule;
}
pub struct AddPrivateCallbackId(__sdk::CallbackId);
#[allow(non_camel_case_types)]
/// Extension trait for access to the reducer `add_private`.
///
/// Implemented for [`super::RemoteReducers`].
pub trait add_private {
/// Request that the remote module invoke the reducer `add_private` to run as soon as possible.
///
/// This method returns immediately, and errors only if we are unable to send the request.
/// The reducer will run asynchronously in the future,
/// and its status can be observed by listening for [`Self::on_add_private`] callbacks.
fn add_private(&self, name: String,
) -> __sdk::Result<()>;
/// Register a callback to run whenever we are notified of an invocation of the reducer `add_private`.
///
/// Callbacks should inspect the [`__sdk::ReducerEvent`] contained in the [`super::ReducerEventContext`]
/// to determine the reducer's status.
///
/// The returned [`AddPrivateCallbackId`] can be passed to [`Self::remove_on_add_private`]
/// to cancel the callback.
fn on_add_private(&self, callback: impl FnMut(&super::ReducerEventContext, &String, ) + Send + 'static) -> AddPrivateCallbackId;
/// Cancel a callback previously registered by [`Self::on_add_private`],
/// causing it not to run in the future.
fn remove_on_add_private(&self, callback: AddPrivateCallbackId);
}
impl add_private for super::RemoteReducers {
fn add_private(&self, name: String,
) -> __sdk::Result<()> {
self.imp.call_reducer("add_private", AddPrivateArgs { name, })
}
fn on_add_private(
&self,
mut callback: impl FnMut(&super::ReducerEventContext, &String, ) + Send + 'static,
) -> AddPrivateCallbackId {
AddPrivateCallbackId(self.imp.on_reducer(
"add_private",
Box::new(move |ctx: &super::ReducerEventContext| {
#[allow(irrefutable_let_patterns)]
let super::ReducerEventContext {
event: __sdk::ReducerEvent {
reducer: super::Reducer::AddPrivate {
name,
},
..
},
..
} = ctx else { unreachable!() };
callback(ctx, name, )
}),
))
}
fn remove_on_add_private(&self, callback: AddPrivateCallbackId) {
self.imp.remove_on_reducer("add_private", callback.0)
}
}
#[allow(non_camel_case_types)]
#[doc(hidden)]
/// Extension trait for setting the call-flags for the reducer `add_private`.
///
/// Implemented for [`super::SetReducerFlags`].
///
/// This type is currently unstable and may be removed without a major version bump.
pub trait set_flags_for_add_private {
/// Set the call-reducer flags for the reducer `add_private` to `flags`.
///
/// This type is currently unstable and may be removed without a major version bump.
fn add_private(&self, flags: __ws::CallReducerFlags);
}
impl set_flags_for_add_private for super::SetReducerFlags {
fn add_private(&self, flags: __ws::CallReducerFlags) {
self.imp.set_call_reducer_flags("add_private", flags);
}
}
'''
"add_reducer.rs" = '''
// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
#![allow(unused, clippy::all)]
use spacetimedb_sdk::__codegen::{
self as __sdk,
__lib,
__sats,
__ws,
};
#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
#[sats(crate = __lib)]
pub(super) struct AddArgs {
pub name: String,
pub age: u8,
}
impl From<AddArgs> for super::Reducer {
fn from(args: AddArgs) -> Self {
Self::Add {
name: args.name,
age: args.age,
}
}
}
impl __sdk::InModule for AddArgs {
type Module = super::RemoteModule;
}
pub struct AddCallbackId(__sdk::CallbackId);
#[allow(non_camel_case_types)]
/// Extension trait for access to the reducer `add`.
///
/// Implemented for [`super::RemoteReducers`].
pub trait add {
/// Request that the remote module invoke the reducer `add` to run as soon as possible.
///
/// This method returns immediately, and errors only if we are unable to send the request.
/// The reducer will run asynchronously in the future,
/// and its status can be observed by listening for [`Self::on_add`] callbacks.
fn add(&self, name: String,
age: u8,
) -> __sdk::Result<()>;
/// Register a callback to run whenever we are notified of an invocation of the reducer `add`.
///
/// Callbacks should inspect the [`__sdk::ReducerEvent`] contained in the [`super::ReducerEventContext`]
/// to determine the reducer's status.
///
/// The returned [`AddCallbackId`] can be passed to [`Self::remove_on_add`]
/// to cancel the callback.
fn on_add(&self, callback: impl FnMut(&super::ReducerEventContext, &String, &u8, ) + Send + 'static) -> AddCallbackId;
/// Cancel a callback previously registered by [`Self::on_add`],
/// causing it not to run in the future.
fn remove_on_add(&self, callback: AddCallbackId);
}
impl add for super::RemoteReducers {
fn add(&self, name: String,
age: u8,
) -> __sdk::Result<()> {
self.imp.call_reducer("add", AddArgs { name, age, })
}
fn on_add(
&self,
mut callback: impl FnMut(&super::ReducerEventContext, &String, &u8, ) + Send + 'static,
) -> AddCallbackId {
AddCallbackId(self.imp.on_reducer(
"add",
Box::new(move |ctx: &super::ReducerEventContext| {
#[allow(irrefutable_let_patterns)]
let super::ReducerEventContext {
event: __sdk::ReducerEvent {
reducer: super::Reducer::Add {
name, age,
},
..
},
..
} = ctx else { unreachable!() };
callback(ctx, name, age, )
}),
))
}
fn remove_on_add(&self, callback: AddCallbackId) {
self.imp.remove_on_reducer("add", callback.0)
}
}
#[allow(non_camel_case_types)]
#[doc(hidden)]
/// Extension trait for setting the call-flags for the reducer `add`.
///
/// Implemented for [`super::SetReducerFlags`].
///
/// This type is currently unstable and may be removed without a major version bump.
pub trait set_flags_for_add {
/// Set the call-reducer flags for the reducer `add` to `flags`.
///
/// This type is currently unstable and may be removed without a major version bump.
fn add(&self, flags: __ws::CallReducerFlags);
}
impl set_flags_for_add for super::SetReducerFlags {
fn add(&self, flags: __ws::CallReducerFlags) {
self.imp.set_call_reducer_flags("add", flags);
}
}
'''
"assert_caller_identity_is_module_identity_reducer.rs" = '''
// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
#![allow(unused, clippy::all)]
use spacetimedb_sdk::__codegen::{
self as __sdk,
__lib,
__sats,
__ws,
};
#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
#[sats(crate = __lib)]
pub(super) struct AssertCallerIdentityIsModuleIdentityArgs {
}
impl From<AssertCallerIdentityIsModuleIdentityArgs> for super::Reducer {
fn from(args: AssertCallerIdentityIsModuleIdentityArgs) -> Self {
Self::AssertCallerIdentityIsModuleIdentity
}
}
impl __sdk::InModule for AssertCallerIdentityIsModuleIdentityArgs {
type Module = super::RemoteModule;
}
pub struct AssertCallerIdentityIsModuleIdentityCallbackId(__sdk::CallbackId);
#[allow(non_camel_case_types)]
/// Extension trait for access to the reducer `assert_caller_identity_is_module_identity`.
///
/// Implemented for [`super::RemoteReducers`].
pub trait assert_caller_identity_is_module_identity {
/// Request that the remote module invoke the reducer `assert_caller_identity_is_module_identity` to run as soon as possible.
///
/// This method returns immediately, and errors only if we are unable to send the request.
/// The reducer will run asynchronously in the future,
/// and its status can be observed by listening for [`Self::on_assert_caller_identity_is_module_identity`] callbacks.
fn assert_caller_identity_is_module_identity(&self, ) -> __sdk::Result<()>;
/// Register a callback to run whenever we are notified of an invocation of the reducer `assert_caller_identity_is_module_identity`.
///
/// Callbacks should inspect the [`__sdk::ReducerEvent`] contained in the [`super::ReducerEventContext`]
/// to determine the reducer's status.
///
/// The returned [`AssertCallerIdentityIsModuleIdentityCallbackId`] can be passed to [`Self::remove_on_assert_caller_identity_is_module_identity`]
/// to cancel the callback.
fn on_assert_caller_identity_is_module_identity(&self, callback: impl FnMut(&super::ReducerEventContext, ) + Send + 'static) -> AssertCallerIdentityIsModuleIdentityCallbackId;
/// Cancel a callback previously registered by [`Self::on_assert_caller_identity_is_module_identity`],
/// causing it not to run in the future.
fn remove_on_assert_caller_identity_is_module_identity(&self, callback: AssertCallerIdentityIsModuleIdentityCallbackId);
}
impl assert_caller_identity_is_module_identity for super::RemoteReducers {
fn assert_caller_identity_is_module_identity(&self, ) -> __sdk::Result<()> {
self.imp.call_reducer("assert_caller_identity_is_module_identity", AssertCallerIdentityIsModuleIdentityArgs { })
}
fn on_assert_caller_identity_is_module_identity(
&self,
mut callback: impl FnMut(&super::ReducerEventContext, ) + Send + 'static,
) -> AssertCallerIdentityIsModuleIdentityCallbackId {
AssertCallerIdentityIsModuleIdentityCallbackId(self.imp.on_reducer(
"assert_caller_identity_is_module_identity",
Box::new(move |ctx: &super::ReducerEventContext| {
#[allow(irrefutable_let_patterns)]
let super::ReducerEventContext {
event: __sdk::ReducerEvent {
reducer: super::Reducer::AssertCallerIdentityIsModuleIdentity {
},
..
},
..
} = ctx else { unreachable!() };
callback(ctx, )
}),
))
}
fn remove_on_assert_caller_identity_is_module_identity(&self, callback: AssertCallerIdentityIsModuleIdentityCallbackId) {
self.imp.remove_on_reducer("assert_caller_identity_is_module_identity", callback.0)
}
}
#[allow(non_camel_case_types)]
#[doc(hidden)]
/// Extension trait for setting the call-flags for the reducer `assert_caller_identity_is_module_identity`.
///
/// Implemented for [`super::SetReducerFlags`].
///
/// This type is currently unstable and may be removed without a major version bump.
pub trait set_flags_for_assert_caller_identity_is_module_identity {
/// Set the call-reducer flags for the reducer `assert_caller_identity_is_module_identity` to `flags`.
///
/// This type is currently unstable and may be removed without a major version bump.
fn assert_caller_identity_is_module_identity(&self, flags: __ws::CallReducerFlags);
}
impl set_flags_for_assert_caller_identity_is_module_identity for super::SetReducerFlags {
fn assert_caller_identity_is_module_identity(&self, flags: __ws::CallReducerFlags) {
self.imp.set_call_reducer_flags("assert_caller_identity_is_module_identity", flags);
}
}
'''
"baz_type.rs" = '''
// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
#![allow(unused, clippy::all)]
use spacetimedb_sdk::__codegen::{
self as __sdk,
__lib,
__sats,
__ws,
};
#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
#[sats(crate = __lib)]
pub struct Baz {
pub field: String,
}
impl __sdk::InModule for Baz {
type Module = super::RemoteModule;
}
'''
"client_connected_reducer.rs" = '''
// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
#![allow(unused, clippy::all)]
use spacetimedb_sdk::__codegen::{
self as __sdk,
__lib,
__sats,
__ws,
};
#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
#[sats(crate = __lib)]
pub(super) struct ClientConnectedArgs {
}
impl From<ClientConnectedArgs> for super::Reducer {
fn from(args: ClientConnectedArgs) -> Self {
Self::ClientConnected
}
}
impl __sdk::InModule for ClientConnectedArgs {
type Module = super::RemoteModule;
}
pub struct ClientConnectedCallbackId(__sdk::CallbackId);
#[allow(non_camel_case_types)]
/// Extension trait for access to the reducer `client_connected`.
///
/// Implemented for [`super::RemoteReducers`].
pub trait client_connected {
/// Request that the remote module invoke the reducer `client_connected` to run as soon as possible.
///
/// This method returns immediately, and errors only if we are unable to send the request.
/// The reducer will run asynchronously in the future,
/// and its status can be observed by listening for [`Self::on_client_connected`] callbacks.
fn client_connected(&self, ) -> __sdk::Result<()>;
/// Register a callback to run whenever we are notified of an invocation of the reducer `client_connected`.
///
/// Callbacks should inspect the [`__sdk::ReducerEvent`] contained in the [`super::ReducerEventContext`]
/// to determine the reducer's status.
///
/// The returned [`ClientConnectedCallbackId`] can be passed to [`Self::remove_on_client_connected`]
/// to cancel the callback.
fn on_client_connected(&self, callback: impl FnMut(&super::ReducerEventContext, ) + Send + 'static) -> ClientConnectedCallbackId;
/// Cancel a callback previously registered by [`Self::on_client_connected`],
/// causing it not to run in the future.
fn remove_on_client_connected(&self, callback: ClientConnectedCallbackId);
}
impl client_connected for super::RemoteReducers {
fn client_connected(&self, ) -> __sdk::Result<()> {
self.imp.call_reducer("client_connected", ClientConnectedArgs { })
}
fn on_client_connected(
&self,
mut callback: impl FnMut(&super::ReducerEventContext, ) + Send + 'static,
) -> ClientConnectedCallbackId {
ClientConnectedCallbackId(self.imp.on_reducer(
"client_connected",
Box::new(move |ctx: &super::ReducerEventContext| {
#[allow(irrefutable_let_patterns)]
let super::ReducerEventContext {
event: __sdk::ReducerEvent {
reducer: super::Reducer::ClientConnected {
},
..
},
..
} = ctx else { unreachable!() };
callback(ctx, )
}),
))
}
fn remove_on_client_connected(&self, callback: ClientConnectedCallbackId) {
self.imp.remove_on_reducer("client_connected", callback.0)
}
}
#[allow(non_camel_case_types)]
#[doc(hidden)]
/// Extension trait for setting the call-flags for the reducer `client_connected`.
///
/// Implemented for [`super::SetReducerFlags`].
///
/// This type is currently unstable and may be removed without a major version bump.
pub trait set_flags_for_client_connected {
/// Set the call-reducer flags for the reducer `client_connected` to `flags`.
///
/// This type is currently unstable and may be removed without a major version bump.
fn client_connected(&self, flags: __ws::CallReducerFlags);
}
impl set_flags_for_client_connected for super::SetReducerFlags {
fn client_connected(&self, flags: __ws::CallReducerFlags) {
self.imp.set_call_reducer_flags("client_connected", flags);
}
}
'''
"delete_player_reducer.rs" = '''
// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
#![allow(unused, clippy::all)]
use spacetimedb_sdk::__codegen::{
self as __sdk,
__lib,
__sats,
__ws,
};
#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
#[sats(crate = __lib)]
pub(super) struct DeletePlayerArgs {
pub id: u64,
}
impl From<DeletePlayerArgs> for super::Reducer {
fn from(args: DeletePlayerArgs) -> Self {
Self::DeletePlayer {
id: args.id,
}
}
}
impl __sdk::InModule for DeletePlayerArgs {
type Module = super::RemoteModule;
}
pub struct DeletePlayerCallbackId(__sdk::CallbackId);
#[allow(non_camel_case_types)]
/// Extension trait for access to the reducer `delete_player`.
///
/// Implemented for [`super::RemoteReducers`].
pub trait delete_player {
/// Request that the remote module invoke the reducer `delete_player` to run as soon as possible.
///
/// This method returns immediately, and errors only if we are unable to send the request.
/// The reducer will run asynchronously in the future,
/// and its status can be observed by listening for [`Self::on_delete_player`] callbacks.
fn delete_player(&self, id: u64,
) -> __sdk::Result<()>;
/// Register a callback to run whenever we are notified of an invocation of the reducer `delete_player`.
///
/// Callbacks should inspect the [`__sdk::ReducerEvent`] contained in the [`super::ReducerEventContext`]
/// to determine the reducer's status.
///
/// The returned [`DeletePlayerCallbackId`] can be passed to [`Self::remove_on_delete_player`]
/// to cancel the callback.
fn on_delete_player(&self, callback: impl FnMut(&super::ReducerEventContext, &u64, ) + Send + 'static) -> DeletePlayerCallbackId;
/// Cancel a callback previously registered by [`Self::on_delete_player`],
/// causing it not to run in the future.
fn remove_on_delete_player(&self, callback: DeletePlayerCallbackId);
}
impl delete_player for super::RemoteReducers {
fn delete_player(&self, id: u64,
) -> __sdk::Result<()> {
self.imp.call_reducer("delete_player", DeletePlayerArgs { id, })
}
fn on_delete_player(
&self,
mut callback: impl FnMut(&super::ReducerEventContext, &u64, ) + Send + 'static,
) -> DeletePlayerCallbackId {
DeletePlayerCallbackId(self.imp.on_reducer(
"delete_player",
Box::new(move |ctx: &super::ReducerEventContext| {
#[allow(irrefutable_let_patterns)]
let super::ReducerEventContext {
event: __sdk::ReducerEvent {
reducer: super::Reducer::DeletePlayer {
id,
},
..
},
..
} = ctx else { unreachable!() };
callback(ctx, id, )
}),
))
}
fn remove_on_delete_player(&self, callback: DeletePlayerCallbackId) {
self.imp.remove_on_reducer("delete_player", callback.0)
}
}
#[allow(non_camel_case_types)]
#[doc(hidden)]
/// Extension trait for setting the call-flags for the reducer `delete_player`.
///
/// Implemented for [`super::SetReducerFlags`].
///
/// This type is currently unstable and may be removed without a major version bump.
pub trait set_flags_for_delete_player {
/// Set the call-reducer flags for the reducer `delete_player` to `flags`.
///
/// This type is currently unstable and may be removed without a major version bump.
fn delete_player(&self, flags: __ws::CallReducerFlags);
}
impl set_flags_for_delete_player for super::SetReducerFlags {
fn delete_player(&self, flags: __ws::CallReducerFlags) {
self.imp.set_call_reducer_flags("delete_player", flags);
}
}
'''
"delete_players_by_name_reducer.rs" = '''
// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
#![allow(unused, clippy::all)]
use spacetimedb_sdk::__codegen::{
self as __sdk,
__lib,
__sats,
__ws,
};
#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
#[sats(crate = __lib)]
pub(super) struct DeletePlayersByNameArgs {
pub name: String,
}
impl From<DeletePlayersByNameArgs> for super::Reducer {
fn from(args: DeletePlayersByNameArgs) -> Self {
Self::DeletePlayersByName {
name: args.name,
}
}
}
impl __sdk::InModule for DeletePlayersByNameArgs {
type Module = super::RemoteModule;
}
pub struct DeletePlayersByNameCallbackId(__sdk::CallbackId);
#[allow(non_camel_case_types)]
/// Extension trait for access to the reducer `delete_players_by_name`.
///
/// Implemented for [`super::RemoteReducers`].
pub trait delete_players_by_name {
/// Request that the remote module invoke the reducer `delete_players_by_name` to run as soon as possible.
///
/// This method returns immediately, and errors only if we are unable to send the request.
/// The reducer will run asynchronously in the future,
/// and its status can be observed by listening for [`Self::on_delete_players_by_name`] callbacks.
fn delete_players_by_name(&self, name: String,
) -> __sdk::Result<()>;
/// Register a callback to run whenever we are notified of an invocation of the reducer `delete_players_by_name`.
///
/// Callbacks should inspect the [`__sdk::ReducerEvent`] contained in the [`super::ReducerEventContext`]
/// to determine the reducer's status.
///
/// The returned [`DeletePlayersByNameCallbackId`] can be passed to [`Self::remove_on_delete_players_by_name`]
/// to cancel the callback.
fn on_delete_players_by_name(&self, callback: impl FnMut(&super::ReducerEventContext, &String, ) + Send + 'static) -> DeletePlayersByNameCallbackId;
/// Cancel a callback previously registered by [`Self::on_delete_players_by_name`],
/// causing it not to run in the future.
fn remove_on_delete_players_by_name(&self, callback: DeletePlayersByNameCallbackId);
}
impl delete_players_by_name for super::RemoteReducers {
fn delete_players_by_name(&self, name: String,
) -> __sdk::Result<()> {
self.imp.call_reducer("delete_players_by_name", DeletePlayersByNameArgs { name, })
}
fn on_delete_players_by_name(
&self,
mut callback: impl FnMut(&super::ReducerEventContext, &String, ) + Send + 'static,
) -> DeletePlayersByNameCallbackId {
DeletePlayersByNameCallbackId(self.imp.on_reducer(
"delete_players_by_name",
Box::new(move |ctx: &super::ReducerEventContext| {
#[allow(irrefutable_let_patterns)]
let super::ReducerEventContext {
event: __sdk::ReducerEvent {
reducer: super::Reducer::DeletePlayersByName {
name,
},
..
},
..
} = ctx else { unreachable!() };
callback(ctx, name, )
}),
))
}
fn remove_on_delete_players_by_name(&self, callback: DeletePlayersByNameCallbackId) {
self.imp.remove_on_reducer("delete_players_by_name", callback.0)
}
}
#[allow(non_camel_case_types)]
#[doc(hidden)]
/// Extension trait for setting the call-flags for the reducer `delete_players_by_name`.
///
/// Implemented for [`super::SetReducerFlags`].
///
/// This type is currently unstable and may be removed without a major version bump.
pub trait set_flags_for_delete_players_by_name {
/// Set the call-reducer flags for the reducer `delete_players_by_name` to `flags`.
///
/// This type is currently unstable and may be removed without a major version bump.
fn delete_players_by_name(&self, flags: __ws::CallReducerFlags);
}
impl set_flags_for_delete_players_by_name for super::SetReducerFlags {
fn delete_players_by_name(&self, flags: __ws::CallReducerFlags) {
self.imp.set_call_reducer_flags("delete_players_by_name", flags);
}
}
'''
"foobar_type.rs" = '''
// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
#![allow(unused, clippy::all)]
use spacetimedb_sdk::__codegen::{
self as __sdk,
__lib,
__sats,
__ws,
};
use super::baz_type::Baz;
#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
#[sats(crate = __lib)]
pub enum Foobar {
Baz(Baz),
Bar,
Har(u32),
}
impl __sdk::InModule for Foobar {
type Module = super::RemoteModule;
}
'''
"get_my_schema_via_http_procedure.rs" = '''
// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
#![allow(unused, clippy::all)]
use spacetimedb_sdk::__codegen::{
self as __sdk,
__lib,
__sats,
__ws,
};
#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
#[sats(crate = __lib)]
struct GetMySchemaViaHttpArgs {
}
impl __sdk::InModule for GetMySchemaViaHttpArgs {
type Module = super::RemoteModule;
}
#[allow(non_camel_case_types)]
/// Extension trait for access to the procedure `get_my_schema_via_http`.
///
/// Implemented for [`super::RemoteProcedures`].
pub trait get_my_schema_via_http {
fn get_my_schema_via_http(&self, ) {
self.get_my_schema_via_http_then( |_, _| {});
}
fn get_my_schema_via_http_then(
&self,
__callback: impl FnOnce(&super::ProcedureEventContext, Result<String, __sdk::InternalError>) + Send + 'static,
);
}
impl get_my_schema_via_http for super::RemoteProcedures {
fn get_my_schema_via_http_then(
&self,
__callback: impl FnOnce(&super::ProcedureEventContext, Result<String, __sdk::InternalError>) + Send + 'static,
) {
self.imp.invoke_procedure_with_callback::<_, String>(
"get_my_schema_via_http",
GetMySchemaViaHttpArgs { },
__callback,
);
}
}
'''
"has_special_stuff_table.rs" = '''
// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
#![allow(unused, clippy::all)]
use spacetimedb_sdk::__codegen::{
self as __sdk,
__lib,
__sats,
__ws,
};
use super::has_special_stuff_type::HasSpecialStuff;
/// Table handle for the table `has_special_stuff`.
///
/// Obtain a handle from the [`HasSpecialStuffTableAccess::has_special_stuff`] method on [`super::RemoteTables`],
/// like `ctx.db.has_special_stuff()`.
///
/// Users are encouraged not to explicitly reference this type,
/// but to directly chain method calls,
/// like `ctx.db.has_special_stuff().on_insert(...)`.
pub struct HasSpecialStuffTableHandle<'ctx> {
imp: __sdk::TableHandle<HasSpecialStuff>,
ctx: std::marker::PhantomData<&'ctx super::RemoteTables>,
}
#[allow(non_camel_case_types)]
/// Extension trait for access to the table `has_special_stuff`.
///
/// Implemented for [`super::RemoteTables`].
pub trait HasSpecialStuffTableAccess {
#[allow(non_snake_case)]
/// Obtain a [`HasSpecialStuffTableHandle`], which mediates access to the table `has_special_stuff`.
fn has_special_stuff(&self) -> HasSpecialStuffTableHandle<'_>;
}
impl HasSpecialStuffTableAccess for super::RemoteTables {
fn has_special_stuff(&self) -> HasSpecialStuffTableHandle<'_> {
HasSpecialStuffTableHandle {
imp: self.imp.get_table::<HasSpecialStuff>("has_special_stuff"),
ctx: std::marker::PhantomData,
}
}
}
pub struct HasSpecialStuffInsertCallbackId(__sdk::CallbackId);
pub struct HasSpecialStuffDeleteCallbackId(__sdk::CallbackId);
impl<'ctx> __sdk::Table for HasSpecialStuffTableHandle<'ctx> {
type Row = HasSpecialStuff;
type EventContext = super::EventContext;
fn count(&self) -> u64 { self.imp.count() }
fn iter(&self) -> impl Iterator<Item = HasSpecialStuff> + '_ { self.imp.iter() }
type InsertCallbackId = HasSpecialStuffInsertCallbackId;
fn on_insert(
&self,
callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
) -> HasSpecialStuffInsertCallbackId {
HasSpecialStuffInsertCallbackId(self.imp.on_insert(Box::new(callback)))
}
fn remove_on_insert(&self, callback: HasSpecialStuffInsertCallbackId) {
self.imp.remove_on_insert(callback.0)
}
type DeleteCallbackId = HasSpecialStuffDeleteCallbackId;
fn on_delete(
&self,
callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
) -> HasSpecialStuffDeleteCallbackId {
HasSpecialStuffDeleteCallbackId(self.imp.on_delete(Box::new(callback)))
}
fn remove_on_delete(&self, callback: HasSpecialStuffDeleteCallbackId) {
self.imp.remove_on_delete(callback.0)
}
}
#[doc(hidden)]
pub(super) fn register_table(client_cache: &mut __sdk::ClientCache<super::RemoteModule>) {
let _table = client_cache.get_or_make_table::<HasSpecialStuff>("has_special_stuff");
}
#[doc(hidden)]
pub(super) fn parse_table_update(
raw_updates: __ws::TableUpdate<__ws::BsatnFormat>,
) -> __sdk::Result<__sdk::TableUpdate<HasSpecialStuff>> {
__sdk::TableUpdate::parse_table_update(raw_updates).map_err(|e| {
__sdk::InternalError::failed_parse(
"TableUpdate<HasSpecialStuff>",
"TableUpdate",
).with_cause(e).into()
})
}
#[allow(non_camel_case_types)]
/// Extension trait for query builder access to the table `HasSpecialStuff`.
///
/// Implemented for [`__sdk::QueryTableAccessor`].
pub trait has_special_stuffQueryTableAccess {
#[allow(non_snake_case)]
/// Get a query builder for the table `HasSpecialStuff`.
fn has_special_stuff(&self) -> __sdk::__query_builder::Table<HasSpecialStuff>;
}
impl has_special_stuffQueryTableAccess for __sdk::QueryTableAccessor {
fn has_special_stuff(&self) -> __sdk::__query_builder::Table<HasSpecialStuff> {
__sdk::__query_builder::Table::new("has_special_stuff")
}
}
'''
"has_special_stuff_type.rs" = '''
// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
#![allow(unused, clippy::all)]
use spacetimedb_sdk::__codegen::{
self as __sdk,
__lib,
__sats,
__ws,
};
#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
#[sats(crate = __lib)]
pub struct HasSpecialStuff {
pub identity: __sdk::Identity,
pub connection_id: __sdk::ConnectionId,
}
impl __sdk::InModule for HasSpecialStuff {
type Module = super::RemoteModule;
}
/// Column accessor struct for the table `HasSpecialStuff`.
///
/// Provides typed access to columns for query building.
pub struct HasSpecialStuffCols {
pub identity: __sdk::__query_builder::Col<HasSpecialStuff, __sdk::Identity>,
pub connection_id: __sdk::__query_builder::Col<HasSpecialStuff, __sdk::ConnectionId>,
}
impl __sdk::__query_builder::HasCols for HasSpecialStuff {
type Cols = HasSpecialStuffCols;
fn cols(table_name: &'static str) -> Self::Cols {
HasSpecialStuffCols {
identity: __sdk::__query_builder::Col::new(table_name, "identity"),
connection_id: __sdk::__query_builder::Col::new(table_name, "connection_id"),
}
}
}
/// Indexed column accessor struct for the table `HasSpecialStuff`.
///
/// Provides typed access to indexed columns for query building.
pub struct HasSpecialStuffIxCols {
}
impl __sdk::__query_builder::HasIxCols for HasSpecialStuff {
type IxCols = HasSpecialStuffIxCols;
fn ix_cols(table_name: &'static str) -> Self::IxCols {
HasSpecialStuffIxCols {
}
}
}
'''
"list_over_age_reducer.rs" = '''
// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
#![allow(unused, clippy::all)]
use spacetimedb_sdk::__codegen::{
self as __sdk,
__lib,
__sats,
__ws,
};
#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
#[sats(crate = __lib)]
pub(super) struct ListOverAgeArgs {
pub age: u8,
}
impl From<ListOverAgeArgs> for super::Reducer {
fn from(args: ListOverAgeArgs) -> Self {
Self::ListOverAge {
age: args.age,
}
}
}
impl __sdk::InModule for ListOverAgeArgs {
type Module = super::RemoteModule;
}
pub struct ListOverAgeCallbackId(__sdk::CallbackId);
#[allow(non_camel_case_types)]
/// Extension trait for access to the reducer `list_over_age`.
///
/// Implemented for [`super::RemoteReducers`].
pub trait list_over_age {
/// Request that the remote module invoke the reducer `list_over_age` to run as soon as possible.
///
/// This method returns immediately, and errors only if we are unable to send the request.
/// The reducer will run asynchronously in the future,
/// and its status can be observed by listening for [`Self::on_list_over_age`] callbacks.
fn list_over_age(&self, age: u8,
) -> __sdk::Result<()>;
/// Register a callback to run whenever we are notified of an invocation of the reducer `list_over_age`.
///
/// Callbacks should inspect the [`__sdk::ReducerEvent`] contained in the [`super::ReducerEventContext`]
/// to determine the reducer's status.
///
/// The returned [`ListOverAgeCallbackId`] can be passed to [`Self::remove_on_list_over_age`]
/// to cancel the callback.
fn on_list_over_age(&self, callback: impl FnMut(&super::ReducerEventContext, &u8, ) + Send + 'static) -> ListOverAgeCallbackId;
/// Cancel a callback previously registered by [`Self::on_list_over_age`],
/// causing it not to run in the future.
fn remove_on_list_over_age(&self, callback: ListOverAgeCallbackId);
}
impl list_over_age for super::RemoteReducers {
fn list_over_age(&self, age: u8,
) -> __sdk::Result<()> {
self.imp.call_reducer("list_over_age", ListOverAgeArgs { age, })
}
fn on_list_over_age(
&self,
mut callback: impl FnMut(&super::ReducerEventContext, &u8, ) + Send + 'static,
) -> ListOverAgeCallbackId {
ListOverAgeCallbackId(self.imp.on_reducer(
"list_over_age",
Box::new(move |ctx: &super::ReducerEventContext| {
#[allow(irrefutable_let_patterns)]
let super::ReducerEventContext {
event: __sdk::ReducerEvent {
reducer: super::Reducer::ListOverAge {
age,
},
..
},
..
} = ctx else { unreachable!() };
callback(ctx, age, )
}),
))
}
fn remove_on_list_over_age(&self, callback: ListOverAgeCallbackId) {
self.imp.remove_on_reducer("list_over_age", callback.0)
}
}
#[allow(non_camel_case_types)]
#[doc(hidden)]
/// Extension trait for setting the call-flags for the reducer `list_over_age`.
///
/// Implemented for [`super::SetReducerFlags`].
///
/// This type is currently unstable and may be removed without a major version bump.
pub trait set_flags_for_list_over_age {
/// Set the call-reducer flags for the reducer `list_over_age` to `flags`.
///
/// This type is currently unstable and may be removed without a major version bump.
fn list_over_age(&self, flags: __ws::CallReducerFlags);
}
impl set_flags_for_list_over_age for super::SetReducerFlags {
fn list_over_age(&self, flags: __ws::CallReducerFlags) {
self.imp.set_call_reducer_flags("list_over_age", flags);
}
}
'''
"log_module_identity_reducer.rs" = '''
// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
#![allow(unused, clippy::all)]
use spacetimedb_sdk::__codegen::{
self as __sdk,
__lib,
__sats,
__ws,
};
#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
#[sats(crate = __lib)]
pub(super) struct LogModuleIdentityArgs {
}
impl From<LogModuleIdentityArgs> for super::Reducer {
fn from(args: LogModuleIdentityArgs) -> Self {
Self::LogModuleIdentity
}
}
impl __sdk::InModule for LogModuleIdentityArgs {
type Module = super::RemoteModule;
}
pub struct LogModuleIdentityCallbackId(__sdk::CallbackId);
#[allow(non_camel_case_types)]
/// Extension trait for access to the reducer `log_module_identity`.
///
/// Implemented for [`super::RemoteReducers`].
pub trait log_module_identity {
/// Request that the remote module invoke the reducer `log_module_identity` to run as soon as possible.
///
/// This method returns immediately, and errors only if we are unable to send the request.
/// The reducer will run asynchronously in the future,
/// and its status can be observed by listening for [`Self::on_log_module_identity`] callbacks.
fn log_module_identity(&self, ) -> __sdk::Result<()>;
/// Register a callback to run whenever we are notified of an invocation of the reducer `log_module_identity`.
///
/// Callbacks should inspect the [`__sdk::ReducerEvent`] contained in the [`super::ReducerEventContext`]
/// to determine the reducer's status.
///
/// The returned [`LogModuleIdentityCallbackId`] can be passed to [`Self::remove_on_log_module_identity`]
/// to cancel the callback.
fn on_log_module_identity(&self, callback: impl FnMut(&super::ReducerEventContext, ) + Send + 'static) -> LogModuleIdentityCallbackId;
/// Cancel a callback previously registered by [`Self::on_log_module_identity`],
/// causing it not to run in the future.
fn remove_on_log_module_identity(&self, callback: LogModuleIdentityCallbackId);
}
impl log_module_identity for super::RemoteReducers {
fn log_module_identity(&self, ) -> __sdk::Result<()> {
self.imp.call_reducer("log_module_identity", LogModuleIdentityArgs { })
}
fn on_log_module_identity(
&self,
mut callback: impl FnMut(&super::ReducerEventContext, ) + Send + 'static,
) -> LogModuleIdentityCallbackId {
LogModuleIdentityCallbackId(self.imp.on_reducer(
"log_module_identity",
Box::new(move |ctx: &super::ReducerEventContext| {
#[allow(irrefutable_let_patterns)]
let super::ReducerEventContext {
event: __sdk::ReducerEvent {
reducer: super::Reducer::LogModuleIdentity {
},
..
},
..
} = ctx else { unreachable!() };
callback(ctx, )
}),
))
}
fn remove_on_log_module_identity(&self, callback: LogModuleIdentityCallbackId) {
self.imp.remove_on_reducer("log_module_identity", callback.0)
}
}
#[allow(non_camel_case_types)]
#[doc(hidden)]
/// Extension trait for setting the call-flags for the reducer `log_module_identity`.
///
/// Implemented for [`super::SetReducerFlags`].
///
/// This type is currently unstable and may be removed without a major version bump.
pub trait set_flags_for_log_module_identity {
/// Set the call-reducer flags for the reducer `log_module_identity` to `flags`.
///
/// This type is currently unstable and may be removed without a major version bump.
fn log_module_identity(&self, flags: __ws::CallReducerFlags);
}
impl set_flags_for_log_module_identity for super::SetReducerFlags {
fn log_module_identity(&self, flags: __ws::CallReducerFlags) {
self.imp.set_call_reducer_flags("log_module_identity", flags);
}
}
'''
"logged_out_player_table.rs" = '''
// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
#![allow(unused, clippy::all)]
use spacetimedb_sdk::__codegen::{
self as __sdk,
__lib,
__sats,
__ws,
};
use super::player_type::Player;
/// Table handle for the table `logged_out_player`.
///
/// Obtain a handle from the [`LoggedOutPlayerTableAccess::logged_out_player`] method on [`super::RemoteTables`],
/// like `ctx.db.logged_out_player()`.
///
/// Users are encouraged not to explicitly reference this type,
/// but to directly chain method calls,
/// like `ctx.db.logged_out_player().on_insert(...)`.
pub struct LoggedOutPlayerTableHandle<'ctx> {
imp: __sdk::TableHandle<Player>,
ctx: std::marker::PhantomData<&'ctx super::RemoteTables>,
}
#[allow(non_camel_case_types)]
/// Extension trait for access to the table `logged_out_player`.
///
/// Implemented for [`super::RemoteTables`].
pub trait LoggedOutPlayerTableAccess {
#[allow(non_snake_case)]
/// Obtain a [`LoggedOutPlayerTableHandle`], which mediates access to the table `logged_out_player`.
fn logged_out_player(&self) -> LoggedOutPlayerTableHandle<'_>;
}
impl LoggedOutPlayerTableAccess for super::RemoteTables {
fn logged_out_player(&self) -> LoggedOutPlayerTableHandle<'_> {
LoggedOutPlayerTableHandle {
imp: self.imp.get_table::<Player>("logged_out_player"),
ctx: std::marker::PhantomData,
}
}
}
pub struct LoggedOutPlayerInsertCallbackId(__sdk::CallbackId);
pub struct LoggedOutPlayerDeleteCallbackId(__sdk::CallbackId);
impl<'ctx> __sdk::Table for LoggedOutPlayerTableHandle<'ctx> {
type Row = Player;
type EventContext = super::EventContext;
fn count(&self) -> u64 { self.imp.count() }
fn iter(&self) -> impl Iterator<Item = Player> + '_ { self.imp.iter() }
type InsertCallbackId = LoggedOutPlayerInsertCallbackId;
fn on_insert(
&self,
callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
) -> LoggedOutPlayerInsertCallbackId {
LoggedOutPlayerInsertCallbackId(self.imp.on_insert(Box::new(callback)))
}
fn remove_on_insert(&self, callback: LoggedOutPlayerInsertCallbackId) {
self.imp.remove_on_insert(callback.0)
}
type DeleteCallbackId = LoggedOutPlayerDeleteCallbackId;
fn on_delete(
&self,
callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
) -> LoggedOutPlayerDeleteCallbackId {
LoggedOutPlayerDeleteCallbackId(self.imp.on_delete(Box::new(callback)))
}
fn remove_on_delete(&self, callback: LoggedOutPlayerDeleteCallbackId) {
self.imp.remove_on_delete(callback.0)
}
}
#[doc(hidden)]
pub(super) fn register_table(client_cache: &mut __sdk::ClientCache<super::RemoteModule>) {
let _table = client_cache.get_or_make_table::<Player>("logged_out_player");
_table.add_unique_constraint::<__sdk::Identity>("identity", |row| &row.identity);
_table.add_unique_constraint::<u64>("player_id", |row| &row.player_id);
_table.add_unique_constraint::<String>("name", |row| &row.name);
}
pub struct LoggedOutPlayerUpdateCallbackId(__sdk::CallbackId);
impl<'ctx> __sdk::TableWithPrimaryKey for LoggedOutPlayerTableHandle<'ctx> {
type UpdateCallbackId = LoggedOutPlayerUpdateCallbackId;
fn on_update(
&self,
callback: impl FnMut(&Self::EventContext, &Self::Row, &Self::Row) + Send + 'static,
) -> LoggedOutPlayerUpdateCallbackId {
LoggedOutPlayerUpdateCallbackId(self.imp.on_update(Box::new(callback)))
}
fn remove_on_update(&self, callback: LoggedOutPlayerUpdateCallbackId) {
self.imp.remove_on_update(callback.0)
}
}
#[doc(hidden)]
pub(super) fn parse_table_update(
raw_updates: __ws::TableUpdate<__ws::BsatnFormat>,
) -> __sdk::Result<__sdk::TableUpdate<Player>> {
__sdk::TableUpdate::parse_table_update(raw_updates).map_err(|e| {
__sdk::InternalError::failed_parse(
"TableUpdate<Player>",
"TableUpdate",
).with_cause(e).into()
})
}
/// Access to the `identity` unique index on the table `logged_out_player`,
/// which allows point queries on the field of the same name
/// via the [`LoggedOutPlayerIdentityUnique::find`] method.
///
/// Users are encouraged not to explicitly reference this type,
/// but to directly chain method calls,
/// like `ctx.db.logged_out_player().identity().find(...)`.
pub struct LoggedOutPlayerIdentityUnique<'ctx> {
imp: __sdk::UniqueConstraintHandle<Player, __sdk::Identity>,
phantom: std::marker::PhantomData<&'ctx super::RemoteTables>,
}
impl<'ctx> LoggedOutPlayerTableHandle<'ctx> {
/// Get a handle on the `identity` unique index on the table `logged_out_player`.
pub fn identity(&self) -> LoggedOutPlayerIdentityUnique<'ctx> {
LoggedOutPlayerIdentityUnique {
imp: self.imp.get_unique_constraint::<__sdk::Identity>("identity"),
phantom: std::marker::PhantomData,
}
}
}
impl<'ctx> LoggedOutPlayerIdentityUnique<'ctx> {
/// Find the subscribed row whose `identity` column value is equal to `col_val`,
/// if such a row is present in the client cache.
pub fn find(&self, col_val: &__sdk::Identity) -> Option<Player> {
self.imp.find(col_val)
}
}
/// Access to the `player_id` unique index on the table `logged_out_player`,
/// which allows point queries on the field of the same name
/// via the [`LoggedOutPlayerPlayerIdUnique::find`] method.
///
/// Users are encouraged not to explicitly reference this type,
/// but to directly chain method calls,
/// like `ctx.db.logged_out_player().player_id().find(...)`.
pub struct LoggedOutPlayerPlayerIdUnique<'ctx> {
imp: __sdk::UniqueConstraintHandle<Player, u64>,
phantom: std::marker::PhantomData<&'ctx super::RemoteTables>,
}
impl<'ctx> LoggedOutPlayerTableHandle<'ctx> {
/// Get a handle on the `player_id` unique index on the table `logged_out_player`.
pub fn player_id(&self) -> LoggedOutPlayerPlayerIdUnique<'ctx> {
LoggedOutPlayerPlayerIdUnique {
imp: self.imp.get_unique_constraint::<u64>("player_id"),
phantom: std::marker::PhantomData,
}
}
}
impl<'ctx> LoggedOutPlayerPlayerIdUnique<'ctx> {
/// Find the subscribed row whose `player_id` column value is equal to `col_val`,
/// if such a row is present in the client cache.
pub fn find(&self, col_val: &u64) -> Option<Player> {
self.imp.find(col_val)
}
}
/// Access to the `name` unique index on the table `logged_out_player`,
/// which allows point queries on the field of the same name
/// via the [`LoggedOutPlayerNameUnique::find`] method.
///
/// Users are encouraged not to explicitly reference this type,
/// but to directly chain method calls,
/// like `ctx.db.logged_out_player().name().find(...)`.
pub struct LoggedOutPlayerNameUnique<'ctx> {
imp: __sdk::UniqueConstraintHandle<Player, String>,
phantom: std::marker::PhantomData<&'ctx super::RemoteTables>,
}
impl<'ctx> LoggedOutPlayerTableHandle<'ctx> {
/// Get a handle on the `name` unique index on the table `logged_out_player`.
pub fn name(&self) -> LoggedOutPlayerNameUnique<'ctx> {
LoggedOutPlayerNameUnique {
imp: self.imp.get_unique_constraint::<String>("name"),
phantom: std::marker::PhantomData,
}
}
}
impl<'ctx> LoggedOutPlayerNameUnique<'ctx> {
/// Find the subscribed row whose `name` column value is equal to `col_val`,
/// if such a row is present in the client cache.
pub fn find(&self, col_val: &String) -> Option<Player> {
self.imp.find(col_val)
}
}
#[allow(non_camel_case_types)]
/// Extension trait for query builder access to the table `Player`.
///
/// Implemented for [`__sdk::QueryTableAccessor`].
pub trait logged_out_playerQueryTableAccess {
#[allow(non_snake_case)]
/// Get a query builder for the table `Player`.
fn logged_out_player(&self) -> __sdk::__query_builder::Table<Player>;
}
impl logged_out_playerQueryTableAccess for __sdk::QueryTableAccessor {
fn logged_out_player(&self) -> __sdk::__query_builder::Table<Player> {
__sdk::__query_builder::Table::new("logged_out_player")
}
}
'''
"mod.rs" = '''
// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
VERSION_COMMENT
#![allow(unused, clippy::all)]
use spacetimedb_sdk::__codegen::{
self as __sdk,
__lib,
__sats,
__ws,
};
pub mod baz_type;
pub mod foobar_type;
pub mod has_special_stuff_type;
pub mod person_type;
pub mod pk_multi_identity_type;
pub mod player_type;
pub mod point_type;
pub mod private_table_type;
pub mod remove_table_type;
pub mod repeating_test_arg_type;
pub mod test_a_type;
pub mod test_b_type;
pub mod test_d_type;
pub mod test_e_type;
pub mod test_foobar_type;
pub mod namespace_test_c_type;
pub mod namespace_test_f_type;
pub mod add_reducer;
pub mod add_player_reducer;
pub mod add_private_reducer;
pub mod assert_caller_identity_is_module_identity_reducer;
pub mod client_connected_reducer;
pub mod delete_player_reducer;
pub mod delete_players_by_name_reducer;
pub mod list_over_age_reducer;
pub mod log_module_identity_reducer;
pub mod query_private_reducer;
pub mod repeating_test_reducer;
pub mod say_hello_reducer;
pub mod test_reducer;
pub mod test_btree_index_args_reducer;
pub mod has_special_stuff_table;
pub mod logged_out_player_table;
pub mod person_table;
pub mod pk_multi_identity_table;
pub mod player_table;
pub mod points_table;
pub mod private_table_table;
pub mod repeating_test_arg_table;
pub mod table_to_remove_table;
pub mod test_a_table;
pub mod test_d_table;
pub mod test_e_table;
pub mod test_f_table;
pub mod my_player_table;
pub mod get_my_schema_via_http_procedure;
pub mod return_value_procedure;
pub mod sleep_one_second_procedure;
pub mod with_tx_procedure;
pub use baz_type::Baz;
pub use foobar_type::Foobar;
pub use has_special_stuff_type::HasSpecialStuff;
pub use person_type::Person;
pub use pk_multi_identity_type::PkMultiIdentity;
pub use player_type::Player;
pub use point_type::Point;
pub use private_table_type::PrivateTable;
pub use remove_table_type::RemoveTable;
pub use repeating_test_arg_type::RepeatingTestArg;
pub use test_a_type::TestA;
pub use test_b_type::TestB;
pub use test_d_type::TestD;
pub use test_e_type::TestE;
pub use test_foobar_type::TestFoobar;
pub use namespace_test_c_type::NamespaceTestC;
pub use namespace_test_f_type::NamespaceTestF;
pub use has_special_stuff_table::*;
pub use logged_out_player_table::*;
pub use my_player_table::*;
pub use person_table::*;
pub use pk_multi_identity_table::*;
pub use player_table::*;
pub use points_table::*;
pub use private_table_table::*;
pub use repeating_test_arg_table::*;
pub use table_to_remove_table::*;
pub use test_a_table::*;
pub use test_d_table::*;
pub use test_e_table::*;
pub use test_f_table::*;
pub use add_reducer::{add, set_flags_for_add, AddCallbackId};
pub use add_player_reducer::{add_player, set_flags_for_add_player, AddPlayerCallbackId};
pub use add_private_reducer::{add_private, set_flags_for_add_private, AddPrivateCallbackId};
pub use assert_caller_identity_is_module_identity_reducer::{assert_caller_identity_is_module_identity, set_flags_for_assert_caller_identity_is_module_identity, AssertCallerIdentityIsModuleIdentityCallbackId};
pub use client_connected_reducer::{client_connected, set_flags_for_client_connected, ClientConnectedCallbackId};
pub use delete_player_reducer::{delete_player, set_flags_for_delete_player, DeletePlayerCallbackId};
pub use delete_players_by_name_reducer::{delete_players_by_name, set_flags_for_delete_players_by_name, DeletePlayersByNameCallbackId};
pub use list_over_age_reducer::{list_over_age, set_flags_for_list_over_age, ListOverAgeCallbackId};
pub use log_module_identity_reducer::{log_module_identity, set_flags_for_log_module_identity, LogModuleIdentityCallbackId};
pub use query_private_reducer::{query_private, set_flags_for_query_private, QueryPrivateCallbackId};
pub use repeating_test_reducer::{repeating_test, set_flags_for_repeating_test, RepeatingTestCallbackId};
pub use say_hello_reducer::{say_hello, set_flags_for_say_hello, SayHelloCallbackId};
pub use test_reducer::{test, set_flags_for_test, TestCallbackId};
pub use test_btree_index_args_reducer::{test_btree_index_args, set_flags_for_test_btree_index_args, TestBtreeIndexArgsCallbackId};
pub use get_my_schema_via_http_procedure::get_my_schema_via_http;
pub use return_value_procedure::return_value;
pub use sleep_one_second_procedure::sleep_one_second;
pub use with_tx_procedure::with_tx;
#[derive(Clone, PartialEq, Debug)]
/// One of the reducers defined by this module.
///
/// Contained within a [`__sdk::ReducerEvent`] in [`EventContext`]s for reducer events
/// to indicate which reducer caused the event.
pub enum Reducer {
Add {
name: String,
age: u8,
} ,
AddPlayer {
name: String,
} ,
AddPrivate {
name: String,
} ,
AssertCallerIdentityIsModuleIdentity ,
ClientConnected ,
DeletePlayer {
id: u64,
} ,
DeletePlayersByName {
name: String,
} ,
ListOverAge {
age: u8,
} ,
LogModuleIdentity ,
QueryPrivate ,
RepeatingTest {
arg: RepeatingTestArg,
} ,
SayHello ,
Test {
arg: TestA,
arg_2: TestB,
arg_3: NamespaceTestC,
arg_4: NamespaceTestF,
} ,
TestBtreeIndexArgs ,
}
impl __sdk::InModule for Reducer {
type Module = RemoteModule;
}
impl __sdk::Reducer for Reducer {
fn reducer_name(&self) -> &'static str {
match self {
Reducer::Add { .. } => "add",
Reducer::AddPlayer { .. } => "add_player",
Reducer::AddPrivate { .. } => "add_private",
Reducer::AssertCallerIdentityIsModuleIdentity => "assert_caller_identity_is_module_identity",
Reducer::ClientConnected => "client_connected",
Reducer::DeletePlayer { .. } => "delete_player",
Reducer::DeletePlayersByName { .. } => "delete_players_by_name",
Reducer::ListOverAge { .. } => "list_over_age",
Reducer::LogModuleIdentity => "log_module_identity",
Reducer::QueryPrivate => "query_private",
Reducer::RepeatingTest { .. } => "repeating_test",
Reducer::SayHello => "say_hello",
Reducer::Test { .. } => "test",
Reducer::TestBtreeIndexArgs => "test_btree_index_args",
_ => unreachable!(),
}
}
}
impl TryFrom<__ws::ReducerCallInfo<__ws::BsatnFormat>> for Reducer {
type Error = __sdk::Error;
fn try_from(value: __ws::ReducerCallInfo<__ws::BsatnFormat>) -> __sdk::Result<Self> {
match &value.reducer_name[..] {
"add" => Ok(__sdk::parse_reducer_args::<add_reducer::AddArgs>("add", &value.args)?.into()),
"add_player" => Ok(__sdk::parse_reducer_args::<add_player_reducer::AddPlayerArgs>("add_player", &value.args)?.into()),
"add_private" => Ok(__sdk::parse_reducer_args::<add_private_reducer::AddPrivateArgs>("add_private", &value.args)?.into()),
"assert_caller_identity_is_module_identity" => Ok(__sdk::parse_reducer_args::<assert_caller_identity_is_module_identity_reducer::AssertCallerIdentityIsModuleIdentityArgs>("assert_caller_identity_is_module_identity", &value.args)?.into()),
"client_connected" => Ok(__sdk::parse_reducer_args::<client_connected_reducer::ClientConnectedArgs>("client_connected", &value.args)?.into()),
"delete_player" => Ok(__sdk::parse_reducer_args::<delete_player_reducer::DeletePlayerArgs>("delete_player", &value.args)?.into()),
"delete_players_by_name" => Ok(__sdk::parse_reducer_args::<delete_players_by_name_reducer::DeletePlayersByNameArgs>("delete_players_by_name", &value.args)?.into()),
"list_over_age" => Ok(__sdk::parse_reducer_args::<list_over_age_reducer::ListOverAgeArgs>("list_over_age", &value.args)?.into()),
"log_module_identity" => Ok(__sdk::parse_reducer_args::<log_module_identity_reducer::LogModuleIdentityArgs>("log_module_identity", &value.args)?.into()),
"query_private" => Ok(__sdk::parse_reducer_args::<query_private_reducer::QueryPrivateArgs>("query_private", &value.args)?.into()),
"repeating_test" => Ok(__sdk::parse_reducer_args::<repeating_test_reducer::RepeatingTestArgs>("repeating_test", &value.args)?.into()),
"say_hello" => Ok(__sdk::parse_reducer_args::<say_hello_reducer::SayHelloArgs>("say_hello", &value.args)?.into()),
"test" => Ok(__sdk::parse_reducer_args::<test_reducer::TestArgs>("test", &value.args)?.into()),
"test_btree_index_args" => Ok(__sdk::parse_reducer_args::<test_btree_index_args_reducer::TestBtreeIndexArgsArgs>("test_btree_index_args", &value.args)?.into()),
unknown => Err(__sdk::InternalError::unknown_name("reducer", unknown, "ReducerCallInfo").into()),
}
}
}
#[derive(Default)]
#[allow(non_snake_case)]
#[doc(hidden)]
pub struct DbUpdate {
has_special_stuff: __sdk::TableUpdate<HasSpecialStuff>,
logged_out_player: __sdk::TableUpdate<Player>,
my_player: __sdk::TableUpdate<Player>,
person: __sdk::TableUpdate<Person>,
pk_multi_identity: __sdk::TableUpdate<PkMultiIdentity>,
player: __sdk::TableUpdate<Player>,
points: __sdk::TableUpdate<Point>,
private_table: __sdk::TableUpdate<PrivateTable>,
repeating_test_arg: __sdk::TableUpdate<RepeatingTestArg>,
table_to_remove: __sdk::TableUpdate<RemoveTable>,
test_a: __sdk::TableUpdate<TestA>,
test_d: __sdk::TableUpdate<TestD>,
test_e: __sdk::TableUpdate<TestE>,
test_f: __sdk::TableUpdate<TestFoobar>,
}
impl TryFrom<__ws::DatabaseUpdate<__ws::BsatnFormat>> for DbUpdate {
type Error = __sdk::Error;
fn try_from(raw: __ws::DatabaseUpdate<__ws::BsatnFormat>) -> Result<Self, Self::Error> {
let mut db_update = DbUpdate::default();
for table_update in raw.tables {
match &table_update.table_name[..] {
"has_special_stuff" => db_update.has_special_stuff.append(has_special_stuff_table::parse_table_update(table_update)?),
"logged_out_player" => db_update.logged_out_player.append(logged_out_player_table::parse_table_update(table_update)?),
"my_player" => db_update.my_player.append(my_player_table::parse_table_update(table_update)?),
"person" => db_update.person.append(person_table::parse_table_update(table_update)?),
"pk_multi_identity" => db_update.pk_multi_identity.append(pk_multi_identity_table::parse_table_update(table_update)?),
"player" => db_update.player.append(player_table::parse_table_update(table_update)?),
"points" => db_update.points.append(points_table::parse_table_update(table_update)?),
"private_table" => db_update.private_table.append(private_table_table::parse_table_update(table_update)?),
"repeating_test_arg" => db_update.repeating_test_arg.append(repeating_test_arg_table::parse_table_update(table_update)?),
"table_to_remove" => db_update.table_to_remove.append(table_to_remove_table::parse_table_update(table_update)?),
"test_a" => db_update.test_a.append(test_a_table::parse_table_update(table_update)?),
"test_d" => db_update.test_d.append(test_d_table::parse_table_update(table_update)?),
"test_e" => db_update.test_e.append(test_e_table::parse_table_update(table_update)?),
"test_f" => db_update.test_f.append(test_f_table::parse_table_update(table_update)?),
unknown => {
return Err(__sdk::InternalError::unknown_name(
"table",
unknown,
"DatabaseUpdate",
).into());
}
}
}
Ok(db_update)
}
}
impl __sdk::InModule for DbUpdate {
type Module = RemoteModule;
}
impl __sdk::DbUpdate for DbUpdate {
fn apply_to_client_cache(&self, cache: &mut __sdk::ClientCache<RemoteModule>) -> AppliedDiff<'_> {
let mut diff = AppliedDiff::default();
diff.has_special_stuff = cache.apply_diff_to_table::<HasSpecialStuff>("has_special_stuff", &self.has_special_stuff);
diff.logged_out_player = cache.apply_diff_to_table::<Player>("logged_out_player", &self.logged_out_player).with_updates_by_pk(|row| &row.identity);
diff.person = cache.apply_diff_to_table::<Person>("person", &self.person).with_updates_by_pk(|row| &row.id);
diff.pk_multi_identity = cache.apply_diff_to_table::<PkMultiIdentity>("pk_multi_identity", &self.pk_multi_identity).with_updates_by_pk(|row| &row.id);
diff.player = cache.apply_diff_to_table::<Player>("player", &self.player).with_updates_by_pk(|row| &row.identity);
diff.points = cache.apply_diff_to_table::<Point>("points", &self.points);
diff.private_table = cache.apply_diff_to_table::<PrivateTable>("private_table", &self.private_table);
diff.repeating_test_arg = cache.apply_diff_to_table::<RepeatingTestArg>("repeating_test_arg", &self.repeating_test_arg).with_updates_by_pk(|row| &row.scheduled_id);
diff.table_to_remove = cache.apply_diff_to_table::<RemoveTable>("table_to_remove", &self.table_to_remove);
diff.test_a = cache.apply_diff_to_table::<TestA>("test_a", &self.test_a);
diff.test_d = cache.apply_diff_to_table::<TestD>("test_d", &self.test_d);
diff.test_e = cache.apply_diff_to_table::<TestE>("test_e", &self.test_e).with_updates_by_pk(|row| &row.id);
diff.test_f = cache.apply_diff_to_table::<TestFoobar>("test_f", &self.test_f);
diff.my_player = cache.apply_diff_to_table::<Player>("my_player", &self.my_player);
diff
}
}
#[derive(Default)]
#[allow(non_snake_case)]
#[doc(hidden)]
pub struct AppliedDiff<'r> {
has_special_stuff: __sdk::TableAppliedDiff<'r, HasSpecialStuff>,
logged_out_player: __sdk::TableAppliedDiff<'r, Player>,
my_player: __sdk::TableAppliedDiff<'r, Player>,
person: __sdk::TableAppliedDiff<'r, Person>,
pk_multi_identity: __sdk::TableAppliedDiff<'r, PkMultiIdentity>,
player: __sdk::TableAppliedDiff<'r, Player>,
points: __sdk::TableAppliedDiff<'r, Point>,
private_table: __sdk::TableAppliedDiff<'r, PrivateTable>,
repeating_test_arg: __sdk::TableAppliedDiff<'r, RepeatingTestArg>,
table_to_remove: __sdk::TableAppliedDiff<'r, RemoveTable>,
test_a: __sdk::TableAppliedDiff<'r, TestA>,
test_d: __sdk::TableAppliedDiff<'r, TestD>,
test_e: __sdk::TableAppliedDiff<'r, TestE>,
test_f: __sdk::TableAppliedDiff<'r, TestFoobar>,
__unused: std::marker::PhantomData<&'r ()>,
}
impl __sdk::InModule for AppliedDiff<'_> {
type Module = RemoteModule;
}
impl<'r> __sdk::AppliedDiff<'r> for AppliedDiff<'r> {
fn invoke_row_callbacks(&self, event: &EventContext, callbacks: &mut __sdk::DbCallbacks<RemoteModule>) {
callbacks.invoke_table_row_callbacks::<HasSpecialStuff>("has_special_stuff", &self.has_special_stuff, event);
callbacks.invoke_table_row_callbacks::<Player>("logged_out_player", &self.logged_out_player, event);
callbacks.invoke_table_row_callbacks::<Player>("my_player", &self.my_player, event);
callbacks.invoke_table_row_callbacks::<Person>("person", &self.person, event);
callbacks.invoke_table_row_callbacks::<PkMultiIdentity>("pk_multi_identity", &self.pk_multi_identity, event);
callbacks.invoke_table_row_callbacks::<Player>("player", &self.player, event);
callbacks.invoke_table_row_callbacks::<Point>("points", &self.points, event);
callbacks.invoke_table_row_callbacks::<PrivateTable>("private_table", &self.private_table, event);
callbacks.invoke_table_row_callbacks::<RepeatingTestArg>("repeating_test_arg", &self.repeating_test_arg, event);
callbacks.invoke_table_row_callbacks::<RemoveTable>("table_to_remove", &self.table_to_remove, event);
callbacks.invoke_table_row_callbacks::<TestA>("test_a", &self.test_a, event);
callbacks.invoke_table_row_callbacks::<TestD>("test_d", &self.test_d, event);
callbacks.invoke_table_row_callbacks::<TestE>("test_e", &self.test_e, event);
callbacks.invoke_table_row_callbacks::<TestFoobar>("test_f", &self.test_f, event);
}
}
#[doc(hidden)]
pub struct RemoteModule;
impl __sdk::InModule for RemoteModule {
type Module = Self;
}
/// The `reducers` field of [`EventContext`] and [`DbConnection`],
/// with methods provided by extension traits for each reducer defined by the module.
pub struct RemoteReducers {
imp: __sdk::DbContextImpl<RemoteModule>,
}
impl __sdk::InModule for RemoteReducers {
type Module = RemoteModule;
}
/// The `procedures` field of [`DbConnection`] and other [`DbContext`] types,
/// with methods provided by extension traits for each procedure defined by the module.
pub struct RemoteProcedures {
imp: __sdk::DbContextImpl<RemoteModule>,
}
impl __sdk::InModule for RemoteProcedures {
type Module = RemoteModule;
}
#[doc(hidden)]
/// The `set_reducer_flags` field of [`DbConnection`],
/// with methods provided by extension traits for each reducer defined by the module.
/// Each method sets the flags for the reducer with the same name.
///
/// This type is currently unstable and may be removed without a major version bump.
pub struct SetReducerFlags {
imp: __sdk::DbContextImpl<RemoteModule>,
}
impl __sdk::InModule for SetReducerFlags {
type Module = RemoteModule;
}
/// The `db` field of [`EventContext`] and [`DbConnection`],
/// with methods provided by extension traits for each table defined by the module.
pub struct RemoteTables {
imp: __sdk::DbContextImpl<RemoteModule>,
}
impl __sdk::InModule for RemoteTables {
type Module = RemoteModule;
}
/// A connection to a remote module, including a materialized view of a subset of the database.
///
/// Connect to a remote module by calling [`DbConnection::builder`]
/// and using the [`__sdk::DbConnectionBuilder`] builder-pattern constructor.
///
/// You must explicitly advance the connection by calling any one of:
///
/// - [`DbConnection::frame_tick`].
/// - [`DbConnection::run_threaded`].
/// - [`DbConnection::run_async`].
/// - [`DbConnection::advance_one_message`].
/// - [`DbConnection::advance_one_message_blocking`].
/// - [`DbConnection::advance_one_message_async`].
///
/// Which of these methods you should call depends on the specific needs of your application,
/// but you must call one of them, or else the connection will never progress.
pub struct DbConnection {
/// Access to tables defined by the module via extension traits implemented for [`RemoteTables`].
pub db: RemoteTables,
/// Access to reducers defined by the module via extension traits implemented for [`RemoteReducers`].
pub reducers: RemoteReducers,
#[doc(hidden)]
/// Access to setting the call-flags of each reducer defined for each reducer defined by the module
/// via extension traits implemented for [`SetReducerFlags`].
///
/// This type is currently unstable and may be removed without a major version bump.
pub set_reducer_flags: SetReducerFlags,
/// Access to procedures defined by the module via extension traits implemented for [`RemoteProcedures`].
pub procedures: RemoteProcedures,
imp: __sdk::DbContextImpl<RemoteModule>,
}
impl __sdk::InModule for DbConnection {
type Module = RemoteModule;
}
impl __sdk::DbContext for DbConnection {
type DbView = RemoteTables;
type Reducers = RemoteReducers;
type Procedures = RemoteProcedures;
type SetReducerFlags = SetReducerFlags;
fn db(&self) -> &Self::DbView {
&self.db
}
fn reducers(&self) -> &Self::Reducers {
&self.reducers
}
fn procedures(&self) -> &Self::Procedures {
&self.procedures
}
fn set_reducer_flags(&self) -> &Self::SetReducerFlags {
&self.set_reducer_flags
}
fn is_active(&self) -> bool {
self.imp.is_active()
}
fn disconnect(&self) -> __sdk::Result<()> {
self.imp.disconnect()
}
type SubscriptionBuilder = __sdk::SubscriptionBuilder<RemoteModule>;
fn subscription_builder(&self) -> Self::SubscriptionBuilder {
__sdk::SubscriptionBuilder::new(&self.imp)
}
fn try_identity(&self) -> Option<__sdk::Identity> {
self.imp.try_identity()
}
fn connection_id(&self) -> __sdk::ConnectionId {
self.imp.connection_id()
}
fn try_connection_id(&self) -> Option<__sdk::ConnectionId> {
self.imp.try_connection_id()
}
}
impl DbConnection {
/// Builder-pattern constructor for a connection to a remote module.
///
/// See [`__sdk::DbConnectionBuilder`] for required and optional configuration for the new connection.
pub fn builder() -> __sdk::DbConnectionBuilder<RemoteModule> {
__sdk::DbConnectionBuilder::new()
}
/// If any WebSocket messages are waiting, process one of them.
///
/// Returns `true` if a message was processed, or `false` if the queue is empty.
/// Callers should invoke this message in a loop until it returns `false`
/// or for as much time is available to process messages.
///
/// Returns an error if the connection is disconnected.
/// If the disconnection in question was normal,
/// i.e. the result of a call to [`__sdk::DbContext::disconnect`],
/// the returned error will be downcastable to [`__sdk::DisconnectedError`].
///
/// This is a low-level primitive exposed for power users who need significant control over scheduling.
/// Most applications should call [`Self::frame_tick`] each frame
/// to fully exhaust the queue whenever time is available.
pub fn advance_one_message(&self) -> __sdk::Result<bool> {
self.imp.advance_one_message()
}
/// Process one WebSocket message, potentially blocking the current thread until one is received.
///
/// Returns an error if the connection is disconnected.
/// If the disconnection in question was normal,
/// i.e. the result of a call to [`__sdk::DbContext::disconnect`],
/// the returned error will be downcastable to [`__sdk::DisconnectedError`].
///
/// This is a low-level primitive exposed for power users who need significant control over scheduling.
/// Most applications should call [`Self::run_threaded`] to spawn a thread
/// which advances the connection automatically.
pub fn advance_one_message_blocking(&self) -> __sdk::Result<()> {
self.imp.advance_one_message_blocking()
}
/// Process one WebSocket message, `await`ing until one is received.
///
/// Returns an error if the connection is disconnected.
/// If the disconnection in question was normal,
/// i.e. the result of a call to [`__sdk::DbContext::disconnect`],
/// the returned error will be downcastable to [`__sdk::DisconnectedError`].
///
/// This is a low-level primitive exposed for power users who need significant control over scheduling.
/// Most applications should call [`Self::run_async`] to run an `async` loop
/// which advances the connection when polled.
pub async fn advance_one_message_async(&self) -> __sdk::Result<()> {
self.imp.advance_one_message_async().await
}
/// Process all WebSocket messages waiting in the queue,
/// then return without `await`ing or blocking the current thread.
pub fn frame_tick(&self) -> __sdk::Result<()> {
self.imp.frame_tick()
}
/// Spawn a thread which processes WebSocket messages as they are received.
pub fn run_threaded(&self) -> std::thread::JoinHandle<()> {
self.imp.run_threaded()
}
/// Run an `async` loop which processes WebSocket messages when polled.
pub async fn run_async(&self) -> __sdk::Result<()> {
self.imp.run_async().await
}
}
impl __sdk::DbConnection for DbConnection {
fn new(imp: __sdk::DbContextImpl<RemoteModule>) -> Self {
Self {
db: RemoteTables { imp: imp.clone() },
reducers: RemoteReducers { imp: imp.clone() },
procedures: RemoteProcedures { imp: imp.clone() },
set_reducer_flags: SetReducerFlags { imp: imp.clone() },
imp,
}
}
}
/// A handle on a subscribed query.
// TODO: Document this better after implementing the new subscription API.
#[derive(Clone)]
pub struct SubscriptionHandle {
imp: __sdk::SubscriptionHandleImpl<RemoteModule>,
}
impl __sdk::InModule for SubscriptionHandle {
type Module = RemoteModule;
}
impl __sdk::SubscriptionHandle for SubscriptionHandle {
fn new(imp: __sdk::SubscriptionHandleImpl<RemoteModule>) -> Self {
Self { imp }
}
/// Returns true if this subscription has been terminated due to an unsubscribe call or an error.
fn is_ended(&self) -> bool {
self.imp.is_ended()
}
/// Returns true if this subscription has been applied and has not yet been unsubscribed.
fn is_active(&self) -> bool {
self.imp.is_active()
}
/// Unsubscribe from the query controlled by this `SubscriptionHandle`,
/// then run `on_end` when its rows are removed from the client cache.
fn unsubscribe_then(self, on_end: __sdk::OnEndedCallback<RemoteModule>) -> __sdk::Result<()> {
self.imp.unsubscribe_then(Some(on_end))
}
fn unsubscribe(self) -> __sdk::Result<()> {
self.imp.unsubscribe_then(None)
}
}
/// Alias trait for a [`__sdk::DbContext`] connected to this module,
/// with that trait's associated types bounded to this module's concrete types.
///
/// Users can use this trait as a boundary on definitions which should accept
/// either a [`DbConnection`] or an [`EventContext`] and operate on either.
pub trait RemoteDbContext: __sdk::DbContext<
DbView = RemoteTables,
Reducers = RemoteReducers,
SetReducerFlags = SetReducerFlags,
SubscriptionBuilder = __sdk::SubscriptionBuilder<RemoteModule>,
> {}
impl<Ctx: __sdk::DbContext<
DbView = RemoteTables,
Reducers = RemoteReducers,
SetReducerFlags = SetReducerFlags,
SubscriptionBuilder = __sdk::SubscriptionBuilder<RemoteModule>,
>> RemoteDbContext for Ctx {}
/// An [`__sdk::DbContext`] augmented with a [`__sdk::Event`],
/// passed to [`__sdk::Table::on_insert`], [`__sdk::Table::on_delete`] and [`__sdk::TableWithPrimaryKey::on_update`] callbacks.
pub struct EventContext {
/// Access to tables defined by the module via extension traits implemented for [`RemoteTables`].
pub db: RemoteTables,
/// Access to reducers defined by the module via extension traits implemented for [`RemoteReducers`].
pub reducers: RemoteReducers,
/// Access to setting the call-flags of each reducer defined for each reducer defined by the module
/// via extension traits implemented for [`SetReducerFlags`].
///
/// This type is currently unstable and may be removed without a major version bump.
pub set_reducer_flags: SetReducerFlags,
/// Access to procedures defined by the module via extension traits implemented for [`RemoteProcedures`].
pub procedures: RemoteProcedures,
/// The event which caused these callbacks to run.
pub event: __sdk::Event<Reducer>,
imp: __sdk::DbContextImpl<RemoteModule>,
}
impl __sdk::AbstractEventContext for EventContext {
type Event = __sdk::Event<Reducer>;
fn event(&self) -> &Self::Event {
&self.event
}
fn new(imp: __sdk::DbContextImpl<RemoteModule>, event: Self::Event) -> Self {
Self {
db: RemoteTables { imp: imp.clone() },
reducers: RemoteReducers { imp: imp.clone() },
set_reducer_flags: SetReducerFlags { imp: imp.clone() },
procedures: RemoteProcedures { imp: imp.clone() },
event,
imp,
}
}
}
impl __sdk::InModule for EventContext {
type Module = RemoteModule;
}
impl __sdk::DbContext for EventContext {
type DbView = RemoteTables;
type Reducers = RemoteReducers;
type Procedures = RemoteProcedures;
type SetReducerFlags = SetReducerFlags;
fn db(&self) -> &Self::DbView {
&self.db
}
fn reducers(&self) -> &Self::Reducers {
&self.reducers
}
fn procedures(&self) -> &Self::Procedures {
&self.procedures
}
fn set_reducer_flags(&self) -> &Self::SetReducerFlags {
&self.set_reducer_flags
}
fn is_active(&self) -> bool {
self.imp.is_active()
}
fn disconnect(&self) -> __sdk::Result<()> {
self.imp.disconnect()
}
type SubscriptionBuilder = __sdk::SubscriptionBuilder<RemoteModule>;
fn subscription_builder(&self) -> Self::SubscriptionBuilder {
__sdk::SubscriptionBuilder::new(&self.imp)
}
fn try_identity(&self) -> Option<__sdk::Identity> {
self.imp.try_identity()
}
fn connection_id(&self) -> __sdk::ConnectionId {
self.imp.connection_id()
}
fn try_connection_id(&self) -> Option<__sdk::ConnectionId> {
self.imp.try_connection_id()
}
}
impl __sdk::EventContext for EventContext {}
/// An [`__sdk::DbContext`] augmented with a [`__sdk::ReducerEvent`],
/// passed to on-reducer callbacks.
pub struct ReducerEventContext {
/// Access to tables defined by the module via extension traits implemented for [`RemoteTables`].
pub db: RemoteTables,
/// Access to reducers defined by the module via extension traits implemented for [`RemoteReducers`].
pub reducers: RemoteReducers,
/// Access to setting the call-flags of each reducer defined for each reducer defined by the module
/// via extension traits implemented for [`SetReducerFlags`].
///
/// This type is currently unstable and may be removed without a major version bump.
pub set_reducer_flags: SetReducerFlags,
/// Access to procedures defined by the module via extension traits implemented for [`RemoteProcedures`].
pub procedures: RemoteProcedures,
/// The event which caused these callbacks to run.
pub event: __sdk::ReducerEvent<Reducer>,
imp: __sdk::DbContextImpl<RemoteModule>,
}
impl __sdk::AbstractEventContext for ReducerEventContext {
type Event = __sdk::ReducerEvent<Reducer>;
fn event(&self) -> &Self::Event {
&self.event
}
fn new(imp: __sdk::DbContextImpl<RemoteModule>, event: Self::Event) -> Self {
Self {
db: RemoteTables { imp: imp.clone() },
reducers: RemoteReducers { imp: imp.clone() },
set_reducer_flags: SetReducerFlags { imp: imp.clone() },
procedures: RemoteProcedures { imp: imp.clone() },
event,
imp,
}
}
}
impl __sdk::InModule for ReducerEventContext {
type Module = RemoteModule;
}
impl __sdk::DbContext for ReducerEventContext {
type DbView = RemoteTables;
type Reducers = RemoteReducers;
type Procedures = RemoteProcedures;
type SetReducerFlags = SetReducerFlags;
fn db(&self) -> &Self::DbView {
&self.db
}
fn reducers(&self) -> &Self::Reducers {
&self.reducers
}
fn procedures(&self) -> &Self::Procedures {
&self.procedures
}
fn set_reducer_flags(&self) -> &Self::SetReducerFlags {
&self.set_reducer_flags
}
fn is_active(&self) -> bool {
self.imp.is_active()
}
fn disconnect(&self) -> __sdk::Result<()> {
self.imp.disconnect()
}
type SubscriptionBuilder = __sdk::SubscriptionBuilder<RemoteModule>;
fn subscription_builder(&self) -> Self::SubscriptionBuilder {
__sdk::SubscriptionBuilder::new(&self.imp)
}
fn try_identity(&self) -> Option<__sdk::Identity> {
self.imp.try_identity()
}
fn connection_id(&self) -> __sdk::ConnectionId {
self.imp.connection_id()
}
fn try_connection_id(&self) -> Option<__sdk::ConnectionId> {
self.imp.try_connection_id()
}
}
impl __sdk::ReducerEventContext for ReducerEventContext {}
/// An [`__sdk::DbContext`] passed to procedure callbacks.
pub struct ProcedureEventContext {
/// Access to tables defined by the module via extension traits implemented for [`RemoteTables`].
pub db: RemoteTables,
/// Access to reducers defined by the module via extension traits implemented for [`RemoteReducers`].
pub reducers: RemoteReducers,
/// Access to setting the call-flags of each reducer defined for each reducer defined by the module
/// via extension traits implemented for [`SetReducerFlags`].
///
/// This type is currently unstable and may be removed without a major version bump.
pub set_reducer_flags: SetReducerFlags,
/// Access to procedures defined by the module via extension traits implemented for [`RemoteProcedures`].
pub procedures: RemoteProcedures,
imp: __sdk::DbContextImpl<RemoteModule>,
}
impl __sdk::AbstractEventContext for ProcedureEventContext {
type Event = ();
fn event(&self) -> &Self::Event {
&()
}
fn new(imp: __sdk::DbContextImpl<RemoteModule>, _event: Self::Event) -> Self {
Self {
db: RemoteTables { imp: imp.clone() },
reducers: RemoteReducers { imp: imp.clone() },
procedures: RemoteProcedures { imp: imp.clone() },
set_reducer_flags: SetReducerFlags { imp: imp.clone() },
imp,
}
}
}
impl __sdk::InModule for ProcedureEventContext {
type Module = RemoteModule;
}
impl __sdk::DbContext for ProcedureEventContext {
type DbView = RemoteTables;
type Reducers = RemoteReducers;
type Procedures = RemoteProcedures;
type SetReducerFlags = SetReducerFlags;
fn db(&self) -> &Self::DbView {
&self.db
}
fn reducers(&self) -> &Self::Reducers {
&self.reducers
}
fn procedures(&self) -> &Self::Procedures {
&self.procedures
}
fn set_reducer_flags(&self) -> &Self::SetReducerFlags {
&self.set_reducer_flags
}
fn is_active(&self) -> bool {
self.imp.is_active()
}
fn disconnect(&self) -> __sdk::Result<()> {
self.imp.disconnect()
}
type SubscriptionBuilder = __sdk::SubscriptionBuilder<RemoteModule>;
fn subscription_builder(&self) -> Self::SubscriptionBuilder {
__sdk::SubscriptionBuilder::new(&self.imp)
}
fn try_identity(&self) -> Option<__sdk::Identity> {
self.imp.try_identity()
}
fn connection_id(&self) -> __sdk::ConnectionId {
self.imp.connection_id()
}
fn try_connection_id(&self) -> Option<__sdk::ConnectionId> {
self.imp.try_connection_id()
}
}
impl __sdk::ProcedureEventContext for ProcedureEventContext {}
/// An [`__sdk::DbContext`] passed to [`__sdk::SubscriptionBuilder::on_applied`] and [`SubscriptionHandle::unsubscribe_then`] callbacks.
pub struct SubscriptionEventContext {
/// Access to tables defined by the module via extension traits implemented for [`RemoteTables`].
pub db: RemoteTables,
/// Access to reducers defined by the module via extension traits implemented for [`RemoteReducers`].
pub reducers: RemoteReducers,
/// Access to setting the call-flags of each reducer defined for each reducer defined by the module
/// via extension traits implemented for [`SetReducerFlags`].
///
/// This type is currently unstable and may be removed without a major version bump.
pub set_reducer_flags: SetReducerFlags,
/// Access to procedures defined by the module via extension traits implemented for [`RemoteProcedures`].
pub procedures: RemoteProcedures,
imp: __sdk::DbContextImpl<RemoteModule>,
}
impl __sdk::AbstractEventContext for SubscriptionEventContext {
type Event = ();
fn event(&self) -> &Self::Event {
&()
}
fn new(imp: __sdk::DbContextImpl<RemoteModule>, _event: Self::Event) -> Self {
Self {
db: RemoteTables { imp: imp.clone() },
reducers: RemoteReducers { imp: imp.clone() },
procedures: RemoteProcedures { imp: imp.clone() },
set_reducer_flags: SetReducerFlags { imp: imp.clone() },
imp,
}
}
}
impl __sdk::InModule for SubscriptionEventContext {
type Module = RemoteModule;
}
impl __sdk::DbContext for SubscriptionEventContext {
type DbView = RemoteTables;
type Reducers = RemoteReducers;
type Procedures = RemoteProcedures;
type SetReducerFlags = SetReducerFlags;
fn db(&self) -> &Self::DbView {
&self.db
}
fn reducers(&self) -> &Self::Reducers {
&self.reducers
}
fn procedures(&self) -> &Self::Procedures {
&self.procedures
}
fn set_reducer_flags(&self) -> &Self::SetReducerFlags {
&self.set_reducer_flags
}
fn is_active(&self) -> bool {
self.imp.is_active()
}
fn disconnect(&self) -> __sdk::Result<()> {
self.imp.disconnect()
}
type SubscriptionBuilder = __sdk::SubscriptionBuilder<RemoteModule>;
fn subscription_builder(&self) -> Self::SubscriptionBuilder {
__sdk::SubscriptionBuilder::new(&self.imp)
}
fn try_identity(&self) -> Option<__sdk::Identity> {
self.imp.try_identity()
}
fn connection_id(&self) -> __sdk::ConnectionId {
self.imp.connection_id()
}
fn try_connection_id(&self) -> Option<__sdk::ConnectionId> {
self.imp.try_connection_id()
}
}
impl __sdk::SubscriptionEventContext for SubscriptionEventContext {}
/// An [`__sdk::DbContext`] augmented with a [`__sdk::Error`],
/// passed to [`__sdk::DbConnectionBuilder::on_disconnect`], [`__sdk::DbConnectionBuilder::on_connect_error`] and [`__sdk::SubscriptionBuilder::on_error`] callbacks.
pub struct ErrorContext {
/// Access to tables defined by the module via extension traits implemented for [`RemoteTables`].
pub db: RemoteTables,
/// Access to reducers defined by the module via extension traits implemented for [`RemoteReducers`].
pub reducers: RemoteReducers,
/// Access to setting the call-flags of each reducer defined for each reducer defined by the module
/// via extension traits implemented for [`SetReducerFlags`].
///
/// This type is currently unstable and may be removed without a major version bump.
pub set_reducer_flags: SetReducerFlags,
/// Access to procedures defined by the module via extension traits implemented for [`RemoteProcedures`].
pub procedures: RemoteProcedures,
/// The event which caused these callbacks to run.
pub event: Option<__sdk::Error>,
imp: __sdk::DbContextImpl<RemoteModule>,
}
impl __sdk::AbstractEventContext for ErrorContext {
type Event = Option<__sdk::Error>;
fn event(&self) -> &Self::Event {
&self.event
}
fn new(imp: __sdk::DbContextImpl<RemoteModule>, event: Self::Event) -> Self {
Self {
db: RemoteTables { imp: imp.clone() },
reducers: RemoteReducers { imp: imp.clone() },
set_reducer_flags: SetReducerFlags { imp: imp.clone() },
procedures: RemoteProcedures { imp: imp.clone() },
event,
imp,
}
}
}
impl __sdk::InModule for ErrorContext {
type Module = RemoteModule;
}
impl __sdk::DbContext for ErrorContext {
type DbView = RemoteTables;
type Reducers = RemoteReducers;
type Procedures = RemoteProcedures;
type SetReducerFlags = SetReducerFlags;
fn db(&self) -> &Self::DbView {
&self.db
}
fn reducers(&self) -> &Self::Reducers {
&self.reducers
}
fn procedures(&self) -> &Self::Procedures {
&self.procedures
}
fn set_reducer_flags(&self) -> &Self::SetReducerFlags {
&self.set_reducer_flags
}
fn is_active(&self) -> bool {
self.imp.is_active()
}
fn disconnect(&self) -> __sdk::Result<()> {
self.imp.disconnect()
}
type SubscriptionBuilder = __sdk::SubscriptionBuilder<RemoteModule>;
fn subscription_builder(&self) -> Self::SubscriptionBuilder {
__sdk::SubscriptionBuilder::new(&self.imp)
}
fn try_identity(&self) -> Option<__sdk::Identity> {
self.imp.try_identity()
}
fn connection_id(&self) -> __sdk::ConnectionId {
self.imp.connection_id()
}
fn try_connection_id(&self) -> Option<__sdk::ConnectionId> {
self.imp.try_connection_id()
}
}
impl __sdk::ErrorContext for ErrorContext {}
impl __sdk::SpacetimeModule for RemoteModule {
type DbConnection = DbConnection;
type EventContext = EventContext;
type ReducerEventContext = ReducerEventContext;
type ProcedureEventContext = ProcedureEventContext;
type SubscriptionEventContext = SubscriptionEventContext;
type ErrorContext = ErrorContext;
type Reducer = Reducer;
type DbView = RemoteTables;
type Reducers = RemoteReducers;
type SetReducerFlags = SetReducerFlags;
type DbUpdate = DbUpdate;
type AppliedDiff<'r> = AppliedDiff<'r>;
type SubscriptionHandle = SubscriptionHandle;
type QueryBuilder = __sdk::QueryBuilder;
fn register_tables(client_cache: &mut __sdk::ClientCache<Self>) {
has_special_stuff_table::register_table(client_cache);
logged_out_player_table::register_table(client_cache);
my_player_table::register_table(client_cache);
person_table::register_table(client_cache);
pk_multi_identity_table::register_table(client_cache);
player_table::register_table(client_cache);
points_table::register_table(client_cache);
private_table_table::register_table(client_cache);
repeating_test_arg_table::register_table(client_cache);
table_to_remove_table::register_table(client_cache);
test_a_table::register_table(client_cache);
test_d_table::register_table(client_cache);
test_e_table::register_table(client_cache);
test_f_table::register_table(client_cache);
}
}
'''
"my_player_table.rs" = '''
// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
#![allow(unused, clippy::all)]
use spacetimedb_sdk::__codegen::{
self as __sdk,
__lib,
__sats,
__ws,
};
use super::player_type::Player;
/// Table handle for the table `my_player`.
///
/// Obtain a handle from the [`MyPlayerTableAccess::my_player`] method on [`super::RemoteTables`],
/// like `ctx.db.my_player()`.
///
/// Users are encouraged not to explicitly reference this type,
/// but to directly chain method calls,
/// like `ctx.db.my_player().on_insert(...)`.
pub struct MyPlayerTableHandle<'ctx> {
imp: __sdk::TableHandle<Player>,
ctx: std::marker::PhantomData<&'ctx super::RemoteTables>,
}
#[allow(non_camel_case_types)]
/// Extension trait for access to the table `my_player`.
///
/// Implemented for [`super::RemoteTables`].
pub trait MyPlayerTableAccess {
#[allow(non_snake_case)]
/// Obtain a [`MyPlayerTableHandle`], which mediates access to the table `my_player`.
fn my_player(&self) -> MyPlayerTableHandle<'_>;
}
impl MyPlayerTableAccess for super::RemoteTables {
fn my_player(&self) -> MyPlayerTableHandle<'_> {
MyPlayerTableHandle {
imp: self.imp.get_table::<Player>("my_player"),
ctx: std::marker::PhantomData,
}
}
}
pub struct MyPlayerInsertCallbackId(__sdk::CallbackId);
pub struct MyPlayerDeleteCallbackId(__sdk::CallbackId);
impl<'ctx> __sdk::Table for MyPlayerTableHandle<'ctx> {
type Row = Player;
type EventContext = super::EventContext;
fn count(&self) -> u64 { self.imp.count() }
fn iter(&self) -> impl Iterator<Item = Player> + '_ { self.imp.iter() }
type InsertCallbackId = MyPlayerInsertCallbackId;
fn on_insert(
&self,
callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
) -> MyPlayerInsertCallbackId {
MyPlayerInsertCallbackId(self.imp.on_insert(Box::new(callback)))
}
fn remove_on_insert(&self, callback: MyPlayerInsertCallbackId) {
self.imp.remove_on_insert(callback.0)
}
type DeleteCallbackId = MyPlayerDeleteCallbackId;
fn on_delete(
&self,
callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
) -> MyPlayerDeleteCallbackId {
MyPlayerDeleteCallbackId(self.imp.on_delete(Box::new(callback)))
}
fn remove_on_delete(&self, callback: MyPlayerDeleteCallbackId) {
self.imp.remove_on_delete(callback.0)
}
}
#[doc(hidden)]
pub(super) fn register_table(client_cache: &mut __sdk::ClientCache<super::RemoteModule>) {
let _table = client_cache.get_or_make_table::<Player>("my_player");
}
#[doc(hidden)]
pub(super) fn parse_table_update(
raw_updates: __ws::TableUpdate<__ws::BsatnFormat>,
) -> __sdk::Result<__sdk::TableUpdate<Player>> {
__sdk::TableUpdate::parse_table_update(raw_updates).map_err(|e| {
__sdk::InternalError::failed_parse(
"TableUpdate<Player>",
"TableUpdate",
).with_cause(e).into()
})
}
#[allow(non_camel_case_types)]
/// Extension trait for query builder access to the table `Player`.
///
/// Implemented for [`__sdk::QueryTableAccessor`].
pub trait my_playerQueryTableAccess {
#[allow(non_snake_case)]
/// Get a query builder for the table `Player`.
fn my_player(&self) -> __sdk::__query_builder::Table<Player>;
}
impl my_playerQueryTableAccess for __sdk::QueryTableAccessor {
fn my_player(&self) -> __sdk::__query_builder::Table<Player> {
__sdk::__query_builder::Table::new("my_player")
}
}
'''
"namespace_test_c_type.rs" = '''
// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
#![allow(unused, clippy::all)]
use spacetimedb_sdk::__codegen::{
self as __sdk,
__lib,
__sats,
__ws,
};
#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
#[sats(crate = __lib)]
#[derive(Copy, Eq, Hash)]
pub enum NamespaceTestC {
Foo,
Bar,
}
impl __sdk::InModule for NamespaceTestC {
type Module = super::RemoteModule;
}
'''
"namespace_test_f_type.rs" = '''
// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
#![allow(unused, clippy::all)]
use spacetimedb_sdk::__codegen::{
self as __sdk,
__lib,
__sats,
__ws,
};
#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
#[sats(crate = __lib)]
pub enum NamespaceTestF {
Foo,
Bar,
Baz(String),
}
impl __sdk::InModule for NamespaceTestF {
type Module = super::RemoteModule;
}
'''
"person_table.rs" = '''
// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
#![allow(unused, clippy::all)]
use spacetimedb_sdk::__codegen::{
self as __sdk,
__lib,
__sats,
__ws,
};
use super::person_type::Person;
/// Table handle for the table `person`.
///
/// Obtain a handle from the [`PersonTableAccess::person`] method on [`super::RemoteTables`],
/// like `ctx.db.person()`.
///
/// Users are encouraged not to explicitly reference this type,
/// but to directly chain method calls,
/// like `ctx.db.person().on_insert(...)`.
pub struct PersonTableHandle<'ctx> {
imp: __sdk::TableHandle<Person>,
ctx: std::marker::PhantomData<&'ctx super::RemoteTables>,
}
#[allow(non_camel_case_types)]
/// Extension trait for access to the table `person`.
///
/// Implemented for [`super::RemoteTables`].
pub trait PersonTableAccess {
#[allow(non_snake_case)]
/// Obtain a [`PersonTableHandle`], which mediates access to the table `person`.
fn person(&self) -> PersonTableHandle<'_>;
}
impl PersonTableAccess for super::RemoteTables {
fn person(&self) -> PersonTableHandle<'_> {
PersonTableHandle {
imp: self.imp.get_table::<Person>("person"),
ctx: std::marker::PhantomData,
}
}
}
pub struct PersonInsertCallbackId(__sdk::CallbackId);
pub struct PersonDeleteCallbackId(__sdk::CallbackId);
impl<'ctx> __sdk::Table for PersonTableHandle<'ctx> {
type Row = Person;
type EventContext = super::EventContext;
fn count(&self) -> u64 { self.imp.count() }
fn iter(&self) -> impl Iterator<Item = Person> + '_ { self.imp.iter() }
type InsertCallbackId = PersonInsertCallbackId;
fn on_insert(
&self,
callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
) -> PersonInsertCallbackId {
PersonInsertCallbackId(self.imp.on_insert(Box::new(callback)))
}
fn remove_on_insert(&self, callback: PersonInsertCallbackId) {
self.imp.remove_on_insert(callback.0)
}
type DeleteCallbackId = PersonDeleteCallbackId;
fn on_delete(
&self,
callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
) -> PersonDeleteCallbackId {
PersonDeleteCallbackId(self.imp.on_delete(Box::new(callback)))
}
fn remove_on_delete(&self, callback: PersonDeleteCallbackId) {
self.imp.remove_on_delete(callback.0)
}
}
#[doc(hidden)]
pub(super) fn register_table(client_cache: &mut __sdk::ClientCache<super::RemoteModule>) {
let _table = client_cache.get_or_make_table::<Person>("person");
_table.add_unique_constraint::<u32>("id", |row| &row.id);
}
pub struct PersonUpdateCallbackId(__sdk::CallbackId);
impl<'ctx> __sdk::TableWithPrimaryKey for PersonTableHandle<'ctx> {
type UpdateCallbackId = PersonUpdateCallbackId;
fn on_update(
&self,
callback: impl FnMut(&Self::EventContext, &Self::Row, &Self::Row) + Send + 'static,
) -> PersonUpdateCallbackId {
PersonUpdateCallbackId(self.imp.on_update(Box::new(callback)))
}
fn remove_on_update(&self, callback: PersonUpdateCallbackId) {
self.imp.remove_on_update(callback.0)
}
}
#[doc(hidden)]
pub(super) fn parse_table_update(
raw_updates: __ws::TableUpdate<__ws::BsatnFormat>,
) -> __sdk::Result<__sdk::TableUpdate<Person>> {
__sdk::TableUpdate::parse_table_update(raw_updates).map_err(|e| {
__sdk::InternalError::failed_parse(
"TableUpdate<Person>",
"TableUpdate",
).with_cause(e).into()
})
}
/// Access to the `id` unique index on the table `person`,
/// which allows point queries on the field of the same name
/// via the [`PersonIdUnique::find`] method.
///
/// Users are encouraged not to explicitly reference this type,
/// but to directly chain method calls,
/// like `ctx.db.person().id().find(...)`.
pub struct PersonIdUnique<'ctx> {
imp: __sdk::UniqueConstraintHandle<Person, u32>,
phantom: std::marker::PhantomData<&'ctx super::RemoteTables>,
}
impl<'ctx> PersonTableHandle<'ctx> {
/// Get a handle on the `id` unique index on the table `person`.
pub fn id(&self) -> PersonIdUnique<'ctx> {
PersonIdUnique {
imp: self.imp.get_unique_constraint::<u32>("id"),
phantom: std::marker::PhantomData,
}
}
}
impl<'ctx> PersonIdUnique<'ctx> {
/// Find the subscribed row whose `id` column value is equal to `col_val`,
/// if such a row is present in the client cache.
pub fn find(&self, col_val: &u32) -> Option<Person> {
self.imp.find(col_val)
}
}
#[allow(non_camel_case_types)]
/// Extension trait for query builder access to the table `Person`.
///
/// Implemented for [`__sdk::QueryTableAccessor`].
pub trait personQueryTableAccess {
#[allow(non_snake_case)]
/// Get a query builder for the table `Person`.
fn person(&self) -> __sdk::__query_builder::Table<Person>;
}
impl personQueryTableAccess for __sdk::QueryTableAccessor {
fn person(&self) -> __sdk::__query_builder::Table<Person> {
__sdk::__query_builder::Table::new("person")
}
}
'''
"person_type.rs" = '''
// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
#![allow(unused, clippy::all)]
use spacetimedb_sdk::__codegen::{
self as __sdk,
__lib,
__sats,
__ws,
};
#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
#[sats(crate = __lib)]
pub struct Person {
pub id: u32,
pub name: String,
pub age: u8,
}
impl __sdk::InModule for Person {
type Module = super::RemoteModule;
}
/// Column accessor struct for the table `Person`.
///
/// Provides typed access to columns for query building.
pub struct PersonCols {
pub id: __sdk::__query_builder::Col<Person, u32>,
pub name: __sdk::__query_builder::Col<Person, String>,
pub age: __sdk::__query_builder::Col<Person, u8>,
}
impl __sdk::__query_builder::HasCols for Person {
type Cols = PersonCols;
fn cols(table_name: &'static str) -> Self::Cols {
PersonCols {
id: __sdk::__query_builder::Col::new(table_name, "id"),
name: __sdk::__query_builder::Col::new(table_name, "name"),
age: __sdk::__query_builder::Col::new(table_name, "age"),
}
}
}
/// Indexed column accessor struct for the table `Person`.
///
/// Provides typed access to indexed columns for query building.
pub struct PersonIxCols {
pub age: __sdk::__query_builder::IxCol<Person, u8>,
pub id: __sdk::__query_builder::IxCol<Person, u32>,
}
impl __sdk::__query_builder::HasIxCols for Person {
type IxCols = PersonIxCols;
fn ix_cols(table_name: &'static str) -> Self::IxCols {
PersonIxCols {
age: __sdk::__query_builder::IxCol::new(table_name, "age"),
id: __sdk::__query_builder::IxCol::new(table_name, "id"),
}
}
}
'''
"pk_multi_identity_table.rs" = '''
// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
#![allow(unused, clippy::all)]
use spacetimedb_sdk::__codegen::{
self as __sdk,
__lib,
__sats,
__ws,
};
use super::pk_multi_identity_type::PkMultiIdentity;
/// Table handle for the table `pk_multi_identity`.
///
/// Obtain a handle from the [`PkMultiIdentityTableAccess::pk_multi_identity`] method on [`super::RemoteTables`],
/// like `ctx.db.pk_multi_identity()`.
///
/// Users are encouraged not to explicitly reference this type,
/// but to directly chain method calls,
/// like `ctx.db.pk_multi_identity().on_insert(...)`.
pub struct PkMultiIdentityTableHandle<'ctx> {
imp: __sdk::TableHandle<PkMultiIdentity>,
ctx: std::marker::PhantomData<&'ctx super::RemoteTables>,
}
#[allow(non_camel_case_types)]
/// Extension trait for access to the table `pk_multi_identity`.
///
/// Implemented for [`super::RemoteTables`].
pub trait PkMultiIdentityTableAccess {
#[allow(non_snake_case)]
/// Obtain a [`PkMultiIdentityTableHandle`], which mediates access to the table `pk_multi_identity`.
fn pk_multi_identity(&self) -> PkMultiIdentityTableHandle<'_>;
}
impl PkMultiIdentityTableAccess for super::RemoteTables {
fn pk_multi_identity(&self) -> PkMultiIdentityTableHandle<'_> {
PkMultiIdentityTableHandle {
imp: self.imp.get_table::<PkMultiIdentity>("pk_multi_identity"),
ctx: std::marker::PhantomData,
}
}
}
pub struct PkMultiIdentityInsertCallbackId(__sdk::CallbackId);
pub struct PkMultiIdentityDeleteCallbackId(__sdk::CallbackId);
impl<'ctx> __sdk::Table for PkMultiIdentityTableHandle<'ctx> {
type Row = PkMultiIdentity;
type EventContext = super::EventContext;
fn count(&self) -> u64 { self.imp.count() }
fn iter(&self) -> impl Iterator<Item = PkMultiIdentity> + '_ { self.imp.iter() }
type InsertCallbackId = PkMultiIdentityInsertCallbackId;
fn on_insert(
&self,
callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
) -> PkMultiIdentityInsertCallbackId {
PkMultiIdentityInsertCallbackId(self.imp.on_insert(Box::new(callback)))
}
fn remove_on_insert(&self, callback: PkMultiIdentityInsertCallbackId) {
self.imp.remove_on_insert(callback.0)
}
type DeleteCallbackId = PkMultiIdentityDeleteCallbackId;
fn on_delete(
&self,
callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
) -> PkMultiIdentityDeleteCallbackId {
PkMultiIdentityDeleteCallbackId(self.imp.on_delete(Box::new(callback)))
}
fn remove_on_delete(&self, callback: PkMultiIdentityDeleteCallbackId) {
self.imp.remove_on_delete(callback.0)
}
}
#[doc(hidden)]
pub(super) fn register_table(client_cache: &mut __sdk::ClientCache<super::RemoteModule>) {
let _table = client_cache.get_or_make_table::<PkMultiIdentity>("pk_multi_identity");
_table.add_unique_constraint::<u32>("id", |row| &row.id);
_table.add_unique_constraint::<u32>("other", |row| &row.other);
}
pub struct PkMultiIdentityUpdateCallbackId(__sdk::CallbackId);
impl<'ctx> __sdk::TableWithPrimaryKey for PkMultiIdentityTableHandle<'ctx> {
type UpdateCallbackId = PkMultiIdentityUpdateCallbackId;
fn on_update(
&self,
callback: impl FnMut(&Self::EventContext, &Self::Row, &Self::Row) + Send + 'static,
) -> PkMultiIdentityUpdateCallbackId {
PkMultiIdentityUpdateCallbackId(self.imp.on_update(Box::new(callback)))
}
fn remove_on_update(&self, callback: PkMultiIdentityUpdateCallbackId) {
self.imp.remove_on_update(callback.0)
}
}
#[doc(hidden)]
pub(super) fn parse_table_update(
raw_updates: __ws::TableUpdate<__ws::BsatnFormat>,
) -> __sdk::Result<__sdk::TableUpdate<PkMultiIdentity>> {
__sdk::TableUpdate::parse_table_update(raw_updates).map_err(|e| {
__sdk::InternalError::failed_parse(
"TableUpdate<PkMultiIdentity>",
"TableUpdate",
).with_cause(e).into()
})
}
/// Access to the `id` unique index on the table `pk_multi_identity`,
/// which allows point queries on the field of the same name
/// via the [`PkMultiIdentityIdUnique::find`] method.
///
/// Users are encouraged not to explicitly reference this type,
/// but to directly chain method calls,
/// like `ctx.db.pk_multi_identity().id().find(...)`.
pub struct PkMultiIdentityIdUnique<'ctx> {
imp: __sdk::UniqueConstraintHandle<PkMultiIdentity, u32>,
phantom: std::marker::PhantomData<&'ctx super::RemoteTables>,
}
impl<'ctx> PkMultiIdentityTableHandle<'ctx> {
/// Get a handle on the `id` unique index on the table `pk_multi_identity`.
pub fn id(&self) -> PkMultiIdentityIdUnique<'ctx> {
PkMultiIdentityIdUnique {
imp: self.imp.get_unique_constraint::<u32>("id"),
phantom: std::marker::PhantomData,
}
}
}
impl<'ctx> PkMultiIdentityIdUnique<'ctx> {
/// Find the subscribed row whose `id` column value is equal to `col_val`,
/// if such a row is present in the client cache.
pub fn find(&self, col_val: &u32) -> Option<PkMultiIdentity> {
self.imp.find(col_val)
}
}
/// Access to the `other` unique index on the table `pk_multi_identity`,
/// which allows point queries on the field of the same name
/// via the [`PkMultiIdentityOtherUnique::find`] method.
///
/// Users are encouraged not to explicitly reference this type,
/// but to directly chain method calls,
/// like `ctx.db.pk_multi_identity().other().find(...)`.
pub struct PkMultiIdentityOtherUnique<'ctx> {
imp: __sdk::UniqueConstraintHandle<PkMultiIdentity, u32>,
phantom: std::marker::PhantomData<&'ctx super::RemoteTables>,
}
impl<'ctx> PkMultiIdentityTableHandle<'ctx> {
/// Get a handle on the `other` unique index on the table `pk_multi_identity`.
pub fn other(&self) -> PkMultiIdentityOtherUnique<'ctx> {
PkMultiIdentityOtherUnique {
imp: self.imp.get_unique_constraint::<u32>("other"),
phantom: std::marker::PhantomData,
}
}
}
impl<'ctx> PkMultiIdentityOtherUnique<'ctx> {
/// Find the subscribed row whose `other` column value is equal to `col_val`,
/// if such a row is present in the client cache.
pub fn find(&self, col_val: &u32) -> Option<PkMultiIdentity> {
self.imp.find(col_val)
}
}
#[allow(non_camel_case_types)]
/// Extension trait for query builder access to the table `PkMultiIdentity`.
///
/// Implemented for [`__sdk::QueryTableAccessor`].
pub trait pk_multi_identityQueryTableAccess {
#[allow(non_snake_case)]
/// Get a query builder for the table `PkMultiIdentity`.
fn pk_multi_identity(&self) -> __sdk::__query_builder::Table<PkMultiIdentity>;
}
impl pk_multi_identityQueryTableAccess for __sdk::QueryTableAccessor {
fn pk_multi_identity(&self) -> __sdk::__query_builder::Table<PkMultiIdentity> {
__sdk::__query_builder::Table::new("pk_multi_identity")
}
}
'''
"pk_multi_identity_type.rs" = '''
// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
#![allow(unused, clippy::all)]
use spacetimedb_sdk::__codegen::{
self as __sdk,
__lib,
__sats,
__ws,
};
#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
#[sats(crate = __lib)]
pub struct PkMultiIdentity {
pub id: u32,
pub other: u32,
}
impl __sdk::InModule for PkMultiIdentity {
type Module = super::RemoteModule;
}
/// Column accessor struct for the table `PkMultiIdentity`.
///
/// Provides typed access to columns for query building.
pub struct PkMultiIdentityCols {
pub id: __sdk::__query_builder::Col<PkMultiIdentity, u32>,
pub other: __sdk::__query_builder::Col<PkMultiIdentity, u32>,
}
impl __sdk::__query_builder::HasCols for PkMultiIdentity {
type Cols = PkMultiIdentityCols;
fn cols(table_name: &'static str) -> Self::Cols {
PkMultiIdentityCols {
id: __sdk::__query_builder::Col::new(table_name, "id"),
other: __sdk::__query_builder::Col::new(table_name, "other"),
}
}
}
/// Indexed column accessor struct for the table `PkMultiIdentity`.
///
/// Provides typed access to indexed columns for query building.
pub struct PkMultiIdentityIxCols {
pub id: __sdk::__query_builder::IxCol<PkMultiIdentity, u32>,
pub other: __sdk::__query_builder::IxCol<PkMultiIdentity, u32>,
}
impl __sdk::__query_builder::HasIxCols for PkMultiIdentity {
type IxCols = PkMultiIdentityIxCols;
fn ix_cols(table_name: &'static str) -> Self::IxCols {
PkMultiIdentityIxCols {
id: __sdk::__query_builder::IxCol::new(table_name, "id"),
other: __sdk::__query_builder::IxCol::new(table_name, "other"),
}
}
}
'''
"player_table.rs" = '''
// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
#![allow(unused, clippy::all)]
use spacetimedb_sdk::__codegen::{
self as __sdk,
__lib,
__sats,
__ws,
};
use super::player_type::Player;
/// Table handle for the table `player`.
///
/// Obtain a handle from the [`PlayerTableAccess::player`] method on [`super::RemoteTables`],
/// like `ctx.db.player()`.
///
/// Users are encouraged not to explicitly reference this type,
/// but to directly chain method calls,
/// like `ctx.db.player().on_insert(...)`.
pub struct PlayerTableHandle<'ctx> {
imp: __sdk::TableHandle<Player>,
ctx: std::marker::PhantomData<&'ctx super::RemoteTables>,
}
#[allow(non_camel_case_types)]
/// Extension trait for access to the table `player`.
///
/// Implemented for [`super::RemoteTables`].
pub trait PlayerTableAccess {
#[allow(non_snake_case)]
/// Obtain a [`PlayerTableHandle`], which mediates access to the table `player`.
fn player(&self) -> PlayerTableHandle<'_>;
}
impl PlayerTableAccess for super::RemoteTables {
fn player(&self) -> PlayerTableHandle<'_> {
PlayerTableHandle {
imp: self.imp.get_table::<Player>("player"),
ctx: std::marker::PhantomData,
}
}
}
pub struct PlayerInsertCallbackId(__sdk::CallbackId);
pub struct PlayerDeleteCallbackId(__sdk::CallbackId);
impl<'ctx> __sdk::Table for PlayerTableHandle<'ctx> {
type Row = Player;
type EventContext = super::EventContext;
fn count(&self) -> u64 { self.imp.count() }
fn iter(&self) -> impl Iterator<Item = Player> + '_ { self.imp.iter() }
type InsertCallbackId = PlayerInsertCallbackId;
fn on_insert(
&self,
callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
) -> PlayerInsertCallbackId {
PlayerInsertCallbackId(self.imp.on_insert(Box::new(callback)))
}
fn remove_on_insert(&self, callback: PlayerInsertCallbackId) {
self.imp.remove_on_insert(callback.0)
}
type DeleteCallbackId = PlayerDeleteCallbackId;
fn on_delete(
&self,
callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
) -> PlayerDeleteCallbackId {
PlayerDeleteCallbackId(self.imp.on_delete(Box::new(callback)))
}
fn remove_on_delete(&self, callback: PlayerDeleteCallbackId) {
self.imp.remove_on_delete(callback.0)
}
}
#[doc(hidden)]
pub(super) fn register_table(client_cache: &mut __sdk::ClientCache<super::RemoteModule>) {
let _table = client_cache.get_or_make_table::<Player>("player");
_table.add_unique_constraint::<__sdk::Identity>("identity", |row| &row.identity);
_table.add_unique_constraint::<u64>("player_id", |row| &row.player_id);
_table.add_unique_constraint::<String>("name", |row| &row.name);
}
pub struct PlayerUpdateCallbackId(__sdk::CallbackId);
impl<'ctx> __sdk::TableWithPrimaryKey for PlayerTableHandle<'ctx> {
type UpdateCallbackId = PlayerUpdateCallbackId;
fn on_update(
&self,
callback: impl FnMut(&Self::EventContext, &Self::Row, &Self::Row) + Send + 'static,
) -> PlayerUpdateCallbackId {
PlayerUpdateCallbackId(self.imp.on_update(Box::new(callback)))
}
fn remove_on_update(&self, callback: PlayerUpdateCallbackId) {
self.imp.remove_on_update(callback.0)
}
}
#[doc(hidden)]
pub(super) fn parse_table_update(
raw_updates: __ws::TableUpdate<__ws::BsatnFormat>,
) -> __sdk::Result<__sdk::TableUpdate<Player>> {
__sdk::TableUpdate::parse_table_update(raw_updates).map_err(|e| {
__sdk::InternalError::failed_parse(
"TableUpdate<Player>",
"TableUpdate",
).with_cause(e).into()
})
}
/// Access to the `identity` unique index on the table `player`,
/// which allows point queries on the field of the same name
/// via the [`PlayerIdentityUnique::find`] method.
///
/// Users are encouraged not to explicitly reference this type,
/// but to directly chain method calls,
/// like `ctx.db.player().identity().find(...)`.
pub struct PlayerIdentityUnique<'ctx> {
imp: __sdk::UniqueConstraintHandle<Player, __sdk::Identity>,
phantom: std::marker::PhantomData<&'ctx super::RemoteTables>,
}
impl<'ctx> PlayerTableHandle<'ctx> {
/// Get a handle on the `identity` unique index on the table `player`.
pub fn identity(&self) -> PlayerIdentityUnique<'ctx> {
PlayerIdentityUnique {
imp: self.imp.get_unique_constraint::<__sdk::Identity>("identity"),
phantom: std::marker::PhantomData,
}
}
}
impl<'ctx> PlayerIdentityUnique<'ctx> {
/// Find the subscribed row whose `identity` column value is equal to `col_val`,
/// if such a row is present in the client cache.
pub fn find(&self, col_val: &__sdk::Identity) -> Option<Player> {
self.imp.find(col_val)
}
}
/// Access to the `player_id` unique index on the table `player`,
/// which allows point queries on the field of the same name
/// via the [`PlayerPlayerIdUnique::find`] method.
///
/// Users are encouraged not to explicitly reference this type,
/// but to directly chain method calls,
/// like `ctx.db.player().player_id().find(...)`.
pub struct PlayerPlayerIdUnique<'ctx> {
imp: __sdk::UniqueConstraintHandle<Player, u64>,
phantom: std::marker::PhantomData<&'ctx super::RemoteTables>,
}
impl<'ctx> PlayerTableHandle<'ctx> {
/// Get a handle on the `player_id` unique index on the table `player`.
pub fn player_id(&self) -> PlayerPlayerIdUnique<'ctx> {
PlayerPlayerIdUnique {
imp: self.imp.get_unique_constraint::<u64>("player_id"),
phantom: std::marker::PhantomData,
}
}
}
impl<'ctx> PlayerPlayerIdUnique<'ctx> {
/// Find the subscribed row whose `player_id` column value is equal to `col_val`,
/// if such a row is present in the client cache.
pub fn find(&self, col_val: &u64) -> Option<Player> {
self.imp.find(col_val)
}
}
/// Access to the `name` unique index on the table `player`,
/// which allows point queries on the field of the same name
/// via the [`PlayerNameUnique::find`] method.
///
/// Users are encouraged not to explicitly reference this type,
/// but to directly chain method calls,
/// like `ctx.db.player().name().find(...)`.
pub struct PlayerNameUnique<'ctx> {
imp: __sdk::UniqueConstraintHandle<Player, String>,
phantom: std::marker::PhantomData<&'ctx super::RemoteTables>,
}
impl<'ctx> PlayerTableHandle<'ctx> {
/// Get a handle on the `name` unique index on the table `player`.
pub fn name(&self) -> PlayerNameUnique<'ctx> {
PlayerNameUnique {
imp: self.imp.get_unique_constraint::<String>("name"),
phantom: std::marker::PhantomData,
}
}
}
impl<'ctx> PlayerNameUnique<'ctx> {
/// Find the subscribed row whose `name` column value is equal to `col_val`,
/// if such a row is present in the client cache.
pub fn find(&self, col_val: &String) -> Option<Player> {
self.imp.find(col_val)
}
}
#[allow(non_camel_case_types)]
/// Extension trait for query builder access to the table `Player`.
///
/// Implemented for [`__sdk::QueryTableAccessor`].
pub trait playerQueryTableAccess {
#[allow(non_snake_case)]
/// Get a query builder for the table `Player`.
fn player(&self) -> __sdk::__query_builder::Table<Player>;
}
impl playerQueryTableAccess for __sdk::QueryTableAccessor {
fn player(&self) -> __sdk::__query_builder::Table<Player> {
__sdk::__query_builder::Table::new("player")
}
}
'''
"player_type.rs" = '''
// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
#![allow(unused, clippy::all)]
use spacetimedb_sdk::__codegen::{
self as __sdk,
__lib,
__sats,
__ws,
};
#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
#[sats(crate = __lib)]
pub struct Player {
pub identity: __sdk::Identity,
pub player_id: u64,
pub name: String,
}
impl __sdk::InModule for Player {
type Module = super::RemoteModule;
}
/// Column accessor struct for the table `Player`.
///
/// Provides typed access to columns for query building.
pub struct PlayerCols {
pub identity: __sdk::__query_builder::Col<Player, __sdk::Identity>,
pub player_id: __sdk::__query_builder::Col<Player, u64>,
pub name: __sdk::__query_builder::Col<Player, String>,
}
impl __sdk::__query_builder::HasCols for Player {
type Cols = PlayerCols;
fn cols(table_name: &'static str) -> Self::Cols {
PlayerCols {
identity: __sdk::__query_builder::Col::new(table_name, "identity"),
player_id: __sdk::__query_builder::Col::new(table_name, "player_id"),
name: __sdk::__query_builder::Col::new(table_name, "name"),
}
}
}
/// Indexed column accessor struct for the table `Player`.
///
/// Provides typed access to indexed columns for query building.
pub struct PlayerIxCols {
pub identity: __sdk::__query_builder::IxCol<Player, __sdk::Identity>,
pub name: __sdk::__query_builder::IxCol<Player, String>,
pub player_id: __sdk::__query_builder::IxCol<Player, u64>,
}
impl __sdk::__query_builder::HasIxCols for Player {
type IxCols = PlayerIxCols;
fn ix_cols(table_name: &'static str) -> Self::IxCols {
PlayerIxCols {
identity: __sdk::__query_builder::IxCol::new(table_name, "identity"),
name: __sdk::__query_builder::IxCol::new(table_name, "name"),
player_id: __sdk::__query_builder::IxCol::new(table_name, "player_id"),
}
}
}
'''
"point_type.rs" = '''
// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
#![allow(unused, clippy::all)]
use spacetimedb_sdk::__codegen::{
self as __sdk,
__lib,
__sats,
__ws,
};
#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
#[sats(crate = __lib)]
pub struct Point {
pub x: i64,
pub y: i64,
}
impl __sdk::InModule for Point {
type Module = super::RemoteModule;
}
/// Column accessor struct for the table `Point`.
///
/// Provides typed access to columns for query building.
pub struct PointCols {
pub x: __sdk::__query_builder::Col<Point, i64>,
pub y: __sdk::__query_builder::Col<Point, i64>,
}
impl __sdk::__query_builder::HasCols for Point {
type Cols = PointCols;
fn cols(table_name: &'static str) -> Self::Cols {
PointCols {
x: __sdk::__query_builder::Col::new(table_name, "x"),
y: __sdk::__query_builder::Col::new(table_name, "y"),
}
}
}
/// Indexed column accessor struct for the table `Point`.
///
/// Provides typed access to indexed columns for query building.
pub struct PointIxCols {
}
impl __sdk::__query_builder::HasIxCols for Point {
type IxCols = PointIxCols;
fn ix_cols(table_name: &'static str) -> Self::IxCols {
PointIxCols {
}
}
}
'''
"points_table.rs" = '''
// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
#![allow(unused, clippy::all)]
use spacetimedb_sdk::__codegen::{
self as __sdk,
__lib,
__sats,
__ws,
};
use super::point_type::Point;
/// Table handle for the table `points`.
///
/// Obtain a handle from the [`PointsTableAccess::points`] method on [`super::RemoteTables`],
/// like `ctx.db.points()`.
///
/// Users are encouraged not to explicitly reference this type,
/// but to directly chain method calls,
/// like `ctx.db.points().on_insert(...)`.
pub struct PointsTableHandle<'ctx> {
imp: __sdk::TableHandle<Point>,
ctx: std::marker::PhantomData<&'ctx super::RemoteTables>,
}
#[allow(non_camel_case_types)]
/// Extension trait for access to the table `points`.
///
/// Implemented for [`super::RemoteTables`].
pub trait PointsTableAccess {
#[allow(non_snake_case)]
/// Obtain a [`PointsTableHandle`], which mediates access to the table `points`.
fn points(&self) -> PointsTableHandle<'_>;
}
impl PointsTableAccess for super::RemoteTables {
fn points(&self) -> PointsTableHandle<'_> {
PointsTableHandle {
imp: self.imp.get_table::<Point>("points"),
ctx: std::marker::PhantomData,
}
}
}
pub struct PointsInsertCallbackId(__sdk::CallbackId);
pub struct PointsDeleteCallbackId(__sdk::CallbackId);
impl<'ctx> __sdk::Table for PointsTableHandle<'ctx> {
type Row = Point;
type EventContext = super::EventContext;
fn count(&self) -> u64 { self.imp.count() }
fn iter(&self) -> impl Iterator<Item = Point> + '_ { self.imp.iter() }
type InsertCallbackId = PointsInsertCallbackId;
fn on_insert(
&self,
callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
) -> PointsInsertCallbackId {
PointsInsertCallbackId(self.imp.on_insert(Box::new(callback)))
}
fn remove_on_insert(&self, callback: PointsInsertCallbackId) {
self.imp.remove_on_insert(callback.0)
}
type DeleteCallbackId = PointsDeleteCallbackId;
fn on_delete(
&self,
callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
) -> PointsDeleteCallbackId {
PointsDeleteCallbackId(self.imp.on_delete(Box::new(callback)))
}
fn remove_on_delete(&self, callback: PointsDeleteCallbackId) {
self.imp.remove_on_delete(callback.0)
}
}
#[doc(hidden)]
pub(super) fn register_table(client_cache: &mut __sdk::ClientCache<super::RemoteModule>) {
let _table = client_cache.get_or_make_table::<Point>("points");
}
#[doc(hidden)]
pub(super) fn parse_table_update(
raw_updates: __ws::TableUpdate<__ws::BsatnFormat>,
) -> __sdk::Result<__sdk::TableUpdate<Point>> {
__sdk::TableUpdate::parse_table_update(raw_updates).map_err(|e| {
__sdk::InternalError::failed_parse(
"TableUpdate<Point>",
"TableUpdate",
).with_cause(e).into()
})
}
#[allow(non_camel_case_types)]
/// Extension trait for query builder access to the table `Point`.
///
/// Implemented for [`__sdk::QueryTableAccessor`].
pub trait pointsQueryTableAccess {
#[allow(non_snake_case)]
/// Get a query builder for the table `Point`.
fn points(&self) -> __sdk::__query_builder::Table<Point>;
}
impl pointsQueryTableAccess for __sdk::QueryTableAccessor {
fn points(&self) -> __sdk::__query_builder::Table<Point> {
__sdk::__query_builder::Table::new("points")
}
}
'''
"private_table_table.rs" = '''
// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
#![allow(unused, clippy::all)]
use spacetimedb_sdk::__codegen::{
self as __sdk,
__lib,
__sats,
__ws,
};
use super::private_table_type::PrivateTable;
/// Table handle for the table `private_table`.
///
/// Obtain a handle from the [`PrivateTableTableAccess::private_table`] method on [`super::RemoteTables`],
/// like `ctx.db.private_table()`.
///
/// Users are encouraged not to explicitly reference this type,
/// but to directly chain method calls,
/// like `ctx.db.private_table().on_insert(...)`.
pub struct PrivateTableTableHandle<'ctx> {
imp: __sdk::TableHandle<PrivateTable>,
ctx: std::marker::PhantomData<&'ctx super::RemoteTables>,
}
#[allow(non_camel_case_types)]
/// Extension trait for access to the table `private_table`.
///
/// Implemented for [`super::RemoteTables`].
pub trait PrivateTableTableAccess {
#[allow(non_snake_case)]
/// Obtain a [`PrivateTableTableHandle`], which mediates access to the table `private_table`.
fn private_table(&self) -> PrivateTableTableHandle<'_>;
}
impl PrivateTableTableAccess for super::RemoteTables {
fn private_table(&self) -> PrivateTableTableHandle<'_> {
PrivateTableTableHandle {
imp: self.imp.get_table::<PrivateTable>("private_table"),
ctx: std::marker::PhantomData,
}
}
}
pub struct PrivateTableInsertCallbackId(__sdk::CallbackId);
pub struct PrivateTableDeleteCallbackId(__sdk::CallbackId);
impl<'ctx> __sdk::Table for PrivateTableTableHandle<'ctx> {
type Row = PrivateTable;
type EventContext = super::EventContext;
fn count(&self) -> u64 { self.imp.count() }
fn iter(&self) -> impl Iterator<Item = PrivateTable> + '_ { self.imp.iter() }
type InsertCallbackId = PrivateTableInsertCallbackId;
fn on_insert(
&self,
callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
) -> PrivateTableInsertCallbackId {
PrivateTableInsertCallbackId(self.imp.on_insert(Box::new(callback)))
}
fn remove_on_insert(&self, callback: PrivateTableInsertCallbackId) {
self.imp.remove_on_insert(callback.0)
}
type DeleteCallbackId = PrivateTableDeleteCallbackId;
fn on_delete(
&self,
callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
) -> PrivateTableDeleteCallbackId {
PrivateTableDeleteCallbackId(self.imp.on_delete(Box::new(callback)))
}
fn remove_on_delete(&self, callback: PrivateTableDeleteCallbackId) {
self.imp.remove_on_delete(callback.0)
}
}
#[doc(hidden)]
pub(super) fn register_table(client_cache: &mut __sdk::ClientCache<super::RemoteModule>) {
let _table = client_cache.get_or_make_table::<PrivateTable>("private_table");
}
#[doc(hidden)]
pub(super) fn parse_table_update(
raw_updates: __ws::TableUpdate<__ws::BsatnFormat>,
) -> __sdk::Result<__sdk::TableUpdate<PrivateTable>> {
__sdk::TableUpdate::parse_table_update(raw_updates).map_err(|e| {
__sdk::InternalError::failed_parse(
"TableUpdate<PrivateTable>",
"TableUpdate",
).with_cause(e).into()
})
}
#[allow(non_camel_case_types)]
/// Extension trait for query builder access to the table `PrivateTable`.
///
/// Implemented for [`__sdk::QueryTableAccessor`].
pub trait private_tableQueryTableAccess {
#[allow(non_snake_case)]
/// Get a query builder for the table `PrivateTable`.
fn private_table(&self) -> __sdk::__query_builder::Table<PrivateTable>;
}
impl private_tableQueryTableAccess for __sdk::QueryTableAccessor {
fn private_table(&self) -> __sdk::__query_builder::Table<PrivateTable> {
__sdk::__query_builder::Table::new("private_table")
}
}
'''
"private_table_type.rs" = '''
// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
#![allow(unused, clippy::all)]
use spacetimedb_sdk::__codegen::{
self as __sdk,
__lib,
__sats,
__ws,
};
#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
#[sats(crate = __lib)]
pub struct PrivateTable {
pub name: String,
}
impl __sdk::InModule for PrivateTable {
type Module = super::RemoteModule;
}
/// Column accessor struct for the table `PrivateTable`.
///
/// Provides typed access to columns for query building.
pub struct PrivateTableCols {
pub name: __sdk::__query_builder::Col<PrivateTable, String>,
}
impl __sdk::__query_builder::HasCols for PrivateTable {
type Cols = PrivateTableCols;
fn cols(table_name: &'static str) -> Self::Cols {
PrivateTableCols {
name: __sdk::__query_builder::Col::new(table_name, "name"),
}
}
}
/// Indexed column accessor struct for the table `PrivateTable`.
///
/// Provides typed access to indexed columns for query building.
pub struct PrivateTableIxCols {
}
impl __sdk::__query_builder::HasIxCols for PrivateTable {
type IxCols = PrivateTableIxCols;
fn ix_cols(table_name: &'static str) -> Self::IxCols {
PrivateTableIxCols {
}
}
}
'''
"query_private_reducer.rs" = '''
// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
#![allow(unused, clippy::all)]
use spacetimedb_sdk::__codegen::{
self as __sdk,
__lib,
__sats,
__ws,
};
#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
#[sats(crate = __lib)]
pub(super) struct QueryPrivateArgs {
}
impl From<QueryPrivateArgs> for super::Reducer {
fn from(args: QueryPrivateArgs) -> Self {
Self::QueryPrivate
}
}
impl __sdk::InModule for QueryPrivateArgs {
type Module = super::RemoteModule;
}
pub struct QueryPrivateCallbackId(__sdk::CallbackId);
#[allow(non_camel_case_types)]
/// Extension trait for access to the reducer `query_private`.
///
/// Implemented for [`super::RemoteReducers`].
pub trait query_private {
/// Request that the remote module invoke the reducer `query_private` to run as soon as possible.
///
/// This method returns immediately, and errors only if we are unable to send the request.
/// The reducer will run asynchronously in the future,
/// and its status can be observed by listening for [`Self::on_query_private`] callbacks.
fn query_private(&self, ) -> __sdk::Result<()>;
/// Register a callback to run whenever we are notified of an invocation of the reducer `query_private`.
///
/// Callbacks should inspect the [`__sdk::ReducerEvent`] contained in the [`super::ReducerEventContext`]
/// to determine the reducer's status.
///
/// The returned [`QueryPrivateCallbackId`] can be passed to [`Self::remove_on_query_private`]
/// to cancel the callback.
fn on_query_private(&self, callback: impl FnMut(&super::ReducerEventContext, ) + Send + 'static) -> QueryPrivateCallbackId;
/// Cancel a callback previously registered by [`Self::on_query_private`],
/// causing it not to run in the future.
fn remove_on_query_private(&self, callback: QueryPrivateCallbackId);
}
impl query_private for super::RemoteReducers {
fn query_private(&self, ) -> __sdk::Result<()> {
self.imp.call_reducer("query_private", QueryPrivateArgs { })
}
fn on_query_private(
&self,
mut callback: impl FnMut(&super::ReducerEventContext, ) + Send + 'static,
) -> QueryPrivateCallbackId {
QueryPrivateCallbackId(self.imp.on_reducer(
"query_private",
Box::new(move |ctx: &super::ReducerEventContext| {
#[allow(irrefutable_let_patterns)]
let super::ReducerEventContext {
event: __sdk::ReducerEvent {
reducer: super::Reducer::QueryPrivate {
},
..
},
..
} = ctx else { unreachable!() };
callback(ctx, )
}),
))
}
fn remove_on_query_private(&self, callback: QueryPrivateCallbackId) {
self.imp.remove_on_reducer("query_private", callback.0)
}
}
#[allow(non_camel_case_types)]
#[doc(hidden)]
/// Extension trait for setting the call-flags for the reducer `query_private`.
///
/// Implemented for [`super::SetReducerFlags`].
///
/// This type is currently unstable and may be removed without a major version bump.
pub trait set_flags_for_query_private {
/// Set the call-reducer flags for the reducer `query_private` to `flags`.
///
/// This type is currently unstable and may be removed without a major version bump.
fn query_private(&self, flags: __ws::CallReducerFlags);
}
impl set_flags_for_query_private for super::SetReducerFlags {
fn query_private(&self, flags: __ws::CallReducerFlags) {
self.imp.set_call_reducer_flags("query_private", flags);
}
}
'''
"remove_table_type.rs" = '''
// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
#![allow(unused, clippy::all)]
use spacetimedb_sdk::__codegen::{
self as __sdk,
__lib,
__sats,
__ws,
};
#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
#[sats(crate = __lib)]
pub struct RemoveTable {
pub id: u32,
}
impl __sdk::InModule for RemoveTable {
type Module = super::RemoteModule;
}
/// Column accessor struct for the table `RemoveTable`.
///
/// Provides typed access to columns for query building.
pub struct RemoveTableCols {
pub id: __sdk::__query_builder::Col<RemoveTable, u32>,
}
impl __sdk::__query_builder::HasCols for RemoveTable {
type Cols = RemoveTableCols;
fn cols(table_name: &'static str) -> Self::Cols {
RemoveTableCols {
id: __sdk::__query_builder::Col::new(table_name, "id"),
}
}
}
/// Indexed column accessor struct for the table `RemoveTable`.
///
/// Provides typed access to indexed columns for query building.
pub struct RemoveTableIxCols {
}
impl __sdk::__query_builder::HasIxCols for RemoveTable {
type IxCols = RemoveTableIxCols;
fn ix_cols(table_name: &'static str) -> Self::IxCols {
RemoveTableIxCols {
}
}
}
'''
"repeating_test_arg_table.rs" = '''
// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
#![allow(unused, clippy::all)]
use spacetimedb_sdk::__codegen::{
self as __sdk,
__lib,
__sats,
__ws,
};
use super::repeating_test_arg_type::RepeatingTestArg;
/// Table handle for the table `repeating_test_arg`.
///
/// Obtain a handle from the [`RepeatingTestArgTableAccess::repeating_test_arg`] method on [`super::RemoteTables`],
/// like `ctx.db.repeating_test_arg()`.
///
/// Users are encouraged not to explicitly reference this type,
/// but to directly chain method calls,
/// like `ctx.db.repeating_test_arg().on_insert(...)`.
pub struct RepeatingTestArgTableHandle<'ctx> {
imp: __sdk::TableHandle<RepeatingTestArg>,
ctx: std::marker::PhantomData<&'ctx super::RemoteTables>,
}
#[allow(non_camel_case_types)]
/// Extension trait for access to the table `repeating_test_arg`.
///
/// Implemented for [`super::RemoteTables`].
pub trait RepeatingTestArgTableAccess {
#[allow(non_snake_case)]
/// Obtain a [`RepeatingTestArgTableHandle`], which mediates access to the table `repeating_test_arg`.
fn repeating_test_arg(&self) -> RepeatingTestArgTableHandle<'_>;
}
impl RepeatingTestArgTableAccess for super::RemoteTables {
fn repeating_test_arg(&self) -> RepeatingTestArgTableHandle<'_> {
RepeatingTestArgTableHandle {
imp: self.imp.get_table::<RepeatingTestArg>("repeating_test_arg"),
ctx: std::marker::PhantomData,
}
}
}
pub struct RepeatingTestArgInsertCallbackId(__sdk::CallbackId);
pub struct RepeatingTestArgDeleteCallbackId(__sdk::CallbackId);
impl<'ctx> __sdk::Table for RepeatingTestArgTableHandle<'ctx> {
type Row = RepeatingTestArg;
type EventContext = super::EventContext;
fn count(&self) -> u64 { self.imp.count() }
fn iter(&self) -> impl Iterator<Item = RepeatingTestArg> + '_ { self.imp.iter() }
type InsertCallbackId = RepeatingTestArgInsertCallbackId;
fn on_insert(
&self,
callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
) -> RepeatingTestArgInsertCallbackId {
RepeatingTestArgInsertCallbackId(self.imp.on_insert(Box::new(callback)))
}
fn remove_on_insert(&self, callback: RepeatingTestArgInsertCallbackId) {
self.imp.remove_on_insert(callback.0)
}
type DeleteCallbackId = RepeatingTestArgDeleteCallbackId;
fn on_delete(
&self,
callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
) -> RepeatingTestArgDeleteCallbackId {
RepeatingTestArgDeleteCallbackId(self.imp.on_delete(Box::new(callback)))
}
fn remove_on_delete(&self, callback: RepeatingTestArgDeleteCallbackId) {
self.imp.remove_on_delete(callback.0)
}
}
#[doc(hidden)]
pub(super) fn register_table(client_cache: &mut __sdk::ClientCache<super::RemoteModule>) {
let _table = client_cache.get_or_make_table::<RepeatingTestArg>("repeating_test_arg");
_table.add_unique_constraint::<u64>("scheduled_id", |row| &row.scheduled_id);
}
pub struct RepeatingTestArgUpdateCallbackId(__sdk::CallbackId);
impl<'ctx> __sdk::TableWithPrimaryKey for RepeatingTestArgTableHandle<'ctx> {
type UpdateCallbackId = RepeatingTestArgUpdateCallbackId;
fn on_update(
&self,
callback: impl FnMut(&Self::EventContext, &Self::Row, &Self::Row) + Send + 'static,
) -> RepeatingTestArgUpdateCallbackId {
RepeatingTestArgUpdateCallbackId(self.imp.on_update(Box::new(callback)))
}
fn remove_on_update(&self, callback: RepeatingTestArgUpdateCallbackId) {
self.imp.remove_on_update(callback.0)
}
}
#[doc(hidden)]
pub(super) fn parse_table_update(
raw_updates: __ws::TableUpdate<__ws::BsatnFormat>,
) -> __sdk::Result<__sdk::TableUpdate<RepeatingTestArg>> {
__sdk::TableUpdate::parse_table_update(raw_updates).map_err(|e| {
__sdk::InternalError::failed_parse(
"TableUpdate<RepeatingTestArg>",
"TableUpdate",
).with_cause(e).into()
})
}
/// Access to the `scheduled_id` unique index on the table `repeating_test_arg`,
/// which allows point queries on the field of the same name
/// via the [`RepeatingTestArgScheduledIdUnique::find`] method.
///
/// Users are encouraged not to explicitly reference this type,
/// but to directly chain method calls,
/// like `ctx.db.repeating_test_arg().scheduled_id().find(...)`.
pub struct RepeatingTestArgScheduledIdUnique<'ctx> {
imp: __sdk::UniqueConstraintHandle<RepeatingTestArg, u64>,
phantom: std::marker::PhantomData<&'ctx super::RemoteTables>,
}
impl<'ctx> RepeatingTestArgTableHandle<'ctx> {
/// Get a handle on the `scheduled_id` unique index on the table `repeating_test_arg`.
pub fn scheduled_id(&self) -> RepeatingTestArgScheduledIdUnique<'ctx> {
RepeatingTestArgScheduledIdUnique {
imp: self.imp.get_unique_constraint::<u64>("scheduled_id"),
phantom: std::marker::PhantomData,
}
}
}
impl<'ctx> RepeatingTestArgScheduledIdUnique<'ctx> {
/// Find the subscribed row whose `scheduled_id` column value is equal to `col_val`,
/// if such a row is present in the client cache.
pub fn find(&self, col_val: &u64) -> Option<RepeatingTestArg> {
self.imp.find(col_val)
}
}
#[allow(non_camel_case_types)]
/// Extension trait for query builder access to the table `RepeatingTestArg`.
///
/// Implemented for [`__sdk::QueryTableAccessor`].
pub trait repeating_test_argQueryTableAccess {
#[allow(non_snake_case)]
/// Get a query builder for the table `RepeatingTestArg`.
fn repeating_test_arg(&self) -> __sdk::__query_builder::Table<RepeatingTestArg>;
}
impl repeating_test_argQueryTableAccess for __sdk::QueryTableAccessor {
fn repeating_test_arg(&self) -> __sdk::__query_builder::Table<RepeatingTestArg> {
__sdk::__query_builder::Table::new("repeating_test_arg")
}
}
'''
"repeating_test_arg_type.rs" = '''
// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
#![allow(unused, clippy::all)]
use spacetimedb_sdk::__codegen::{
self as __sdk,
__lib,
__sats,
__ws,
};
#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
#[sats(crate = __lib)]
pub struct RepeatingTestArg {
pub scheduled_id: u64,
pub scheduled_at: __sdk::ScheduleAt,
pub prev_time: __sdk::Timestamp,
}
impl __sdk::InModule for RepeatingTestArg {
type Module = super::RemoteModule;
}
/// Column accessor struct for the table `RepeatingTestArg`.
///
/// Provides typed access to columns for query building.
pub struct RepeatingTestArgCols {
pub scheduled_id: __sdk::__query_builder::Col<RepeatingTestArg, u64>,
pub scheduled_at: __sdk::__query_builder::Col<RepeatingTestArg, __sdk::ScheduleAt>,
pub prev_time: __sdk::__query_builder::Col<RepeatingTestArg, __sdk::Timestamp>,
}
impl __sdk::__query_builder::HasCols for RepeatingTestArg {
type Cols = RepeatingTestArgCols;
fn cols(table_name: &'static str) -> Self::Cols {
RepeatingTestArgCols {
scheduled_id: __sdk::__query_builder::Col::new(table_name, "scheduled_id"),
scheduled_at: __sdk::__query_builder::Col::new(table_name, "scheduled_at"),
prev_time: __sdk::__query_builder::Col::new(table_name, "prev_time"),
}
}
}
/// Indexed column accessor struct for the table `RepeatingTestArg`.
///
/// Provides typed access to indexed columns for query building.
pub struct RepeatingTestArgIxCols {
pub scheduled_id: __sdk::__query_builder::IxCol<RepeatingTestArg, u64>,
}
impl __sdk::__query_builder::HasIxCols for RepeatingTestArg {
type IxCols = RepeatingTestArgIxCols;
fn ix_cols(table_name: &'static str) -> Self::IxCols {
RepeatingTestArgIxCols {
scheduled_id: __sdk::__query_builder::IxCol::new(table_name, "scheduled_id"),
}
}
}
'''
"repeating_test_reducer.rs" = '''
// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
#![allow(unused, clippy::all)]
use spacetimedb_sdk::__codegen::{
self as __sdk,
__lib,
__sats,
__ws,
};
use super::repeating_test_arg_type::RepeatingTestArg;
#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
#[sats(crate = __lib)]
pub(super) struct RepeatingTestArgs {
pub arg: RepeatingTestArg,
}
impl From<RepeatingTestArgs> for super::Reducer {
fn from(args: RepeatingTestArgs) -> Self {
Self::RepeatingTest {
arg: args.arg,
}
}
}
impl __sdk::InModule for RepeatingTestArgs {
type Module = super::RemoteModule;
}
pub struct RepeatingTestCallbackId(__sdk::CallbackId);
#[allow(non_camel_case_types)]
/// Extension trait for access to the reducer `repeating_test`.
///
/// Implemented for [`super::RemoteReducers`].
pub trait repeating_test {
/// Request that the remote module invoke the reducer `repeating_test` to run as soon as possible.
///
/// This method returns immediately, and errors only if we are unable to send the request.
/// The reducer will run asynchronously in the future,
/// and its status can be observed by listening for [`Self::on_repeating_test`] callbacks.
fn repeating_test(&self, arg: RepeatingTestArg,
) -> __sdk::Result<()>;
/// Register a callback to run whenever we are notified of an invocation of the reducer `repeating_test`.
///
/// Callbacks should inspect the [`__sdk::ReducerEvent`] contained in the [`super::ReducerEventContext`]
/// to determine the reducer's status.
///
/// The returned [`RepeatingTestCallbackId`] can be passed to [`Self::remove_on_repeating_test`]
/// to cancel the callback.
fn on_repeating_test(&self, callback: impl FnMut(&super::ReducerEventContext, &RepeatingTestArg, ) + Send + 'static) -> RepeatingTestCallbackId;
/// Cancel a callback previously registered by [`Self::on_repeating_test`],
/// causing it not to run in the future.
fn remove_on_repeating_test(&self, callback: RepeatingTestCallbackId);
}
impl repeating_test for super::RemoteReducers {
fn repeating_test(&self, arg: RepeatingTestArg,
) -> __sdk::Result<()> {
self.imp.call_reducer("repeating_test", RepeatingTestArgs { arg, })
}
fn on_repeating_test(
&self,
mut callback: impl FnMut(&super::ReducerEventContext, &RepeatingTestArg, ) + Send + 'static,
) -> RepeatingTestCallbackId {
RepeatingTestCallbackId(self.imp.on_reducer(
"repeating_test",
Box::new(move |ctx: &super::ReducerEventContext| {
#[allow(irrefutable_let_patterns)]
let super::ReducerEventContext {
event: __sdk::ReducerEvent {
reducer: super::Reducer::RepeatingTest {
arg,
},
..
},
..
} = ctx else { unreachable!() };
callback(ctx, arg, )
}),
))
}
fn remove_on_repeating_test(&self, callback: RepeatingTestCallbackId) {
self.imp.remove_on_reducer("repeating_test", callback.0)
}
}
#[allow(non_camel_case_types)]
#[doc(hidden)]
/// Extension trait for setting the call-flags for the reducer `repeating_test`.
///
/// Implemented for [`super::SetReducerFlags`].
///
/// This type is currently unstable and may be removed without a major version bump.
pub trait set_flags_for_repeating_test {
/// Set the call-reducer flags for the reducer `repeating_test` to `flags`.
///
/// This type is currently unstable and may be removed without a major version bump.
fn repeating_test(&self, flags: __ws::CallReducerFlags);
}
impl set_flags_for_repeating_test for super::SetReducerFlags {
fn repeating_test(&self, flags: __ws::CallReducerFlags) {
self.imp.set_call_reducer_flags("repeating_test", flags);
}
}
'''
"return_value_procedure.rs" = '''
// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
#![allow(unused, clippy::all)]
use spacetimedb_sdk::__codegen::{
self as __sdk,
__lib,
__sats,
__ws,
};
use super::baz_type::Baz;
#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
#[sats(crate = __lib)]
struct ReturnValueArgs {
pub foo: u64,
}
impl __sdk::InModule for ReturnValueArgs {
type Module = super::RemoteModule;
}
#[allow(non_camel_case_types)]
/// Extension trait for access to the procedure `return_value`.
///
/// Implemented for [`super::RemoteProcedures`].
pub trait return_value {
fn return_value(&self, foo: u64,
) {
self.return_value_then(foo, |_, _| {});
}
fn return_value_then(
&self,
foo: u64,
__callback: impl FnOnce(&super::ProcedureEventContext, Result<Baz, __sdk::InternalError>) + Send + 'static,
);
}
impl return_value for super::RemoteProcedures {
fn return_value_then(
&self,
foo: u64,
__callback: impl FnOnce(&super::ProcedureEventContext, Result<Baz, __sdk::InternalError>) + Send + 'static,
) {
self.imp.invoke_procedure_with_callback::<_, Baz>(
"return_value",
ReturnValueArgs { foo, },
__callback,
);
}
}
'''
"say_hello_reducer.rs" = '''
// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
#![allow(unused, clippy::all)]
use spacetimedb_sdk::__codegen::{
self as __sdk,
__lib,
__sats,
__ws,
};
#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
#[sats(crate = __lib)]
pub(super) struct SayHelloArgs {
}
impl From<SayHelloArgs> for super::Reducer {
fn from(args: SayHelloArgs) -> Self {
Self::SayHello
}
}
impl __sdk::InModule for SayHelloArgs {
type Module = super::RemoteModule;
}
pub struct SayHelloCallbackId(__sdk::CallbackId);
#[allow(non_camel_case_types)]
/// Extension trait for access to the reducer `say_hello`.
///
/// Implemented for [`super::RemoteReducers`].
pub trait say_hello {
/// Request that the remote module invoke the reducer `say_hello` to run as soon as possible.
///
/// This method returns immediately, and errors only if we are unable to send the request.
/// The reducer will run asynchronously in the future,
/// and its status can be observed by listening for [`Self::on_say_hello`] callbacks.
fn say_hello(&self, ) -> __sdk::Result<()>;
/// Register a callback to run whenever we are notified of an invocation of the reducer `say_hello`.
///
/// Callbacks should inspect the [`__sdk::ReducerEvent`] contained in the [`super::ReducerEventContext`]
/// to determine the reducer's status.
///
/// The returned [`SayHelloCallbackId`] can be passed to [`Self::remove_on_say_hello`]
/// to cancel the callback.
fn on_say_hello(&self, callback: impl FnMut(&super::ReducerEventContext, ) + Send + 'static) -> SayHelloCallbackId;
/// Cancel a callback previously registered by [`Self::on_say_hello`],
/// causing it not to run in the future.
fn remove_on_say_hello(&self, callback: SayHelloCallbackId);
}
impl say_hello for super::RemoteReducers {
fn say_hello(&self, ) -> __sdk::Result<()> {
self.imp.call_reducer("say_hello", SayHelloArgs { })
}
fn on_say_hello(
&self,
mut callback: impl FnMut(&super::ReducerEventContext, ) + Send + 'static,
) -> SayHelloCallbackId {
SayHelloCallbackId(self.imp.on_reducer(
"say_hello",
Box::new(move |ctx: &super::ReducerEventContext| {
#[allow(irrefutable_let_patterns)]
let super::ReducerEventContext {
event: __sdk::ReducerEvent {
reducer: super::Reducer::SayHello {
},
..
},
..
} = ctx else { unreachable!() };
callback(ctx, )
}),
))
}
fn remove_on_say_hello(&self, callback: SayHelloCallbackId) {
self.imp.remove_on_reducer("say_hello", callback.0)
}
}
#[allow(non_camel_case_types)]
#[doc(hidden)]
/// Extension trait for setting the call-flags for the reducer `say_hello`.
///
/// Implemented for [`super::SetReducerFlags`].
///
/// This type is currently unstable and may be removed without a major version bump.
pub trait set_flags_for_say_hello {
/// Set the call-reducer flags for the reducer `say_hello` to `flags`.
///
/// This type is currently unstable and may be removed without a major version bump.
fn say_hello(&self, flags: __ws::CallReducerFlags);
}
impl set_flags_for_say_hello for super::SetReducerFlags {
fn say_hello(&self, flags: __ws::CallReducerFlags) {
self.imp.set_call_reducer_flags("say_hello", flags);
}
}
'''
"sleep_one_second_procedure.rs" = '''
// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
#![allow(unused, clippy::all)]
use spacetimedb_sdk::__codegen::{
self as __sdk,
__lib,
__sats,
__ws,
};
#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
#[sats(crate = __lib)]
struct SleepOneSecondArgs {
}
impl __sdk::InModule for SleepOneSecondArgs {
type Module = super::RemoteModule;
}
#[allow(non_camel_case_types)]
/// Extension trait for access to the procedure `sleep_one_second`.
///
/// Implemented for [`super::RemoteProcedures`].
pub trait sleep_one_second {
fn sleep_one_second(&self, ) {
self.sleep_one_second_then( |_, _| {});
}
fn sleep_one_second_then(
&self,
__callback: impl FnOnce(&super::ProcedureEventContext, Result<(), __sdk::InternalError>) + Send + 'static,
);
}
impl sleep_one_second for super::RemoteProcedures {
fn sleep_one_second_then(
&self,
__callback: impl FnOnce(&super::ProcedureEventContext, Result<(), __sdk::InternalError>) + Send + 'static,
) {
self.imp.invoke_procedure_with_callback::<_, ()>(
"sleep_one_second",
SleepOneSecondArgs { },
__callback,
);
}
}
'''
"table_to_remove_table.rs" = '''
// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
#![allow(unused, clippy::all)]
use spacetimedb_sdk::__codegen::{
self as __sdk,
__lib,
__sats,
__ws,
};
use super::remove_table_type::RemoveTable;
/// Table handle for the table `table_to_remove`.
///
/// Obtain a handle from the [`TableToRemoveTableAccess::table_to_remove`] method on [`super::RemoteTables`],
/// like `ctx.db.table_to_remove()`.
///
/// Users are encouraged not to explicitly reference this type,
/// but to directly chain method calls,
/// like `ctx.db.table_to_remove().on_insert(...)`.
pub struct TableToRemoveTableHandle<'ctx> {
imp: __sdk::TableHandle<RemoveTable>,
ctx: std::marker::PhantomData<&'ctx super::RemoteTables>,
}
#[allow(non_camel_case_types)]
/// Extension trait for access to the table `table_to_remove`.
///
/// Implemented for [`super::RemoteTables`].
pub trait TableToRemoveTableAccess {
#[allow(non_snake_case)]
/// Obtain a [`TableToRemoveTableHandle`], which mediates access to the table `table_to_remove`.
fn table_to_remove(&self) -> TableToRemoveTableHandle<'_>;
}
impl TableToRemoveTableAccess for super::RemoteTables {
fn table_to_remove(&self) -> TableToRemoveTableHandle<'_> {
TableToRemoveTableHandle {
imp: self.imp.get_table::<RemoveTable>("table_to_remove"),
ctx: std::marker::PhantomData,
}
}
}
pub struct TableToRemoveInsertCallbackId(__sdk::CallbackId);
pub struct TableToRemoveDeleteCallbackId(__sdk::CallbackId);
impl<'ctx> __sdk::Table for TableToRemoveTableHandle<'ctx> {
type Row = RemoveTable;
type EventContext = super::EventContext;
fn count(&self) -> u64 { self.imp.count() }
fn iter(&self) -> impl Iterator<Item = RemoveTable> + '_ { self.imp.iter() }
type InsertCallbackId = TableToRemoveInsertCallbackId;
fn on_insert(
&self,
callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
) -> TableToRemoveInsertCallbackId {
TableToRemoveInsertCallbackId(self.imp.on_insert(Box::new(callback)))
}
fn remove_on_insert(&self, callback: TableToRemoveInsertCallbackId) {
self.imp.remove_on_insert(callback.0)
}
type DeleteCallbackId = TableToRemoveDeleteCallbackId;
fn on_delete(
&self,
callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
) -> TableToRemoveDeleteCallbackId {
TableToRemoveDeleteCallbackId(self.imp.on_delete(Box::new(callback)))
}
fn remove_on_delete(&self, callback: TableToRemoveDeleteCallbackId) {
self.imp.remove_on_delete(callback.0)
}
}
#[doc(hidden)]
pub(super) fn register_table(client_cache: &mut __sdk::ClientCache<super::RemoteModule>) {
let _table = client_cache.get_or_make_table::<RemoveTable>("table_to_remove");
}
#[doc(hidden)]
pub(super) fn parse_table_update(
raw_updates: __ws::TableUpdate<__ws::BsatnFormat>,
) -> __sdk::Result<__sdk::TableUpdate<RemoveTable>> {
__sdk::TableUpdate::parse_table_update(raw_updates).map_err(|e| {
__sdk::InternalError::failed_parse(
"TableUpdate<RemoveTable>",
"TableUpdate",
).with_cause(e).into()
})
}
#[allow(non_camel_case_types)]
/// Extension trait for query builder access to the table `RemoveTable`.
///
/// Implemented for [`__sdk::QueryTableAccessor`].
pub trait table_to_removeQueryTableAccess {
#[allow(non_snake_case)]
/// Get a query builder for the table `RemoveTable`.
fn table_to_remove(&self) -> __sdk::__query_builder::Table<RemoveTable>;
}
impl table_to_removeQueryTableAccess for __sdk::QueryTableAccessor {
fn table_to_remove(&self) -> __sdk::__query_builder::Table<RemoveTable> {
__sdk::__query_builder::Table::new("table_to_remove")
}
}
'''
"test_a_table.rs" = '''
// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
#![allow(unused, clippy::all)]
use spacetimedb_sdk::__codegen::{
self as __sdk,
__lib,
__sats,
__ws,
};
use super::test_a_type::TestA;
/// Table handle for the table `test_a`.
///
/// Obtain a handle from the [`TestATableAccess::test_a`] method on [`super::RemoteTables`],
/// like `ctx.db.test_a()`.
///
/// Users are encouraged not to explicitly reference this type,
/// but to directly chain method calls,
/// like `ctx.db.test_a().on_insert(...)`.
pub struct TestATableHandle<'ctx> {
imp: __sdk::TableHandle<TestA>,
ctx: std::marker::PhantomData<&'ctx super::RemoteTables>,
}
#[allow(non_camel_case_types)]
/// Extension trait for access to the table `test_a`.
///
/// Implemented for [`super::RemoteTables`].
pub trait TestATableAccess {
#[allow(non_snake_case)]
/// Obtain a [`TestATableHandle`], which mediates access to the table `test_a`.
fn test_a(&self) -> TestATableHandle<'_>;
}
impl TestATableAccess for super::RemoteTables {
fn test_a(&self) -> TestATableHandle<'_> {
TestATableHandle {
imp: self.imp.get_table::<TestA>("test_a"),
ctx: std::marker::PhantomData,
}
}
}
pub struct TestAInsertCallbackId(__sdk::CallbackId);
pub struct TestADeleteCallbackId(__sdk::CallbackId);
impl<'ctx> __sdk::Table for TestATableHandle<'ctx> {
type Row = TestA;
type EventContext = super::EventContext;
fn count(&self) -> u64 { self.imp.count() }
fn iter(&self) -> impl Iterator<Item = TestA> + '_ { self.imp.iter() }
type InsertCallbackId = TestAInsertCallbackId;
fn on_insert(
&self,
callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
) -> TestAInsertCallbackId {
TestAInsertCallbackId(self.imp.on_insert(Box::new(callback)))
}
fn remove_on_insert(&self, callback: TestAInsertCallbackId) {
self.imp.remove_on_insert(callback.0)
}
type DeleteCallbackId = TestADeleteCallbackId;
fn on_delete(
&self,
callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
) -> TestADeleteCallbackId {
TestADeleteCallbackId(self.imp.on_delete(Box::new(callback)))
}
fn remove_on_delete(&self, callback: TestADeleteCallbackId) {
self.imp.remove_on_delete(callback.0)
}
}
#[doc(hidden)]
pub(super) fn register_table(client_cache: &mut __sdk::ClientCache<super::RemoteModule>) {
let _table = client_cache.get_or_make_table::<TestA>("test_a");
}
#[doc(hidden)]
pub(super) fn parse_table_update(
raw_updates: __ws::TableUpdate<__ws::BsatnFormat>,
) -> __sdk::Result<__sdk::TableUpdate<TestA>> {
__sdk::TableUpdate::parse_table_update(raw_updates).map_err(|e| {
__sdk::InternalError::failed_parse(
"TableUpdate<TestA>",
"TableUpdate",
).with_cause(e).into()
})
}
#[allow(non_camel_case_types)]
/// Extension trait for query builder access to the table `TestA`.
///
/// Implemented for [`__sdk::QueryTableAccessor`].
pub trait test_aQueryTableAccess {
#[allow(non_snake_case)]
/// Get a query builder for the table `TestA`.
fn test_a(&self) -> __sdk::__query_builder::Table<TestA>;
}
impl test_aQueryTableAccess for __sdk::QueryTableAccessor {
fn test_a(&self) -> __sdk::__query_builder::Table<TestA> {
__sdk::__query_builder::Table::new("test_a")
}
}
'''
"test_a_type.rs" = '''
// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
#![allow(unused, clippy::all)]
use spacetimedb_sdk::__codegen::{
self as __sdk,
__lib,
__sats,
__ws,
};
#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
#[sats(crate = __lib)]
pub struct TestA {
pub x: u32,
pub y: u32,
pub z: String,
}
impl __sdk::InModule for TestA {
type Module = super::RemoteModule;
}
/// Column accessor struct for the table `TestA`.
///
/// Provides typed access to columns for query building.
pub struct TestACols {
pub x: __sdk::__query_builder::Col<TestA, u32>,
pub y: __sdk::__query_builder::Col<TestA, u32>,
pub z: __sdk::__query_builder::Col<TestA, String>,
}
impl __sdk::__query_builder::HasCols for TestA {
type Cols = TestACols;
fn cols(table_name: &'static str) -> Self::Cols {
TestACols {
x: __sdk::__query_builder::Col::new(table_name, "x"),
y: __sdk::__query_builder::Col::new(table_name, "y"),
z: __sdk::__query_builder::Col::new(table_name, "z"),
}
}
}
/// Indexed column accessor struct for the table `TestA`.
///
/// Provides typed access to indexed columns for query building.
pub struct TestAIxCols {
pub x: __sdk::__query_builder::IxCol<TestA, u32>,
}
impl __sdk::__query_builder::HasIxCols for TestA {
type IxCols = TestAIxCols;
fn ix_cols(table_name: &'static str) -> Self::IxCols {
TestAIxCols {
x: __sdk::__query_builder::IxCol::new(table_name, "x"),
}
}
}
'''
"test_b_type.rs" = '''
// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
#![allow(unused, clippy::all)]
use spacetimedb_sdk::__codegen::{
self as __sdk,
__lib,
__sats,
__ws,
};
#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
#[sats(crate = __lib)]
pub struct TestB {
pub foo: String,
}
impl __sdk::InModule for TestB {
type Module = super::RemoteModule;
}
'''
"test_btree_index_args_reducer.rs" = '''
// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
#![allow(unused, clippy::all)]
use spacetimedb_sdk::__codegen::{
self as __sdk,
__lib,
__sats,
__ws,
};
#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
#[sats(crate = __lib)]
pub(super) struct TestBtreeIndexArgsArgs {
}
impl From<TestBtreeIndexArgsArgs> for super::Reducer {
fn from(args: TestBtreeIndexArgsArgs) -> Self {
Self::TestBtreeIndexArgs
}
}
impl __sdk::InModule for TestBtreeIndexArgsArgs {
type Module = super::RemoteModule;
}
pub struct TestBtreeIndexArgsCallbackId(__sdk::CallbackId);
#[allow(non_camel_case_types)]
/// Extension trait for access to the reducer `test_btree_index_args`.
///
/// Implemented for [`super::RemoteReducers`].
pub trait test_btree_index_args {
/// Request that the remote module invoke the reducer `test_btree_index_args` to run as soon as possible.
///
/// This method returns immediately, and errors only if we are unable to send the request.
/// The reducer will run asynchronously in the future,
/// and its status can be observed by listening for [`Self::on_test_btree_index_args`] callbacks.
fn test_btree_index_args(&self, ) -> __sdk::Result<()>;
/// Register a callback to run whenever we are notified of an invocation of the reducer `test_btree_index_args`.
///
/// Callbacks should inspect the [`__sdk::ReducerEvent`] contained in the [`super::ReducerEventContext`]
/// to determine the reducer's status.
///
/// The returned [`TestBtreeIndexArgsCallbackId`] can be passed to [`Self::remove_on_test_btree_index_args`]
/// to cancel the callback.
fn on_test_btree_index_args(&self, callback: impl FnMut(&super::ReducerEventContext, ) + Send + 'static) -> TestBtreeIndexArgsCallbackId;
/// Cancel a callback previously registered by [`Self::on_test_btree_index_args`],
/// causing it not to run in the future.
fn remove_on_test_btree_index_args(&self, callback: TestBtreeIndexArgsCallbackId);
}
impl test_btree_index_args for super::RemoteReducers {
fn test_btree_index_args(&self, ) -> __sdk::Result<()> {
self.imp.call_reducer("test_btree_index_args", TestBtreeIndexArgsArgs { })
}
fn on_test_btree_index_args(
&self,
mut callback: impl FnMut(&super::ReducerEventContext, ) + Send + 'static,
) -> TestBtreeIndexArgsCallbackId {
TestBtreeIndexArgsCallbackId(self.imp.on_reducer(
"test_btree_index_args",
Box::new(move |ctx: &super::ReducerEventContext| {
#[allow(irrefutable_let_patterns)]
let super::ReducerEventContext {
event: __sdk::ReducerEvent {
reducer: super::Reducer::TestBtreeIndexArgs {
},
..
},
..
} = ctx else { unreachable!() };
callback(ctx, )
}),
))
}
fn remove_on_test_btree_index_args(&self, callback: TestBtreeIndexArgsCallbackId) {
self.imp.remove_on_reducer("test_btree_index_args", callback.0)
}
}
#[allow(non_camel_case_types)]
#[doc(hidden)]
/// Extension trait for setting the call-flags for the reducer `test_btree_index_args`.
///
/// Implemented for [`super::SetReducerFlags`].
///
/// This type is currently unstable and may be removed without a major version bump.
pub trait set_flags_for_test_btree_index_args {
/// Set the call-reducer flags for the reducer `test_btree_index_args` to `flags`.
///
/// This type is currently unstable and may be removed without a major version bump.
fn test_btree_index_args(&self, flags: __ws::CallReducerFlags);
}
impl set_flags_for_test_btree_index_args for super::SetReducerFlags {
fn test_btree_index_args(&self, flags: __ws::CallReducerFlags) {
self.imp.set_call_reducer_flags("test_btree_index_args", flags);
}
}
'''
"test_d_table.rs" = '''
// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
#![allow(unused, clippy::all)]
use spacetimedb_sdk::__codegen::{
self as __sdk,
__lib,
__sats,
__ws,
};
use super::test_d_type::TestD;
use super::namespace_test_c_type::NamespaceTestC;
/// Table handle for the table `test_d`.
///
/// Obtain a handle from the [`TestDTableAccess::test_d`] method on [`super::RemoteTables`],
/// like `ctx.db.test_d()`.
///
/// Users are encouraged not to explicitly reference this type,
/// but to directly chain method calls,
/// like `ctx.db.test_d().on_insert(...)`.
pub struct TestDTableHandle<'ctx> {
imp: __sdk::TableHandle<TestD>,
ctx: std::marker::PhantomData<&'ctx super::RemoteTables>,
}
#[allow(non_camel_case_types)]
/// Extension trait for access to the table `test_d`.
///
/// Implemented for [`super::RemoteTables`].
pub trait TestDTableAccess {
#[allow(non_snake_case)]
/// Obtain a [`TestDTableHandle`], which mediates access to the table `test_d`.
fn test_d(&self) -> TestDTableHandle<'_>;
}
impl TestDTableAccess for super::RemoteTables {
fn test_d(&self) -> TestDTableHandle<'_> {
TestDTableHandle {
imp: self.imp.get_table::<TestD>("test_d"),
ctx: std::marker::PhantomData,
}
}
}
pub struct TestDInsertCallbackId(__sdk::CallbackId);
pub struct TestDDeleteCallbackId(__sdk::CallbackId);
impl<'ctx> __sdk::Table for TestDTableHandle<'ctx> {
type Row = TestD;
type EventContext = super::EventContext;
fn count(&self) -> u64 { self.imp.count() }
fn iter(&self) -> impl Iterator<Item = TestD> + '_ { self.imp.iter() }
type InsertCallbackId = TestDInsertCallbackId;
fn on_insert(
&self,
callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
) -> TestDInsertCallbackId {
TestDInsertCallbackId(self.imp.on_insert(Box::new(callback)))
}
fn remove_on_insert(&self, callback: TestDInsertCallbackId) {
self.imp.remove_on_insert(callback.0)
}
type DeleteCallbackId = TestDDeleteCallbackId;
fn on_delete(
&self,
callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
) -> TestDDeleteCallbackId {
TestDDeleteCallbackId(self.imp.on_delete(Box::new(callback)))
}
fn remove_on_delete(&self, callback: TestDDeleteCallbackId) {
self.imp.remove_on_delete(callback.0)
}
}
#[doc(hidden)]
pub(super) fn register_table(client_cache: &mut __sdk::ClientCache<super::RemoteModule>) {
let _table = client_cache.get_or_make_table::<TestD>("test_d");
}
#[doc(hidden)]
pub(super) fn parse_table_update(
raw_updates: __ws::TableUpdate<__ws::BsatnFormat>,
) -> __sdk::Result<__sdk::TableUpdate<TestD>> {
__sdk::TableUpdate::parse_table_update(raw_updates).map_err(|e| {
__sdk::InternalError::failed_parse(
"TableUpdate<TestD>",
"TableUpdate",
).with_cause(e).into()
})
}
#[allow(non_camel_case_types)]
/// Extension trait for query builder access to the table `TestD`.
///
/// Implemented for [`__sdk::QueryTableAccessor`].
pub trait test_dQueryTableAccess {
#[allow(non_snake_case)]
/// Get a query builder for the table `TestD`.
fn test_d(&self) -> __sdk::__query_builder::Table<TestD>;
}
impl test_dQueryTableAccess for __sdk::QueryTableAccessor {
fn test_d(&self) -> __sdk::__query_builder::Table<TestD> {
__sdk::__query_builder::Table::new("test_d")
}
}
'''
"test_d_type.rs" = '''
// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
#![allow(unused, clippy::all)]
use spacetimedb_sdk::__codegen::{
self as __sdk,
__lib,
__sats,
__ws,
};
use super::namespace_test_c_type::NamespaceTestC;
#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
#[sats(crate = __lib)]
pub struct TestD {
pub test_c: Option::<NamespaceTestC>,
}
impl __sdk::InModule for TestD {
type Module = super::RemoteModule;
}
/// Column accessor struct for the table `TestD`.
///
/// Provides typed access to columns for query building.
pub struct TestDCols {
pub test_c: __sdk::__query_builder::Col<TestD, Option::<NamespaceTestC>>,
}
impl __sdk::__query_builder::HasCols for TestD {
type Cols = TestDCols;
fn cols(table_name: &'static str) -> Self::Cols {
TestDCols {
test_c: __sdk::__query_builder::Col::new(table_name, "test_c"),
}
}
}
/// Indexed column accessor struct for the table `TestD`.
///
/// Provides typed access to indexed columns for query building.
pub struct TestDIxCols {
}
impl __sdk::__query_builder::HasIxCols for TestD {
type IxCols = TestDIxCols;
fn ix_cols(table_name: &'static str) -> Self::IxCols {
TestDIxCols {
}
}
}
'''
"test_e_table.rs" = '''
// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
#![allow(unused, clippy::all)]
use spacetimedb_sdk::__codegen::{
self as __sdk,
__lib,
__sats,
__ws,
};
use super::test_e_type::TestE;
/// Table handle for the table `test_e`.
///
/// Obtain a handle from the [`TestETableAccess::test_e`] method on [`super::RemoteTables`],
/// like `ctx.db.test_e()`.
///
/// Users are encouraged not to explicitly reference this type,
/// but to directly chain method calls,
/// like `ctx.db.test_e().on_insert(...)`.
pub struct TestETableHandle<'ctx> {
imp: __sdk::TableHandle<TestE>,
ctx: std::marker::PhantomData<&'ctx super::RemoteTables>,
}
#[allow(non_camel_case_types)]
/// Extension trait for access to the table `test_e`.
///
/// Implemented for [`super::RemoteTables`].
pub trait TestETableAccess {
#[allow(non_snake_case)]
/// Obtain a [`TestETableHandle`], which mediates access to the table `test_e`.
fn test_e(&self) -> TestETableHandle<'_>;
}
impl TestETableAccess for super::RemoteTables {
fn test_e(&self) -> TestETableHandle<'_> {
TestETableHandle {
imp: self.imp.get_table::<TestE>("test_e"),
ctx: std::marker::PhantomData,
}
}
}
pub struct TestEInsertCallbackId(__sdk::CallbackId);
pub struct TestEDeleteCallbackId(__sdk::CallbackId);
impl<'ctx> __sdk::Table for TestETableHandle<'ctx> {
type Row = TestE;
type EventContext = super::EventContext;
fn count(&self) -> u64 { self.imp.count() }
fn iter(&self) -> impl Iterator<Item = TestE> + '_ { self.imp.iter() }
type InsertCallbackId = TestEInsertCallbackId;
fn on_insert(
&self,
callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
) -> TestEInsertCallbackId {
TestEInsertCallbackId(self.imp.on_insert(Box::new(callback)))
}
fn remove_on_insert(&self, callback: TestEInsertCallbackId) {
self.imp.remove_on_insert(callback.0)
}
type DeleteCallbackId = TestEDeleteCallbackId;
fn on_delete(
&self,
callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
) -> TestEDeleteCallbackId {
TestEDeleteCallbackId(self.imp.on_delete(Box::new(callback)))
}
fn remove_on_delete(&self, callback: TestEDeleteCallbackId) {
self.imp.remove_on_delete(callback.0)
}
}
#[doc(hidden)]
pub(super) fn register_table(client_cache: &mut __sdk::ClientCache<super::RemoteModule>) {
let _table = client_cache.get_or_make_table::<TestE>("test_e");
_table.add_unique_constraint::<u64>("id", |row| &row.id);
}
pub struct TestEUpdateCallbackId(__sdk::CallbackId);
impl<'ctx> __sdk::TableWithPrimaryKey for TestETableHandle<'ctx> {
type UpdateCallbackId = TestEUpdateCallbackId;
fn on_update(
&self,
callback: impl FnMut(&Self::EventContext, &Self::Row, &Self::Row) + Send + 'static,
) -> TestEUpdateCallbackId {
TestEUpdateCallbackId(self.imp.on_update(Box::new(callback)))
}
fn remove_on_update(&self, callback: TestEUpdateCallbackId) {
self.imp.remove_on_update(callback.0)
}
}
#[doc(hidden)]
pub(super) fn parse_table_update(
raw_updates: __ws::TableUpdate<__ws::BsatnFormat>,
) -> __sdk::Result<__sdk::TableUpdate<TestE>> {
__sdk::TableUpdate::parse_table_update(raw_updates).map_err(|e| {
__sdk::InternalError::failed_parse(
"TableUpdate<TestE>",
"TableUpdate",
).with_cause(e).into()
})
}
/// Access to the `id` unique index on the table `test_e`,
/// which allows point queries on the field of the same name
/// via the [`TestEIdUnique::find`] method.
///
/// Users are encouraged not to explicitly reference this type,
/// but to directly chain method calls,
/// like `ctx.db.test_e().id().find(...)`.
pub struct TestEIdUnique<'ctx> {
imp: __sdk::UniqueConstraintHandle<TestE, u64>,
phantom: std::marker::PhantomData<&'ctx super::RemoteTables>,
}
impl<'ctx> TestETableHandle<'ctx> {
/// Get a handle on the `id` unique index on the table `test_e`.
pub fn id(&self) -> TestEIdUnique<'ctx> {
TestEIdUnique {
imp: self.imp.get_unique_constraint::<u64>("id"),
phantom: std::marker::PhantomData,
}
}
}
impl<'ctx> TestEIdUnique<'ctx> {
/// Find the subscribed row whose `id` column value is equal to `col_val`,
/// if such a row is present in the client cache.
pub fn find(&self, col_val: &u64) -> Option<TestE> {
self.imp.find(col_val)
}
}
#[allow(non_camel_case_types)]
/// Extension trait for query builder access to the table `TestE`.
///
/// Implemented for [`__sdk::QueryTableAccessor`].
pub trait test_eQueryTableAccess {
#[allow(non_snake_case)]
/// Get a query builder for the table `TestE`.
fn test_e(&self) -> __sdk::__query_builder::Table<TestE>;
}
impl test_eQueryTableAccess for __sdk::QueryTableAccessor {
fn test_e(&self) -> __sdk::__query_builder::Table<TestE> {
__sdk::__query_builder::Table::new("test_e")
}
}
'''
"test_e_type.rs" = '''
// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
#![allow(unused, clippy::all)]
use spacetimedb_sdk::__codegen::{
self as __sdk,
__lib,
__sats,
__ws,
};
#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
#[sats(crate = __lib)]
pub struct TestE {
pub id: u64,
pub name: String,
}
impl __sdk::InModule for TestE {
type Module = super::RemoteModule;
}
/// Column accessor struct for the table `TestE`.
///
/// Provides typed access to columns for query building.
pub struct TestECols {
pub id: __sdk::__query_builder::Col<TestE, u64>,
pub name: __sdk::__query_builder::Col<TestE, String>,
}
impl __sdk::__query_builder::HasCols for TestE {
type Cols = TestECols;
fn cols(table_name: &'static str) -> Self::Cols {
TestECols {
id: __sdk::__query_builder::Col::new(table_name, "id"),
name: __sdk::__query_builder::Col::new(table_name, "name"),
}
}
}
/// Indexed column accessor struct for the table `TestE`.
///
/// Provides typed access to indexed columns for query building.
pub struct TestEIxCols {
pub id: __sdk::__query_builder::IxCol<TestE, u64>,
pub name: __sdk::__query_builder::IxCol<TestE, String>,
}
impl __sdk::__query_builder::HasIxCols for TestE {
type IxCols = TestEIxCols;
fn ix_cols(table_name: &'static str) -> Self::IxCols {
TestEIxCols {
id: __sdk::__query_builder::IxCol::new(table_name, "id"),
name: __sdk::__query_builder::IxCol::new(table_name, "name"),
}
}
}
'''
"test_f_table.rs" = '''
// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
#![allow(unused, clippy::all)]
use spacetimedb_sdk::__codegen::{
self as __sdk,
__lib,
__sats,
__ws,
};
use super::test_foobar_type::TestFoobar;
use super::foobar_type::Foobar;
/// Table handle for the table `test_f`.
///
/// Obtain a handle from the [`TestFTableAccess::test_f`] method on [`super::RemoteTables`],
/// like `ctx.db.test_f()`.
///
/// Users are encouraged not to explicitly reference this type,
/// but to directly chain method calls,
/// like `ctx.db.test_f().on_insert(...)`.
pub struct TestFTableHandle<'ctx> {
imp: __sdk::TableHandle<TestFoobar>,
ctx: std::marker::PhantomData<&'ctx super::RemoteTables>,
}
#[allow(non_camel_case_types)]
/// Extension trait for access to the table `test_f`.
///
/// Implemented for [`super::RemoteTables`].
pub trait TestFTableAccess {
#[allow(non_snake_case)]
/// Obtain a [`TestFTableHandle`], which mediates access to the table `test_f`.
fn test_f(&self) -> TestFTableHandle<'_>;
}
impl TestFTableAccess for super::RemoteTables {
fn test_f(&self) -> TestFTableHandle<'_> {
TestFTableHandle {
imp: self.imp.get_table::<TestFoobar>("test_f"),
ctx: std::marker::PhantomData,
}
}
}
pub struct TestFInsertCallbackId(__sdk::CallbackId);
pub struct TestFDeleteCallbackId(__sdk::CallbackId);
impl<'ctx> __sdk::Table for TestFTableHandle<'ctx> {
type Row = TestFoobar;
type EventContext = super::EventContext;
fn count(&self) -> u64 { self.imp.count() }
fn iter(&self) -> impl Iterator<Item = TestFoobar> + '_ { self.imp.iter() }
type InsertCallbackId = TestFInsertCallbackId;
fn on_insert(
&self,
callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
) -> TestFInsertCallbackId {
TestFInsertCallbackId(self.imp.on_insert(Box::new(callback)))
}
fn remove_on_insert(&self, callback: TestFInsertCallbackId) {
self.imp.remove_on_insert(callback.0)
}
type DeleteCallbackId = TestFDeleteCallbackId;
fn on_delete(
&self,
callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
) -> TestFDeleteCallbackId {
TestFDeleteCallbackId(self.imp.on_delete(Box::new(callback)))
}
fn remove_on_delete(&self, callback: TestFDeleteCallbackId) {
self.imp.remove_on_delete(callback.0)
}
}
#[doc(hidden)]
pub(super) fn register_table(client_cache: &mut __sdk::ClientCache<super::RemoteModule>) {
let _table = client_cache.get_or_make_table::<TestFoobar>("test_f");
}
#[doc(hidden)]
pub(super) fn parse_table_update(
raw_updates: __ws::TableUpdate<__ws::BsatnFormat>,
) -> __sdk::Result<__sdk::TableUpdate<TestFoobar>> {
__sdk::TableUpdate::parse_table_update(raw_updates).map_err(|e| {
__sdk::InternalError::failed_parse(
"TableUpdate<TestFoobar>",
"TableUpdate",
).with_cause(e).into()
})
}
#[allow(non_camel_case_types)]
/// Extension trait for query builder access to the table `TestFoobar`.
///
/// Implemented for [`__sdk::QueryTableAccessor`].
pub trait test_fQueryTableAccess {
#[allow(non_snake_case)]
/// Get a query builder for the table `TestFoobar`.
fn test_f(&self) -> __sdk::__query_builder::Table<TestFoobar>;
}
impl test_fQueryTableAccess for __sdk::QueryTableAccessor {
fn test_f(&self) -> __sdk::__query_builder::Table<TestFoobar> {
__sdk::__query_builder::Table::new("test_f")
}
}
'''
"test_foobar_type.rs" = '''
// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
#![allow(unused, clippy::all)]
use spacetimedb_sdk::__codegen::{
self as __sdk,
__lib,
__sats,
__ws,
};
use super::foobar_type::Foobar;
#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
#[sats(crate = __lib)]
pub struct TestFoobar {
pub field: Foobar,
}
impl __sdk::InModule for TestFoobar {
type Module = super::RemoteModule;
}
/// Column accessor struct for the table `TestFoobar`.
///
/// Provides typed access to columns for query building.
pub struct TestFoobarCols {
pub field: __sdk::__query_builder::Col<TestFoobar, Foobar>,
}
impl __sdk::__query_builder::HasCols for TestFoobar {
type Cols = TestFoobarCols;
fn cols(table_name: &'static str) -> Self::Cols {
TestFoobarCols {
field: __sdk::__query_builder::Col::new(table_name, "field"),
}
}
}
/// Indexed column accessor struct for the table `TestFoobar`.
///
/// Provides typed access to indexed columns for query building.
pub struct TestFoobarIxCols {
}
impl __sdk::__query_builder::HasIxCols for TestFoobar {
type IxCols = TestFoobarIxCols;
fn ix_cols(table_name: &'static str) -> Self::IxCols {
TestFoobarIxCols {
}
}
}
'''
"test_reducer.rs" = '''
// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
#![allow(unused, clippy::all)]
use spacetimedb_sdk::__codegen::{
self as __sdk,
__lib,
__sats,
__ws,
};
use super::test_a_type::TestA;
use super::test_b_type::TestB;
use super::namespace_test_c_type::NamespaceTestC;
use super::namespace_test_f_type::NamespaceTestF;
#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
#[sats(crate = __lib)]
pub(super) struct TestArgs {
pub arg: TestA,
pub arg_2: TestB,
pub arg_3: NamespaceTestC,
pub arg_4: NamespaceTestF,
}
impl From<TestArgs> for super::Reducer {
fn from(args: TestArgs) -> Self {
Self::Test {
arg: args.arg,
arg_2: args.arg_2,
arg_3: args.arg_3,
arg_4: args.arg_4,
}
}
}
impl __sdk::InModule for TestArgs {
type Module = super::RemoteModule;
}
pub struct TestCallbackId(__sdk::CallbackId);
#[allow(non_camel_case_types)]
/// Extension trait for access to the reducer `test`.
///
/// Implemented for [`super::RemoteReducers`].
pub trait test {
/// Request that the remote module invoke the reducer `test` to run as soon as possible.
///
/// This method returns immediately, and errors only if we are unable to send the request.
/// The reducer will run asynchronously in the future,
/// and its status can be observed by listening for [`Self::on_test`] callbacks.
fn test(&self, arg: TestA,
arg_2: TestB,
arg_3: NamespaceTestC,
arg_4: NamespaceTestF,
) -> __sdk::Result<()>;
/// Register a callback to run whenever we are notified of an invocation of the reducer `test`.
///
/// Callbacks should inspect the [`__sdk::ReducerEvent`] contained in the [`super::ReducerEventContext`]
/// to determine the reducer's status.
///
/// The returned [`TestCallbackId`] can be passed to [`Self::remove_on_test`]
/// to cancel the callback.
fn on_test(&self, callback: impl FnMut(&super::ReducerEventContext, &TestA, &TestB, &NamespaceTestC, &NamespaceTestF, ) + Send + 'static) -> TestCallbackId;
/// Cancel a callback previously registered by [`Self::on_test`],
/// causing it not to run in the future.
fn remove_on_test(&self, callback: TestCallbackId);
}
impl test for super::RemoteReducers {
fn test(&self, arg: TestA,
arg_2: TestB,
arg_3: NamespaceTestC,
arg_4: NamespaceTestF,
) -> __sdk::Result<()> {
self.imp.call_reducer("test", TestArgs { arg, arg_2, arg_3, arg_4, })
}
fn on_test(
&self,
mut callback: impl FnMut(&super::ReducerEventContext, &TestA, &TestB, &NamespaceTestC, &NamespaceTestF, ) + Send + 'static,
) -> TestCallbackId {
TestCallbackId(self.imp.on_reducer(
"test",
Box::new(move |ctx: &super::ReducerEventContext| {
#[allow(irrefutable_let_patterns)]
let super::ReducerEventContext {
event: __sdk::ReducerEvent {
reducer: super::Reducer::Test {
arg, arg_2, arg_3, arg_4,
},
..
},
..
} = ctx else { unreachable!() };
callback(ctx, arg, arg_2, arg_3, arg_4, )
}),
))
}
fn remove_on_test(&self, callback: TestCallbackId) {
self.imp.remove_on_reducer("test", callback.0)
}
}
#[allow(non_camel_case_types)]
#[doc(hidden)]
/// Extension trait for setting the call-flags for the reducer `test`.
///
/// Implemented for [`super::SetReducerFlags`].
///
/// This type is currently unstable and may be removed without a major version bump.
pub trait set_flags_for_test {
/// Set the call-reducer flags for the reducer `test` to `flags`.
///
/// This type is currently unstable and may be removed without a major version bump.
fn test(&self, flags: __ws::CallReducerFlags);
}
impl set_flags_for_test for super::SetReducerFlags {
fn test(&self, flags: __ws::CallReducerFlags) {
self.imp.set_call_reducer_flags("test", flags);
}
}
'''
"with_tx_procedure.rs" = '''
// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
#![allow(unused, clippy::all)]
use spacetimedb_sdk::__codegen::{
self as __sdk,
__lib,
__sats,
__ws,
};
#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
#[sats(crate = __lib)]
struct WithTxArgs {
}
impl __sdk::InModule for WithTxArgs {
type Module = super::RemoteModule;
}
#[allow(non_camel_case_types)]
/// Extension trait for access to the procedure `with_tx`.
///
/// Implemented for [`super::RemoteProcedures`].
pub trait with_tx {
fn with_tx(&self, ) {
self.with_tx_then( |_, _| {});
}
fn with_tx_then(
&self,
__callback: impl FnOnce(&super::ProcedureEventContext, Result<(), __sdk::InternalError>) + Send + 'static,
);
}
impl with_tx for super::RemoteProcedures {
fn with_tx_then(
&self,
__callback: impl FnOnce(&super::ProcedureEventContext, Result<(), __sdk::InternalError>) + Send + 'static,
) {
self.imp.invoke_procedure_with_callback::<_, ()>(
"with_tx",
WithTxArgs { },
__callback,
);
}
}
'''
Reference in New Issue View Git Blame Copy Permalink