feat: add SQLite backend support

.github/workflows/test.yml

@@ -18,3 +18,17 @@ jobs:
       - uses: actions/checkout@v3
       - name: Run integration tests
         run: nix run .#nextest
+
+  sqlite-tests:
+    name: sqlite tests
+    runs-on: ubuntu-latest
+    steps:
+      - name: Install Nix
+        uses: DeterminateSystems/nix-installer-action@v16
+      - uses: cachix/cachix-action@v15
+        with:
+          name: lana-ci
+          authToken: ${{ env.CACHIX_AUTH_TOKEN }}
+      - uses: actions/checkout@v3
+      - name: Run SQLite tests
+        run: nix run .#nextest-sqlite

Cargo.toml

@@ -13,17 +13,22 @@ inherits = "dev"
 
 [features]
 
-fail-on-warnings = ["es-entity-macros/fail-on-warnings"]
+default = ["postgres"]
+postgres = ["sqlx/postgres", "dep:es-entity-macros"]
+sqlite = ["sqlx/sqlite", "dep:es-entity-macros-sqlite"]
+
+fail-on-warnings = ["es-entity-macros?/fail-on-warnings", "es-entity-macros-sqlite?/fail-on-warnings"]
 tracing-context = ["dep:tracing", "dep:tracing-opentelemetry", "dep:opentelemetry", "dep:opentelemetry_sdk"]
-graphql = ["es-entity-macros/graphql", "dep:async-graphql", "dep:base64"]
-event-context = ["es-entity-macros/event-context", "event-context-enabled"]
-event-context-enabled = ["es-entity-macros/event-context-enabled"]
+graphql = ["es-entity-macros?/graphql", "es-entity-macros-sqlite?/graphql", "dep:async-graphql", "dep:base64"]
+event-context = ["es-entity-macros?/event-context", "es-entity-macros-sqlite?/event-context", "event-context-enabled"]
+event-context-enabled = ["es-entity-macros?/event-context-enabled", "es-entity-macros-sqlite?/event-context-enabled"]
 json-schema = ["dep:schemars"]
 mdbook-test = ["dep:anyhow"]
-instrument = ["es-entity-macros/instrument", "dep:tracing"]
+instrument = ["es-entity-macros?/instrument", "es-entity-macros-sqlite?/instrument", "dep:tracing"]
 
 [dependencies]
-es-entity-macros = { workspace = true }
+es-entity-macros = { workspace = true, optional = true }
+es-entity-macros-sqlite = { workspace = true, optional = true }
 
 base64 = { workspace = true, optional = true }
 sqlx = { workspace = true }
@@ -53,16 +58,19 @@ tokio = { workspace = true }
 anyhow = { workspace = true }
 async-trait = { workspace = true }
 futures = { workspace = true }
+sqlx = { workspace = true, features = ["migrate"] }
 
 [workspace]
 resolver = "2"
 members = [
   "es-entity-macros",
+  "es-entity-macros-sqlite",
 ]
 
 [workspace.dependencies]
 
 es-entity-macros = { path = "es-entity-macros", version = "0.10.28-dev" }
+es-entity-macros-sqlite = { path = "es-entity-macros-sqlite", version = "0.10.28-dev" }
 
 anyhow = "1.0"
 async-graphql = { version = "8.0.0-rc.3", default-features = false }
@@ -74,7 +82,7 @@ schemars = { version = "1.0", features = ["uuid1"] }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 serde_with = "3.15"
-sqlx = { version = "0.8", default-features = false, features = ["macros", "runtime-tokio-rustls", "postgres", "uuid", "chrono", "json" ] }
+sqlx = { version = "0.8", default-features = false, features = ["macros", "runtime-tokio-rustls", "uuid", "chrono", "json" ] }
 tokio = { version = "1.50", features = ["rt-multi-thread", "macros", "time"] }
 thiserror = "2.0"
 uuid = { version = "1.22", features = ["serde", "v7"] }

es-entity-macros-sqlite/Cargo.toml

@@ -0,0 +1,28 @@
+[package]
+name = "es-entity-macros-sqlite"
+description = "Proc macros for es-entity (SQLite backend)"
+repository = "https://github.com/GaloyMoney/cala"
+version = "0.10.28-dev"
+edition = "2024"
+license = "Apache-2.0"
+categories = ["data-structures", "database"]
+
+[features]
+
+fail-on-warnings = []
+graphql = []
+event-context = ["event-context-enabled"]
+event-context-enabled = []
+instrument = []
+
+[lib]
+proc-macro = true
+
+[dependencies]
+proc-macro2 = "1.0"
+syn = "2.0"
+quote = "1.0"
+darling = "0.23"
+pluralizer = "0.5"
+convert_case = "0.11"
+regex = "1.12"

es-entity-macros-sqlite/src/entity.rs

@@ -0,0 +1,242 @@
+use darling::{FromDeriveInput, FromField, ToTokens};
+use proc_macro2::TokenStream;
+use quote::{TokenStreamExt, quote};
+use syn::Type;
+
+#[derive(Debug, FromField)]
+#[darling(attributes(es_entity))]
+struct Field {
+    ident: Option<syn::Ident>,
+    ty: Type,
+    #[darling(default)]
+    events: bool,
+    #[darling(default)]
+    nested: bool,
+}
+
+impl Field {
+    fn is_events_field(&self) -> bool {
+        self.events || self.ident.as_ref().is_some_and(|i| i == "events")
+    }
+
+    fn extract_nested_entity_type(&self) -> &Type {
+        if let Type::Path(type_path) = &self.ty
+            && let Some(segment) = type_path.path.segments.last()
+            && segment.ident == "Nested"
+            && let syn::PathArguments::AngleBracketed(generic_args) = &segment.arguments
+            && let Some(syn::GenericArgument::Type(inner_type)) = generic_args.args.first()
+        {
+            return inner_type;
+        }
+        panic!("Field must be of type Nested<T>");
+    }
+}
+
+#[derive(Debug, FromDeriveInput)]
+#[darling(supports(struct_named), attributes(es_entity))]
+pub struct EsEntity {
+    ident: syn::Ident,
+    #[darling(default, rename = "new")]
+    new_entity_ident: Option<syn::Ident>,
+    #[darling(default, rename = "event")]
+    event_ident: Option<syn::Ident>,
+    data: darling::ast::Data<(), Field>,
+}
+
+impl EsEntity {
+    fn find_events_field(&self) -> Option<&Field> {
+        match &self.data {
+            darling::ast::Data::Struct(fields) => {
+                fields.iter().find(|field| field.is_events_field())
+            }
+            _ => None,
+        }
+    }
+
+    fn nested_fields(&self) -> Vec<&Field> {
+        match &self.data {
+            darling::ast::Data::Struct(fields) => {
+                fields.iter().filter(|field| field.nested).collect()
+            }
+            _ => Vec::new(),
+        }
+    }
+}
+
+pub fn derive(ast: syn::DeriveInput) -> darling::Result<proc_macro2::TokenStream> {
+    let entity = EsEntity::from_derive_input(&ast)?;
+    Ok(quote!(#entity))
+}
+
+impl ToTokens for EsEntity {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        let ident = &self.ident;
+        let events_field = self
+            .find_events_field()
+            .expect("Struct must have a field marked with #[es_entity(events)]")
+            .ident
+            .as_ref()
+            .expect("Not ident on #[events]");
+
+        let event = self.event_ident.clone().unwrap_or_else(|| {
+            syn::Ident::new(
+                &format!("{}Event", self.ident),
+                proc_macro2::Span::call_site(),
+            )
+        });
+        let new = self.new_entity_ident.clone().unwrap_or_else(|| {
+            syn::Ident::new(
+                &format!("New{}", self.ident),
+                proc_macro2::Span::call_site(),
+            )
+        });
+
+        let nested = self.nested_fields().into_iter().map(|f| {
+            let field = &f.ident;
+            let ty = f.extract_nested_entity_type();
+            quote! {
+                impl es_entity::Parent<#ty> for #ident {
+                    fn new_children_mut(&mut self) -> &mut Vec<<#ty as es_entity::EsEntity>::New> {
+                        self.#field.new_entities_mut()
+                    }
+
+                    fn inject_children(&mut self, children: impl IntoIterator<Item = #ty>) {
+                        self.#field.load(children)
+                    }
+
+                    fn iter_persisted_children_mut(
+                        &mut self
+                    ) -> std::collections::hash_map::ValuesMut<'_, <<#ty as EsEntity>::Event as EsEvent>::EntityId, #ty>
+                    {
+                        self.#field.iter_persisted_mut()
+                    }
+                }
+            }
+        });
+
+        tokens.append_all(quote! {
+            impl es_entity::EsEntity for #ident {
+                type Event = #event;
+                type New = #new;
+
+                fn events_mut(&mut self) -> &mut es_entity::EntityEvents<#event> {
+                    &mut self.#events_field
+                }
+                fn events(&self) -> &es_entity::EntityEvents<#event> {
+                    &self.#events_field
+                }
+            }
+
+            #(#nested)*
+        });
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use quote::quote;
+    use syn::parse_quote;
+
+    #[test]
+    fn test_derive_es_entity() {
+        let input: syn::DeriveInput = parse_quote! {
+            #[derive(EsEntity)]
+            pub struct User {
+                pub id: UserId,
+                pub email: String,
+                #[es_entity(events)]
+                the_events: EntityEvents<UserEvent>
+            }
+        };
+
+        let output = derive(input).unwrap();
+        let expected = quote! {
+            impl es_entity::EsEntity for User {
+                type Event = UserEvent;
+                type New = NewUser;
+                fn events_mut(&mut self) -> &mut es_entity::EntityEvents<UserEvent> {
+                    &mut self.the_events
+                }
+                fn events(&self) -> &es_entity::EntityEvents<UserEvent> {
+                    &self.the_events
+                }
+            }
+        };
+
+        assert_eq!(output.to_string(), expected.to_string());
+    }
+
+    #[test]
+    fn test_derive_without_events_attr() {
+        let input: syn::DeriveInput = parse_quote! {
+            #[derive(EsEntity)]
+            pub struct User {
+                pub id: UserId,
+                events: EntityEvents<UserEvent>
+            }
+        };
+
+        let output = derive(input).unwrap();
+        let expected = quote! {
+            impl es_entity::EsEntity for User {
+                type Event = UserEvent;
+                type New = NewUser;
+                fn events_mut(&mut self) -> &mut es_entity::EntityEvents<UserEvent> {
+                    &mut self.events
+                }
+                fn events(&self) -> &es_entity::EntityEvents<UserEvent> {
+                    &self.events
+                }
+            }
+        };
+
+        assert_eq!(output.to_string(), expected.to_string());
+    }
+
+    #[test]
+    fn test_derive_with_nested() {
+        let input: syn::DeriveInput = parse_quote! {
+            #[derive(EsEntity)]
+            pub struct User {
+                pub id: UserId,
+                #[es_entity(nested)]
+                children: Nested<ChildEntity>,
+                events: EntityEvents<UserEvent>
+            }
+        };
+
+        let output = derive(input).unwrap();
+        let expected = quote! {
+            impl es_entity::EsEntity for User {
+                type Event = UserEvent;
+                type New = NewUser;
+                fn events_mut(&mut self) -> &mut es_entity::EntityEvents<UserEvent> {
+                    &mut self.events
+                }
+                fn events(&self) -> &es_entity::EntityEvents<UserEvent> {
+                    &self.events
+                }
+            }
+
+            impl es_entity::Parent<ChildEntity> for User {
+                fn new_children_mut(&mut self) -> &mut Vec<<ChildEntity as es_entity::EsEntity>::New> {
+                    self.children.new_entities_mut()
+                }
+
+                fn inject_children(&mut self, children: impl IntoIterator<Item = ChildEntity>) {
+                    self.children.load(children)
+                }
+
+                fn iter_persisted_children_mut(
+                    &mut self
+                ) -> std::collections::hash_map::ValuesMut<'_, <<ChildEntity as EsEntity>::Event as EsEvent>::EntityId, ChildEntity>
+                {
+                    self.children.iter_persisted_mut()
+                }
+            }
+        };
+
+        assert_eq!(output.to_string(), expected.to_string());
+    }
+}