Generate read-only table handles for #[table] (#3364)

# Description of Changes

<!-- Please describe your change, mention any related tickets, and so on
here. -->

The `#[table]` macro now generates read-only table and index handles.

# API and ABI breaking changes

<!-- If this is an API or ABI breaking change, please apply the
corresponding GitHub label. -->

None

# Expected complexity level and risk

<!--
How complicated do you think these changes are? Grade on a scale from 1
to 5,
where 1 is a trivial change, and 5 is a deep-reaching and complex
change.

This complexity rating applies not only to the complexity apparent in
the diff,
but also to its interactions with existing and future code.

If you answered more than a 2, explain what is complex about the PR,
and what other components it interacts with in potentially concerning
ways. -->

1

# Testing

<!-- Describe any testing you've done, and any testing you'd like your
reviewers to do,
so that you're confident that all the changes work as expected! -->

- [x] positive and negative test cases using
`ReducerContext::as_read_only()`

Author: joshua-spacetime

crates/bindings-macro/src/table.rs

@@ -275,6 +275,41 @@ impl IndexArg {
     }
 }
 
+enum AccessorType {
+    Read,
+    ReadWrite,
+}
+
+impl AccessorType {
+    fn unique(&self) -> proc_macro2::TokenStream {
+        match self {
+            AccessorType::Read => quote!(spacetimedb::UniqueColumnReadOnly),
+            AccessorType::ReadWrite => quote!(spacetimedb::UniqueColumn),
+        }
+    }
+
+    fn range(&self) -> proc_macro2::TokenStream {
+        match self {
+            AccessorType::Read => quote!(spacetimedb::RangedIndexReadOnly),
+            AccessorType::ReadWrite => quote!(spacetimedb::RangedIndex),
+        }
+    }
+
+    fn unique_doc_typename(&self) -> &'static str {
+        match self {
+            AccessorType::Read => "UniqueColumnReadOnly",
+            AccessorType::ReadWrite => "UniqueColumn",
+        }
+    }
+
+    fn range_doc_typename(&self) -> &'static str {
+        match self {
+            AccessorType::Read => "RangedIndexReadOnly",
+            AccessorType::ReadWrite => "RangedIndex",
+        }
+    }
+}
+
 struct ValidatedIndex<'a> {
     index_name: String,
     accessor_name: &'a Ident,
@@ -312,46 +347,71 @@ impl ValidatedIndex<'_> {
         })
     }
 
-    fn accessor(&self, vis: &syn::Visibility, row_type_ident: &Ident) -> TokenStream {
+    fn accessor(
+        &self,
+        vis: &syn::Visibility,
+        row_type_ident: &Ident,
+        tbl_type_ident: &Ident,
+        flavor: AccessorType,
+    ) -> TokenStream {
         let cols = match &self.kind {
             ValidatedIndexType::BTree { cols } => &**cols,
             ValidatedIndexType::Direct { col } => slice::from_ref(col),
         };
         if self.is_unique {
             assert_eq!(cols.len(), 1);
-            let col = cols[0];
-            self.accessor_unique(col, row_type_ident)
+            self.unique_accessor(cols[0], row_type_ident, tbl_type_ident, flavor)
         } else {
-            self.accessor_general(vis, row_type_ident, cols)
+            self.range_accessor(vis, row_type_ident, tbl_type_ident, cols, flavor)
         }
     }
 
-    fn accessor_unique(&self, col: &Column<'_>, row_type_ident: &Ident) -> TokenStream {
+    fn unique_accessor(
+        &self,
+        col: &Column<'_>,
+        row_type_ident: &Ident,
+        tbl_type_ident: &Ident,
+        flavor: AccessorType,
+    ) -> TokenStream {
         let index_ident = self.accessor_name;
         let vis = col.vis;
         let col_ty = col.ty;
         let column_ident = col.ident;
 
+        let unique_ty = flavor.unique();
+        let tbl_token = quote!(#tbl_type_ident);
+        let doc_type = flavor.unique_doc_typename();
+
         let doc = format!(
-            "Gets the [`UniqueColumn`][spacetimedb::UniqueColumn] for the \
+            "Gets the [`{doc_type}`][spacetimedb::{doc_type}] for the \
              [`{column_ident}`][{row_type_ident}::{column_ident}] column."
         );
         quote! {
             #[doc = #doc]
-            #vis fn #column_ident(&self) -> spacetimedb::UniqueColumn<Self, #col_ty, __indices::#index_ident> {
-                spacetimedb::UniqueColumn::__NEW
+            #vis fn #column_ident(&self) -> #unique_ty<#tbl_token, #col_ty, __indices::#index_ident> {
+                #unique_ty::__NEW
             }
         }
     }
 
-    fn accessor_general(&self, vis: &syn::Visibility, row_type_ident: &Ident, cols: &[&Column<'_>]) -> TokenStream {
+    fn range_accessor(
+        &self,
+        vis: &syn::Visibility,
+        row_type_ident: &Ident,
+        tbl_type_ident: &Ident,
+        cols: &[&Column<'_>],
+        flavor: AccessorType,
+    ) -> TokenStream {
         let index_ident = self.accessor_name;
-        let col_tys = cols.iter().map(|col| col.ty);
+        let col_tys = cols.iter().map(|c| c.ty);
+
+        let range_ty = flavor.range();
+        let tbl_token = quote!(#tbl_type_ident);
+        let doc_type = flavor.range_doc_typename();
+
         let mut doc = format!(
-            "Gets the `{index_ident}` [`RangedIndex`][spacetimedb::RangedIndex] as defined \
-             on this table. \n\
-             \n\
-             This B-tree index is defined on the following columns, in order:\n"
+            "Gets the `{index_ident}` [`{doc_type}`][spacetimedb::{doc_type}] as defined \
+             on this table.\n\nThis B-tree index is defined on the following columns, in order:\n"
         );
         for col in cols {
             use std::fmt::Write;
@@ -363,10 +423,11 @@ impl ValidatedIndex<'_> {
             )
             .unwrap();
         }
+
         quote! {
             #[doc = #doc]
-            #vis fn #index_ident(&self) -> spacetimedb::RangedIndex<Self, (#(#col_tys,)*), __indices::#index_ident> {
-                spacetimedb::RangedIndex::__NEW
+            #vis fn #index_ident(&self) -> #range_ty<#tbl_token, (#(#col_tys,)*), __indices::#index_ident> {
+                #range_ty::__NEW
             }
         }
     }
@@ -521,6 +582,7 @@ pub(crate) fn table_impl(mut args: TableArgs, item: &syn::DeriveInput) -> syn::R
 
     let original_struct_ident = sats_ty.ident;
     let table_ident = &args.name;
+    let view_trait_ident = format_ident!("{}__view", table_ident);
     let table_name = table_ident.unraw().to_string();
     let sats::SatsTypeData::Product(fields) = &sats_ty.data else {
         return Err(syn::Error::new(Span::call_site(), "spacetimedb table must be a struct"));
@@ -656,9 +718,15 @@ pub(crate) fn table_impl(mut args: TableArgs, item: &syn::DeriveInput) -> syn::R
     indices.sort_by_key(|index| !index.is_unique);
 
     let tablehandle_ident = format_ident!("{}__TableHandle", table_ident);
+    let viewhandle_ident = format_ident!("{}__ViewHandle", table_ident);
 
     let index_descs = indices.iter().map(|index| index.desc());
-    let index_accessors = indices.iter().map(|index| index.accessor(vis, original_struct_ident));
+    let index_accessors_rw = indices
+        .iter()
+        .map(|index| index.accessor(vis, original_struct_ident, &tablehandle_ident, AccessorType::ReadWrite));
+    let index_accessors_ro = indices
+        .iter()
+        .map(|index| index.accessor(vis, original_struct_ident, &tablehandle_ident, AccessorType::Read));
     let index_marker_types = indices.iter().map(|index| index.marker_type(vis, &tablehandle_ident));
 
     // Generate `integrate_generated_columns`
@@ -831,12 +899,31 @@ pub(crate) fn table_impl(mut args: TableArgs, item: &syn::DeriveInput) -> syn::R
         }
     };
 
+    let trait_def_view = quote_spanned! {table_ident.span()=>
+        #[allow(non_camel_case_types, dead_code)]
+        #vis trait #view_trait_ident {
+            fn #table_ident(&self) -> &#viewhandle_ident;
+        }
+        impl #view_trait_ident for spacetimedb::LocalReadOnly {
+            #[inline]
+            fn #table_ident(&self) -> &#viewhandle_ident {
+                &#viewhandle_ident {}
+            }
+        }
+    };
+
     let tablehandle_def = quote! {
         #[allow(non_camel_case_types)]
         #[non_exhaustive]
         #vis struct #tablehandle_ident {}
     };
 
+    let viewhandle_def = quote! {
+        #[allow(non_camel_case_types)]
+        #[non_exhaustive]
+        #vis struct #viewhandle_ident {}
+    };
+
     let emission = quote! {
         const _: () = {
             #(let _ = <#field_types as spacetimedb::rt::TableColumn>::_ITEM;)*
@@ -845,12 +932,18 @@ pub(crate) fn table_impl(mut args: TableArgs, item: &syn::DeriveInput) -> syn::R
         };
 
         #trait_def
+        #trait_def_view
 
         #tablehandle_def
+        #viewhandle_def
 
         const _: () = {
             impl #tablehandle_ident {
-                #(#index_accessors)*
+                #(#index_accessors_rw)*
+            }
+
+            impl #viewhandle_ident {
+                #(#index_accessors_ro)*
             }
 
             #tabletype_impl

crates/bindings/src/lib.rs

@@ -41,7 +41,10 @@ pub use spacetimedb_lib::TimeDuration;
 pub use spacetimedb_lib::Timestamp;
 pub use spacetimedb_primitives::TableId;
 pub use sys::Errno;
-pub use table::{AutoIncOverflow, RangedIndex, Table, TryInsertError, UniqueColumn, UniqueConstraintViolation};
+pub use table::{
+    AutoIncOverflow, RangedIndex, RangedIndexReadOnly, Table, TryInsertError, UniqueColumn, UniqueColumnReadOnly,
+    UniqueConstraintViolation,
+};
 
 pub type ReducerResult = core::result::Result<(), Box<str>>;
 
@@ -663,6 +666,22 @@ pub use spacetimedb_bindings_macro::table;
 #[doc(inline)]
 pub use spacetimedb_bindings_macro::reducer;
 
+/// One of two possible types that can be passed as the first argument to a `#[view]`.
+/// The other is [`ViewContext`].
+/// Use this type if the view does not depend on the caller's identity.
+pub struct AnonymousViewContext {
+    pub db: LocalReadOnly,
+}
+
+/// One of two possible types that can be passed as the first argument to a `#[view]`.
+/// The other is [`AnonymousViewContext`].
+/// Use this type if the view depends on the caller's identity.
+pub struct ViewContext {
+    pub sender: Identity,
+    pub connection_id: Option<ConnectionId>,
+    pub db: LocalReadOnly,
+}
+
 /// The context that any reducer is provided with.
 ///
 /// This must be the first argument of the reducer. Clients of the module will
@@ -760,6 +779,20 @@ impl ReducerContext {
         // which reads the module identity out of the `InstanceEnv`.
         Identity::from_byte_array(spacetimedb_bindings_sys::identity())
     }
+
+    /// Create an anonymous (no sender) read-only view context
+    pub fn as_anonymous_read_only(&self) -> AnonymousViewContext {
+        AnonymousViewContext { db: LocalReadOnly {} }
+    }
+
+    /// Create a sender-bound read-only view context using this reducer's caller.
+    pub fn as_read_only(&self) -> ViewContext {
+        ViewContext {
+            sender: self.sender,
+            connection_id: self.connection_id,
+            db: LocalReadOnly {},
+        }
+    }
 }
 
 /// A handle on a database with a particular table schema.
@@ -796,6 +829,10 @@ impl DbContext for ReducerContext {
 #[non_exhaustive]
 pub struct Local {}
 
+/// The read-only version of [`Local`]
+#[non_exhaustive]
+pub struct LocalReadOnly {}
+
 // #[cfg(target_arch = "wasm32")]
 // #[global_allocator]
 // static ALLOC: wee_alloc::WeeAlloc = wee_alloc::WeeAlloc::INIT;