refactor: move error into utils/src/error.rs

rust/cocoindex/src/builder/analyzed_flow.rs

@@ -1,7 +1,7 @@
 use crate::{ops::interface::FlowInstanceContext, prelude::*};
 
 use super::{analyzer, plan};
-use crate::service::error::{SharedError, SharedResultExt, shared_ok};
+use cocoindex_utils::error::{SharedError, SharedResultExt, shared_ok};
 
 pub struct AnalyzedFlow {
     pub flow_instance: spec::FlowInstanceSpec,

rust/cocoindex/src/execution/memoization.rs

@@ -7,10 +7,8 @@ use std::{
     sync::{Arc, Mutex},
 };
 
-use crate::{
-    base::{schema, value},
-    service::error::{SharedError, SharedResultExtRef},
-};
+use crate::base::{schema, value};
+use cocoindex_utils::error::{SharedError, SharedResultExtRef};
 use cocoindex_utils::fingerprint::{Fingerprint, Fingerprinter};
 
 #[derive(Debug, Clone, Serialize, Deserialize)]

rust/cocoindex/src/lib_context.rs

@@ -4,11 +4,11 @@ use crate::prelude::*;
 
 use crate::builder::AnalyzedFlow;
 use crate::execution::source_indexer::SourceIndexingContext;
-use crate::service::error::ApiError;
 use crate::service::query_handler::{QueryHandler, QueryHandlerSpec};
 use crate::settings;
 use crate::setup::ObjectSetupChange;
 use axum::http::StatusCode;
+use cocoindex_utils::error::ApiError;
 use indicatif::MultiProgress;
 use sqlx::PgPool;
 use sqlx::postgres::{PgConnectOptions, PgPoolOptions};

rust/cocoindex/src/ops/factory_bases.rs

@@ -5,7 +5,6 @@ use std::hash::Hash;
 
 use super::interface::*;
 use super::registry::*;
-use crate::api_bail;
 use crate::base::schema::*;
 use crate::base::spec::*;
 use crate::builder::plan::AnalyzedValueMapping;

rust/cocoindex/src/prelude.rs

@@ -23,11 +23,11 @@ pub(crate) use crate::builder::{self, exec_ctx, plan};
 pub(crate) use crate::execution;
 pub(crate) use crate::lib_context::{FlowContext, LibContext, get_lib_context, get_runtime};
 pub(crate) use crate::ops::interface;
-pub(crate) use crate::service::error::{ApiError, invariance_violation};
 pub(crate) use crate::setup;
 pub(crate) use crate::setup::AuthRegistry;
-pub(crate) use crate::{api_bail, api_error};
 pub(crate) use cocoindex_utils as utils;
+pub(crate) use cocoindex_utils::error::{ApiError, invariance_violation};
+pub(crate) use cocoindex_utils::{api_bail, api_error};
 pub(crate) use cocoindex_utils::{batching, concur_control, http, retryable};
 
 pub(crate) use anyhow::{anyhow, bail};

rust/cocoindex/src/service/mod.rs

@@ -1,3 +1,2 @@
-pub(crate) mod error;
 pub(crate) mod flows;
 pub(crate) mod query_handler;

rust/utils/Cargo.toml

@@ -11,6 +11,9 @@ anyhow = { workspace = true }
 async-trait = { workspace = true }
 log = { workspace = true }
 
+# Web framework
+axum = { workspace = true }
+
 # Serialization
 serde = { workspace = true }
 serde_json = { workspace = true }

rust/utils/src/error.rs

@@ -1,4 +1,10 @@
 use anyhow;
+use axum::{
+    Json,
+    http::StatusCode,
+    response::{IntoResponse, Response},
+};
+use serde::Serialize;
 use std::{
     error::Error,
     fmt::{Debug, Display},
@@ -134,3 +140,73 @@ impl<'a, T> SharedResultExtRef<'a, T> for &'a Result<T, SharedError> {
 pub fn invariance_violation() -> anyhow::Error {
     anyhow::anyhow!("Invariance violation")
 }
+
+// API Error types for HTTP responses
+
+#[derive(Debug)]
+pub struct ApiError {
+    pub err: anyhow::Error,
+    pub status_code: StatusCode,
+}
+
+impl ApiError {
+    pub fn new(message: &str, status_code: StatusCode) -> Self {
+        Self {
+            err: anyhow::anyhow!("{}", message),
+            status_code,
+        }
+    }
+}
+
+impl Display for ApiError {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        Display::fmt(&self.err, f)
+    }
+}
+
+impl Error for ApiError {
+    fn source(&self) -> Option<&(dyn Error + 'static)> {
+        self.err.source()
+    }
+}
+
+#[derive(Serialize)]
+struct ErrorResponse {
+    error: String,
+}
+
+impl IntoResponse for ApiError {
+    fn into_response(self) -> Response {
+        log::debug!("Internal server error:\n{:?}", self.err);
+        let error_response = ErrorResponse {
+            error: format!("{:?}", self.err),
+        };
+        (self.status_code, Json(error_response)).into_response()
+    }
+}
+
+impl From<anyhow::Error> for ApiError {
+    fn from(err: anyhow::Error) -> ApiError {
+        if err.is::<ApiError>() {
+            return err.downcast::<ApiError>().unwrap();
+        }
+        Self {
+            err,
+            status_code: StatusCode::INTERNAL_SERVER_ERROR,
+        }
+    }
+}
+
+#[macro_export]
+macro_rules! api_bail {
+    ( $fmt:literal $(, $($arg:tt)*)?) => {
+        return Err($crate::error::ApiError::new(&format!($fmt $(, $($arg)*)?), axum::http::StatusCode::BAD_REQUEST).into())
+    };
+}
+
+#[macro_export]
+macro_rules! api_error {
+    ( $fmt:literal $(, $($arg:tt)*)?) => {
+        $crate::error::ApiError::new(&format!($fmt $(, $($arg)*)?), axum::http::StatusCode::BAD_REQUEST)
+    };
+}