kjuulh/crunch
1
0
Fork 0
Code Issues 1 Pull Requests 2 Packages Projects Releases Wiki Activity

feat: with complete example and generated code

Browse Source 
Signed-off-by: kjuulh <contact@kjuulh.io>
This commit is contained in:
Kasper Juul Hermansen 2023-09-24 21:57:24 +02:00
parent c32aab5630
commit dd024ec8fb
Signed by: kjuulh
GPG Key ID: 9AA7BC13CE474394
13 changed files with 106 additions and 114 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Cargo.lock generated
View File

@ -635,6 +635,7 @@ dependencies = [
"anyhow",
"async-trait",
"futures",
"prost 0.12.1",
"thiserror",
"tokio",
"uuid",

17
crates/crunch-codegen/src/lib.rs
View File

@ -64,28 +64,28 @@ impl Node {
let padding = " ".repeat(indent * 4);
let mut message_tokens = Vec::new();
if let Some(file) = &self.file {
if let Some(messages) = &self.messages {
for message in messages.iter() {
let tokens: genco::lang::rust::Tokens = quote! {
$['\r']$(&padding)impl ::crunch::Serializer for $(message) {
$['\r']$(&padding)impl ::crunch::traits::Serializer for $(message) {
$['\r']$(&padding) fn serialize(&self) -> Result<Vec<u8>, ::crunch::errors::SerializeError> {
$['\r']$(&padding) todo!()
$['\r']$(&padding) Ok(self.encode_to_vec())
$['\r']$(&padding) }
$['\r']$(&padding)}
$['\r']$(&padding)impl ::crunch::Deserializer for $(message) {
$['\r']$(&padding) fn deserialize(_raw: Vec<u8>) -> Result<Self, ::crunch::errors::DeserializeError>
$['\r']$(&padding)impl ::crunch::traits::Deserializer for $(message) {
$['\r']$(&padding) fn deserialize(raw: Vec<u8>) -> Result<Self, ::crunch::errors::DeserializeError>
$['\r']$(&padding) where
$['\r']$(&padding) Self: Sized,
$['\r']$(&padding) {
$['\r']$(&padding) todo!()
$['\r']$(&padding) let output = Self::decode(raw.as_slice()).map_err(|e| ::crunch::errors::DeserializeError::ProtoErr(e))?;
$['\r']$(&padding) Ok(output)
$['\r']$(&padding) }
$['\r']$(&padding)}
$['\r']$(&padding)
$['\r']$(&padding)impl Event for $(message) {
$['\r']$(&padding)impl crunch::traits::Event for $(message) {
$['\r']$(&padding) fn event_info() -> ::crunch::traits::EventInfo {
$['\r']$(&padding) EventInfo {
$['\r']$(&padding) ::crunch::traits::EventInfo {
$['\r']$(&padding) domain: "my-domain",
$['\r']$(&padding) entity_type: "my-entity-type",
$['\r']$(&padding) event_name: "my-event-name",
@ -100,6 +100,7 @@ impl Node {
quote! {
$['\r']$(&padding)pub mod $(&self.segment) {
use prost::Message;
$['\r']$(&padding)include!($(quoted(file)));
$['\r']$(&padding)$(for tokens in message_tokens join ($['\r']) => $tokens)
$['\r']$(&padding)}

1
crates/crunch-traits/Cargo.toml
View File

@ -12,3 +12,4 @@ thiserror.workspace = true
async-trait.workspace = true
uuid.workspace = true
futures.workspace = true
prost.workspace = true

4
crates/crunch-traits/src/errors.rs
View File

@ -8,8 +8,10 @@ pub enum SerializeError {
#[derive(Error, Debug)]
pub enum DeserializeError {
#[error("failed to serialize {0}")]
#[error("failed to deserialize {0}")]
FailedToDeserialize(anyhow::Error),
#[error("failed to deserialize {0}")]
ProtoErr(prost::DecodeError),
}
#[derive(Error, Debug)]

2
crates/crunch-traits/src/lib.rs
View File

@ -1,4 +1,4 @@
use std::{fmt::Display};
use std::fmt::Display;
use async_trait::async_trait;
use errors::{DeserializeError, PersistenceError, SerializeError};

18
crates/crunch/src/impls.rs
View File

@ -56,13 +56,17 @@ impl crunch_traits::Persistence for InMemoryPersistence {
}
async fn get(&self, event_id: &str) -> Result<Option<(EventInfo, Vec<u8>)>, PersistenceError> {
Ok(self
.store
.read()
.await
.get(event_id)
.filter(|m| m.state == MsgState::Pending).cloned()
.map(|m| (m.info, m.msg)))
let store = self.store.read().await;
let event = match store.get(event_id).filter(|m| m.state == MsgState::Pending) {
Some(event) => event,
None => return Ok(None),
};
let (content, _) = crunch_envelope::proto::unwrap(event.msg.as_slice())
.map_err(|e| PersistenceError::GetErr(anyhow::anyhow!(e)))?;
Ok(Some((event.info, content)))
}
async fn update_published(&self, event_id: &str) -> Result<(), PersistenceError> {

2
crates/crunch/src/subscriber.rs
View File

@ -1,4 +1,4 @@
use crunch_traits::{Event};
use crunch_traits::Event;
use futures::StreamExt;
use crate::{errors, Transport};

2
examples/basic-setup/crunch.toml
View File

@ -5,4 +5,4 @@ codegen = ["rust"]
[[publish]]
schema-path = "schemas/crunch"
output-path = "src/crunch"
output-path = "src/gencrunch"

58
examples/basic-setup/src/crunch/mod.rs
View File

@ -1,58 +0,0 @@
pub mod basic {
pub mod my_event {
include!("basic.my_event.rs");
impl ::crunch::Serializer for MyEvent {
fn serialize(&self) -> Result<Vec<u8>, ::crunch::errors::SerializeError> {
todo!()
}
}
impl ::crunch::Deserializer for MyEvent {
fn deserialize(_raw: Vec<u8>) -> Result<Self, ::crunch::errors::DeserializeError>
where
Self: Sized,
{
todo!()
}
}
impl Event for MyEvent {
fn event_info() -> ::crunch::traits::EventInfo {
EventInfo {
domain: "my-domain",
entity_type: "my-entity-type",
event_name: "my-event-name",
}
}
}
}
pub mod includes {
pub mod my_include {
include!("basic.includes.my_include.rs");
impl ::crunch::Serializer for MyInclude {
fn serialize(&self) -> Result<Vec<u8>, ::crunch::errors::SerializeError> {
todo!()
}
}
impl ::crunch::Deserializer for MyInclude {
fn deserialize(_raw: Vec<u8>) -> Result<Self, ::crunch::errors::DeserializeError>
where
Self: Sized,
{
todo!()
}
}
impl Event for MyInclude {
fn event_info() -> ::crunch::traits::EventInfo {
EventInfo {
domain: "my-domain",
entity_type: "my-entity-type",
event_name: "my-event-name",
}
}
}
}
}
}

0
examples/basic-setup/src/crunch/basic.includes.my_include.rs → examples/basic-setup/src/gencrunch/basic.includes.my_include.rs
View File

0
examples/basic-setup/src/crunch/basic.my_event.rs → examples/basic-setup/src/gencrunch/basic.my_event.rs
View File

60
examples/basic-setup/src/gencrunch/mod.rs Normal file
View File

@ -0,0 +1,60 @@
pub mod basic {
pub mod includes {
pub mod my_include { use prost::Message;
include!("basic.includes.my_include.rs");
impl ::crunch::traits::Serializer for MyInclude {
fn serialize(&self) -> Result<Vec<u8>, ::crunch::errors::SerializeError> {
Ok(self.encode_to_vec())
}
}
impl ::crunch::traits::Deserializer for MyInclude {
fn deserialize(raw: Vec<u8>) -> Result<Self, ::crunch::errors::DeserializeError>
where
Self: Sized,
{
let output = Self::decode(raw.as_slice()).map_err(|e| ::crunch::errors::DeserializeError::ProtoErr(e))?;
Ok(output)
}
}
impl crunch::traits::Event for MyInclude {
fn event_info() -> ::crunch::traits::EventInfo {
::crunch::traits::EventInfo {
domain: "my-domain",
entity_type: "my-entity-type",
event_name: "my-event-name",
}
}
}
}
}
pub mod my_event { use prost::Message;
include!("basic.my_event.rs");
impl ::crunch::traits::Serializer for MyEvent {
fn serialize(&self) -> Result<Vec<u8>, ::crunch::errors::SerializeError> {
Ok(self.encode_to_vec())
}
}
impl ::crunch::traits::Deserializer for MyEvent {
fn deserialize(raw: Vec<u8>) -> Result<Self, ::crunch::errors::DeserializeError>
where
Self: Sized,
{
let output = Self::decode(raw.as_slice()).map_err(|e| ::crunch::errors::DeserializeError::ProtoErr(e))?;
Ok(output)
}
}
impl crunch::traits::Event for MyEvent {
fn event_info() -> ::crunch::traits::EventInfo {
::crunch::traits::EventInfo {
domain: "my-domain",
entity_type: "my-entity-type",
event_name: "my-event-name",
}
}
}
}
}

55
examples/basic-setup/src/main.rs
View File

@ -1,49 +1,30 @@
mod crunch;
mod gencrunch;
use ::crunch::traits::{Deserializer, Event, EventInfo, Serializer};
struct MyEvent {}
impl Serializer for MyEvent {
fn serialize(&self) -> Result<Vec<u8>, ::crunch::errors::SerializeError> {
todo!()
}
}
impl Deserializer for MyEvent {
fn deserialize(_raw: Vec<u8>) -> Result<Self, ::crunch::errors::DeserializeError>
where
Self: Sized,
{
todo!()
}
}
impl Event for MyEvent {
fn event_info() -> ::crunch::traits::EventInfo {
EventInfo {
domain: "my-domain",
entity_type: "my-entity-type",
event_name: "my-event-name",
}
}
}
use gencrunch::basic::{includes::my_include::MyInclude, my_event::MyEvent};
#[tokio::main]
async fn main() -> anyhow::Result<()> {
crunch::basic::my_event::MyEvent {
name: "some-name".into(),
include: Some(crunch::basic::includes::my_include::MyInclude {
name: "some-name".into(),
}),
};
let crunch = ::crunch::builder::Builder::default().build()?;
crunch
.subscribe(|_item: MyEvent| async move { Ok(()) })
.subscribe(|item: MyEvent| async move {
println!("received item: {:?}", item);
Ok(())
})
.await?;
crunch.publish(MyEvent {}).await?;
crunch
.publish(MyEvent {
name: "some-name".into(),
include: Some(MyInclude {
name: "some-name".into(),
}),
})
.await?;
// Sleep a while to let subscriber catch item
tokio::time::sleep(std::time::Duration::from_secs(1)).await;
Ok(())
}