Consider a SessionBucket trait to better enable strong typing

[maxcountryman]

After announcing this crate there was a lengthy discussion regarding the strength of typing possible with key-value interfaces like tower-sessions (specifically we currently use an intermediate of HashMap<String, serde_json::Value>).

To illustrate one approach to stronger typing, we have https://github.com/maxcountryman/tower-sessions/blob/main/examples/strongly-typed.rs.

Parts of this implementation could be encapsulated as a trait. For example, SessionBucket:

trait SessionBucket {
    const BUCKET_DATA_KEY: &'static str;

    type BucketData: Default + Clone + Serialize + for<'a> Deserialize<'a>;

    fn get_bucket_data(session: &Session) -> Self::BucketData {
        session
            .get(Self::BUCKET_DATA_KEY)
            .expect("infallible")
            .unwrap_or_default()
    }

    fn update_session(session: &Session, bucket_data: &Self::BucketData) {
        session
            .insert(Self::BUCKET_DATA_KEY, bucket_data.clone())
            .expect("infallible")
    }
}

Implementors would define their own BucketData and extractor and implement SessionBucket for it. In our example above, we have Guest paired with GuestData.

#[derive(Clone, Deserialize, Serialize)]
struct GuestData {
    id: Uuid,
    pageviews: usize,
    first_seen: OffsetDateTime,
    last_seen: OffsetDateTime,
}

impl SessionBucket for Guest {
    const BUCKET_DATA_KEY: &'static str = "guest_data";
    type BucketData = GuestData;
}

I've used the word "bucket" here because part of what this enables is strongly typed buckets that live in the same session. In other words, you might define a set of several buckets, living alongside each other in the session. This is useful for name-spacing related data and ensuring it adheres to the user-defined structure. You might imagine an analytics bucket, a site preferences bucket, anonymous and authenticated user buckets, and so on.

It's unclear to me if this is something that should be brought into the crate directly.