feat: response streaming and disable non presigned uploads

Author: jacobtread

cspell.json

@@ -6,6 +6,7 @@
     "utoipa",
     "thiserror",
     "chrono",
-    "dotenvy"
+    "dotenvy",
+    "dotenv"
   ]
 }

lambdas/http/src/docs.rs

@@ -52,6 +52,7 @@ use crate::{
         document_box::delete,
         document_box::search,
         // File routes
+        file::upload,
         file::create_presigned,
         file::get_presigned,
         file::get,

lambdas/http/src/error.rs

@@ -107,12 +107,15 @@ pub struct HttpErrorResponse {
 pub enum HttpCommonError {
     #[error("internal server error")]
     ServerError,
+    #[error("unsupported endpoint")]
+    Unsupported,
 }
 
 impl HttpError for HttpCommonError {
     fn status(&self) -> axum::http::StatusCode {
         match self {
             HttpCommonError::ServerError => StatusCode::INTERNAL_SERVER_ERROR,
+            HttpCommonError::Unsupported => StatusCode::NOT_IMPLEMENTED,
         }
     }
 }

lambdas/http/src/main.rs

@@ -1,8 +1,7 @@
 use crate::{
     extensions::max_file_size::MaxFileSizeBytes, middleware::api_key::ApiKeyLayer, routes::router,
-    service::LambdaService,
 };
-use axum::{Extension, Router, extract::DefaultBodyLimit};
+use axum::{Extension, Router};
 use docbox_core::{
     aws::{SqsClient, aws_config},
     events::{EventPublisherFactory, sqs::SqsEventPublisherFactory},
@@ -17,17 +16,16 @@ use docbox_search::{SearchIndexFactory, SearchIndexFactoryConfig};
 use docbox_secrets::{SecretManager, SecretsManagerConfig};
 use docbox_storage::{StorageLayerFactory, StorageLayerFactoryConfig};
 use docbox_web_scraper::{WebsiteMetaService, WebsiteMetaServiceConfig};
-use lambda_http::{Error, run, tracing};
+use lambda_http::{Error, run_with_streaming_response, tracing};
 use std::sync::Arc;
-use tower_http::{limit::RequestBodyLimitLayer, trace::TraceLayer};
+use tower_http::trace::TraceLayer;
 
 pub mod docs;
 mod error;
 mod extensions;
 mod middleware;
 mod models;
 mod routes;
-mod service;
 
 /// The server version extracted from the Cargo.toml
 pub const VERSION: &str = env!("CARGO_PKG_VERSION");
@@ -46,11 +44,11 @@ async fn main() -> Result<(), Error> {
         // TODO: Handle
         .unwrap();
 
-    run(app).await
+    run_with_streaming_response(app).await
 }
 
 // TODO: Needs a db_cache.close_all() cleanup logic when the program exits
-async fn app() -> Result<LambdaService<Router>, Box<dyn std::error::Error>> {
+async fn app() -> Result<Router, Box<dyn std::error::Error>> {
     let max_file_size_bytes = match std::env::var("DOCBOX_MAX_FILE_SIZE_BYTES") {
         Ok(value) => value.parse::<i32>()?,
         // Default max file size in bytes (100MB)
@@ -124,8 +122,6 @@ async fn app() -> Result<LambdaService<Router>, Box<dyn std::error::Error>> {
         .layer(Extension(processing))
         .layer(Extension(tenant_cache))
         .layer(Extension(MaxFileSizeBytes(max_file_size_bytes)))
-        .layer(DefaultBodyLimit::disable())
-        .layer(RequestBodyLimitLayer::new(max_file_size_bytes as usize))
         .layer(TraceLayer::new_for_http());
 
     if let Some(api_key) = api_key {
@@ -140,5 +136,5 @@ async fn app() -> Result<LambdaService<Router>, Box<dyn std::error::Error>> {
     #[cfg(debug_assertions)]
     let app = app.layer(tower_http::cors::CorsLayer::very_permissive());
 
-    Ok(LambdaService { inner: app })
+    Ok(app)
 }

lambdas/http/src/routes/file.rs

@@ -44,6 +44,28 @@ use std::{str::FromStr, time::Duration};
 
 pub const FILE_TAG: &str = "File";
 
+/// Upload file
+///
+/// This endpoint is not available in docbox serverless, for serverless
+/// environments use presigned file uploads instead
+#[utoipa::path(
+    post,
+    operation_id = "file_upload",
+    tag = FILE_TAG,
+    path = "/box/{scope}/file",
+    responses(
+        (status = 501, description = "unsupported endpoint", body = HttpErrorResponse)
+    ),
+    params(
+        ("scope" = DocumentBoxScope, Path, description = "Scope to create the file within"),
+        TenantParams,
+        UserParams
+    )
+)]
+pub async fn upload() -> HttpResult<()> {
+    Err(HttpCommonError::Unsupported.into())
+}
+
 /// Create presigned file upload
 ///
 /// Creates a new "presigned" upload, where the file is uploaded

lambdas/http/src/routes/mod.rs

@@ -90,6 +90,7 @@ pub fn folder_router() -> Router {
 /// Routes for /box/:scope/file/
 pub fn file_router() -> Router {
     Router::new()
+        .route("/", post(file::upload))
         .nest(
             "/presigned",
             Router::new()