clippy fix (#231)

* clippy fix

* fmt

Author: JasonShin

src/common/config.rs

@@ -132,6 +132,7 @@ impl Config {
 
   /// Retrieves the configuration required for generating typescript interface
   /// If there is CLI_ARGS.generate_types set already, it would prioritise using CLI_ARGS
+  #[allow(deprecated)]
   fn generate_types_config(file_config_path: &PathBuf) -> Option<GenerateTypesConfig> {
     let file_based_config = fs::read_to_string(file_config_path);
     let file_based_config = &file_based_config.map(|f| serde_json::from_str::<SqlxConfig>(f.as_str()).unwrap());

src/common/logger.rs

@@ -73,6 +73,7 @@ macro_rules! warning {
 
 pub(crate) use warning;
 
+#[allow(unused_macros)]
 macro_rules! error {
     ($arg:tt) => ({
         use crate::common::lazy::CONFIG;
@@ -98,4 +99,5 @@ macro_rules! error {
     });
 }
 
+#[allow(unused_imports)]
 pub(crate) use error;

src/parser/js_parser.rs

@@ -15,16 +15,16 @@ use crate::parser::decl::{process_decl, process_default_decl};
 use crate::parser::import::find_sqlx_import_alias;
 use crate::parser::tag::get_sql_from_expr;
 use swc_ecma_ast::{Key, ModuleDecl, ModuleItem, Stmt};
-use swc_ecma_parser::TsConfig;
+use swc_ecma_parser::TsSyntax;
 use swc_ecma_parser::{lexer::Lexer, Parser, Syntax};
 
-fn insert_or_append_sqls(sqls_container: &mut HashMap<PathBuf, Vec<SQL>>, sqls: &Vec<SQL>, file_path: &PathBuf) {
+fn insert_or_append_sqls(sqls_container: &mut HashMap<PathBuf, Vec<SQL>>, sqls: &[SQL], file_path: &PathBuf) {
   if sqls_container.contains_key(&*file_path.clone()) {
     let mut value = sqls_container.get(file_path).unwrap().clone();
-    value.extend(sqls.clone());
+    value.extend(sqls.to_owned());
     sqls_container.insert(file_path.clone(), (*value.to_owned()).to_owned());
   } else {
-    sqls_container.insert(file_path.clone(), sqls.clone());
+    sqls_container.insert(file_path.clone(), sqls.to_owned());
   }
 }
 
@@ -135,15 +135,15 @@ pub fn parse_js_file(path: &PathBuf) -> Result<(HashMap<PathBuf, Vec<SQL>>, Hand
 
   let file_path = path.as_os_str().to_str().unwrap().to_string();
   let fm = cm.new_source_file(Rc::new(FileName::Custom(file_path)), contents);
-  let ts_config: TsConfig = TsConfig {
+  let ts_syntax = TsSyntax {
     tsx: false,
     decorators: true,
     dts: false,
     no_early_errors: false,
     disallow_ambiguous_jsx_like: false,
   };
   let lexer = Lexer::new(
-    Syntax::Typescript(ts_config),
+    Syntax::Typescript(ts_syntax),
     Default::default(),
     StringInput::from(&*fm),
     None,

src/parser/sql_parser.rs

@@ -3,7 +3,7 @@ use color_eyre::eyre::Result;
 use regex::Regex;
 use std::collections::HashMap;
 use std::fs;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 use swc_common::{
   errors::{ColorConfig, Handler},
   sync::Lrc,
@@ -27,7 +27,7 @@ pub fn parse_sql_file(path: &PathBuf) -> Result<(HashMap<PathBuf, Vec<SQL>>, Han
 
 /// Extract SQL queries from raw SQL file content
 /// Supports multiple queries separated by semicolons and annotations
-fn extract_sql_queries_from_file(content: &str, file_path: &PathBuf) -> Result<Vec<SQL>> {
+fn extract_sql_queries_from_file(content: &str, file_path: &Path) -> Result<Vec<SQL>> {
   let mut queries = Vec::new();
 
   // Split content by semicolons to handle multiple queries
@@ -42,7 +42,7 @@ fn extract_sql_queries_from_file(content: &str, file_path: &PathBuf) -> Result<V
     }
 
     // Extract annotations and clean query
-    let (query_name, db_connection, cleaned_query) = extract_annotations_from_sql(trimmed_block);
+    let (query_name, _db_connection, cleaned_query) = extract_annotations_from_sql(trimmed_block);
 
     // Skip if no actual SQL content after cleaning
     if cleaned_query.trim().is_empty() {
@@ -191,8 +191,8 @@ fn extract_annotations_from_sql(content: &str) -> (Option<String>, Option<String
     }
 
     // Check for name annotation in comments
-    if trimmed_line.starts_with("--") {
-      let comment_content = &trimmed_line[2..].trim();
+    if let Some(stripped) = trimmed_line.strip_prefix("--") {
+      let comment_content = &stripped.trim();
 
       if let Some(captures) = name_re.captures(comment_content) {
         query_name = Some(captures.get(1).unwrap().as_str().trim().to_string());
@@ -232,7 +232,7 @@ fn extract_annotations_from_sql(content: &str) -> (Option<String>, Option<String
 }
 
 /// Generate a default query name from file path and index
-fn generate_default_query_name(file_path: &PathBuf, index: usize) -> Option<String> {
+fn generate_default_query_name(file_path: &Path, index: usize) -> Option<String> {
   let file_stem = file_path.file_stem()?.to_str()?;
 
   // Convert to camelCase and add index if multiple queries

src/ts_generator/errors.rs

@@ -23,6 +23,7 @@ pub enum TsGeneratorError {
   #[error("[E009] When translating a function in a SELECT clause, you must provide an alias - query : `{0}`")]
   FunctionWithoutAliasInSelectClause(String),
   #[error("[E010] Unknown function detected while processing a SELECT clause - query: `{0}`")]
+  #[allow(dead_code)]
   FunctionUnknown(String),
   // Errors while handling FROM statement
   #[error("[E012] Failed to handle a from statement without the `FROM` keyword - query: `{0}`")]

src/ts_generator/generator.rs

@@ -1,9 +1,6 @@
 use std::fs::OpenOptions;
 use std::io::Write;
-use std::{
-  fs,
-  path::{Path, PathBuf},
-};
+use std::{fs, path::Path};
 
 use super::annotations::extract_param_annotations;
 
@@ -52,7 +49,7 @@ pub fn get_query_name(sql: &SQL) -> Result<String> {
 }
 
 /// Write colocated Type definition file next to the TS source code
-pub fn write_colocated_ts_file(file_path: &PathBuf, sqls_to_write: String) -> Result<()> {
+pub fn write_colocated_ts_file(file_path: &Path, sqls_to_write: String) -> Result<()> {
   let path = file_path.parent().unwrap();
   let file = file_path.file_stem().unwrap();
   let file_name = file.to_str().unwrap();

src/ts_generator/sql_parser/expressions/translate_expr.rs

@@ -482,10 +482,6 @@ pub async fn translate_expr(
       root: _,
       access_chain: _,
     } => ts_query.insert_result(alias, &[TsFieldType::Any], is_selection, false, expr_for_logging),
-    // JsonAccess handles semi-structured data access (e.g., Snowflake VARIANT type)
-    Expr::JsonAccess { value: _, path: _ } => {
-      ts_query.insert_result(alias, &[TsFieldType::Any], is_selection, false, expr_for_logging)
-    }
     Expr::Interval(_) => ts_query.insert_result(alias, &[TsFieldType::Number], is_selection, false, expr_for_logging),
     Expr::MatchAgainst {
       columns: _,

src/ts_generator/sql_parser/expressions/translate_table_with_joins.rs

@@ -3,7 +3,7 @@ use crate::ts_generator::sql_parser::quoted_strings::*;
 use color_eyre::eyre::Result;
 use sqlparser::ast::{Assignment, AssignmentTarget, Expr, Join, SelectItem, TableFactor, TableWithJoins};
 
-pub fn get_default_table(table_with_joins: &Vec<TableWithJoins>) -> String {
+pub fn get_default_table(table_with_joins: &[TableWithJoins]) -> String {
   table_with_joins
     .first()
     .and_then(|x| match &x.relation {
@@ -25,8 +25,8 @@ pub fn get_default_table(table_with_joins: &Vec<TableWithJoins>) -> String {
 }
 
 pub fn find_table_name_from_identifier(
-  table_with_joins: &Vec<TableWithJoins>,
-  identifiers: &Vec<String>, // can be the actual identifier or an alias
+  table_with_joins: &[TableWithJoins],
+  identifiers: &[String], // can be the actual identifier or an alias
 ) -> Result<String, TsGeneratorError> {
   let left = identifiers
     .first()
@@ -128,11 +128,11 @@ pub fn translate_table_from_expr(
     Expr::Identifier(_) => Ok(get_default_table(table_with_joins)),
     Expr::CompoundIdentifier(compound_identifier) => {
       // Assumes that [0] of the compound identifiers is the alias that points to the table
-      let identifiers = &compound_identifier
+      let identifiers: Vec<String> = compound_identifier
         .iter()
         .map(|x| DisplayIndent(x).to_string())
         .collect();
-      find_table_name_from_identifier(table_with_joins, identifiers)
+      find_table_name_from_identifier(table_with_joins, &identifiers)
     }
     _ => Err(TsGeneratorError::UnknownErrorWhileProcessingTableWithJoins(
       expr.to_string(),
@@ -141,7 +141,7 @@ pub fn translate_table_from_expr(
 }
 
 pub fn translate_table_from_assignments(
-  table_with_joins: &Vec<TableWithJoins>,
+  table_with_joins: &[TableWithJoins],
   assignment: &Assignment,
 ) -> Result<String, TsGeneratorError> {
   // In sqlparser 0.59.0, Assignment.id was replaced with Assignment.target
@@ -158,7 +158,7 @@ pub fn translate_table_from_assignments(
       match first_part {
         Some(part) => {
           if let Some(ident) = part.as_ident() {
-            find_table_name_from_identifier(table_with_joins, &vec![ident.value.to_string()])
+            find_table_name_from_identifier(table_with_joins, &[ident.value.to_string()])
           } else {
             // If it's a function-based name, use default table
             Ok(get_default_table(table_with_joins))
@@ -192,11 +192,11 @@ pub fn translate_table_with_joins(
       match expr {
         Expr::CompoundIdentifier(compound_identifier) => {
           // Assumes that [0] of the compound identifiers is the alias that points to the table
-          let identifiers = &compound_identifier
+          let identifiers: Vec<String> = compound_identifier
             .iter()
             .map(|x| DisplayIndent(x).to_string())
             .collect();
-          find_table_name_from_identifier(table_with_joins, identifiers)
+          find_table_name_from_identifier(table_with_joins, &identifiers)
         }
         _ => Ok(default_table_name),
       }
@@ -208,11 +208,11 @@ pub fn translate_table_with_joins(
         Ok(default_table_name)
       }
       Expr::CompoundIdentifier(compound_identifier) => {
-        let identifiers = &compound_identifier
+        let identifiers: Vec<String> = compound_identifier
           .iter()
           .map(|x| DisplayIndent(x).to_string())
           .collect();
-        find_table_name_from_identifier(table_with_joins, identifiers)
+        find_table_name_from_identifier(table_with_joins, &identifiers)
       }
       _ => Ok(default_table_name),
     },

src/ts_generator/sql_parser/expressions/translate_wildcard_expr.rs

@@ -8,7 +8,7 @@ use crate::ts_generator::types::ts_query::TsQuery;
 use color_eyre::eyre::Result;
 use sqlparser::ast::{Join, Select, TableFactor};
 
-pub fn get_all_table_names_from_select(select: &Box<Select>) -> Result<Vec<String>, TsGeneratorError> {
+pub fn get_all_table_names_from_select(select: &Select) -> Result<Vec<String>, TsGeneratorError> {
   let table_with_joins = select
     .from
     .first()
@@ -53,7 +53,7 @@ pub fn get_all_table_names_from_select(select: &Box<Select>) -> Result<Vec<Strin
 ///
 /// and it appends result into the hashmap for type generation
 pub async fn translate_wildcard_expr(
-  select: &Box<Select>,
+  select: &Select,
   ts_query: &mut TsQuery,
   db_conn: &DBConn,
 ) -> Result<(), TsGeneratorError> {

src/ts_generator/sql_parser/translate_query.rs

@@ -16,7 +16,7 @@ use crate::{
 pub async fn translate_select(
   ts_query: &mut TsQuery,
   table_with_joins: &Option<Vec<TableWithJoins>>,
-  select: &Box<Select>,
+  select: &Select,
   db_conn: &DBConn,
   alias: Option<&str>,
   is_selection: bool,
@@ -41,7 +41,7 @@ pub async fn translate_select(
   // Handle all select projects and figure out each field's type
   for select_item in projection {
     // Determine the default table name within the scope of this select item
-    let mut table_name_owned: Option<String> = None;
+    let table_name_owned: Option<String>;
     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(