Add counter to collection and map views (#4616)

## Motivation

Add some missing APIs + improve GraphQL code for collections

## Proposal

* support count() for collections
* make SetView similar to MapView (**GraphQL API breaking change**)
* (nit) remove unnecessary Clone bounds

## Test Plan

CI + tested manually

## Release Plan

These changes should be backported to the latest `testnet` branch, then
be released in a new SDK.

(Note that the SDK will be breaking certain queries but that's ok)

Author: ma2bd

linera-service-graphql-client/gql/service_schema.graphql

@@ -229,10 +229,12 @@ A block height to identify blocks in a chain
 scalar BlockHeight
 
 type BucketQueueView_BlockHeight_e824a938 {
+	count: Int!
 	entries(count: Int): [BlockHeight!]!
 }
 
 type BucketQueueView_TimestampedBundleInInbox_5a630c55 {
+	count: Int!
 	entries(count: Int): [TimestampedBundleInInbox!]!
 }
 
@@ -368,7 +370,7 @@ type ChainStateExtendedView {
 	"""
 	Unskippable bundles that have been removed but are still in the queue.
 	"""
-	removedUnskippableBundles: [BundleInInbox!]!
+	removedUnskippableBundles: SetView_BundleInInbox_092a4377!
 	"""
 	The heights of previous blocks that sent messages to the same recipients.
 	"""
@@ -658,10 +660,12 @@ A scalar that can represent any JSON Object value.
 scalar JSONObject
 
 type LogView_ChainAndHeight_7af83576 {
+	count: Int!
 	entries(start: Int, end: Int): [ChainAndHeight!]!
 }
 
 type LogView_CryptoHash_87fbb60c {
+	count: Int!
 	entries(start: Int, end: Int): [CryptoHash!]!
 }
 
@@ -707,42 +711,49 @@ input MapInput_StreamIdInput_b7c3909d {
 
 type MapView_AccountOwner_Amount_11ef1379 {
 	keys(count: Int): [AccountOwner!]!
+	count: Int!
 	entry(key: AccountOwner!): Entry_AccountOwner_Amount_aaf96548!
 	entries(input: MapInput_AccountOwner_d6668c53): [Entry_AccountOwner_Amount_aaf96548!]!
 }
 
 type MapView_BlobId_Blob_3711e760 {
 	keys(count: Int): [BlobId!]!
+	count: Int!
 	entry(key: BlobId!): Entry_BlobId_Blob_9f0b41f3!
 	entries(input: MapInput_BlobId_4d2a0555): [Entry_BlobId_Blob_9f0b41f3!]!
 }
 
 type MapView_BlobId_Blob_9f0b41f3 {
 	keys(count: Int): [BlobId!]!
+	count: Int!
 	entry(key: BlobId!): Entry_BlobId_Blob_50b95aa1!
 	entries(input: MapInput_BlobId_4d2a0555): [Entry_BlobId_Blob_50b95aa1!]!
 }
 
 type MapView_BlockHeight_CryptoHash_1bae6d76 {
 	keys(count: Int): [BlockHeight!]!
+	count: Int!
 	entry(key: BlockHeight!): Entry_BlockHeight_CryptoHash_74e16b71!
 	entries(input: MapInput_BlockHeight_e824a938): [Entry_BlockHeight_CryptoHash_74e16b71!]!
 }
 
 type MapView_ChainId_BlockHeight_f2e56e12 {
 	keys(count: Int): [ChainId!]!
+	count: Int!
 	entry(key: ChainId!): Entry_ChainId_BlockHeight_2fe78645!
 	entries(input: MapInput_ChainId_37f83aa9): [Entry_ChainId_BlockHeight_2fe78645!]!
 }
 
 type MapView_StreamId_BlockHeight_e6657ad9 {
 	keys(count: Int): [StreamId!]!
+	count: Int!
 	entry(key: StreamIdInput!): Entry_StreamId_BlockHeight_50cd702e!
 	entries(input: MapInput_StreamIdInput_b7c3909d): [Entry_StreamId_BlockHeight_50cd702e!]!
 }
 
 type MapView_StreamId_Int_3d7f5335 {
 	keys(count: Int): [StreamId!]!
+	count: Int!
 	entry(key: StreamIdInput!): Entry_StreamId_Int_459c4ec3!
 	entries(input: MapInput_StreamIdInput_b7c3909d): [Entry_StreamId_Int_459c4ec3!]!
 }
@@ -1249,23 +1260,27 @@ type QueryRoot {
 }
 
 type QueueView_MessageBundle_f4399f0b {
+	count: Int!
 	entries(count: Int): [MessageBundle!]!
 }
 
 type ReentrantCollectionView_AccountOwner_PendingBlobsView_d58d342d {
 	keys: [AccountOwner!]!
+	count: Int!
 	entry(key: AccountOwner!): Entry_AccountOwner_PendingBlobsView_5d91edcf!
 	entries(input: MapInput_AccountOwner_d6668c53): [Entry_AccountOwner_PendingBlobsView_5d91edcf!]!
 }
 
 type ReentrantCollectionView_ChainId_InboxStateView_466640be {
 	keys: [ChainId!]!
+	count: Int!
 	entry(key: ChainId!): Entry_ChainId_InboxStateView_a9e4d828!
 	entries(input: MapInput_ChainId_37f83aa9): [Entry_ChainId_InboxStateView_a9e4d828!]!
 }
 
 type ReentrantCollectionView_ChainId_OutboxStateView_06c2376d {
 	keys: [ChainId!]!
+	count: Int!
 	entry(key: ChainId!): Entry_ChainId_OutboxStateView_855dcf53!
 	entries(input: MapInput_ChainId_37f83aa9): [Entry_ChainId_OutboxStateView_855dcf53!]!
 }
@@ -1280,6 +1295,11 @@ A number to identify successive attempts to decide a value in a consensus protoc
 """
 scalar Round
 
+type SetView_BundleInInbox_092a4377 {
+	elements(count: Int): [BundleInInbox!]!
+	count: Int!
+}
+
 """
 An event stream ID.
 """

linera-views/src/views/bucket_queue_view.rs

@@ -746,6 +746,11 @@ mod graphql {
         C: Send + Sync,
         T: serde::ser::Serialize + serde::de::DeserializeOwned + Clone + Send + Sync,
     {
+        #[graphql(derived(name = "count"))]
+        async fn count_(&self) -> Result<u32, async_graphql::Error> {
+            Ok(self.count() as u32)
+        }
+
         async fn entries(&self, count: Option<usize>) -> async_graphql::Result<Vec<T>> {
             Ok(self
                 .read_front(count.unwrap_or_else(|| self.count()))

linera-views/src/views/collection_view.rs

@@ -1152,7 +1152,7 @@ impl<I: DeserializeOwned, W: View> CollectionView<W::Context, I, W> {
 
 impl<I, W: HashableView> HashableView for CollectionView<W::Context, I, W>
 where
-    I: Clone + Send + Sync + Serialize + DeserializeOwned,
+    I: Send + Sync + Serialize + DeserializeOwned,
 {
     type Hasher = sha3::Sha3_256;
 
@@ -1615,6 +1615,11 @@ mod graphql {
             Ok(self.indices().await?)
         }
 
+        #[graphql(derived(name = "count"))]
+        async fn count_(&self) -> Result<u32, async_graphql::Error> {
+            Ok(self.count().await? as u32)
+        }
+
         async fn entry(
             &self,
             key: K,
@@ -1675,6 +1680,11 @@ mod graphql {
             Ok(self.indices().await?)
         }
 
+        #[graphql(derived(name = "count"))]
+        async fn count_(&self) -> Result<u32, async_graphql::Error> {
+            Ok(self.count().await? as u32)
+        }
+
         async fn entry(
             &self,
             key: K,

linera-views/src/views/log_view.rs

@@ -398,6 +398,11 @@ mod graphql {
     where
         T: serde::ser::Serialize + serde::de::DeserializeOwned + Clone + Send + Sync,
     {
+        #[graphql(derived(name = "count"))]
+        async fn count_(&self) -> Result<u32, async_graphql::Error> {
+            Ok(self.count() as u32)
+        }
+
         async fn entries(
             &self,
             start: Option<usize>,

linera-views/src/views/map_view.rs

@@ -2083,6 +2083,11 @@ mod graphql {
             })
         }
 
+        #[graphql(derived(name = "count"))]
+        async fn count_(&self) -> Result<u32, async_graphql::Error> {
+            Ok(self.count().await? as u32)
+        }
+
         async fn entry(&self, key: I) -> Result<Entry<I, Option<V>>, async_graphql::Error> {
             Ok(Entry {
                 value: self.get(&key).await?,

linera-views/src/views/queue_view.rs

@@ -503,6 +503,11 @@ mod graphql {
     where
         T: serde::ser::Serialize + serde::de::DeserializeOwned + Clone + Send + Sync,
     {
+        #[graphql(derived(name = "count"))]
+        async fn count_(&self) -> Result<u32, async_graphql::Error> {
+            Ok(self.count() as u32)
+        }
+
         async fn entries(&self, count: Option<usize>) -> async_graphql::Result<Vec<T>> {
             Ok(self
                 .read_front(count.unwrap_or_else(|| self.count()))

linera-views/src/views/reentrant_collection_view.rs

@@ -2122,6 +2122,11 @@ mod graphql {
             Ok(self.indices().await?)
         }
 
+        #[graphql(derived(name = "count"))]
+        async fn count_(&self) -> Result<u32, async_graphql::Error> {
+            Ok(self.count().await? as u32)
+        }
+
         async fn entry(
             &self,
             key: K,

linera-views/src/views/set_view.rs

@@ -795,7 +795,7 @@ where
 impl<C, I> CustomSetView<C, I>
 where
     C: Context,
-    I: Sync + Clone + Send + CustomSerialize,
+    I: Sync + Send + CustomSerialize,
 {
     /// Returns the list of indices in the set. The order is determined by the custom
     /// serialization.
@@ -939,70 +939,74 @@ pub type HashedCustomSetView<C, I> =
 mod graphql {
     use std::borrow::Cow;
 
+    use serde::{de::DeserializeOwned, Serialize};
+
     use super::{CustomSetView, SetView};
-    use crate::context::Context;
+    use crate::{
+        common::CustomSerialize,
+        context::Context,
+        graphql::{hash_name, mangle},
+    };
 
-    impl<C: Context, I: async_graphql::OutputType> async_graphql::OutputType for SetView<C, I>
-    where
-        I: serde::ser::Serialize + serde::de::DeserializeOwned + Clone + Send + Sync,
-    {
+    impl<C: Send + Sync, I: async_graphql::OutputType> async_graphql::TypeName for SetView<C, I> {
         fn type_name() -> Cow<'static, str> {
-            format!("[{}]", I::qualified_type_name()).into()
+            format!(
+                "SetView_{}_{:08x}",
+                mangle(I::type_name()),
+                hash_name::<I>(),
+            )
+            .into()
         }
+    }
 
-        fn qualified_type_name() -> String {
-            format!("[{}]!", I::qualified_type_name())
+    #[async_graphql::Object(cache_control(no_cache), name_type)]
+    impl<C, I> SetView<C, I>
+    where
+        C: Context,
+        I: Send + Sync + Serialize + DeserializeOwned + async_graphql::OutputType,
+    {
+        async fn elements(&self, count: Option<usize>) -> Result<Vec<I>, async_graphql::Error> {
+            let mut indices = self.indices().await?;
+            if let Some(count) = count {
+                indices.truncate(count);
+            }
+            Ok(indices)
         }
 
-        fn create_type_info(registry: &mut async_graphql::registry::Registry) -> String {
-            I::create_type_info(registry);
-            Self::qualified_type_name()
+        #[graphql(derived(name = "count"))]
+        async fn count_(&self) -> Result<u32, async_graphql::Error> {
+            Ok(self.count().await? as u32)
         }
+    }
 
-        async fn resolve(
-            &self,
-            ctx: &async_graphql::ContextSelectionSet<'_>,
-            field: &async_graphql::Positioned<async_graphql::parser::types::Field>,
-        ) -> async_graphql::ServerResult<async_graphql::Value> {
-            let indices = self
-                .indices()
-                .await
-                .map_err(|e| async_graphql::Error::from(e).into_server_error(ctx.item.pos))?;
-            let indices_len = indices.len();
-            async_graphql::resolver_utils::resolve_list(ctx, field, indices, Some(indices_len))
-                .await
+    impl<C: Send + Sync, I: async_graphql::OutputType> async_graphql::TypeName for CustomSetView<C, I> {
+        fn type_name() -> Cow<'static, str> {
+            format!(
+                "CustomSetView_{}_{:08x}",
+                mangle(I::type_name()),
+                hash_name::<I>(),
+            )
+            .into()
         }
     }
 
-    impl<C: Context, I: async_graphql::OutputType> async_graphql::OutputType for CustomSetView<C, I>
+    #[async_graphql::Object(cache_control(no_cache), name_type)]
+    impl<C, I> CustomSetView<C, I>
     where
-        I: crate::common::CustomSerialize + Clone + Send + Sync,
+        C: Context,
+        I: Send + Sync + CustomSerialize + async_graphql::OutputType,
     {
-        fn type_name() -> Cow<'static, str> {
-            format!("[{}]", I::qualified_type_name()).into()
-        }
-
-        fn qualified_type_name() -> String {
-            format!("[{}]!", I::qualified_type_name())
-        }
-
-        fn create_type_info(registry: &mut async_graphql::registry::Registry) -> String {
-            I::create_type_info(registry);
-            Self::qualified_type_name()
+        async fn elements(&self, count: Option<usize>) -> Result<Vec<I>, async_graphql::Error> {
+            let mut indices = self.indices().await?;
+            if let Some(count) = count {
+                indices.truncate(count);
+            }
+            Ok(indices)
         }
 
-        async fn resolve(
-            &self,
-            ctx: &async_graphql::ContextSelectionSet<'_>,
-            field: &async_graphql::Positioned<async_graphql::parser::types::Field>,
-        ) -> async_graphql::ServerResult<async_graphql::Value> {
-            let indices = self
-                .indices()
-                .await
-                .map_err(|e| async_graphql::Error::from(e).into_server_error(ctx.item.pos))?;
-            let indices_len = indices.len();
-            async_graphql::resolver_utils::resolve_list(ctx, field, indices, Some(indices_len))
-                .await
+        #[graphql(derived(name = "count"))]
+        async fn count_(&self) -> Result<u32, async_graphql::Error> {
+            Ok(self.count().await? as u32)
         }
     }
 }