in progress, routers and main split up

crates/api-router/src/api_state.rs

@@ -0,0 +1,33 @@
+use std::sync::Arc;
+
+use common::{ingress::jobqueue::JobQueue, storage::db::SurrealDbClient, utils::config::AppConfig};
+
+#[derive(Clone)]
+pub struct ApiState {
+    pub surreal_db_client: Arc<SurrealDbClient>,
+    pub job_queue: Arc<JobQueue>,
+}
+
+impl ApiState {
+    pub async fn new(config: &AppConfig) -> Result<Self, Box<dyn std::error::Error>> {
+        let surreal_db_client = Arc::new(
+            SurrealDbClient::new(
+                &config.surrealdb_address,
+                &config.surrealdb_username,
+                &config.surrealdb_password,
+                &config.surrealdb_namespace,
+                &config.surrealdb_database,
+            )
+            .await?,
+        );
+
+        surreal_db_client.ensure_initialized().await?;
+
+        let app_state = ApiState {
+            surreal_db_client: surreal_db_client.clone(),
+            job_queue: Arc::new(JobQueue::new(surreal_db_client)),
+        };
+
+        Ok(app_state)
+    }
+}

crates/api-router/src/lib.rs

@@ -0,0 +1,25 @@
+use api_state::ApiState;
+use axum::{
+    extract::{DefaultBodyLimit, FromRef},
+    middleware::from_fn_with_state,
+    routing::post,
+    Router,
+};
+use middleware_api_auth::api_auth;
+use routes::ingress::ingress_data;
+
+pub mod api_state;
+mod middleware_api_auth;
+mod routes;
+
+/// Router for API functionality, version 1
+pub fn api_routes_v1<S>(app_state: &ApiState) -> Router<S>
+where
+    S: Clone + Send + Sync + 'static,
+    ApiState: FromRef<S>,
+{
+    Router::new()
+        .route("/ingress", post(ingress_data))
+        .layer(DefaultBodyLimit::max(1024 * 1024 * 1024))
+        .route_layer(from_fn_with_state(app_state.clone(), api_auth))
+}

crates/api-router/src/middleware_api_auth.rs

@@ -0,0 +1,43 @@
+use axum::{
+    extract::{Request, State},
+    middleware::Next,
+    response::Response,
+};
+
+use common::{error::ApiError, storage::types::user::User};
+
+use crate::api_state::ApiState;
+
+pub async fn api_auth(
+    State(state): State<ApiState>,
+    mut request: Request,
+    next: Next,
+) -> Result<Response, ApiError> {
+    let api_key = extract_api_key(&request).ok_or(ApiError::Unauthorized(
+        "You have to be authenticated".to_string(),
+    ))?;
+
+    let user = User::find_by_api_key(&api_key, &state.surreal_db_client).await?;
+    let user = user.ok_or(ApiError::Unauthorized(
+        "You have to be authenticated".to_string(),
+    ))?;
+
+    request.extensions_mut().insert(user);
+
+    Ok(next.run(request).await)
+}
+
+fn extract_api_key(request: &Request) -> Option<String> {
+    request
+        .headers()
+        .get("X-API-Key")
+        .and_then(|v| v.to_str().ok())
+        .or_else(|| {
+            request
+                .headers()
+                .get("Authorization")
+                .and_then(|v| v.to_str().ok())
+                .and_then(|auth| auth.strip_prefix("Bearer ").map(|s| s.trim()))
+        })
+        .map(String::from)
+}

crates/api-router/src/routes/ingress.rs

@@ -0,0 +1,57 @@
+use axum::{extract::State, http::StatusCode, response::IntoResponse, Extension};
+use axum_typed_multipart::{FieldData, TryFromMultipart, TypedMultipart};
+use common::{
+    error::{ApiError, AppError},
+    ingress::ingress_input::{create_ingress_objects, IngressInput},
+    storage::types::{file_info::FileInfo, user::User},
+};
+use futures::{future::try_join_all, TryFutureExt};
+use tempfile::NamedTempFile;
+use tracing::{debug, info};
+
+use crate::api_state::ApiState;
+
+#[derive(Debug, TryFromMultipart)]
+pub struct IngressParams {
+    pub content: Option<String>,
+    pub instructions: String,
+    pub category: String,
+    #[form_data(limit = "10000000")] // Adjust limit as needed
+    #[form_data(default)]
+    pub files: Vec<FieldData<NamedTempFile>>,
+}
+
+pub async fn ingress_data(
+    State(state): State<ApiState>,
+    Extension(user): Extension<User>,
+    TypedMultipart(input): TypedMultipart<IngressParams>,
+) -> Result<impl IntoResponse, ApiError> {
+    info!("Received input: {:?}", input);
+
+    let file_infos = try_join_all(input.files.into_iter().map(|file| {
+        FileInfo::new(file, &state.surreal_db_client, &user.id).map_err(AppError::from)
+    }))
+    .await?;
+
+    debug!("Got file infos");
+
+    let ingress_objects = create_ingress_objects(
+        IngressInput {
+            content: input.content,
+            instructions: input.instructions,
+            category: input.category,
+            files: file_infos,
+        },
+        user.id.as_str(),
+    )?;
+    debug!("Got ingress objects");
+
+    let futures: Vec<_> = ingress_objects
+        .into_iter()
+        .map(|object| state.job_queue.enqueue(object.clone(), user.id.clone()))
+        .collect();
+
+    try_join_all(futures).await.map_err(AppError::from)?;
+
+    Ok(StatusCode::OK)
+}

crates/api-router/src/routes/mod.rs

@@ -0,0 +1 @@
+pub mod ingress;