setup

Author: indpurvesh

assets/js/app.js

@@ -18,7 +18,7 @@ export function setupPage() {
             this.submitting = true;
             this.errorMessage = '';
 
-            const res = await http.post('/api/setup', {
+            const res = await http.post('/api/misc/setup', {
                 name: this.name,
                 email: this.email,
                 password: this.password,
@@ -28,7 +28,7 @@ export function setupPage() {
             this.submitting = false;
 
             if (res.ok) {
-                window.location.href = '/admin/login';
+                window.location.href = '/auth/login';
             } else {
                 this.errorMessage = res.error || 'Setup failed';
             }

resources/js/misc/SetupPage.ts

@@ -15,6 +15,10 @@ pub fn rest_api_routes(state: AppState) -> crate::error::Result<Router> {
             "/api/auth/login",
             axum::routing::post(crate::interfaces::api::auth::login_handler),
         )
+        .route(
+            "/api/misc/setup",
+            axum::routing::post(crate::interfaces::api::misc::setup_handler::setup_handler),
+        )
         .leptos_routes_with_context(
             &state,
             routes,

src/api/rest_api_routes.rs

@@ -4,9 +4,7 @@ use axum::extract::FromRef;
 use leptos::config::LeptosOptions;
 
 use crate::{
-    core::application::use_cases::AuthUseCase,
-    infrastructure::persistence::AuthRepositoryImpl,
-    providers::{
+    core::application::use_cases::{AuthUseCase, MiscUseCase}, infrastructure::persistence::{AuthRepositoryImpl, misc_repository::MiscRepositoryImpl}, providers::{
         avored_config_provider::AvoRedConfigProvider,
         avored_database_provider::AvoRedDatabaseProvider,
     },
@@ -19,6 +17,9 @@ pub struct AppState {
     /// Auth use case with SurrealDB persistence repository
     pub auth_use_case: AuthUseCase<AuthRepositoryImpl>,
 
+
+    pub misc_use_case: MiscUseCase<MiscRepositoryImpl>,
+
     /// Database provider for `AvoRed` (SurrealDB).
     pub database_provider: Arc<AvoRedDatabaseProvider>,
 
@@ -41,11 +42,16 @@ impl AppState {
         let auth_repository = AuthRepositoryImpl::new(avored_database_provider.clone());
         let auth_use_case = AuthUseCase::new(auth_repository);
 
+        let misc_repository = MiscRepositoryImpl::new(avored_database_provider.clone());
+        let misc_use_case = MiscUseCase::new(misc_repository);
+
+
         Ok(Self {
             leptos_options,
-            auth_use_case,
             database_provider: avored_database_provider,
             config: Arc::new(config),
+            auth_use_case,
+            misc_use_case
         })
     }
 }

src/avored_state.rs

@@ -0,0 +1,24 @@
+use crate::core::domain::{entities::{User, user::StorableUser}, repositories::MiscRepository};
+
+#[derive(Clone)]
+pub struct MiscUseCase<R>
+where
+    R: MiscRepository,
+{
+    repository: R,
+}
+
+impl<R> MiscUseCase<R>
+where
+    R: MiscRepository,
+{
+    pub fn new(repository: R) -> Self {
+        Self { repository }
+    }
+
+    pub async fn setup(&self, storable_user: StorableUser) -> crate::error::Result<User> {
+        println!("->> {:<12} - setup", "MISC_USE_CASE");
+
+        self.repository.create_user(storable_user).await
+    }
+}

src/core/application/use_cases/misc_use_case.rs

@@ -1,3 +1,8 @@
 pub mod auth_use_case;
 
 pub use auth_use_case::AuthUseCase;
+
+
+pub mod misc_use_case;
+
+pub use misc_use_case::MiscUseCase;

src/core/application/use_cases/mod.rs

@@ -9,6 +9,16 @@ pub struct User {
 }
 
 
+
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+pub struct StorableUser {
+    pub name: String,
+    pub email: String,
+    pub password: String
+}
+
+
+
 #[cfg(feature = "ssr")]
 impl TryFrom<surrealdb::types::Object> for User {
     type Error = crate::error::Error;

src/core/domain/entities/user.rs

@@ -0,0 +1,9 @@
+use crate::core::domain::entities::User;
+use crate::core::domain::entities::user::StorableUser;
+use crate::error::Result;
+
+#[async_trait::async_trait]
+pub trait MiscRepository: Send + Sync {
+    async fn create_user(&self, storable_user: StorableUser) -> Result<User>;
+}
+

src/core/domain/repositories/misc_repository.rs

@@ -3,3 +3,7 @@
 pub mod auth_repository;
 
 pub use auth_repository::AuthRepository;
+
+pub mod misc_repository;
+
+pub use misc_repository::MiscRepository;

src/core/domain/repositories/mod.rs

@@ -0,0 +1,49 @@
+use surrealdb::types::Value;
+
+use crate::core::domain::entities::User;
+use crate::core::domain::entities::user::StorableUser;
+use crate::core::domain::repositories::MiscRepository;
+use crate::error::Result;
+use crate::infrastructure::persistence::into_iter_objects;
+use crate::providers::avored_database_provider::AvoRedDatabaseProvider;
+use std::collections::BTreeMap;
+use std::sync::Arc;
+
+#[derive(Clone)]
+pub struct MiscRepositoryImpl {
+    pub database_provider: Arc<AvoRedDatabaseProvider>,
+}
+
+impl MiscRepositoryImpl {
+    pub fn new(database_provider: Arc<AvoRedDatabaseProvider>) -> Self {
+        Self { database_provider }
+    }
+}
+
+#[async_trait::async_trait]
+impl MiscRepository for MiscRepositoryImpl {
+    async fn create_user(&self, storable_user: StorableUser) -> Result<User> {
+        let (datastore, database_session) = &self.database_provider.db;
+
+        let sql = "CREATE users SET name=$name, email=$email, password=$password;";
+        let data: BTreeMap<String, Value> = [
+            ("name".into(), Value::String(storable_user.name.into())),
+            ("email".into(), Value::String(storable_user.email.into())),
+            ("password".into(), Value::String(storable_user.password.into())),
+        ]
+        .into();
+
+        let responses = datastore
+            .execute(sql, database_session, Some(data.into()))
+            .await?;
+
+        let result_object = into_iter_objects(responses)?
+            .next()
+            .ok_or_else(|| crate::error::Error::Generic("No user returned from insert".to_string()))??;
+
+        let user: User = result_object.try_into()?;
+
+        Ok(user)
+    }
+}
+