improved error handling

Author: JasonShin

src/ts_generator/errors.rs

@@ -34,6 +34,20 @@ pub enum TsGeneratorError {
   UnknownErrorWhileProcessingTableWithJoins(String),
   #[error("[E015] Table expressions are not supported in INSERT statements - query: `{0}`")]
   TableExpressionInInsertStatement(String),
+  #[error("[E016] Column '{column}' not found in table '{table}'. Available columns: {available_columns}")]
+  ColumnNotFoundInTable {
+    column: String,
+    table: String,
+    available_columns: String,
+  },
+  #[error("[E017] Failed to process INSERT statement: {reason}. Query: `{query}`")]
+  InsertStatementProcessingFailed { reason: String, query: String },
+  #[error("[E018] Table '{table}' not found in database schema. Check that the table exists and is accessible.")]
+  TableNotFoundInSchema { table: String },
+  #[error("[E019] Failed to infer table name while processing WHERE clause. Query: `{query}`")]
+  TableNameInferenceFailedInWhere { query: String },
+  #[error("[E020] Invalid column reference '{column}' for table '{table}'. Ensure the column exists in the table schema.")]
+  InvalidColumnReference { column: String, table: String },
   #[error("Unknown error: `{0}`")]
   Unknown(String),
 }

src/ts_generator/sql_parser/expressions/translate_expr.rs

@@ -132,7 +132,11 @@ pub async fn get_sql_query_param(
   } else if single_table_name.is_some() {
     table_name = single_table_name.map(|x| x.to_string());
   } else {
-    panic!("failed to find an appropriate table name while processing WHERE statement")
+    error!(
+      "Failed to infer table name while processing WHERE clause. Expression: {}",
+      left
+    );
+    return None;
   }
 
   let column_name = translate_column_name_expr(left);
@@ -148,13 +152,30 @@ pub async fn get_sql_query_param(
         .lock()
         .await
         .fetch_table(&table_names, db_conn)
-        .await
-        .unwrap_or_else(|| panic!("Failed to fetch columns for table {table_name}"));
+        .await;
+
+      if columns.is_none() {
+        error!(
+          "Table '{}' not found in database schema. Check that the table exists and is accessible.",
+          table_name
+        );
+        return None;
+      }
+
+      let columns = columns.unwrap();
 
       // get column and return TsFieldType
-      let column = columns
-        .get(column_name.as_str())
-        .unwrap_or_else(|| panic!("Failed to find the column from the table schema of {table_name}"));
+      let column = columns.get(column_name.as_str());
+      if column.is_none() {
+        let available_columns = columns.keys().map(|k| k.as_str()).collect::<Vec<_>>().join(", ");
+        error!(
+          "Column '{}' not found in table '{}'. Available columns: {}",
+          column_name, table_name, available_columns
+        );
+        return None;
+      }
+
+      let column = column.unwrap();
       Some((column.field_type.to_owned(), column.is_nullable, Some(expr_placeholder)))
     }
     _ => None,
@@ -731,16 +752,35 @@ pub async fn translate_assignment(
   let value = get_expr_placeholder(&assignment.value);
 
   if value.is_some() {
-    let table_details = &DB_SCHEMA
+    let table_details = DB_SCHEMA
       .lock()
       .await
       .fetch_table(&vec![table_name], db_conn)
       .await
-      .unwrap();
-    let column_name = translate_column_name_assignment(assignment).unwrap();
-    let field = table_details
-      .get(&column_name)
-      .unwrap_or_else(|| panic!("Failed to find the column detail for {column_name}"));
+      .ok_or_else(|| TsGeneratorError::TableNotFoundInSchema {
+        table: table_name.to_string(),
+      })?;
+
+    let column_name = translate_column_name_assignment(assignment).ok_or_else(|| {
+      TsGeneratorError::InsertStatementProcessingFailed {
+        reason: "Failed to extract column name from assignment".to_string(),
+        query: format!("UPDATE {} SET {} = ...", table_name, assignment),
+      }
+    })?;
+
+    let field = table_details.get(&column_name).ok_or_else(|| {
+      let available_columns = table_details
+        .keys()
+        .map(|k| k.as_str())
+        .collect::<Vec<_>>()
+        .join(", ");
+      TsGeneratorError::ColumnNotFoundInTable {
+        column: column_name.clone(),
+        table: table_name.to_string(),
+        available_columns,
+      }
+    })?;
+
     let _ = ts_query.insert_param(&field.field_type, &field.is_nullable, &value);
   }
   Ok(())

src/ts_generator/sql_parser/translate_insert.rs

@@ -41,24 +41,28 @@ pub async fn translate_insert(
           if placeholder.is_some() {
             let match_col = &columns
               .get(column)
-              .unwrap_or_else(|| {
-                panic!(
-                  r#"
-Failed to process values of insert statement as column names are not provided or incorrectly specified
-
-Try specifying column names
-```
-INSERT INTO table_name (column1, column2, column3, ...)
-VALUES (value1, value2, value3, ...);
-```
-              "#
-                )
-              })
+              .ok_or_else(|| {
+                TsGeneratorError::InsertStatementProcessingFailed {
+                  reason: format!(
+                    "Column at position {} is not provided in the column list. Expected {} columns but found {} values.",
+                    column, columns.len(), values.len()
+                  ),
+                  query: format!(
+                    "INSERT INTO {} VALUES (...). Try specifying column names explicitly: INSERT INTO {} (column1, column2, ...) VALUES (...)",
+                    table_name, table_name
+                  ),
+                }
+              })?
               .value;
 
-            let field = table_details
-              .get(match_col.as_str())
-              .unwrap_or_else(|| panic!("Column {match_col} is not found while processing insert params"));
+            let field = table_details.get(match_col.as_str()).ok_or_else(|| {
+              let available_columns = table_details.keys().map(|k| k.as_str()).collect::<Vec<_>>().join(", ");
+              TsGeneratorError::ColumnNotFoundInTable {
+                column: match_col.clone(),
+                table: table_name.to_string(),
+                available_columns,
+              }
+            })?;
 
             if value.to_string() == "?" {
               // If the placeholder is `'?'`, we can process it using insert_value_params and generate nested params type

src/ts_generator/sql_parser/translate_query.rs

@@ -123,8 +123,12 @@ pub async fn translate_select(
     let mut table_name: Option<&str> = None;
     if full_table_with_joins.is_some() && !full_table_with_joins.as_ref().unwrap().is_empty() {
       table_name_owned = Some(
-        translate_table_with_joins(full_table_with_joins, &select_item)
-          .unwrap_or_else(|_| panic!("{}", format!("Default FROM table is not found from the query {select}"))),
+        translate_table_with_joins(full_table_with_joins, &select_item).map_err(|_| {
+          TsGeneratorError::UnknownErrorWhileProcessingTableWithJoins(format!(
+            "Default FROM table is not found from the query: {}. Ensure your query has a valid FROM clause.",
+            select
+          ))
+        })?,
       );
       table_name = table_name_owned.as_deref();
     }