feat(api): implement user authentication and registration endpoints

- Add main application logic in `api/src/main.rs` to initialize server, database, and services.
- Create authentication routes in `api/src/routes/auth.rs` for login, register, logout, and user info retrieval.
- Implement configuration route in `api/src/routes/config.rs` to expose application settings.
- Define application state management in `api/src/state.rs` to share user service and configuration.
- Set up Docker Compose configuration in `compose.yml` for backend, worker, and database services.
- Establish domain logic in `domain` crate with user entities, repositories, and services.
- Implement SQLite user repository in `infra/src/user_repository.rs` for user data persistence.
- Create database migration handling in `infra/src/db.rs` and session store in `infra/src/session_store.rs`.
- Add necessary dependencies and features in `Cargo.toml` files for both `domain` and `infra` crates.

infra/src/session_store.rs

@@ -0,0 +1,73 @@
+use async_trait::async_trait;
+use sqlx;
+use tower_sessions::{
+    SessionStore,
+    session::{Id, Record},
+};
+#[cfg(feature = "postgres")]
+use tower_sessions_sqlx_store::PostgresStore;
+#[cfg(feature = "sqlite")]
+use tower_sessions_sqlx_store::SqliteStore;
+
+#[derive(Clone, Debug)]
+pub enum InfraSessionStore {
+    #[cfg(feature = "sqlite")]
+    Sqlite(SqliteStore),
+    #[cfg(feature = "postgres")]
+    Postgres(PostgresStore),
+}
+
+#[async_trait]
+impl SessionStore for InfraSessionStore {
+    async fn save(&self, session_record: &Record) -> tower_sessions::session_store::Result<()> {
+        match self {
+            #[cfg(feature = "sqlite")]
+            Self::Sqlite(store) => store.save(session_record).await,
+            #[cfg(feature = "postgres")]
+            Self::Postgres(store) => store.save(session_record).await,
+            #[allow(unreachable_patterns)]
+            _ => Err(tower_sessions::session_store::Error::Backend(
+                "No backend enabled".to_string(),
+            )),
+        }
+    }
+
+    async fn load(&self, session_id: &Id) -> tower_sessions::session_store::Result<Option<Record>> {
+        match self {
+            #[cfg(feature = "sqlite")]
+            Self::Sqlite(store) => store.load(session_id).await,
+            #[cfg(feature = "postgres")]
+            Self::Postgres(store) => store.load(session_id).await,
+            #[allow(unreachable_patterns)]
+            _ => Err(tower_sessions::session_store::Error::Backend(
+                "No backend enabled".to_string(),
+            )),
+        }
+    }
+
+    async fn delete(&self, session_id: &Id) -> tower_sessions::session_store::Result<()> {
+        match self {
+            #[cfg(feature = "sqlite")]
+            Self::Sqlite(store) => store.delete(session_id).await,
+            #[cfg(feature = "postgres")]
+            Self::Postgres(store) => store.delete(session_id).await,
+            #[allow(unreachable_patterns)]
+            _ => Err(tower_sessions::session_store::Error::Backend(
+                "No backend enabled".to_string(),
+            )),
+        }
+    }
+}
+
+impl InfraSessionStore {
+    pub async fn migrate(&self) -> Result<(), sqlx::Error> {
+        match self {
+            #[cfg(feature = "sqlite")]
+            Self::Sqlite(store) => store.migrate().await,
+            #[cfg(feature = "postgres")]
+            Self::Postgres(store) => store.migrate().await,
+            #[allow(unreachable_patterns)]
+            _ => Err(sqlx::Error::Configuration("No backend enabled".into())),
+        }
+    }
+}