feat: add direnv for local dev (#262)

* feat: add direnv config for local dev

* chore: run cargo fmt with new rustfmt config

Author: ar3s3ru

.envrc

@@ -0,0 +1 @@
+use flake

.gitignore

@@ -2,3 +2,5 @@
 **/*.rs.bk
 Cargo.lock
 lcov.info
+
+.direnv

.gitpod.yml

@@ -1,13 +1,10 @@
 use std::marker::PhantomData;
 
 use async_trait::async_trait;
-use eventually::{
-    aggregate,
-    aggregate::Aggregate,
-    serde::{Deserializer, Serde, Serializer},
-    version,
-    version::Version,
-};
+use eventually::aggregate::Aggregate;
+use eventually::serde::{Deserializer, Serde, Serializer};
+use eventually::version::Version;
+use eventually::{aggregate, version};
 use sqlx::{PgPool, Postgres, Row};
 
 #[derive(Debug, Clone)]
@@ -131,7 +128,7 @@ where
                             expected: expected_version,
                             actual: root.version(),
                         })
-                    }
+                    },
                     _ => SaveError::SaveAggregateState(err),
                 },
             })?;

.rustfmt.toml

@@ -1,21 +1,18 @@
-use std::{marker::PhantomData, string::ToString};
+use std::marker::PhantomData;
+use std::string::ToString;
 
 use async_trait::async_trait;
 use chrono::Utc;
-use eventually::{
-    event,
-    message::{Message, Metadata},
-    serde::{Deserializer, Serde, Serializer},
-    version,
-    version::Version,
-};
-use futures::{future::ready, StreamExt, TryStreamExt};
+use eventually::message::{Message, Metadata};
+use eventually::serde::{Deserializer, Serde, Serializer};
+use eventually::version::Version;
+use eventually::{event, version};
+use futures::future::ready;
+use futures::{StreamExt, TryStreamExt};
 use lazy_static::lazy_static;
 use regex::Regex;
-use sqlx::{
-    postgres::{PgDatabaseError, PgRow},
-    PgPool, Postgres, Row, Transaction,
-};
+use sqlx::postgres::{PgDatabaseError, PgRow};
+use sqlx::{PgPool, Postgres, Row, Transaction};
 
 #[derive(Debug, thiserror::Error)]
 pub enum StreamError {
@@ -285,7 +282,7 @@ where
                     .fetch_one(&mut tx)
                     .await
                     .and_then(|row| row.try_get(0))?
-            }
+            },
             event::StreamVersionExpected::MustBe(v) => {
                 let new_version = v + (events.len() as Version);
 
@@ -303,12 +300,12 @@ where
                                     expected: v,
                                     actual: new_version,
                                 })
-                            }
+                            },
                             _ => AppendError::UpsertEventStream(err),
                         },
                     })
                     .map(|_| new_version as i32)?
-            }
+            },
         };
 
         append_domain_events(&mut tx, &self.serde, &string_id, new_version, events)

eventually-postgres/src/aggregate.rs

@@ -1,8 +1,6 @@
-use eventually::{
-    aggregate::repository::{GetError, Getter, Saver},
-    serde::json::Json,
-    version,
-};
+use eventually::aggregate::repository::{GetError, Getter, Saver};
+use eventually::serde::json::Json;
+use eventually::version;
 use eventually_postgres::aggregate;
 use futures::TryFutureExt;
 use rand::Rng;

eventually-postgres/src/event.rs

@@ -1,11 +1,9 @@
 use std::time::{SystemTime, UNIX_EPOCH};
 
-use eventually::{
-    event::{Appender, Persisted, StreamVersionExpected, Streamer, VersionSelect},
-    serde::json::Json,
-    version,
-    version::Version,
-};
+use eventually::event::{Appender, Persisted, StreamVersionExpected, Streamer, VersionSelect};
+use eventually::serde::json::Json;
+use eventually::version;
+use eventually::version::Version;
 use eventually_postgres::event;
 use futures::{TryFutureExt, TryStreamExt};
 use rand::Rng;
@@ -187,7 +185,7 @@ async fn it_handles_concurrent_writes_to_the_same_stream() {
             } else {
                 panic!("unexpected error, {:?}", err);
             }
-        }
+        },
         (first, second) => panic!(
             "invalid state detected, first: {:?}, second: {:?}",
             first, second

eventually-postgres/tests/aggregate_repository.rs

@@ -1,9 +1,9 @@
-use std::{
-    fmt::{Display, Formatter, Result as FmtResult},
-    time::{SystemTime, UNIX_EPOCH},
-};
+use std::fmt::{Display, Formatter, Result as FmtResult};
+use std::time::{SystemTime, UNIX_EPOCH};
 
-use eventually::{aggregate, aggregate::Aggregate, message::Message};
+use eventually::aggregate;
+use eventually::aggregate::Aggregate;
+use eventually::message::Message;
 use eventually_macros::aggregate_root;
 use serde::{Deserialize, Serialize};
 use sqlx::PgPool;
@@ -83,7 +83,7 @@ impl Aggregate for TestAggregate {
             (Some(mut a), TestDomainEvent::WasDeleted { .. }) => {
                 a.is_deleted = true;
                 Ok(a)
-            }
+            },
             (None, TestDomainEvent::WasDeleted { .. }) => Err(TestAggregateError::NotCreatedYet),
         }
     }

eventually-postgres/tests/event_store.rs

@@ -25,7 +25,8 @@
 //! Aggregates should provide a way to **fold** Domain Events on the
 //! current value of the state, to produce the next state.
 
-use crate::{event, message, version::Version};
+use crate::version::Version;
+use crate::{event, message};
 
 pub mod repository;
 
@@ -347,7 +348,7 @@ pub(crate) mod test_user_domain {
                     UserEvent::PasswordWasChanged { password } => {
                         state.password = password;
                         Ok(state)
-                    }
+                    },
                     UserEvent::WasCreated { .. } => Err(UserError::AlreadyCreated),
                 },
             }
@@ -386,14 +387,10 @@ pub(crate) mod test_user_domain {
 mod test {
     use std::error::Error;
 
-    use crate::{
-        aggregate,
-        aggregate::repository::{Getter, Saver},
-        aggregate::test_user_domain::{User, UserEvent},
-        event,
-        event::store::EventStoreExt,
-        version,
-    };
+    use crate::aggregate::repository::{Getter, Saver};
+    use crate::aggregate::test_user_domain::{User, UserEvent};
+    use crate::event::store::EventStoreExt;
+    use crate::{aggregate, event, version};
 
     #[tokio::test]
     async fn repository_persists_new_aggregate_root() {