🧹 Removed unused dependencies

Signed-off-by: Martin Berg Alstad <600878@stud.hvl.no>

.github/workflows/build.yaml

@@ -15,4 +15,4 @@ jobs:
       - name: Build
         run: cargo build --verbose
       - name: Run tests
-        run: cargo test --verbose --all-features
+        run: cargo test --verbose --all-features --workspace

.idea/lib.iml

@@ -2,10 +2,22 @@
 <module type="EMPTY_MODULE" version="4">
   <component name="NewModuleRootManager">
     <content url="file://$MODULE_DIR$">
-      <sourceFolder url="file://$MODULE_DIR$/derive/src" isTestSource="false" />
       <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
-      <excludeFolder url="file://$MODULE_DIR$/derive/target" />
+      <sourceFolder url="file://$MODULE_DIR$/examples" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/examples/multipart_file/src" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/crates/into_response_derive/src" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/crates/read_files/src" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/crates/read_files/tests" isTestSource="true" />
+      <sourceFolder url="file://$MODULE_DIR$/crates/read_files/tests" isTestSource="true" />
+      <sourceFolder url="file://$MODULE_DIR$/crates/diesel_crud_derive/src" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/crates/diesel_crud_trait/src" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/crates/tests/src" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/crates/tests/tests" isTestSource="true" />
+      <sourceFolder url="file://$MODULE_DIR$/tests" isTestSource="true" />
       <excludeFolder url="file://$MODULE_DIR$/target" />
+      <excludeFolder url="file://$MODULE_DIR$/examples/multipart_file/target" />
+      <excludeFolder url="file://$MODULE_DIR$/crates/into_response_derive/target" />
+      <excludeFolder url="file://$MODULE_DIR$/crates/read_files/target" />
     </content>
     <orderEntry type="inheritedJdk" />
     <orderEntry type="sourceFolder" forTests="false" />

.idea/runConfigurations/All_Tests.xml

@@ -0,0 +1,20 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="All Tests" type="CargoCommandRunConfiguration" factoryName="Cargo Command">
+    <option name="buildProfile" value="Test" />
+    <option name="command" value="test --workspace" />
+    <option name="workingDirectory" value="file://$PROJECT_DIR$" />
+    <envs />
+    <option name="emulateTerminal" value="true" />
+    <option name="channel" value="DEFAULT" />
+    <option name="requiredFeatures" value="true" />
+    <option name="allFeatures" value="true" />
+    <option name="withSudo" value="false" />
+    <option name="buildTarget" value="REMOTE" />
+    <option name="backtrace" value="SHORT" />
+    <option name="isRedirectInput" value="false" />
+    <option name="redirectInputPath" value="" />
+    <method v="2">
+      <option name="CARGO.BUILD_TASK_PROVIDER" enabled="true" />
+    </method>
+  </configuration>
+</component>

.idea/runConfigurations/Release.xml

@@ -1,12 +1,12 @@
 <component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="Test" type="CargoCommandRunConfiguration" factoryName="Cargo Command">
-    <option name="command" value="test --package lib --lib tests --all-features" />
+  <configuration default="false" name="Release" type="CargoCommandRunConfiguration" factoryName="Cargo Command">
+    <option name="command" value="build --release --all-features" />
     <option name="workingDirectory" value="file://$PROJECT_DIR$" />
     <envs />
     <option name="emulateTerminal" value="true" />
     <option name="channel" value="DEFAULT" />
     <option name="requiredFeatures" value="true" />
-    <option name="allFeatures" value="false" />
+    <option name="allFeatures" value="true" />
     <option name="withSudo" value="false" />
     <option name="buildTarget" value="REMOTE" />
     <option name="backtrace" value="SHORT" />

.idea/rust.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="RsVcsConfiguration">
+    <option name="rustFmt" value="true" />
+  </component>
+</project>

Cargo.toml

@@ -1,33 +1,80 @@
+[workspace]
+members = ["crates/*"]
+exclude = ["examples"]
+
+[workspace.package]
+edition = "2021"
+rust-version = "1.80.1"
+authors = ["Martin Berg Alstad"]
+homepage = "emberal.github.io"
+
 [package]
 name = "lib"
-version = "1.1.0"
-edition = "2021"
-authors = ["Martin Berg Alstad"]
+version = "1.4.3"
+description = "A library with utilities and helper fuctions."
+edition = { workspace = true }
+rust-version = { workspace = true }
+authors = { workspace = true }
+homepage = { workspace = true }
 
 [lib]
 
 [dependencies]
 # Api
-axum = { version = "0.7.5", optional = true }
-tower = { version = "0.4.13", optional = true }
-tower-http = { version = "0.5.2", optional = true, features = ["trace", "cors", "normalize-path"] }
+axum = { version = "0.7", optional = true, features = ["multipart"] }
+tower = { version = "0.5", optional = true }
+tower-http = { version = "0.5", optional = true, features = ["trace", "cors", "normalize-path"] }
+mime = { version = "0.3", optional = true }
 # Async
-tokio = { version = "1.38.0", optional = true, features = ["fs"] }
-tokio-util = { version = "0.7.11", optional = true, features = ["io"] }
+tokio = { workspace = true, optional = true, features = ["fs", "rt-multi-thread"] }
+tokio-util = { version = "0.7", optional = true, features = ["io"] }
+# Database
+diesel = { workspace = true, optional = true, features = ["postgres"] }
+diesel-async = { workspace = true, optional = true, features = ["postgres", "deadpool"] }
+diesel-crud-derive = { path = "crates/diesel_crud_derive", optional = true }
+diesel-crud-trait = { path = "crates/diesel_crud_trait", optional = true }
+deadpool-diesel = { workspace = true, optional = true, features = ["postgres"] }
+# Error handling
+thiserror = { workspace = true, optional = true }
 # Logging
-tracing = "0.1.40"
-tracing-subscriber = "0.3.18"
+tracing = { version = "0.1", optional = true }
+tracing-subscriber = { version = "0.3", optional = true }
 # Parsing
-nom = { version = "7.1.3", optional = true }
+nom = { version = "7.1", optional = true }
+# Procedural macros
+into-response-derive = { path = "crates/into_response_derive", optional = true }
+read-files = { path = "crates/read_files", optional = true }
 # Serialization / Deserialization
-serde = { version = "1.0.203", optional = true, features = ["derive"] }
-# Derive macros
-derive = { path = "derive", optional = true }
+serde = { version = "1.0", optional = true, features = ["derive"] }
+# Time
+chrono = { version = "0.4", optional = true, features = ["serde"] }
+# Utils
+derive_more = { workspace = true, features = ["from", "constructor"] }
+
+[workspace.dependencies]
+# Async
+tokio = "1.40"
+# Database
+diesel = "2.2"
+diesel-async = "0.5"
+deadpool-diesel = "0.6"
+# Error handling
+thiserror = "1.0"
+# Procedural macros
+syn = "2.0"
+quote = "1.0"
+deluxe = "0.5"
+proc-macro2 = "1.0"
+# Utils
+derive_more = "1.0"
 
 [features]
-axum = ["dep:axum", "dep:tower", "dep:tower-http"]
-tokio = ["dep:tokio", "dep:tokio-util"]
-vec = []
+axum = ["dep:axum", "dep:tower", "dep:tower-http", "dep:thiserror", "dep:tracing", "dep:tracing-subscriber", "dep:tokio", "dep:mime"]
+diesel = ["dep:diesel-crud-trait", "dep:diesel", "dep:diesel-async", "dep:deadpool-diesel"]
+io = ["dep:tokio", "dep:tokio-util"]
+iter = []
 nom = ["dep:nom"]
 serde = ["dep:serde"]
-derive = ["dep:derive", "axum", "serde"]
+derive = ["dep:into-response-derive", "dep:diesel-crud-derive"]
+read-files = ["dep:read-files"]
+time = ["dep:chrono"]

Makefile.toml

@@ -0,0 +1,15 @@
+[tasks.clippy]
+command = "cargo"
+args = ["clippy", "--all-targets", "--all-features", "--", "-D", "warnings"]
+
+[tasks.fmt]
+command = "cargo"
+args = ["fmt", "--all"]
+
+[tasks.test]
+command = "cargo"
+args = ["test", "--all-features"]
+
+[tasks.coverage]
+command = "cargo"
+args = ["llvm-cov", "--all-features"]

README.md

@@ -0,0 +1,3 @@
+# Lib
+
+-_-

crates/diesel_crud_derive/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "diesel-crud-derive"
+version = "0.1.0"
+edition = { workspace = true }
+rust-version = { workspace = true }
+
+[lib]
+proc-macro = true
+
+[dependencies]
+syn = { workspace = true }
+quote = { workspace = true }
+deluxe = { workspace = true }
+proc-macro2 = { workspace = true }

crates/diesel_crud_derive/src/attributes.rs

@@ -0,0 +1,73 @@
+use crate::common::PrimaryKey;
+use deluxe::{extract_attributes, ExtractAttributes};
+use proc_macro2::Ident;
+use quote::quote;
+use std::collections::HashMap;
+use syn::spanned::Spanned;
+use syn::{Data, DeriveInput, Expr, Path, Type};
+
+#[derive(ExtractAttributes)]
+#[deluxe(attributes(diesel))]
+pub(crate) struct DieselStructAttributes {
+    table_name: Option<Expr>,
+    #[deluxe(rest)]
+    _rest: HashMap<Path, Expr>,
+}
+
+#[derive(ExtractAttributes)]
+#[deluxe(attributes(diesel_crud))]
+pub(crate) struct StructAttributes {
+    table: Option<Expr>,
+    #[deluxe(default)]
+    insert: Option<Type>,
+    #[deluxe(default)]
+    update: Option<Type>,
+}
+
+#[derive(ExtractAttributes)]
+#[deluxe(attributes(diesel_crud))]
+pub(crate) struct FieldAttributes(#[allow(unused)] Expr);
+
+pub(crate) struct Attributes {
+    pub struct_ident: Ident,
+    pub table: Expr,
+    pub insert: Type,
+    pub update: Type,
+    pub pk: Option<PrimaryKey>,
+}
+
+pub(crate) fn extract_attrs(ast: &mut DeriveInput) -> deluxe::Result<Attributes> {
+    let struct_attributes: StructAttributes = extract_attributes(ast)?;
+    let diesel_attributes: DieselStructAttributes = extract_attributes(ast)?;
+    Ok(Attributes {
+        struct_ident: ast.ident.clone(),
+        table: diesel_attributes.table_name.unwrap_or_else(|| {
+            struct_attributes
+                .table
+                .expect("Table name should be provided on either diesel or diesel_crud attribute")
+        }),
+        insert: struct_attributes
+            .insert
+            .unwrap_or_else(|| Type::Verbatim(quote! { Self })),
+        update: struct_attributes
+            .update
+            .unwrap_or_else(|| Type::Verbatim(quote! { Self })),
+        pk: extract_field_attrs(ast).ok(),
+    })
+}
+
+fn extract_field_attrs(ast: &mut DeriveInput) -> deluxe::Result<PrimaryKey> {
+    if let Data::Struct(data_struct) = &mut ast.data {
+        for field in data_struct.fields.iter_mut() {
+            if let Ok(FieldAttributes(_)) = extract_attributes(field) {
+                return Ok(PrimaryKey {
+                    ident: field.ident.clone().unwrap(),
+                    ty: field.ty.clone(),
+                });
+            }
+        }
+    } else {
+        return Err(deluxe::Error::new(ast.span(), "Expected a struct"));
+    };
+    Err(deluxe::Error::new(ast.span(), "Primary key not found"))
+}

crates/diesel_crud_derive/src/common.rs

@@ -0,0 +1,14 @@
+use proc_macro2::Ident;
+use quote::quote;
+use syn::Type;
+
+pub(crate) struct PrimaryKey {
+    pub ident: Ident,
+    pub ty: Type,
+}
+
+pub(crate) fn return_type(output: proc_macro2::TokenStream) -> proc_macro2::TokenStream {
+    quote! {
+        std::pin::Pin<Box<dyn core::future::Future<Output = Result<#output, lib::diesel_crud_trait::CrudError>> + Send + 'async_trait>>
+    }
+}

crates/diesel_crud_derive/src/create.rs

@@ -0,0 +1,53 @@
+use crate::{common, Attributes};
+use quote::quote;
+
+pub(crate) fn derive_diesel_crud_create_impl(
+    Attributes {
+        struct_ident,
+        table,
+        insert,
+        ..
+    }: &Attributes,
+) -> proc_macro2::TokenStream {
+    let return_type = common::return_type(quote! { Self });
+    let many_return_type = common::return_type(quote! { Vec<Self> });
+
+    quote! {
+        #[automatically_derived]
+        impl lib::diesel_crud_trait::DieselCrudCreate<#table::table> for #struct_ident {
+            type Insert = #insert;
+            fn insert<'a, 'async_trait>(insert: Self::Insert, conn: &'a mut diesel_async::AsyncPgConnection) -> #return_type
+                where
+                    Self: Sized + Sync + 'a,
+                    'a: 'async_trait,
+            {
+                Box::pin(async move {
+                    use diesel::associations::HasTable;
+                    diesel_async::RunQueryDsl::get_result(
+                        diesel::dsl::insert_into(#table::table::table()).values(insert),
+                        conn
+                    )
+                        .await
+                        .map_err(Into::into)
+                })
+            }
+
+            fn insert_many<'a, 'b, 'async_trait>(insert: &'a [Self::Insert], conn: &'b mut diesel_async::AsyncPgConnection) -> #many_return_type
+                where
+                    Self: Sized + Sync + 'async_trait,
+                    'a: 'async_trait,
+                    'b: 'async_trait,
+            {
+                Box::pin(async move {
+                    use diesel::associations::HasTable;
+                    diesel_async::RunQueryDsl::get_results(
+                        diesel::dsl::insert_into(#table::table::table()).values(insert),
+                        conn
+                    )
+                        .await
+                        .map_err(Into::into)
+                })
+            }
+        }
+    }
+}

crates/diesel_crud_derive/src/delete.rs

@@ -0,0 +1,46 @@
+use crate::{common, Attributes, PrimaryKey};
+use quote::quote;
+
+pub(crate) fn derive_diesel_crud_delete_impl(
+    Attributes {
+        struct_ident,
+        table,
+        pk,
+        ..
+    }: &Attributes,
+) -> proc_macro2::TokenStream {
+    if pk.is_none() {
+        panic!("Please specify a primary key using #[diesel_crud(pk)]");
+    }
+    let PrimaryKey {
+        ident: pk_ident,
+        ty: pk_type,
+    } = pk.as_ref().unwrap();
+    let return_type = common::return_type(quote! { Self });
+
+    quote! {
+        #[automatically_derived]
+        impl lib::diesel_crud_trait::DieselCrudDelete for #struct_ident {
+            type PK = #pk_type;
+            fn delete<'a, 'async_trait>(pk: Self::PK, conn: &'a mut diesel_async::AsyncPgConnection) -> #return_type
+                where
+                    Self: Sized + Sync + 'a,
+                    'a: 'async_trait,
+            {
+                Box::pin(async move {
+                    use diesel::QueryDsl;
+                    use diesel::associations::HasTable;
+                    diesel_async::RunQueryDsl::get_result(
+                        diesel::delete(
+                            #table::table
+                                .filter(diesel::expression_methods::ExpressionMethods::eq(#table::#pk_ident, pk))
+                        ),
+                        conn,
+                    )
+                        .await
+                        .map_err(Into::into)
+                })
+            }
+        }
+    }
+}

crates/diesel_crud_derive/src/lib.rs

@@ -0,0 +1,165 @@
+extern crate proc_macro;
+
+use crate::attributes::{extract_attrs, Attributes};
+use crate::common::PrimaryKey;
+use crate::create::derive_diesel_crud_create_impl;
+use crate::delete::derive_diesel_crud_delete_impl;
+use crate::list::derive_diesel_crud_list_impl;
+use crate::read::derive_diesel_crud_read_impl;
+use crate::update::derive_diesel_crud_update_impl;
+use quote::quote;
+use syn::{parse_macro_input, DeriveInput};
+
+mod attributes;
+mod common;
+mod create;
+mod delete;
+mod list;
+mod read;
+mod update;
+
+/// Derives 5 functions for CRUD operations
+/// 1. create
+/// 2. read
+/// 3. update
+/// 4. delete
+/// 5. list
+#[proc_macro_derive(DieselCrud, attributes(diesel_crud))]
+pub fn derive_diesel_crud(item: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let mut item = parse_macro_input!(item as DeriveInput);
+    let attrs = extract_attrs(&mut item).unwrap();
+
+    let create = derive_diesel_crud_create_impl(&attrs);
+    let read = derive_diesel_crud_read_impl(&attrs);
+    let update = derive_diesel_crud_update_impl(&attrs);
+    let delete = derive_diesel_crud_delete_impl(&attrs);
+    let list = derive_diesel_crud_list_impl(&attrs);
+
+    let Attributes {
+        table,
+        struct_ident,
+        ..
+    } = attrs;
+    let expanded = quote! {
+        #create
+        #read
+        #update
+        #delete
+        #list
+
+        impl lib::diesel_crud_trait::DieselCrud<#table::table> for #struct_ident {}
+    };
+    expanded.into()
+}
+
+/// Derives the create function for CRUD operations.
+/// Must be used on a struct.
+/// # Struct Attributes
+/// - table: Expr - The schema struct for the table (can be provided on either diesel or diesel_crud attribute)
+/// - insert: Type - The insertable model (Optional, defaults to `Self`)
+/// # Example
+/// ```ignore
+/// #[derive(Queryable, diesel_crud_derive::DieselCrudCreate)]
+/// #[diesel_crud(create = crate::models::InsertUser)]
+/// #[diesel(table_name = crate::schema::user)]
+/// struct User {
+///     #[diesel_crud(pk)]
+///     email: String,
+///     password: String,
+/// }
+/// ```
+#[proc_macro_derive(DieselCrudCreate, attributes(diesel_crud))]
+pub fn derive_diesel_crud_create(item: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let mut item = syn::parse_macro_input!(item as DeriveInput);
+    let attrs = extract_attrs(&mut item).unwrap();
+    derive_diesel_crud_create_impl(&attrs).into()
+}
+
+/// Derives the read function for CRUD operations.
+/// Must be used on a struct with one field marked as the primary key.
+/// # Struct Attributes
+/// - table: Expr - The schema struct for the table (can be provided on either diesel or diesel_crud attribute)
+/// # Field Attributes
+/// - pk: Ident - The primary key field (Only one field should be marked as the primary key)
+/// # Example
+/// ```ignore
+/// #[derive(Queryable, diesel_crud_derive::DieselCrudRead)]
+/// #[diesel(table_name = crate::schema::user)]
+/// struct User {
+///     #[diesel_crud(pk)]
+///     email: String,
+///     password: String,
+/// }
+/// ```
+#[proc_macro_derive(DieselCrudRead, attributes(diesel_crud))]
+pub fn derive_diesel_crud_read(item: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let mut item = syn::parse_macro_input!(item as DeriveInput);
+    let attrs = extract_attrs(&mut item).unwrap();
+    derive_diesel_crud_read_impl(&attrs).into()
+}
+
+/// Derives the update function for CRUD operations.
+/// Must be used on a struct.
+/// # Struct Attributes
+/// - table: Expr - The schema struct for the table (can be provided on either diesel or diesel_crud attribute)
+/// - update: Type - The update model (Optional, defaults to `Self`)
+/// # Example
+/// ```ignore
+/// #[derive(Queryable, diesel_crud_derive::DieselCrudUpdate)]
+/// #[diesel(table_name = crate::schema::user)]
+/// struct User {
+///     #[diesel_crud(pk)]
+///     email: String,
+///     password: String,
+/// }
+/// ```
+#[proc_macro_derive(DieselCrudUpdate, attributes(diesel_crud))]
+pub fn derive_diesel_crud_update(item: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let mut item = syn::parse_macro_input!(item as DeriveInput);
+    let attrs = extract_attrs(&mut item).unwrap();
+    derive_diesel_crud_update_impl(&attrs).into()
+}
+
+/// Derives the delete function for CRUD operations.
+/// Must be used on a struct with a field marked as primary key.
+/// # Struct Attributes
+/// - table: Expr - The schema struct for the table (can be provided on either diesel or diesel_crud attribute)
+/// # Field Attributes
+/// - pk: Ident - The primary key field (Only one field should be marked as the primary key)
+/// # Example
+/// ```ignore
+/// #[derive(Queryable, diesel_crud_derive::DieselCrudDelete)]
+/// #[diesel(table_name = crate::schema::user)]
+/// struct User {
+///     #[diesel_crud(pk)]
+///     email: String,
+///     password: String,
+/// }
+/// ```
+#[proc_macro_derive(DieselCrudDelete, attributes(diesel_crud))]
+pub fn derive_diesel_crud_delete(item: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let mut item = syn::parse_macro_input!(item as DeriveInput);
+    let attrs = extract_attrs(&mut item).unwrap();
+    derive_diesel_crud_delete_impl(&attrs).into()
+}
+
+/// Derives the list function for CRUD operations.
+/// Must be used on a struct.
+/// # Struct Attributes
+/// - table: Expr - The schema struct for the table (can be provided on either diesel or diesel_crud attribute)
+/// # Example
+/// ```ignore
+/// #[derive(Queryable, diesel_crud_derive::DieselCrudList)]
+/// #[diesel(table_name = crate::schema::user)]
+/// struct User {
+///     #[diesel_crud(pk)]
+///     email: String,
+///     password: String,
+/// }
+/// ```
+#[proc_macro_derive(DieselCrudList, attributes(diesel_crud))]
+pub fn derive_diesel_crud_list(item: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let mut item = syn::parse_macro_input!(item as DeriveInput);
+    let attrs = extract_attrs(&mut item).unwrap();
+    derive_diesel_crud_list_impl(&attrs).into()
+}

crates/diesel_crud_derive/src/list.rs

@@ -0,0 +1,28 @@
+use crate::{common, Attributes};
+use quote::quote;
+
+pub(crate) fn derive_diesel_crud_list_impl(
+    Attributes {
+        struct_ident,
+        table,
+        ..
+    }: &Attributes,
+) -> proc_macro2::TokenStream {
+    let return_type = common::return_type(quote! { Vec<Self> });
+
+    quote! {
+        #[automatically_derived]
+        impl lib::diesel_crud_trait::DieselCrudList for #struct_ident {
+            fn list<'a, 'async_trait>(conn: &'a mut diesel_async::AsyncPgConnection) -> #return_type
+                where
+                    Self: Sized + Sync + 'a,
+                    'a: 'async_trait
+            {
+                Box::pin(async move {
+                    use diesel::associations::HasTable;
+                    diesel_async::RunQueryDsl::get_results(#table::table::table(), conn).await.map_err(Into::into)
+                })
+            }
+        }
+    }
+}

crates/diesel_crud_derive/src/read.rs

@@ -0,0 +1,40 @@
+use crate::common::PrimaryKey;
+use crate::{common, Attributes};
+use quote::quote;
+
+pub(crate) fn derive_diesel_crud_read_impl(
+    Attributes {
+        struct_ident,
+        table,
+        pk,
+        ..
+    }: &Attributes,
+) -> proc_macro2::TokenStream {
+    if pk.is_none() {
+        panic!("Please specify a primary key using #[diesel_crud(pk)]");
+    }
+    let PrimaryKey { ty: pk_type, .. } = pk.as_ref().unwrap();
+    let return_type = common::return_type(quote! { Self });
+
+    quote! {
+        #[automatically_derived]
+        impl lib::diesel_crud_trait::DieselCrudRead for #struct_ident {
+            type PK = #pk_type;
+            fn read<'a, 'async_trait>(pk: Self::PK, conn: &'a mut diesel_async::AsyncPgConnection) -> #return_type
+                where
+                    Self: Sized + Sync + 'a,
+                    'a: 'async_trait
+            {
+                Box::pin(async move {
+                    use diesel::associations::HasTable;
+                    diesel_async::RunQueryDsl::get_result(
+                        diesel::QueryDsl::find(#table::table::table(), pk),
+                        conn
+                    )
+                        .await
+                        .map_err(Into::into)
+                })
+            }
+        }
+    }
+}

crates/diesel_crud_derive/src/update.rs

@@ -0,0 +1,35 @@
+use crate::{common, Attributes};
+use quote::quote;
+
+pub(crate) fn derive_diesel_crud_update_impl(
+    Attributes {
+        struct_ident,
+        table,
+        update,
+        ..
+    }: &Attributes,
+) -> proc_macro2::TokenStream {
+    let return_type = common::return_type(quote! { Self });
+
+    quote! {
+        #[automatically_derived]
+        impl lib::diesel_crud_trait::DieselCrudUpdate for #struct_ident {
+            type Update = #update;
+            fn update<'a, 'async_trait>(update: Self::Update, conn: &'a mut diesel_async::AsyncPgConnection) -> #return_type
+                where
+                    Self: Sized + Sync + 'a,
+                    'a: 'async_trait,
+            {
+                Box::pin(async move {
+                    use diesel::associations::HasTable;
+                    diesel_async::RunQueryDsl::get_result(
+                        diesel::dsl::update(#table::table::table()).set(update),
+                        conn,
+                    )
+                        .await
+                        .map_err(Into::into)
+                })
+            }
+        }
+    }
+}

crates/diesel_crud_trait/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "diesel-crud-trait"
+version = "0.1.0"
+edition = { workspace = true }
+rust-version = { workspace = true }
+
+[dependencies]
+diesel = { workspace = true, features = ["postgres"] }
+diesel-async = { workspace = true, features = ["postgres", "deadpool"] }
+async-trait = "0.1"
+deadpool-diesel = { version = "0.6", features = ["postgres"] }
+thiserror = "1.0"

crates/diesel_crud_trait/src/error.rs

@@ -0,0 +1,22 @@
+use diesel::result::Error;
+use thiserror::Error;
+
+/// Error type for CRUD operations
+#[derive(Debug, PartialEq, Error)]
+pub enum CrudError {
+    #[error("Resource not found")]
+    NotFound,
+    #[error("Database pool error: {0}")]
+    PoolError(String),
+    #[error(transparent)]
+    Other(Error),
+}
+
+impl From<Error> for CrudError {
+    fn from(error: Error) -> Self {
+        match error {
+            Error::NotFound => CrudError::NotFound,
+            _ => CrudError::Other(error),
+        }
+    }
+}

crates/diesel_crud_trait/src/lib.rs

@@ -0,0 +1,118 @@
+mod error;
+
+use async_trait::async_trait;
+use diesel::{AsChangeset, Insertable};
+use diesel_async::AsyncPgConnection;
+pub use error::CrudError;
+
+/// Combines all CRUD operations into a single trait
+/// Includes:
+/// - Create
+/// - Read
+/// - Update
+/// - Delete
+/// - List
+pub trait DieselCrud<Table>:
+    DieselCrudCreate<Table> + DieselCrudRead + DieselCrudUpdate + DieselCrudDelete + DieselCrudList
+{
+}
+
+/// Insert an entity into the database
+/// The entity must implement `Insertable<Table>` for the given table.
+///
+/// Implementing the trait requires the `async_trait` macro.
+/// # Associations
+/// - `Insert` - The type to insert, must implement `Insertable<Table>`
+/// # Parameters
+/// - `insert` - The entity to insert
+/// - `conn` - The database connection
+/// # Returns
+/// A result containing the inserted entity or a `CrudError`
+#[async_trait]
+pub trait DieselCrudCreate<Table>
+where
+    Self: Sized,
+{
+    type Insert: Insertable<Table>;
+    async fn insert(insert: Self::Insert, conn: &mut AsyncPgConnection) -> Result<Self, CrudError>;
+    async fn insert_many(
+        insert: &[Self::Insert],
+        conn: &mut AsyncPgConnection,
+    ) -> Result<Vec<Self>, CrudError>;
+}
+
+/// Gets an entity from the database
+///
+/// Implementing the trait requires the `async_trait` macro.
+/// # Associations
+/// - `PK` - The primary key of the entity
+/// # Parameters
+/// - `pk` - The primary key of the entity
+/// - `conn` - The database connection
+/// # Returns
+/// A result containing the entity or a `CrudError`.
+/// If the entity is not found, the error should be `CrudError::NotFound`.
+#[async_trait]
+pub trait DieselCrudRead
+where
+    Self: Sized,
+{
+    type PK;
+    async fn read(pk: Self::PK, conn: &mut AsyncPgConnection) -> Result<Self, CrudError>;
+}
+
+/// Updates an entity in the database
+/// The entity must implement `AsChangeset` for the given table.
+///
+/// Implementing the trait requires the `async_trait` macro.
+/// # Associations
+/// - `Update` - The type to update
+/// # Parameters
+/// - `update` - The update to apply
+/// - `conn` - The database connection
+/// # Returns
+/// A result containing the old entry of the entity if successful or a `CrudError`.
+/// If the entity is not found, the error should be `CrudError::NotFound`.
+#[async_trait]
+pub trait DieselCrudUpdate
+where
+    Self: Sized,
+{
+    type Update: AsChangeset;
+    async fn update(update: Self::Update, conn: &mut AsyncPgConnection) -> Result<Self, CrudError>;
+}
+
+/// Deletes an entity from the database
+///
+/// Implementing the trait requires the `async_trait` macro.
+/// # Associations
+/// - `PK` - The primary key of the entity
+/// # Parameters
+/// - `pk` - The primary key of the entity
+/// - `conn` - The database connection
+/// # Returns
+/// A result containing the deleted entity or a `CrudError`.
+/// If the entity is not found, the error should be `CrudError::NotFound`.
+#[async_trait]
+pub trait DieselCrudDelete
+where
+    Self: Sized,
+{
+    type PK;
+    async fn delete(pk: Self::PK, conn: &mut AsyncPgConnection) -> Result<Self, CrudError>;
+}
+
+/// Lists all entities in the table
+///
+/// Implementing the trait requires the `async_trait` macro.
+/// # Parameters
+/// - `conn` - The database connection
+/// # Returns
+/// A result containing a Vec of entities or a `CrudError`.
+#[async_trait]
+pub trait DieselCrudList
+where
+    Self: Sized,
+{
+    async fn list(conn: &mut AsyncPgConnection) -> Result<Vec<Self>, CrudError>;
+}

crates/into_response_derive/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "into-response-derive"
+version = "1.1.0"
+edition = { workspace = true }
+rust-version = { workspace = true }
+
+[lib]
+proc-macro = true
+
+[dependencies]
+syn = { workspace = true }
+quote = { workspace = true }

crates/into_response_derive/src/derive.rs

@@ -0,0 +1,21 @@
+use proc_macro::TokenStream;
+
+use quote::quote;
+use syn::DeriveInput;
+
+// TODO derive generic types
+pub fn into_response_derive_impl(input: DeriveInput) -> TokenStream {
+    let name = &input.ident;
+
+    let expanded = quote! {
+        impl axum::response::IntoResponse for #name {
+            fn into_response(self) -> axum::response::Response {
+                let version = env!("CARGO_PKG_VERSION");
+                lib::serde::response::BaseResponse::new(version, self)
+                    .into_response()
+            }
+        }
+    };
+
+    TokenStream::from(expanded)
+}

crates/into_response_derive/src/lib.rs

@@ -0,0 +1,13 @@
+extern crate proc_macro;
+use {
+    proc_macro::TokenStream,
+    syn::{parse_macro_input, DeriveInput},
+};
+
+mod derive;
+
+#[proc_macro_derive(IntoResponse)]
+pub fn into_response_derive(input: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(input as DeriveInput);
+    derive::into_response_derive_impl(input)
+}

crates/read_files/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "read-files"
+version = "0.1.0"
+edition = { workspace = true }
+rust-version = { workspace = true }
+
+[lib]
+proc-macro = true
+
+[dependencies]
+syn = { workspace = true }
+quote = { workspace = true }
+regex = "1.10"

crates/read_files/src/lib.rs

@@ -0,0 +1,34 @@
+extern crate proc_macro;
+use proc_macro::TokenStream;
+
+use syn::parse_macro_input;
+
+use crate::read_files::read_files_to_string_impl;
+
+mod read_files;
+
+/// Read files from a directory into a HashMap.
+/// The key is the file path relative to the root directory.
+/// The value is the file contents as a string.
+/// # Arguments
+/// * `path` - The directory to search for files, relative to the root directory.
+/// * `pattern` - The regex pattern to match files against. If missing, all files are matched.
+/// # Returns
+/// A HashMap containing the file paths and contents.
+/// # Example
+/// ```
+/// use read_files::read_files_to_string;
+///
+/// let files = read_files_to_string!("./src", ".rs$");
+/// assert!(!files.is_empty());
+/// ```
+/// # Panics
+/// If the path is empty. \
+/// If the pattern is invalid. \
+/// If the path does not exist. \
+/// If there are unexpected tokens. \
+#[proc_macro]
+pub fn read_files_to_string(input: TokenStream) -> TokenStream {
+    let args = parse_macro_input!(input as read_files::Args);
+    read_files_to_string_impl(args)
+}

crates/read_files/src/read_files.rs

@@ -0,0 +1,124 @@
+extern crate proc_macro;
+
+use proc_macro::TokenStream;
+use std::{
+    collections::HashMap,
+    fs::{metadata, read_dir, read_to_string},
+    io,
+    path::{Path, PathBuf},
+};
+
+use quote::quote;
+use syn::{
+    parse::{Parse, ParseStream},
+    LitStr, Token,
+};
+
+pub fn read_files_to_string_impl(args: Args) -> TokenStream {
+    let (keys, values) = split_hashmap(args);
+
+    let expanded = quote! {
+        {
+            let keys = vec![#( #keys, )*];
+            let values = vec![#( #values, )*];
+            keys.into_iter()
+                .zip(values.into_iter())
+                .collect::<std::collections::HashMap<&'static str, &'static str>>()
+        }
+    };
+    expanded.into()
+}
+
+pub struct Args {
+    pub path: String,
+    pub pattern: String,
+}
+
+struct Syntax {
+    path: LitStr,
+    /* Comma */
+    pattern: Option<LitStr>,
+}
+
+impl From<Syntax> for Args {
+    fn from(syntax: Syntax) -> Self {
+        Self {
+            path: syntax.path.value(),
+            pattern: syntax
+                .pattern
+                .map(|pattern| pattern.value())
+                .unwrap_or_default(),
+        }
+    }
+}
+
+impl Parse for Args {
+    fn parse(stream: ParseStream) -> syn::Result<Self> {
+        if stream.is_empty() {
+            panic!("Expected path argument");
+        }
+
+        let path: LitStr = stream.parse()?;
+        if path.value().is_empty() {
+            panic!("Path must not be empty");
+        }
+
+        let pattern = if stream.peek(Token![,]) {
+            stream.parse::<Token![,]>()?;
+            Some(stream.parse()?)
+        } else {
+            None
+        };
+
+        let syntax = Syntax { path, pattern };
+        if !stream.is_empty() {
+            panic!("Expected end of input");
+        }
+
+        Ok(syntax.into())
+    }
+}
+
+pub fn split_hashmap(args: Args) -> (Vec<String>, Vec<String>) {
+    read_files_to_string(Path::new(&args.path), &args.pattern)
+        .unwrap()
+        .into_iter()
+        .map(|(key, value)| (key.to_string_lossy().to_string(), value))
+        .collect()
+}
+
+/// Find files within a directory and load them into a HashMap.
+/// The key is the file path relative to the root directory.
+/// The value is the file contents as a string.
+/// # Arguments
+/// * `path` - The directory to search for files.
+/// * `extension` - The pattern to match files against.
+/// # Returns
+/// A HashMap containing the file paths and contents.
+pub fn read_files_to_string(
+    path: &Path,
+    pattern: &str,
+) -> Result<HashMap<PathBuf, String>, io::Error> {
+    use regex::Regex;
+
+    let mut files: HashMap<PathBuf, String> = HashMap::new();
+    let dir = read_dir(path)?;
+
+    for entry in dir {
+        let entry = entry?;
+        let path = entry.path();
+        let file_name = entry.file_name();
+        let file_name = file_name.to_string_lossy();
+        let metadata = metadata(&path)?;
+
+        let regex =
+            Regex::new(pattern).map_err(|e| io::Error::new(io::ErrorKind::InvalidInput, e))?;
+        if metadata.is_file() && regex.is_match(file_name.as_ref()) {
+            let file = read_to_string(&path)?;
+            files.insert(path, file);
+        } else if metadata.is_dir() {
+            files.extend(read_files_to_string(&path, pattern)?);
+        }
+    }
+    Ok(files)
+}

crates/read_files/tests/lib.rs

@@ -0,0 +1,13 @@
+use read_files::read_files_to_string;
+
+#[test]
+fn test_load_files() {
+    let files = read_files_to_string!("./src", ".rs$");
+    assert!(!files.is_empty());
+}
+
+#[test]
+fn test_load_all_files() {
+    let files = read_files_to_string!("./src");
+    assert!(!files.is_empty());
+}

crates/tests/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "tests"
+version = "0.1.0"
+edition.workspace = true
+rust-version.workspace = true
+authors.workspace = true
+homepage.workspace = true
+
+[dependencies]
+diesel = { workspace = true }
+diesel-async = { workspace = true }
+lib = { path = "../../../rust-lib", features = ["diesel", "derive"] }
+derive_more = { workspace = true, features = ["constructor", "from"] }
+
+[dev-dependencies]
+tokio = { workspace = true, features = ["macros"] }
+testcontainers-modules = { version = "0.9", features = ["postgres"] }
+diesel_async_migrations = "0.14"

crates/tests/diesel.toml

@@ -0,0 +1,9 @@
+# For documentation on how to configure this file,
+# see https://diesel.rs/guides/configuring-diesel-cli
+
+[print_schema]
+file = "src/schema.rs"
+custom_type_derives = ["diesel::query_builder::QueryId", "Clone"]
+
+[migrations_directory]
+dir = "/home/martin/git/rust/lib/crates/tests/migrations"

crates/tests/migrations/00000000000000_diesel_initial_setup/down.sql

@@ -0,0 +1,6 @@
+-- This file was automatically created by Diesel to setup helper functions
+-- and other internal bookkeeping. This file is safe to edit, any future
+-- changes will be added to existing projects as new migrations.
+
+DROP FUNCTION IF EXISTS diesel_manage_updated_at(_tbl regclass);
+DROP FUNCTION IF EXISTS diesel_set_updated_at();

crates/tests/migrations/00000000000000_diesel_initial_setup/up.sql

@@ -0,0 +1,36 @@
+-- This file was automatically created by Diesel to setup helper functions
+-- and other internal bookkeeping. This file is safe to edit, any future
+-- changes will be added to existing projects as new migrations.
+
+
+
+
+-- Sets up a trigger for the given table to automatically set a column called
+-- `updated_at` whenever the row is modified (unless `updated_at` was included
+-- in the modified columns)
+--
+-- # Example
+--
+-- ```sql
+-- CREATE TABLE users (id SERIAL PRIMARY KEY, updated_at TIMESTAMP NOT NULL DEFAULT NOW());
+--
+-- SELECT diesel_manage_updated_at('users');
+-- ```
+CREATE OR REPLACE FUNCTION diesel_manage_updated_at(_tbl regclass) RETURNS VOID AS $$
+BEGIN
+    EXECUTE format('CREATE TRIGGER set_updated_at BEFORE UPDATE ON %s
+                    FOR EACH ROW EXECUTE PROCEDURE diesel_set_updated_at()', _tbl);
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE OR REPLACE FUNCTION diesel_set_updated_at() RETURNS trigger AS $$
+BEGIN
+    IF (
+        NEW IS DISTINCT FROM OLD AND
+        NEW.updated_at IS NOT DISTINCT FROM OLD.updated_at
+    ) THEN
+        NEW.updated_at := current_timestamp;
+    END IF;
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;

crates/tests/migrations/2024-08-04-214620_init_tables/down.sql

@@ -0,0 +1 @@
+DROP TABLE IF EXISTS "user" CASCADE;

crates/tests/migrations/2024-08-04-214620_init_tables/up.sql

@@ -0,0 +1,4 @@
+CREATE TABLE "user"
+(
+    email VARCHAR(255) PRIMARY KEY
+);

crates/tests/src/lib.rs

@@ -0,0 +1 @@
+// This file is needed to make the tests directory a crate

crates/tests/tests/diesel_crud_derive.rs

@@ -0,0 +1,61 @@
+use diesel::{AsChangeset, Insertable, Queryable, Selectable};
+use lib::diesel_crud_derive::{
+    DieselCrudCreate, DieselCrudDelete, DieselCrudList, DieselCrudRead, DieselCrudUpdate,
+};
+use lib::diesel_crud_trait::DieselCrudCreate;
+use test_containers::create_test_containers_pool;
+
+#[cfg(test)]
+pub mod test_containers;
+
+diesel::table! {
+    user (email) {
+        #[max_length = 255]
+        email -> Varchar,
+    }
+}
+
+#[derive(
+    Debug,
+    PartialEq,
+    Queryable,
+    Selectable,
+    Insertable,
+    AsChangeset,
+    DieselCrudCreate,
+    DieselCrudDelete,
+    DieselCrudList,
+    DieselCrudRead,
+    DieselCrudUpdate,
+)]
+#[diesel_crud(insert = InsertUser)]
+#[diesel(table_name = user)]
+struct User {
+    #[diesel_crud(pk)]
+    email: String,
+}
+
+#[derive(Clone, Insertable)]
+#[diesel(table_name = user)]
+struct InsertUser {
+    email: String,
+}
+
+#[tokio::test]
+async fn test_insert_user() {
+    let container = create_test_containers_pool().await.unwrap();
+    let mut conn = container.pool.get().await.unwrap();
+    let user = User::insert(
+        InsertUser {
+            email: "test".to_string(),
+        },
+        &mut conn,
+    )
+    .await;
+    assert_eq!(
+        user,
+        Ok(User {
+            email: "test".to_string()
+        })
+    );
+}

crates/tests/tests/test_containers.rs

@@ -0,0 +1,50 @@
+use derive_more::{Constructor, From};
+use diesel_async::pooled_connection::deadpool::{BuildError, PoolError};
+use diesel_async::AsyncPgConnection;
+use diesel_async_migrations::EmbeddedMigrations;
+use lib::diesel::pool::{create_pool_from_url, PgPool};
+use lib::diesel::DieselError;
+use testcontainers_modules::postgres::Postgres;
+use testcontainers_modules::testcontainers::runners::AsyncRunner;
+use testcontainers_modules::testcontainers::{ContainerAsync, TestcontainersError};
+
+/// When the TestContainer is dropped, the container will be removed.
+/// # Errors
+/// If destructed and the container field is dropped, the container will be stopped
+/// and all connections from the pool will result in DatabaseError.
+#[derive(Constructor)]
+pub struct TestContainer {
+    pub container: ContainerAsync<Postgres>,
+    pub pool: PgPool,
+}
+
+#[derive(Debug, From)]
+pub enum ContainerError {
+    TestContainers(TestcontainersError),
+    BuildError(BuildError),
+    PoolError(PoolError),
+    DieselError(DieselError),
+}
+
+pub async fn create_test_containers_pool<'a>() -> Result<TestContainer, ContainerError> {
+    let container = create_postgres_container().await?;
+    let connection_string = format!(
+        "postgres://postgres:postgres@localhost:{}/postgres",
+        container.get_host_port_ipv4(5432).await?
+    );
+    let pool = create_pool_from_url(connection_string)?;
+    run_migrations(pool.get().await?.as_mut()).await?;
+    Ok(TestContainer::new(container, pool))
+}
+
+pub(crate) async fn run_migrations(
+    conn: &mut AsyncPgConnection,
+) -> Result<(), diesel::result::Error> {
+    static EMBEDDED_MIGRATIONS: EmbeddedMigrations =
+        diesel_async_migrations::embed_migrations!("./migrations");
+    EMBEDDED_MIGRATIONS.run_pending_migrations(conn).await
+}
+
+pub async fn create_postgres_container() -> Result<ContainerAsync<Postgres>, TestcontainersError> {
+    Postgres::default().start().await
+}

derive/Cargo.lock

@@ -1,46 +0,0 @@
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-version = 3
-
-[[package]]
-name = "derive"
-version = "1.0.0"
-dependencies = [
- "quote",
- "syn",
-]
-
-[[package]]
-name = "proc-macro2"
-version = "1.0.85"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22244ce15aa966053a896d1accb3a6e68469b97c7f33f284b99f0d576879fc23"
-dependencies = [
- "unicode-ident",
-]
-
-[[package]]
-name = "quote"
-version = "1.0.36"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fa76aaf39101c457836aec0ce2316dbdc3ab723cdda1c6bd4e6ad4208acaca7"
-dependencies = [
- "proc-macro2",
-]
-
-[[package]]
-name = "syn"
-version = "2.0.67"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ff8655ed1d86f3af4ee3fd3263786bc14245ad17c4c7e85ba7187fb3ae028c90"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-ident",
-]
-
-[[package]]
-name = "unicode-ident"
-version = "1.0.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"

derive/Cargo.toml

@@ -1,12 +0,0 @@
-[package]
-name = "derive"
-version = "1.0.0"
-edition = "2021"
-authors = ["Martin Berg Alstad"]
-
-[lib]
-proc-macro = true
-
-[dependencies]
-syn = "2.0.66"
-quote = "1.0.36"

derive/src/lib.rs

@@ -1,27 +0,0 @@
-extern crate proc_macro;
-
-use proc_macro::TokenStream;
-use quote::quote;
-use syn::{parse_macro_input, DeriveInput};
-
-#[proc_macro_derive(IntoResponse)]
-pub fn into_response_derive(input: TokenStream) -> TokenStream {
-    let input = parse_macro_input!(input as DeriveInput);
-    into_response_derive_impl(input)
-}
-
-fn into_response_derive_impl(input: DeriveInput) -> TokenStream {
-    let name = &input.ident;
-
-    let expanded = quote! {
-        impl IntoResponse for #name {
-            fn into_response(self) -> Response {
-                let version = env!("CARGO_PKG_VERSION");
-                lib::serde::response::BaseResponse::new(version, self)
-                    .into_response()
-            }
-        }
-    };
-
-    TokenStream::from(expanded)
-}

examples/multipart_file/Cargo.lock

@@ -0,0 +1,897 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "addr2line"
+version = "0.22.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e4503c46a5c0c7844e948c9a4d6acd9f50cccb4de1c48eb9e291ea17470c678"
+dependencies = [
+ "gimli",
+]
+
+[[package]]
+name = "adler"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
+
+[[package]]
+name = "async-trait"
+version = "0.1.80"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c6fa2087f2753a7da8cc1c0dbfcf89579dd57458e36769de5ac750b4671737ca"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "axum"
+version = "0.7.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a6c9af12842a67734c9a2e355436e5d03b22383ed60cf13cd0c18fbfe3dcbcf"
+dependencies = [
+ "async-trait",
+ "axum-core",
+ "bytes",
+ "futures-util",
+ "http",
+ "http-body",
+ "http-body-util",
+ "hyper",
+ "hyper-util",
+ "itoa",
+ "matchit",
+ "memchr",
+ "mime",
+ "multer",
+ "percent-encoding",
+ "pin-project-lite",
+ "rustversion",
+ "serde",
+ "serde_json",
+ "serde_path_to_error",
+ "serde_urlencoded",
+ "sync_wrapper 1.0.1",
+ "tokio",
+ "tower 0.4.13",
+ "tower-layer",
+ "tower-service",
+ "tracing",
+]
+
+[[package]]
+name = "axum-core"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a15c63fd72d41492dc4f497196f5da1fb04fb7529e631d73630d1b491e47a2e3"
+dependencies = [
+ "async-trait",
+ "bytes",
+ "futures-util",
+ "http",
+ "http-body",
+ "http-body-util",
+ "mime",
+ "pin-project-lite",
+ "rustversion",
+ "sync_wrapper 0.1.2",
+ "tower-layer",
+ "tower-service",
+ "tracing",
+]
+
+[[package]]
+name = "backtrace"
+version = "0.3.73"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5cc23269a4f8976d0a4d2e7109211a419fe30e8d88d677cd60b6bc79c5732e0a"
+dependencies = [
+ "addr2line",
+ "cc",
+ "cfg-if",
+ "libc",
+ "miniz_oxide",
+ "object",
+ "rustc-demangle",
+]
+
+[[package]]
+name = "bitflags"
+version = "2.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de"
+
+[[package]]
+name = "bytes"
+version = "1.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "514de17de45fdb8dc022b1a7975556c53c86f9f0aa5f534b98977b171857c2c9"
+
+[[package]]
+name = "cc"
+version = "1.0.104"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "74b6a57f98764a267ff415d50a25e6e166f3831a5071af4995296ea97d210490"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "derive_more"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4a9b99b9cbbe49445b21764dc0625032a89b145a2642e67603e1c936f5458d05"
+dependencies = [
+ "derive_more-impl",
+]
+
+[[package]]
+name = "derive_more-impl"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb7330aeadfbe296029522e6c40f315320aba36fc43a5b3632f3795348f3bd22"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "encoding_rs"
+version = "0.8.34"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b45de904aa0b010bce2ab45264d0631681847fa7b6f2eaa7dab7619943bc4f59"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "fnv"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
+
+[[package]]
+name = "form_urlencoded"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e13624c2627564efccf4934284bdd98cbaa14e79b0b5a141218e507b3a823456"
+dependencies = [
+ "percent-encoding",
+]
+
+[[package]]
+name = "futures-channel"
+version = "0.3.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eac8f7d7865dcb88bd4373ab671c8cf4508703796caa2b1985a9ca867b3fcb78"
+dependencies = [
+ "futures-core",
+]
+
+[[package]]
+name = "futures-core"
+version = "0.3.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dfc6580bb841c5a68e9ef15c77ccc837b40a7504914d52e47b8b0e9bbda25a1d"
+
+[[package]]
+name = "futures-task"
+version = "0.3.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38d84fa142264698cdce1a9f9172cf383a0c82de1bddcf3092901442c4097004"
+
+[[package]]
+name = "futures-util"
+version = "0.3.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d6401deb83407ab3da39eba7e33987a73c3df0c82b4bb5813ee871c19c41d48"
+dependencies = [
+ "futures-core",
+ "futures-task",
+ "pin-project-lite",
+ "pin-utils",
+]
+
+[[package]]
+name = "gimli"
+version = "0.29.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "40ecd4077b5ae9fd2e9e169b102c6c330d0605168eb0e8bf79952b256dbefffd"
+
+[[package]]
+name = "hermit-abi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d231dfb89cfffdbc30e7fc41579ed6066ad03abda9e567ccafae602b97ec5024"
+
+[[package]]
+name = "http"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "21b9ddb458710bc376481b842f5da65cdf31522de232c1ca8146abce2a358258"
+dependencies = [
+ "bytes",
+ "fnv",
+ "itoa",
+]
+
+[[package]]
+name = "http-body"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1cac85db508abc24a2e48553ba12a996e87244a0395ce011e62b37158745d643"
+dependencies = [
+ "bytes",
+ "http",
+]
+
+[[package]]
+name = "http-body-util"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "793429d76616a256bcb62c2a2ec2bed781c8307e797e2598c50010f2bee2544f"
+dependencies = [
+ "bytes",
+ "futures-util",
+ "http",
+ "http-body",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "httparse"
+version = "1.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fcc0b4a115bf80b728eb8ea024ad5bd707b615bfed49e0665b6e0f86fd082d9"
+
+[[package]]
+name = "httpdate"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"
+
+[[package]]
+name = "hyper"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4fe55fb7a772d59a5ff1dfbff4fe0258d19b89fec4b233e75d35d5d2316badc"
+dependencies = [
+ "bytes",
+ "futures-channel",
+ "futures-util",
+ "http",
+ "http-body",
+ "httparse",
+ "httpdate",
+ "itoa",
+ "pin-project-lite",
+ "smallvec",
+ "tokio",
+]
+
+[[package]]
+name = "hyper-util"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3ab92f4f49ee4fb4f997c784b7a2e0fa70050211e0b6a287f898c3c9785ca956"
+dependencies = [
+ "bytes",
+ "futures-util",
+ "http",
+ "http-body",
+ "hyper",
+ "pin-project-lite",
+ "tokio",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
+
+[[package]]
+name = "lazy_static"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
+
+[[package]]
+name = "lib"
+version = "1.4.3"
+dependencies = [
+ "axum",
+ "derive_more",
+ "mime",
+ "thiserror",
+ "tokio",
+ "tower 0.5.0",
+ "tower-http",
+ "tracing",
+ "tracing-subscriber",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.155"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97b3888a4aecf77e811145cadf6eef5901f4782c53886191b2f693f24761847c"
+
+[[package]]
+name = "log"
+version = "0.4.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24"
+
+[[package]]
+name = "matchit"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0e7465ac9959cc2b1404e8e2367b43684a6d13790fe23056cc8c6c5a6b7bcb94"
+
+[[package]]
+name = "memchr"
+version = "2.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
+
+[[package]]
+name = "mime"
+version = "0.3.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a"
+
+[[package]]
+name = "miniz_oxide"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8a240ddb74feaf34a79a7add65a741f3167852fba007066dcac1ca548d89c08"
+dependencies = [
+ "adler",
+]
+
+[[package]]
+name = "mio"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "80e04d1dcff3aae0704555fe5fee3bcfaf3d1fdf8a7e521d5b9d2b42acb52cec"
+dependencies = [
+ "hermit-abi",
+ "libc",
+ "wasi",
+ "windows-sys",
+]
+
+[[package]]
+name = "multer"
+version = "3.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "83e87776546dc87511aa5ee218730c92b666d7264ab6ed41f9d215af9cd5224b"
+dependencies = [
+ "bytes",
+ "encoding_rs",
+ "futures-util",
+ "http",
+ "httparse",
+ "memchr",
+ "mime",
+ "spin",
+ "version_check",
+]
+
+[[package]]
+name = "multipart_file"
+version = "0.1.0"
+dependencies = [
+ "axum",
+ "lib",
+ "tokio",
+]
+
+[[package]]
+name = "nu-ansi-term"
+version = "0.46.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77a8165726e8236064dbb45459242600304b42a5ea24ee2948e18e023bf7ba84"
+dependencies = [
+ "overload",
+ "winapi",
+]
+
+[[package]]
+name = "object"
+version = "0.36.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "081b846d1d56ddfc18fdf1a922e4f6e07a11768ea1b92dec44e42b72712ccfce"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"
+
+[[package]]
+name = "overload"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39"
+
+[[package]]
+name = "percent-encoding"
+version = "2.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e"
+
+[[package]]
+name = "pin-project"
+version = "1.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6bf43b791c5b9e34c3d182969b4abb522f9343702850a2e57f460d00d09b4b3"
+dependencies = [
+ "pin-project-internal",
+]
+
+[[package]]
+name = "pin-project-internal"
+version = "1.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2f38a4412a78282e09a2cf38d195ea5420d15ba0602cb375210efbc877243965"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "pin-project-lite"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bda66fc9667c18cb2758a2ac84d1167245054bcf85d5d1aaa6923f45801bdd02"
+
+[[package]]
+name = "pin-utils"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.86"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fa76aaf39101c457836aec0ce2316dbdc3ab723cdda1c6bd4e6ad4208acaca7"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rustc-demangle"
+version = "0.1.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "719b953e2095829ee67db738b3bfa9fa368c94900df327b3f07fe6e794d2fe1f"
+
+[[package]]
+name = "rustversion"
+version = "1.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "955d28af4278de8121b7ebeb796b6a45735dc01436d898801014aced2773a3d6"
+
+[[package]]
+name = "ryu"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f"
+
+[[package]]
+name = "serde"
+version = "1.0.203"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7253ab4de971e72fb7be983802300c30b5a7f0c2e56fab8abfc6a214307c0094"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.203"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "500cbc0ebeb6f46627f50f3f5811ccf6bf00643be300b4c3eabc0ef55dc5b5ba"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.119"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e8eddb61f0697cc3989c5d64b452f5488e2b8a60fd7d5076a3045076ffef8cb0"
+dependencies = [
+ "itoa",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "serde_path_to_error"
+version = "0.1.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af99884400da37c88f5e9146b7f1fd0fbcae8f6eec4e9da38b67d05486f814a6"
+dependencies = [
+ "itoa",
+ "serde",
+]
+
+[[package]]
+name = "serde_urlencoded"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3491c14715ca2294c4d6a88f15e84739788c1d030eed8c110436aafdaa2f3fd"
+dependencies = [
+ "form_urlencoded",
+ "itoa",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "sharded-slab"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f40ca3c46823713e0d4209592e8d6e826aa57e928f09752619fc696c499637f6"
+dependencies = [
+ "lazy_static",
+]
+
+[[package]]
+name = "smallvec"
+version = "1.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"
+
+[[package]]
+name = "socket2"
+version = "0.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ce305eb0b4296696835b71df73eb912e0f1ffd2556a501fcede6e0c50349191c"
+dependencies = [
+ "libc",
+ "windows-sys",
+]
+
+[[package]]
+name = "spin"
+version = "0.9.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67"
+
+[[package]]
+name = "syn"
+version = "2.0.68"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "901fa70d88b9d6c98022e23b4136f9f3e54e4662c3bc1bd1d84a42a9a0f0c1e9"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "sync_wrapper"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2047c6ded9c721764247e62cd3b03c09ffc529b2ba5b10ec482ae507a4a70160"
+
+[[package]]
+name = "sync_wrapper"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7065abeca94b6a8a577f9bd45aa0867a2238b74e8eb67cf10d492bc39351394"
+
+[[package]]
+name = "thiserror"
+version = "1.0.61"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c546c80d6be4bc6a00c0f01730c08df82eaa7a7a61f11d656526506112cc1709"
+dependencies = [
+ "thiserror-impl",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.61"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "46c3384250002a6d5af4d114f2845d37b57521033f30d5c3f46c4d70e1197533"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "thread_local"
+version = "1.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b9ef9bad013ada3808854ceac7b46812a6465ba368859a37e2100283d2d719c"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+]
+
+[[package]]
+name = "tokio"
+version = "1.40.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2b070231665d27ad9ec9b8df639893f46727666c6767db40317fbe920a5d998"
+dependencies = [
+ "backtrace",
+ "libc",
+ "mio",
+ "pin-project-lite",
+ "socket2",
+ "tokio-macros",
+ "windows-sys",
+]
+
+[[package]]
+name = "tokio-macros"
+version = "2.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "693d596312e88961bc67d7f1f97af8a70227d9f90c31bba5806eec004978d752"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "tower"
+version = "0.4.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8fa9be0de6cf49e536ce1851f987bd21a43b771b09473c3549a6c853db37c1c"
+dependencies = [
+ "futures-core",
+ "futures-util",
+ "pin-project",
+ "pin-project-lite",
+ "tokio",
+ "tower-layer",
+ "tower-service",
+ "tracing",
+]
+
+[[package]]
+name = "tower"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "36b837f86b25d7c0d7988f00a54e74739be6477f2aac6201b8f429a7569991b7"
+dependencies = [
+ "tower-layer",
+ "tower-service",
+]
+
+[[package]]
+name = "tower-http"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e9cd434a998747dd2c4276bc96ee2e0c7a2eadf3cae88e52be55a05fa9053f5"
+dependencies = [
+ "bitflags",
+ "bytes",
+ "http",
+ "http-body",
+ "http-body-util",
+ "pin-project-lite",
+ "tower-layer",
+ "tower-service",
+ "tracing",
+]
+
+[[package]]
+name = "tower-layer"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c20c8dbed6283a09604c3e69b4b7eeb54e298b8a600d4d5ecb5ad39de609f1d0"
+
+[[package]]
+name = "tower-service"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6bc1c9ce2b5135ac7f93c72918fc37feb872bdc6a5533a8b85eb4b86bfdae52"
+
+[[package]]
+name = "tracing"
+version = "0.1.40"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3523ab5a71916ccf420eebdf5521fcef02141234bbc0b8a49f2fdc4544364ef"
+dependencies = [
+ "log",
+ "pin-project-lite",
+ "tracing-attributes",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-attributes"
+version = "0.1.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34704c8d6ebcbc939824180af020566b01a7c01f80641264eba0999f6c2b6be7"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "tracing-core"
+version = "0.1.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c06d3da6113f116aaee68e4d601191614c9053067f9ab7f6edbcb161237daa54"
+dependencies = [
+ "once_cell",
+ "valuable",
+]
+
+[[package]]
+name = "tracing-log"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee855f1f400bd0e5c02d150ae5de3840039a3f54b025156404e34c23c03f47c3"
+dependencies = [
+ "log",
+ "once_cell",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-subscriber"
+version = "0.3.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ad0f048c97dbd9faa9b7df56362b8ebcaa52adb06b498c050d2f4e32f90a7a8b"
+dependencies = [
+ "nu-ansi-term",
+ "sharded-slab",
+ "smallvec",
+ "thread_local",
+ "tracing-core",
+ "tracing-log",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
+
+[[package]]
+name = "valuable"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "830b7e5d4d90034032940e4ace0d9a9a057e7a45cd94e6c007832e39edb82f6d"
+
+[[package]]
+name = "version_check"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
+
+[[package]]
+name = "wasi"
+version = "0.11.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
+[[package]]
+name = "windows-sys"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
+dependencies = [
+ "windows-targets",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.52.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6f0713a46559409d202e70e28227288446bf7841d3211583a4b53e3f6d96e7eb"
+dependencies = [
+ "windows_aarch64_gnullvm",
+ "windows_aarch64_msvc",
+ "windows_i686_gnu",
+ "windows_i686_gnullvm",
+ "windows_i686_msvc",
+ "windows_x86_64_gnu",
+ "windows_x86_64_gnullvm",
+ "windows_x86_64_msvc",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.52.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7088eed71e8b8dda258ecc8bac5fb1153c5cffaf2578fc8ff5d61e23578d3263"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.52.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9985fd1504e250c615ca5f281c3f7a6da76213ebd5ccc9561496568a2752afb6"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.52.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "88ba073cf16d5372720ec942a8ccbf61626074c6d4dd2e745299726ce8b89670"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.52.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "87f4261229030a858f36b459e748ae97545d6f1ec60e5e0d6a3d32e0dc232ee9"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.52.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db3c2bf3d13d5b658be73463284eaf12830ac9a26a90c717b7f771dfe97487bf"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.52.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4e4246f76bdeff09eb48875a0fd3e2af6aada79d409d33011886d3e1581517d9"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.52.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "852298e482cd67c356ddd9570386e2862b5673c85bd5f88df9ab6802b334c596"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.52.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bec47e5bfd1bff0eeaf6d8b485cc1074891a197ab4225d504cb7a1ab88b02bf0"

examples/multipart_file/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "multipart_file"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+lib = { path = "../..", features = ["axum"] }
+axum = "0.7.5"
+tokio = { version = "1.40", features = ["rt-multi-thread", "macros"] }

examples/multipart_file/src/main.rs

@@ -0,0 +1,37 @@
+use axum::extract::DefaultBodyLimit;
+use lib::axum::app::AppBuilder;
+use lib::axum::extractor::MultipartFiles;
+use lib::routes;
+
+// 0 or more
+async fn with_optional_file(files: Option<MultipartFiles>) -> String {
+    format!(
+        "{:?}",
+        files.map(|files| files
+            .0
+            .into_iter()
+            .map(|file| file.filename)
+            .collect::<Vec<_>>())
+    )
+}
+
+// 1 or more files
+async fn handler(MultipartFiles(files): MultipartFiles) -> String {
+    format!(
+        "{:?} uploaded",
+        files
+            .into_iter()
+            .map(|file| file.filename)
+            .collect::<Vec<_>>()
+    )
+}
+
+#[tokio::main]
+async fn main() {
+    let route = routes!(
+        get "/" => handler,
+        get "/opt" => with_optional_file
+    )
+    .layer(DefaultBodyLimit::disable());
+    AppBuilder::new().route(route).serve().await.unwrap();
+}

src/axum/app.rs

@@ -1,8 +1,15 @@
-#[cfg(feature = "axum")]
 use {
-    axum::{extract::Request, handler::Handler, Router, ServiceExt},
-    std::net::Ipv4Addr,
-    tower::layer::Layer,
+    axum::{
+        extract::Request, handler::Handler, response::IntoResponse, routing::Route, Router,
+        ServiceExt,
+    },
+    std::{
+        convert::Infallible,
+        io,
+        net::{IpAddr, Ipv4Addr, SocketAddr},
+    },
+    tokio::net::TcpListener,
+    tower::{layer::Layer, Service},
     tower_http::{
         cors::CorsLayer,
         normalize_path::NormalizePathLayer,
@@ -11,12 +18,9 @@ use {
     },
     tracing::{info, Level},
 };
-#[cfg(all(feature = "axum", feature = "tokio"))]
-use {std::io, std::net::SocketAddr, tokio::net::TcpListener};
 
 // TODO trim trailing slash into macro > let _app = NormalizePathLayer::trim_trailing_slash().layer(create_app!(routes));
 #[macro_export]
-#[cfg(feature = "axum")]
 macro_rules! create_app {
     ($router:expr) => {
         $router
@@ -27,31 +31,72 @@ macro_rules! create_app {
 }
 
 #[derive(Default)]
-#[cfg(feature = "axum")]
 pub struct AppBuilder {
     router: Router,
-    socket: Option<(Ipv4Addr, u16)>,
+    socket: Option<(IpAddr, u16)>,
     cors: Option<CorsLayer>,
     normalize_path: Option<bool>,
     tracing: Option<TraceLayer<HttpMakeClassifier>>,
 }
 
-#[cfg(all(feature = "axum", feature = "tokio"))]
 impl AppBuilder {
+    /// Creates a new app builder with default options.
     pub fn new() -> Self {
         Self::default()
     }
 
-    pub fn routes(mut self, routes: &[Router]) -> Self {
-        self.router = routes.iter().cloned().fold(self.router, Router::merge);
+    /// Creates the builder from the given router.
+    /// Only the routes and layers will be used.
+    pub fn from_router(router: Router) -> Self {
+        Self {
+            router,
+            ..Self::default()
+        }
+    }
+
+    /// Adds a route to the previously added routes
+    pub fn route(mut self, route: Router) -> Self {
+        self.router = self.router.merge(route);
         self
     }
 
-    pub fn socket(mut self, socket: impl Into<(Ipv4Addr, u16)>) -> Self {
-        self.socket = Some(socket.into());
+    /// Adds multiple routes to the previously added routes
+    pub fn routes(mut self, routes: impl IntoIterator<Item = Router>) -> Self {
+        self.router = routes.into_iter().fold(self.router, Router::merge);
         self
     }
 
+    /// Adds a layer to the previously added routes
+    pub fn layer<L>(mut self, layer: L) -> Self
+    where
+        L: Layer<Route> + Clone + Send + 'static,
+        L::Service: Service<Request> + Clone + Send + 'static,
+        <L::Service as Service<Request>>::Response: IntoResponse + 'static,
+        <L::Service as Service<Request>>::Error: Into<Infallible> + 'static,
+        <L::Service as Service<Request>>::Future: Send + 'static,
+    {
+        self.router = self.router.layer(layer);
+        self
+    }
+
+    /// Sets the socket for the server.
+    pub fn socket<IP: Into<IpAddr>>(mut self, socket: impl Into<(IP, u16)>) -> Self {
+        let (ip, port) = socket.into();
+        self.socket = Some((ip.into(), port));
+        self
+    }
+
+    /// Sets the port for the server.
+    pub fn port(mut self, port: u16) -> Self {
+        self.socket = if let Some((ip, _)) = self.socket {
+            Some((ip, port))
+        } else {
+            Some((Ipv4Addr::UNSPECIFIED.into(), port))
+        };
+        self
+    }
+
+    /// Sets the fallback handler.
     pub fn fallback<H, T>(mut self, fallback: H) -> Self
     where
         H: Handler<T, ()>,
@@ -61,42 +106,28 @@ impl AppBuilder {
         self
     }
 
+    /// Sets the cors layer.
     pub fn cors(mut self, cors: CorsLayer) -> Self {
         self.cors = Some(cors);
         self
     }
 
+    /// Sets the normalize path option. Default is true.
     pub fn normalize_path(mut self, normalize_path: bool) -> Self {
         self.normalize_path = Some(normalize_path);
         self
     }
 
+    /// Sets the trace layer.
     pub fn tracing(mut self, tracing: TraceLayer<HttpMakeClassifier>) -> Self {
         self.tracing = Some(tracing);
         self
     }
 
-    pub async fn serve(self) -> io::Result<()> {
-        let listener = self.listener().await?;
-        let _ = fmt_trace();
-
-        if self.normalize_path.unwrap_or(true) {
-            let app = NormalizePathLayer::trim_trailing_slash().layer(self.create_app());
-            axum::serve(listener, ServiceExt::<Request>::into_make_service(app)).await?;
-        } else {
-            let app = self.create_app();
-            axum::serve(listener, app.into_make_service()).await?;
-        };
-        Ok(())
-    }
-
-    async fn listener(&self) -> io::Result<TcpListener> {
-        let addr = SocketAddr::from(self.socket.unwrap_or((Ipv4Addr::UNSPECIFIED, 8000)));
-        info!("Initializing server on: {addr}");
-        TcpListener::bind(&addr).await
-    }
-
-    fn create_app(self) -> Router {
+    /// Creates the app with the given options.
+    /// This method is useful for testing purposes.
+    /// Options used for configuring the listener will be lost.
+    pub fn build(self) -> Router {
         let mut app = self.router;
         if let Some(cors) = self.cors {
             app = app.layer(cors);
@@ -109,6 +140,33 @@ impl AppBuilder {
             ),
         )
     }
+
+    /// Build the app and start the server
+    /// # Default Options
+    /// - IP == 0.0.0.0
+    /// - Port == 8000
+    /// - Cors == None
+    /// - Normalize Path == true
+    /// - Tracing == Default compact
+    pub async fn serve(self) -> io::Result<()> {
+        let _ = fmt_trace(); // Allowed to fail
+        let listener = self.listener().await?;
+
+        if self.normalize_path.unwrap_or(true) {
+            let app = NormalizePathLayer::trim_trailing_slash().layer(self.build());
+            axum::serve(listener, ServiceExt::<Request>::into_make_service(app)).await?;
+        } else {
+            let app = self.build();
+            axum::serve(listener, app.into_make_service()).await?;
+        };
+        Ok(())
+    }
+
+    async fn listener(&self) -> io::Result<TcpListener> {
+        let addr = SocketAddr::from(self.socket.unwrap_or((Ipv4Addr::UNSPECIFIED.into(), 8000)));
+        info!("Initializing server on: {addr}");
+        TcpListener::bind(&addr).await
+    }
 }
 
 fn fmt_trace() -> Result<(), String> {
@@ -119,46 +177,39 @@ fn fmt_trace() -> Result<(), String> {
         .map_err(|error| error.to_string())
 }
 
-#[cfg(all(test, feature = "axum"))]
+#[cfg(test)]
 mod tests {
-    use axum::Router;
-
     use super::*;
+    use axum::Router;
+    use std::time::Duration;
+    use tokio::time::sleep;
 
-    #[cfg(feature = "tokio")]
-    mod tokio_tests {
-        use std::time::Duration;
+    #[tokio::test]
+    async fn test_app_builder_serve() {
+        let handler = tokio::spawn(async {
+            AppBuilder::new().serve().await.unwrap();
+        });
+        sleep(Duration::from_millis(250)).await;
+        handler.abort();
+    }
 
-        use tokio::time::sleep;
-
-        use super::*;
-
-        #[tokio::test]
-        async fn test_app_builder_serve() {
-            let handler = tokio::spawn(async {
-                AppBuilder::new().serve().await.unwrap();
-            });
-            sleep(Duration::from_secs(1)).await;
-            handler.abort();
-        }
-
-        #[tokio::test]
-        async fn test_app_builder_all() {
-            let handler = tokio::spawn(async {
-                AppBuilder::new()
-                    .socket((Ipv4Addr::LOCALHOST, 8080))
-                    .routes(&[Router::new()])
-                    .fallback(|| async { "Fallback" })
-                    .cors(CorsLayer::new())
-                    .normalize_path(true)
-                    .tracing(TraceLayer::new_for_http())
-                    .serve()
-                    .await
-                    .unwrap();
-            });
-            sleep(Duration::from_secs(1)).await;
-            handler.abort();
-        }
+    #[tokio::test]
+    async fn test_app_builder_all() {
+        let handler = tokio::spawn(async {
+            AppBuilder::new()
+                .socket((Ipv4Addr::LOCALHOST, 8080))
+                .routes([Router::new()])
+                .fallback(|| async { "Fallback" })
+                .cors(CorsLayer::new())
+                .normalize_path(true)
+                .tracing(TraceLayer::new_for_http())
+                .layer(TraceLayer::new_for_http())
+                .serve()
+                .await
+                .unwrap();
+        });
+        sleep(Duration::from_millis(250)).await;
+        handler.abort();
     }
 
     #[test]

src/axum/extractor.rs

@@ -0,0 +1,191 @@
+use axum::{
+    async_trait,
+    extract::{
+        multipart::{Field, MultipartError, MultipartRejection},
+        FromRequest, Multipart, Request,
+    },
+    response::IntoResponse,
+};
+use mime::Mime;
+use std::str::FromStr;
+use thiserror::Error;
+
+/// A file extracted from a multipart request.
+#[derive(Debug, Clone, PartialEq)]
+pub struct File {
+    pub filename: String,
+    pub bytes: Vec<u8>,
+    pub content_type: Mime,
+}
+
+impl File {
+    /// Creates a new file with the given filename, bytes and content type.
+    pub fn new(
+        filename: impl Into<String>,
+        bytes: impl Into<Vec<u8>>,
+        content_type: impl Into<Mime>,
+    ) -> Self {
+        Self {
+            filename: filename.into(),
+            bytes: bytes.into(),
+            content_type: content_type.into(),
+        }
+    }
+
+    /// Creates a new file from a field in a multipart request.
+    pub async fn from_field(field: Field<'_>) -> Result<Self, MultipartFileRejection> {
+        let filename = field
+            .file_name()
+            .ok_or(MultipartFileRejection::MissingFilename)?
+            .to_string();
+        let content_type = Mime::from_str(field.content_type().ok_or_else(|| {
+            MultipartFileRejection::FieldError("Missing or illegal content type".to_string())
+        })?)?;
+        let bytes = field.bytes().await?;
+        Ok(File::new(filename, bytes, content_type))
+    }
+}
+
+/// Extractor for a single file from a multipart request.
+/// Expects exactly one file. A file must have a name, bytes and optionally a content type.
+/// This extractor consumes the request and must ble placed last in the handler.
+#[derive(Debug, Clone, PartialEq)]
+pub struct MultipartFile(pub File);
+/// Extractor for multiple files from a multipart request.
+/// Expects at least one file. A file must have a name, bytes and optionally a content type.
+/// This extractor consumes the request and must ble placed last in the handler.
+#[derive(Debug, Clone, PartialEq)]
+pub struct MultipartFiles(pub Vec<File>);
+
+/// Rejection type for multipart file extractors.
+#[derive(Debug, Error)]
+pub enum MultipartFileRejection {
+    #[error(transparent)]
+    MultipartRejection(#[from] MultipartRejection),
+    #[error("Field error: {0}")]
+    FieldError(String),
+    #[error(transparent)]
+    FromStrError(#[from] mime::FromStrError),
+    #[error("No files found")]
+    NoFiles,
+    #[error("Expected one file, got several")]
+    SeveralFiles,
+    #[error("Missing filename")]
+    MissingFilename,
+    #[error("Error in body of multipart: {0}")]
+    BodyError(String),
+}
+
+impl From<MultipartError> for MultipartFileRejection {
+    fn from(error: MultipartError) -> Self {
+        MultipartFileRejection::BodyError(error.body_text())
+    }
+}
+
+impl IntoResponse for MultipartFileRejection {
+    fn into_response(self) -> axum::response::Response {
+        match self {
+            MultipartFileRejection::MultipartRejection(rejection) => rejection.into_response(),
+            MultipartFileRejection::FieldError(error) => {
+                (axum::http::StatusCode::BAD_REQUEST, error).into_response()
+            }
+            MultipartFileRejection::NoFiles => {
+                (axum::http::StatusCode::BAD_REQUEST, "No files found").into_response()
+            }
+            MultipartFileRejection::SeveralFiles => (
+                axum::http::StatusCode::BAD_REQUEST,
+                "Expected one file, got several",
+            )
+                .into_response(),
+            MultipartFileRejection::MissingFilename => {
+                (axum::http::StatusCode::BAD_REQUEST, "Missing filename").into_response()
+            }
+            MultipartFileRejection::BodyError(error) => {
+                (axum::http::StatusCode::BAD_REQUEST, error).into_response()
+            }
+            MultipartFileRejection::FromStrError(error) => {
+                (axum::http::StatusCode::BAD_REQUEST, error.to_string()).into_response()
+            }
+        }
+    }
+}
+
+#[async_trait]
+impl<S> FromRequest<S> for MultipartFile
+where
+    S: Send + Sync,
+{
+    type Rejection = MultipartFileRejection;
+
+    /// Extracts a single file from a multipart request.
+    /// Expects exactly one file. A file must have a name, bytes and optionally a content type.
+    /// This extractor consumes the request and must ble placed last in the handler.
+    /// # Example
+    /// ```
+    /// use std::str::from_utf8;
+    /// use axum::response::Html;
+    /// use lib::axum::extractor::MultipartFile;
+    ///
+    /// async fn upload_file(MultipartFile(file): MultipartFile) -> Html<String> {
+    ///     Html(String::from_utf8(file.bytes).unwrap())
+    /// }
+    /// ```
+    async fn from_request(req: Request, state: &S) -> Result<Self, Self::Rejection> {
+        let multipart = Multipart::from_request(req, state).await?;
+        let files = get_files(multipart).await?;
+        if files.len() > 1 {
+            Err(MultipartFileRejection::SeveralFiles)
+        } else {
+            let field = files.first().ok_or(MultipartFileRejection::NoFiles)?;
+            Ok(MultipartFile(field.clone()))
+        }
+    }
+}
+
+#[async_trait]
+impl<S> FromRequest<S> for MultipartFiles
+where
+    S: Send + Sync,
+{
+    type Rejection = MultipartFileRejection;
+
+    /// Extracts multiple files from a multipart request.
+    /// Expects at least one file. A file must have a name, bytes and optionally a content type.
+    /// This extractor consumes the request and must ble placed last in the handler.
+    /// # Example
+    /// ```
+    /// use axum::response::Html;
+    /// use lib::axum::extractor::MultipartFiles;
+    /// use std::str::from_utf8;
+    ///
+    /// async fn upload_files(MultipartFiles(files): MultipartFiles) -> Html<String> {
+    ///     let content = files
+    ///         .iter()
+    ///         .map(|file| String::from_utf8(file.bytes.clone()).unwrap())
+    ///         .collect::<Vec<String>>()
+    ///         .join("<br>");
+    ///     Html(content)
+    /// }
+    /// ```
+    async fn from_request(req: Request, state: &S) -> Result<Self, Self::Rejection> {
+        let multipart = Multipart::from_request(req, state).await?;
+        let files = get_files(multipart).await?;
+        if files.is_empty() {
+            Err(MultipartFileRejection::NoFiles)
+        } else {
+            Ok(MultipartFiles(files))
+        }
+    }
+}
+
+async fn get_files<'a>(mut multipart: Multipart) -> Result<Vec<File>, MultipartFileRejection> {
+    let mut files = vec![];
+    while let Some(field) = multipart.next_field().await? {
+        files.push(File::from_field(field).await?);
+    }
+    if files.is_empty() {
+        Err(MultipartFileRejection::NoFiles)
+    } else {
+        Ok(files)
+    }
+}

src/axum/load.rs

@@ -1,5 +1,9 @@
-#[cfg(all(feature = "tokio", feature = "axum"))]
-use {crate::io::file, axum::body::Body, axum::response::Html, std::io};
+#[cfg(feature = "io")]
+use {
+    crate::io::file,
+    axum::{body::Body, response::Html},
+    std::io,
+};
 
 /// Load an HTML file from the given file path, relative to the current directory.
 /// # Arguments
@@ -10,7 +14,7 @@ use {crate::io::file, axum::body::Body, axum::response::Html, std::io};
 /// ```
 /// let html = async { lib::axum::load::load_html("openapi.html").await.unwrap() };
 /// ```
-#[cfg(all(feature = "tokio", feature = "axum"))]
+#[cfg(feature = "io")]
 pub async fn load_html<Path>(file_path: Path) -> Result<Html<Body>, io::Error>
 where
     Path: AsRef<std::path::Path>,
@@ -18,7 +22,7 @@ where
     load_file(file_path).await.map(Html)
 }
 
-#[cfg(all(feature = "tokio", feature = "axum"))]
+#[cfg(feature = "io")]
 pub async fn load_file<Path>(file_path: Path) -> Result<Body, io::Error>
 where
     Path: AsRef<std::path::Path>,
@@ -38,7 +42,6 @@ where
 /// ```
 // TODO check platform and use correct path separator
 #[macro_export]
-#[cfg(feature = "axum")]
 macro_rules! load_html {
     ($filepath:expr) => {
         axum::response::Html(
@@ -58,7 +61,7 @@ macro_rules! load_html {
     };
 }
 
-#[cfg(all(test, feature = "axum"))]
+#[cfg(test)]
 mod tests {
     #[test]
     fn test_load_html() {
@@ -71,7 +74,7 @@ mod tests {
             load_html!("load.rs", "{{replace_me}}" => "hello", "{{replace_me_too}}" => "world");
     }
 
-    #[cfg(feature = "tokio")]
+    #[cfg(feature = "io")]
     mod tokio {
         use super::super::*;
 

src/axum/mod.rs

@@ -1,4 +1,8 @@
 pub mod app;
+pub mod extractor;
 pub mod load;
+#[cfg(feature = "serde")]
 pub mod response;
 pub mod router;
+#[cfg(feature = "serde")]
+pub mod wrappers;

src/axum/response.rs

@@ -1,4 +1,3 @@
-#[cfg(all(feature = "axum", feature = "serde"))]
 use {
     crate::serde::response::BaseResponse,
     axum::{
@@ -8,18 +7,18 @@ use {
     serde::Serialize,
 };
 
-#[cfg(all(feature = "axum", feature = "serde"))]
 impl<T: Serialize> IntoResponse for BaseResponse<T> {
     fn into_response(self) -> Response {
         Json(self).into_response()
     }
 }
 
-#[cfg(all(test, feature = "axum", feature = "serde"))]
+#[cfg(test)]
 mod tests {
     use axum::http::header::CONTENT_TYPE;
     use axum::http::{HeaderValue, StatusCode};
     use axum::response::IntoResponse;
+    use mime::APPLICATION_JSON;
     use serde::Serialize;
 
     use crate::serde::response::BaseResponse;
@@ -41,7 +40,7 @@ mod tests {
         assert_eq!(json_response.status(), StatusCode::OK);
         assert_eq!(
             json_response.headers().get(CONTENT_TYPE),
-            Some(&HeaderValue::from_static("application/json"))
+            Some(&HeaderValue::from_static(APPLICATION_JSON.as_ref()))
         );
     }
 

src/axum/router.rs

@@ -18,16 +18,39 @@
 /// ));
 /// ```
 #[macro_export]
-#[cfg(feature = "axum")]
 macro_rules! router {
     ($body:expr) => {
-        pub(crate) fn router() -> axum::Router<()> {
+        pub fn router() -> axum::Router {
+            $body
+        }
+    };
+    ($body:expr; $state:ty) => {
+        pub fn router() -> axum::Router<$state> {
+            $body
+        }
+    };
+    ($body:expr; $state:ident: $($bound:tt),*) => {
+        pub fn router<$state: $($bound+)* 'static>() -> axum::Router<$state> {
+            $body
+        }
+    };
+    ($body:expr; $generic:ident: $($bound:tt),* -> $state:ty) => {
+        pub fn router<$generic: $($bound+)* 'static>() -> axum::Router<$state<$generic>> {
             $body
         }
     };
     ($route:expr, $router:expr) => {
         router!(axum::Router::new().nest($route, $router));
     };
+    ($route:expr, $router:expr, $state:ty) => {
+        router!(axum::Router::new().nest($route, $router); $state);
+    };
+    ($route:expr, $router:expr, $state:ident: $($bound:tt),*) => {
+        router!(axum::Router::new().nest($route, $router); $state: $($bound),*);
+    };
+      ($route:expr, $router:expr, $generic:ident: $($bound:tt),* -> $state:ty) => {
+        router!(axum::Router::new().nest($route, $router); $generic: $($bound),* -> $state);
+    };
     ($($method:ident $route:expr => $func:expr),* $(,)?) => {
         router!($crate::routes!($($method $route => $func),*));
     };
@@ -44,7 +67,6 @@ macro_rules! router {
 /// );
 /// ```
 #[macro_export]
-#[cfg(feature = "axum")]
 macro_rules! routes {
     ($($method:ident $route:expr => $func:expr),* $(,)?) => {
         axum::Router::new()
@@ -54,8 +76,12 @@ macro_rules! routes {
     };
 }
 
+/// Merges the given routers into a single router.
+/// # Examples
+/// ```
+/// let _: axum::Router<()> = lib::join_routes![axum::Router::new(), axum::Router::new()];
+/// ```
 #[macro_export]
-#[cfg(feature = "axum")]
 macro_rules! join_routes {
     ($($route:expr),* $(,)?) => {
         axum::Router::new()$(
@@ -64,8 +90,9 @@ macro_rules! join_routes {
     };
 }
 
-#[cfg(all(test, feature = "axum"))]
+#[cfg(test)]
 mod tests {
+    use axum::extract::State;
     use axum::Router;
 
     async fn index() {}
@@ -94,9 +121,33 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_nested_router_with_state() {
+        router!(
+            "/simplify",
+            routes!(
+                get "/:exp" => || async {},
+                get "/table/:exp" => |_state: State<String>| async {}
+            ),
+            String
+        );
+    }
+
+    #[test]
+    fn test_nested_router_with_generic_state() {
+        router!(
+            "/simplify",
+            routes!(
+                get "/:exp" => || async {},
+                get "/table/:exp" => |_state: State<T>| async {}
+            ),
+            T: Clone, Send, Sync
+        );
+    }
+
     #[test]
     fn test_routes() {
-        let _router: Router<()> = routes!(
+        let _router: Router = routes!(
             get "/" => index,
             post "/" => || async {}
         );
@@ -104,6 +155,6 @@ mod tests {
 
     #[test]
     fn test_join_routes() {
-        let _router: Router<()> = join_routes![Router::new(), Router::new()];
+        let _router: Router = join_routes![Router::new(), Router::new()];
     }
 }

src/axum/wrappers.rs

@@ -0,0 +1,24 @@
+use axum::response::{IntoResponse, Response};
+use derive_more::{Constructor, From};
+use into_response_derive::IntoResponse;
+use serde::Serialize;
+
+/// Wrapper for a vector of items.
+#[derive(Debug, Clone, PartialEq, Default, Serialize, From, Constructor)]
+pub struct Array<T: Serialize> {
+    pub data: Vec<T>,
+}
+
+/// Wrapper for a count.
+#[derive(
+    Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, IntoResponse, From, Constructor,
+)]
+pub struct Count {
+    pub count: usize,
+}
+
+impl<T: Serialize> IntoResponse for Array<T> {
+    fn into_response(self) -> Response {
+        crate::from!(self).into_response()
+    }
+}

src/diesel/mod.rs

@@ -0,0 +1,4 @@
+pub mod pool;
+
+/// Re-export diesel::result::Error as DieselError
+pub type DieselError = diesel::result::Error;

src/diesel/pool.rs

@@ -0,0 +1,24 @@
+use deadpool_diesel::postgres::BuildError;
+use diesel_async::pooled_connection::deadpool::Pool;
+use diesel_async::pooled_connection::AsyncDieselConnectionManager;
+use diesel_async::AsyncPgConnection;
+
+/// A type alias for the asynchronous PostgreSQL connection pool.
+pub type PgPool = Pool<AsyncPgConnection>;
+
+/// Create a deadpool connection pool from the given URL.
+/// Using the default pool size and other settings.
+pub fn create_pool_from_url(url: impl Into<String>) -> Result<PgPool, BuildError> {
+    let config = AsyncDieselConnectionManager::<AsyncPgConnection>::new(url);
+    Pool::builder(config).build()
+}
+
+/// Create a deadpool connection pool from the given URL.
+/// Using the given pool size and other default settings.
+pub fn create_pool_from_url_with_size(
+    url: impl Into<String>,
+    size: usize,
+) -> Result<PgPool, BuildError> {
+    let config = AsyncDieselConnectionManager::<AsyncPgConnection>::new(url);
+    Pool::builder(config).max_size(size).build()
+}

src/io/file.rs

@@ -1,7 +1,10 @@
-#[cfg(feature = "tokio")]
 use {std::io::Error, tokio::fs::File, tokio_util::io::ReaderStream};
 
-#[cfg(feature = "tokio")]
+/// Loads a file from the file system and returns a stream of bytes.
+/// # Arguments
+/// * `file_path` - The path to the file to load.
+/// # Returns
+/// A stream of bytes from the file if the file is found. Otherwise, an error is returned.
 pub async fn load_file<Path>(file_path: Path) -> Result<ReaderStream<File>, Error>
 where
     Path: AsRef<std::path::Path>,
@@ -9,7 +12,7 @@ where
     File::open(file_path).await.map(ReaderStream::new)
 }
 
-#[cfg(all(test, feature = "tokio"))]
+#[cfg(test)]
 mod tests {
     use super::*;
 

src/lib.rs

@@ -1,10 +1,26 @@
 #![allow(dead_code)]
+#[cfg(all(feature = "derive", feature = "diesel"))]
+pub extern crate diesel_crud_derive;
+#[cfg(feature = "diesel")]
+pub extern crate diesel_crud_trait;
+#[cfg(all(feature = "derive", feature = "axum", feature = "serde"))]
+pub extern crate into_response_derive;
+#[cfg(feature = "read-files")]
+pub extern crate read_files;
+extern crate self as lib;
 
+#[cfg(feature = "axum")]
 pub mod axum;
+#[cfg(feature = "diesel")]
+pub mod diesel;
+#[cfg(feature = "io")]
 pub mod io;
+#[cfg(feature = "nom")]
 pub mod nom;
+#[cfg(feature = "serde")]
 pub mod serde;
+#[cfg(feature = "time")]
+pub mod time;
+pub mod traits;
+#[cfg(feature = "iter")]
 pub mod vector;
-
-#[cfg(feature = "derive")]
-pub extern crate derive;

src/nom/combinators.rs

@@ -1,4 +1,3 @@
-#[cfg(feature = "nom")]
 use {
     nom::{
         bytes::complete::take_while_m_n,
@@ -16,10 +15,9 @@ use {
 /// - Parameters
 ///    - `inner`: The parser to trim
 /// - Returns: A parser that trims leading and trailing whitespace from the input and then runs the value from the inner parser
-#[cfg(feature = "nom")]
 pub fn trim<'a, Parser, R>(inner: Parser) -> impl FnMut(&'a str) -> IResult<&'a str, R>
 where
-    Parser: Fn(&'a str) -> IResult<&'a str, R>,
+    Parser: FnMut(&'a str) -> IResult<&'a str, R>,
 {
     delimited(multispace0, inner, multispace0)
 }
@@ -29,12 +27,11 @@ where
 /// - Parameters
 ///     - `inner`: The parser to run inside the parentheses
 /// - Returns: A parser that parses a parenthesized expression
-#[cfg(feature = "nom")]
 pub fn parenthesized<'a, Parser, R>(inner: Parser) -> impl FnMut(&'a str) -> IResult<&'a str, R>
 where
-    Parser: Fn(&'a str) -> IResult<&'a str, R>,
+    Parser: FnMut(&'a str) -> IResult<&'a str, R>,
 {
-    delimited(char('('), trim(inner), char(')'))
+    delimited(char('('), inner, char(')'))
 }
 
 /// Take where the predicate is true and the length is exactly `n`
@@ -42,7 +39,6 @@ where
 ///   - `n`: The length of the string to take
 ///   - `predicate`: The predicate to call to validate the input
 /// - Returns: A parser that takes `n` characters from the input
-#[cfg(feature = "nom")]
 pub fn take_where<F, Input>(n: usize, predicate: F) -> impl Fn(Input) -> IResult<Input, Input>
 where
     Input: InputTake + InputIter + InputLength + Slice<RangeFrom<usize>>,
@@ -51,17 +47,39 @@ where
     take_while_m_n(n, n, predicate)
 }
 
-#[cfg(feature = "nom")]
+/// Parse the inner parser and then the end of the input.
+/// Very useful for ensuring that the entire input is consumed.
+/// - Parameters
+///     - `inner`: The parser to run
+/// - Returns: A parser that runs the inner parser and then the end of the input
+/// # Example
+/// ```
+/// use nom::bytes::complete::{tag};
+/// use lib::nom::combinators::exhausted;
+///
+/// let input = "test";
+/// let (remaining, result) = exhausted(tag("test"))(input).unwrap();
+/// assert_eq!(remaining, "");
+/// assert_eq!(result, "test");
+/// ```
+/// - Fails if the input is not exhausted
+/// ```
+/// use nom::bytes::complete::{tag};
+/// use lib::nom::combinators::exhausted;
+///
+/// let input = "test";
+/// assert!(exhausted(tag("tes"))(input).is_err());
+/// ```
 pub fn exhausted<'a, Parser, R>(inner: Parser) -> impl FnMut(&'a str) -> IResult<&'a str, R>
 where
-    Parser: Fn(&'a str) -> IResult<&'a str, R>,
+    Parser: FnMut(&'a str) -> IResult<&'a str, R>,
 {
     terminated(inner, eof)
 }
 
-#[cfg(all(test, feature = "nom"))]
+#[cfg(test)]
 mod tests {
-    use nom::bytes::streaming::take_while;
+    use nom::{bytes::complete::take_while, sequence::tuple};
 
     use super::*;
 
@@ -159,4 +177,16 @@ mod tests {
         let input = "test ";
         assert!(exhausted(take_where(4, |c: char| c.is_ascii_alphabetic()))(input).is_err());
     }
+
+    #[test]
+    fn test_exhausted_tuple() {
+        let input = "test";
+        let (remaining, result) = exhausted(tuple((
+            take_where(3, |c: char| c.is_ascii_alphabetic()),
+            take_while(|c: char| c.is_ascii_alphabetic()),
+        )))(input)
+        .unwrap();
+        assert_eq!(remaining, "");
+        assert_eq!(result, ("tes", "t"));
+    }
 }

src/nom/util.rs

@@ -1,13 +1,8 @@
-#[cfg(feature = "nom")]
-use nom::{error::Error, IResult};
+use {
+    crate::traits::IntoResult,
+    nom::{error::Error, IResult},
+};
 
-#[cfg(feature = "nom")]
-pub trait IntoResult<T> {
-    type Error;
-    fn into_result(self) -> Result<T, Self::Error>;
-}
-
-#[cfg(feature = "nom")]
 impl<T, R> IntoResult<T> for IResult<R, T> {
     type Error = nom::Err<Error<R>>;
     fn into_result(self) -> Result<T, Self::Error> {
@@ -15,11 +10,12 @@ impl<T, R> IntoResult<T> for IResult<R, T> {
     }
 }
 
-#[cfg(all(test, feature = "nom"))]
+#[cfg(test)]
 mod tests {
-    use super::*;
     use nom::character::complete::char as c;
 
+    use super::*;
+
     fn parse_char(input: &str) -> IResult<&str, char> {
         c('A')(input)
     }

src/serde/response.rs

@@ -1,15 +1,12 @@
-#[cfg(feature = "serde")]
 use serde::Serialize;
 
 #[derive(Serialize)]
-#[cfg(feature = "serde")]
 pub struct BaseResponse<T: Serialize> {
     pub version: String,
     #[serde(flatten)]
-    pub body: T, // T must be a struct (or enum?)
+    pub body: T, // T must be a struct (or enum?) TODO from! macro that validates T on compile time
 }
 
-#[cfg(feature = "serde")]
 impl<T: Serialize> BaseResponse<T> {
     pub fn new(version: impl Into<String>, body: T) -> Self {
         Self {
@@ -19,7 +16,15 @@ impl<T: Serialize> BaseResponse<T> {
     }
 }
 
-#[cfg(all(test, feature = "serde"))]
+// TODO version should reference the version in caller's Cargo.toml
+#[macro_export]
+macro_rules! from {
+    ($body:expr) => {
+        $crate::serde::response::BaseResponse::new(env!("CARGO_PKG_VERSION"), $body)
+    };
+}
+
+#[cfg(test)]
 mod tests {
     use super::*;
 
@@ -38,4 +43,14 @@ mod tests {
         );
         assert_eq!(response.body.message, "Hi".to_string());
     }
+
+    #[test]
+    fn test_from_macro() {
+        let response = from!(Response {
+            message: "Hi".to_string(),
+        });
+        from!(1); // Should not be allowed
+        assert_eq!(response.version, env!("CARGO_PKG_VERSION"));
+        assert_eq!(response.body.message, "Hi".to_string());
+    }
 }

src/time/common.rs

@@ -0,0 +1,64 @@
+use chrono::NaiveDateTime;
+use derive_more::{Constructor, From};
+
+/// Represents a date-time interval using naive date-time.
+/// All date-times are expected to be in UTC.
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Constructor, From)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub struct DateTimeInterval {
+    pub start: NaiveDateTime,
+    pub end: NaiveDateTime,
+}
+
+impl DateTimeInterval {
+    /// Creates a new `DateTimeInterval` from the given `start` and `end` `NaiveDateTime`s.
+    /// The `start` must be before the `end`.
+    /// If `start` is equal to or after `end`, this function will return `None`.
+    /// # Arguments
+    /// * `start` - The start of the interval.
+    /// * `end` - The end of the interval.
+    /// # Returns
+    /// A new `DateTimeInterval` if `start` is before `end`, otherwise `None`.
+    /// # Examples
+    /// ```
+    /// use chrono::{NaiveDateTime, Duration, Utc};
+    /// use lib::time::DateTimeInterval;
+    ///
+    /// let start = Utc::now().naive_utc();
+    /// let end = start + Duration::days(1);
+    /// let interval = DateTimeInterval::new_safe(start, end);
+    /// assert_eq!(interval, Some((start, end).into()));
+    /// ```
+    /// Illegal interval:
+    /// ```
+    /// use chrono::{NaiveDateTime, Utc};
+    /// use lib::time::DateTimeInterval;
+    /// let start = Utc::now().naive_utc();
+    /// let end = start;
+    /// let interval = DateTimeInterval::new_safe(start, end);
+    /// assert_eq!(interval, None);
+    pub fn new_safe(start: NaiveDateTime, end: NaiveDateTime) -> Option<Self> {
+        if start < end {
+            Some(Self::new(start, end))
+        } else {
+            None
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use chrono::DateTime;
+
+    #[test]
+    fn test_new_safe() {
+        let start = DateTime::from_timestamp(0, 0).unwrap().naive_utc();
+        let end = DateTime::from_timestamp(1, 0).unwrap().naive_utc();
+        assert_eq!(
+            DateTimeInterval::new_safe(start, end),
+            Some(DateTimeInterval::new(start, end))
+        );
+        assert_eq!(DateTimeInterval::new_safe(end, start), None);
+    }
+}

src/time/mod.rs

@@ -0,0 +1,3 @@
+mod common;
+
+pub use common::DateTimeInterval;

src/traits.rs

@@ -0,0 +1,5 @@
+/// Converts a type T into a Result<T, E>
+pub trait IntoResult<T> {
+    type Error;
+    fn into_result(self) -> Result<T, Self::Error>;
+}

src/vector/distinct.rs

@@ -1,9 +1,9 @@
-#[cfg(feature = "vec")]
+/// Modify self to contain only distinct elements.
 pub trait Distinct {
+    /// Modify self to contain only distinct elements.
     fn distinct(&mut self);
 }
 
-#[cfg(feature = "vec")]
 impl<T: PartialEq + Clone> Distinct for Vec<T> {
     fn distinct(&mut self) {
         *self = self.iter().fold(vec![], |mut acc, x| {
@@ -15,7 +15,7 @@ impl<T: PartialEq + Clone> Distinct for Vec<T> {
     }
 }
 
-#[cfg(all(test, feature = "vec"))]
+#[cfg(test)]
 mod tests {
     use super::*;
 

src/vector/map.rs

@@ -1,7 +1,38 @@
+/// Create a `HashMap` with the given key-value pairs.
+/// There are three ways to use this macro:
+/// 1. `map!()`: Create an empty `HashMap`.
+/// 2. `map!(usize; 1, 2)`: Create a `HashMap` with the keys `1` and `2` with the default value of `usize`.
+/// 3. `map!("one" => 1, "two" => 2)`: Create a `HashMap` with the keys `"one"` and `"two"` with the values `1` and `2` respectively.
+/// # Examples
+/// ```
+/// use std::collections::HashMap;
+///
+/// let empty_map: HashMap<usize, usize> = lib::map!();
+/// assert_eq!(empty_map.len(), 0);
+///
+/// let map: HashMap<&str, usize> = lib::map!("one" => 1, "two" => 2);
+/// assert_eq!(map.len(), 2);
+/// assert_eq!(map.get("one"), Some(&1));
+/// assert_eq!(map.get("two"), Some(&2));
+///
+/// let map: HashMap<usize, usize> = lib::map!(usize; 1, 2);
+/// assert_eq!(map.len(), 2);
+/// assert_eq!(map.get(&1), Some(&0));
+/// assert_eq!(map.get(&2), Some(&0));
+/// ```
 #[macro_export]
-#[cfg(feature = "vec")]
 macro_rules! map {
     () => { std::collections::HashMap::new() };
+    ($default:ty; $($key:expr),* $(,)?) => {
+        {
+            #[allow(unused_mut)]
+            let mut temp_map = std::collections::HashMap::new();
+            $(
+                temp_map.insert($key, <$default>::default());
+            )*
+            temp_map
+        }
+    };
     ($($k:expr => $v:expr),* $(,)?) => {
         {
             let mut temp_map = std::collections::HashMap::new();
@@ -13,7 +44,7 @@ macro_rules! map {
     };
 }
 
-#[cfg(all(test, feature = "vec"))]
+#[cfg(test)]
 mod tests {
     use std::collections::HashMap;
 
@@ -34,4 +65,19 @@ mod tests {
         assert_eq!(map.get("two"), Some(&2));
         assert_eq!(map.get("three"), Some(&3));
     }
+
+    #[test]
+    fn test_map_only_keys() {
+        let map: HashMap<usize, usize> = map!(usize; 1, 2, 3);
+        assert_eq!(map.len(), 3);
+        assert_eq!(map.get(&1), Some(&0));
+        assert_eq!(map.get(&2), Some(&0));
+        assert_eq!(map.get(&3), Some(&0));
+    }
+
+    #[test]
+    fn test_map_only_keys_0_keys() {
+        let map: HashMap<usize, usize> = map!(usize;);
+        assert_eq!(map.len(), 0);
+    }
 }

src/vector/matrix.rs

@@ -1,5 +1,4 @@
 #[macro_export]
-#[cfg(feature = "vec")]
 macro_rules! matrix {
     ($x:expr; $m:expr, $n:expr) => {
         vec![vec![$x; $n]; $m]
@@ -16,7 +15,7 @@ macro_rules! matrix {
     };
 }
 
-#[cfg(all(test, feature = "vec"))]
+#[cfg(test)]
 mod tests {
 
     #[test]

src/vector/set.rs

@@ -1,5 +1,4 @@
 #[macro_export]
-#[cfg(feature = "vec")]
 macro_rules! set {
     () => { std::collections::HashSet::new() };
     ($($x:expr),* $(,)?) => {
@@ -13,7 +12,7 @@ macro_rules! set {
     };
 }
 
-#[cfg(all(test, feature = "vec"))]
+#[cfg(test)]
 mod tests {
     use std::collections::HashSet;