pass errors to js

Author: waralexrom

packages/cubejs-backend-native/src/node_export.rs

@@ -467,6 +467,7 @@ fn build_sql_and_params(cx: FunctionContext) -> JsResult<JsValue> {
     //context should be used only inside function
     let mut cx = extend_function_context_lifetime(cx);
     let options = cx.argument::<JsValue>(0)?;
+    let options_tmp = options.clone();
 
     let neon_context_holder = ContextHolder::new(cx);
 
@@ -484,7 +485,7 @@ fn build_sql_and_params(cx: FunctionContext) -> JsResult<JsValue> {
     let base_query = BaseQuery::try_new(context_holder.clone(), base_query_options).unwrap();
 
     //arg_clrep.into_js(&mut cx)
-    let res = base_query.build_sql_and_params().unwrap();
+    let res = base_query.build_sql_and_params();
 
     let result: NeonObject<'static, FunctionContext<'static>> = res.into_object();
     let result = result.into_object();

packages/cubejs-schema-compiler/src/adapter/BaseQuery.js

@@ -654,7 +654,17 @@ export class BaseQuery {
       ungrouped: this.options.ungrouped
 
     };
-    const res = nativeBuildSqlAndParams(queryParams);
+    const buildResult = nativeBuildSqlAndParams(queryParams);
+
+    if (buildResult.error) {
+      if (buildResult.error.cause && buildResult.error.cause === 'User') {
+        throw new UserError(buildResult.error.message);
+      } else {
+        throw new Error(buildResult.error.message);
+      }
+    }
+
+    const res = buildResult.result;
     // FIXME
     res[1] = [...res[1]];
     return res;

rust/cubenativeutils/src/lib.rs

@@ -1,2 +1,2 @@
 pub mod wrappers;
-pub use cubesql::CubeError;
+pub use cubesql::{CubeError, CubeErrorCauseType};

rust/cubesqlplanner/cubesqlplanner/src/planner/base_query.rs

@@ -7,8 +7,8 @@ use cubenativeutils::wrappers::inner_types::InnerTypes;
 use cubenativeutils::wrappers::object::NativeArray;
 use cubenativeutils::wrappers::serializer::NativeSerialize;
 use cubenativeutils::wrappers::NativeType;
-use cubenativeutils::wrappers::{NativeContextHolder, NativeObjectHandle};
-use cubenativeutils::CubeError;
+use cubenativeutils::wrappers::{NativeContextHolder, NativeObjectHandle, NativeStruct};
+use cubenativeutils::{CubeError, CubeErrorCauseType};
 use std::rc::Rc;
 
 pub struct BaseQuery<IT: InnerTypes> {
@@ -38,7 +38,41 @@ impl<IT: InnerTypes> BaseQuery<IT> {
         })
     }
 
-    pub fn build_sql_and_params(&self) -> Result<NativeObjectHandle<IT>, CubeError> {
+    pub fn build_sql_and_params(&self) -> NativeObjectHandle<IT> {
+        let build_result = self.build_sql_and_params_impl();
+        let result = self.context.empty_struct();
+        match build_result {
+            Ok(res) => {
+                result.set_field("result", res).unwrap();
+            }
+            Err(e) => {
+                let error_descr = self.context.empty_struct();
+                let error_cause = match &e.cause {
+                    CubeErrorCauseType::User(_) => "User",
+                    CubeErrorCauseType::Internal(_) => "Internal",
+                };
+                error_descr
+                    .set_field(
+                        "message",
+                        e.message.to_native(self.context.clone()).unwrap(),
+                    )
+                    .unwrap();
+                error_descr
+                    .set_field(
+                        "cause",
+                        error_cause.to_native(self.context.clone()).unwrap(),
+                    )
+                    .unwrap();
+                result
+                    .set_field("error", NativeObjectHandle::new(error_descr.into_object()))
+                    .unwrap();
+            }
+        }
+
+        NativeObjectHandle::new(result.into_object())
+    }
+
+    fn build_sql_and_params_impl(&self) -> Result<NativeObjectHandle<IT>, CubeError> {
         let templates = PlanSqlTemplates::new(self.query_tools.templates_render());
         let query_planner = QueryPlanner::new(self.request.clone(), self.query_tools.clone());
         let plan = query_planner.plan()?;