chore: TS test improvements / missing AST coverage (#65)

* chore: splitting tests into specific categories

* wip: working on await function test

* test: adding await examples

* test: splitting up tests

* test: enahcning binary operation tests

* chore: add more expression tests

* chore: fixing new expression

* chore: adding conditional expression handling

* chore: updating conditional queries

* chore: super express query example

* chore: adding yield expression test

* chore: adding statement tests

* chore: adding an empty file for block statement

* chore: adding for statement coverage

* chore: support Value when generating types from sql

* chore: fix test and fix the logic around computing Value from SQL

* chore: support while and with

* chore: cargo fmt

* chore: filter out empty string queries in parse source before sending off to SQL parser

* chore: update snapshot

* chore: adding ; so the logic proceeds without returning

* chore: optional chaining

* chore: opt chaining test

* chore: class accessors

* chore: update tests

* chore: remove todos

Author: JasonShin

src/core/execute.rs

@@ -12,7 +12,6 @@ use std::path::PathBuf;
 use swc_common::errors::Handler;
 
 pub fn execute(queries: &HashMap<PathBuf, Vec<SQL>>, handler: &Handler) -> Result<bool> {
-    // TODO: later we will add mysql_explain, sqlite_explain depending on the database type
     let mut failed = false;
     let should_generate_types = &CONFIG
         .generate_types_config

src/parser/mod.rs

@@ -176,18 +176,20 @@ fn recurse_and_find_sql(mut sqls: &mut Vec<SQL>, stmt: &Stmt, import_alias: &Str
                     let span: MultiSpan = var.span.into();
                     let new_sqls = get_sql_from_var_decl(var_decl, &span, import_alias);
                     let num_new_sqls = new_sqls.len();
+
                     sqls.extend(new_sqls);
 
                     // We've already found the sqls based on the variable name, we should skip processing further
                     if num_new_sqls > 0 {
                         continue;
                     }
-
+                    // Try to retrieve name of the variable
+                    let name = var_decl.name.as_ident().map(|ident| ident.sym.to_string());
                     // this is when the variable name is not found due to syntax like
                     // const [rows, i] = await connection.execute....
                     if let Some(init) = &var_decl.init {
                         let expr = *init.clone();
-                        get_sql_from_expr(&mut sqls, &None, &expr, &span, import_alias);
+                        get_sql_from_expr(&mut sqls, &name, &expr, &span, import_alias);
                     }
                 }
             }
@@ -277,7 +279,10 @@ pub fn parse_source(path: &PathBuf) -> Result<(HashMap<PathBuf, Vec<SQL>>, Handl
         match item {
             ModuleItem::Stmt(stmt) => {
                 let mut sqls = vec![];
-                recurse_and_find_sql(&mut sqls, stmt, &import_alias).unwrap();
+                recurse_and_find_sql(&mut sqls, stmt, &import_alias)?;
+                // This is to prevent any emptry string queries being inserted into sqls_map
+                // which will be used to run `PREPARE` step and SQL parser logic
+                let sqls: Vec<SQL> = sqls.into_iter().filter(|sql| !sql.query.is_empty()).collect();
                 insert_or_append_sqls(&mut sqls_map, &sqls, path);
             }
             _ => {}

src/parser/tag.rs

@@ -1,6 +1,6 @@
 use crate::common::SQL;
 use swc_common::MultiSpan;
-use swc_ecma_ast::{BlockStmt, ClassMember, Expr, Pat, Prop, PropOrSpread, SuperProp, VarDeclarator};
+use swc_ecma_ast::{BlockStmt, ClassMember, Expr, OptChainBase, Pat, Prop, PropOrSpread, SuperProp, VarDeclarator};
 
 use super::{get_var_decl_name_from_key, recurse_and_find_sql};
 
@@ -21,7 +21,8 @@ pub fn process_block_stmt_as_expr(
                 let expr = &expr.expr;
                 get_sql_from_expr(sqls, var_decl_name, expr, span, import_alias);
             } else {
-                recurse_and_find_sql(sqls, stmt, import_alias);
+                // TODO: we should be using `?` and return Results
+                recurse_and_find_sql(sqls, stmt, import_alias).unwrap();
             }
         }
     }
@@ -83,7 +84,7 @@ pub fn get_sql_from_expr<'a>(
                 }
             }
             for arg in &call_expr.args {
-                get_sql_from_expr(sqls, var_decl_name, &arg.expr, span, import_alias)
+                get_sql_from_expr(sqls, var_decl_name, &arg.expr, span, import_alias);
             }
         }
         Expr::This(_) => {}
@@ -103,24 +104,23 @@ pub fn get_sql_from_expr<'a>(
                         Prop::Shorthand(_) => {}
                         Prop::KeyValue(key_val) => {
                             let value = &key_val.value;
-                            get_sql_from_expr(sqls, var_decl_name, value, span, import_alias)
+                            get_sql_from_expr(sqls, var_decl_name, value, span, import_alias);
                         }
                         Prop::Assign(assign) => {
                             let value = &assign.value;
-                            get_sql_from_expr(sqls, var_decl_name, value, span, import_alias)
+                            get_sql_from_expr(sqls, var_decl_name, value, span, import_alias);
                         }
                         Prop::Getter(getter) => {
                             let body = &getter.body;
-                            process_block_stmt_as_expr(body, sqls, var_decl_name, span, import_alias)
+                            process_block_stmt_as_expr(body, sqls, var_decl_name, span, import_alias);
                         }
-                        // TODO: add test
                         Prop::Setter(setter) => {
                             let body = &setter.body;
-                            process_block_stmt_as_expr(body, sqls, var_decl_name, span, import_alias)
+                            process_block_stmt_as_expr(body, sqls, var_decl_name, span, import_alias);
                         }
                         Prop::Method(method) => {
                             let body = &method.function.body;
-                            process_block_stmt_as_expr(body, sqls, var_decl_name, span, import_alias)
+                            process_block_stmt_as_expr(body, sqls, var_decl_name, span, import_alias);
                         }
                     },
                 }
@@ -142,8 +142,13 @@ pub fn get_sql_from_expr<'a>(
             get_sql_from_expr(sqls, var_decl_name, right, span, import_alias);
         }
         Expr::Assign(assign) => {
-            let expr = &assign.right;
-            return get_sql_from_expr(sqls, var_decl_name, expr, span, import_alias);
+            let right_expr = &assign.right;
+            get_sql_from_expr(sqls, var_decl_name, right_expr, span, import_alias);
+
+            let left_expr = &assign.left;
+            left_expr
+                .as_expr()
+                .map(|expr| get_sql_from_expr(sqls, var_decl_name, &expr, span, import_alias));
         }
         Expr::Member(member) => {
             let obj = &member.obj;
@@ -159,22 +164,50 @@ pub fn get_sql_from_expr<'a>(
                 }
             }
         }
-        Expr::Cond(_) => {}
+        Expr::Cond(cond) => {
+            let test = &cond.test;
+            let cons = &cond.cons;
+            let alt = &cond.alt;
+            get_sql_from_expr(sqls, var_decl_name, test, span, import_alias);
+            get_sql_from_expr(sqls, var_decl_name, cons, span, import_alias);
+            get_sql_from_expr(sqls, var_decl_name, alt, span, import_alias);
+        }
         Expr::New(expr) => {
+            let args = &expr.args;
             let expr = &expr.callee;
-            return get_sql_from_expr(sqls, var_decl_name, expr, span, import_alias);
+            if let Some(args) = &args {
+                for arg in args {
+                    get_sql_from_expr(sqls, var_decl_name, &arg.expr, span, import_alias);
+                }
+            }
+
+            get_sql_from_expr(sqls, var_decl_name, expr, span, import_alias);
         }
         Expr::Seq(seq) => {
             let exprs = &seq.exprs;
             for expr in exprs {
-                get_sql_from_expr(sqls, var_decl_name, expr, span, import_alias)
+                get_sql_from_expr(sqls, var_decl_name, expr, span, import_alias);
             }
         }
         Expr::Ident(ident) => {}
         Expr::Lit(lit) => {}
         Expr::Tpl(tpl) => {
+            let new_sqls: Vec<SQL> = tpl
+                .quasis
+                .iter()
+                .map(|tpl_element| SQL {
+                    var_decl_name: var_decl_name.to_owned(),
+                    query: tpl_element.raw.to_string(),
+                    span: span.clone(),
+                })
+                .collect();
+
+            if !new_sqls.is_empty() {
+                sqls.extend(new_sqls);
+            }
+
             for expr in &tpl.exprs {
-                get_sql_from_expr(sqls, var_decl_name, expr, span, import_alias)
+                get_sql_from_expr(sqls, var_decl_name, expr, span, import_alias);
             }
         }
         Expr::Arrow(arrow) => {
@@ -183,7 +216,14 @@ pub fn get_sql_from_expr<'a>(
             process_block_stmt_as_expr(&block_stmt, sqls, var_decl_name, span, import_alias);
 
             if let Some(expr) = expr {
-                return get_sql_from_expr(sqls, var_decl_name, expr, span, import_alias);
+                get_sql_from_expr(sqls, var_decl_name, expr, span, import_alias);
+            }
+
+            for param in &arrow.params {
+                let param = param.as_expr();
+                if let Some(expr) = &param {
+                    get_sql_from_expr(sqls, var_decl_name, expr, span, import_alias);
+                }
             }
         }
         Expr::Class(class) => {
@@ -203,11 +243,11 @@ pub fn get_sql_from_expr<'a>(
                     }
                     ClassMember::Method(method) => {
                         let body = &method.function.body;
-                        process_block_stmt_as_expr(body, sqls, var_decl_name, span, import_alias)
+                        process_block_stmt_as_expr(body, sqls, var_decl_name, span, import_alias);
                     }
                     ClassMember::PrivateMethod(private_method) => {
                         let body = &private_method.function.body;
-                        process_block_stmt_as_expr(body, sqls, var_decl_name, span, import_alias)
+                        process_block_stmt_as_expr(body, sqls, var_decl_name, span, import_alias);
                     }
                     ClassMember::ClassProp(class_prop) => {
                         let body = &class_prop.value;
@@ -225,15 +265,15 @@ pub fn get_sql_from_expr<'a>(
                     ClassMember::Empty(_) => {}
                     ClassMember::StaticBlock(static_block) => {
                         let body = &static_block.body;
-                        process_block_stmt_as_expr(&Some(body.clone()), sqls, var_decl_name, span, import_alias)
+                        process_block_stmt_as_expr(&Some(body.clone()), sqls, var_decl_name, span, import_alias);
                     }
                     ClassMember::AutoAccessor(auto_accessor) => {
                         let value = &auto_accessor.value;
                         let key = &auto_accessor.key;
 
                         if let Some(expr) = &value {
                             let var_decl_name = &get_var_decl_name_from_key(&key);
-                            get_sql_from_expr(sqls, var_decl_name, expr, span, import_alias)
+                            get_sql_from_expr(sqls, var_decl_name, expr, span, import_alias);
                         }
                     }
                 }
@@ -254,6 +294,25 @@ pub fn get_sql_from_expr<'a>(
             let expr = &paren.expr;
             return get_sql_from_expr(sqls, var_decl_name, expr, span, import_alias);
         }
+        Expr::OptChain(opt_chain) => {
+            let expr = &*opt_chain.base;
+            match &expr {
+                OptChainBase::Member(member) => {
+                    let obj = &member.obj;
+                    get_sql_from_expr(sqls, var_decl_name, obj, span, import_alias);
+                }
+                OptChainBase::Call(call) => {
+                    let expr = &call.callee;
+                    get_sql_from_expr(sqls, var_decl_name, &expr, span, import_alias);
+
+                    let args = &call.args;
+                    for arg in args.iter() {
+                        let expr = &arg.expr;
+                        get_sql_from_expr(sqls, var_decl_name, &expr, span, import_alias);
+                    }
+                }
+            }
+        }
         Expr::JSXMember(_) => {}
         Expr::JSXNamespacedName(_) => {}
         Expr::JSXEmpty(_) => {}
@@ -264,7 +323,6 @@ pub fn get_sql_from_expr<'a>(
         Expr::TsAs(_) => {}
         Expr::TsInstantiation(_) => {}
         Expr::PrivateName(_) => {}
-        Expr::OptChain(_) => {}
         Expr::Invalid(_) => {}
         Expr::TsSatisfies(_) => {}
     }

src/ts_generator/sql_parser/expressions/translate_data_type.rs

@@ -3,6 +3,26 @@ use crate::{
     ts_generator::types::ts_query::TsFieldType,
 };
 use sqlparser::ast::DataType;
+use sqlparser::ast::Value;
+
+pub fn translate_value(value: &Value) -> Option<TsFieldType> {
+    match &value {
+        Value::Number(_, _) => Some(TsFieldType::Number),
+        Value::SingleQuotedString(_) => Some(TsFieldType::String),
+        Value::DollarQuotedString(_) => Some(TsFieldType::String),
+        Value::EscapedStringLiteral(_) => Some(TsFieldType::String),
+        Value::SingleQuotedByteStringLiteral(_) => Some(TsFieldType::String),
+        Value::DoubleQuotedByteStringLiteral(_) => Some(TsFieldType::String),
+        Value::RawStringLiteral(_) => Some(TsFieldType::String),
+        Value::NationalStringLiteral(_) => Some(TsFieldType::String),
+        Value::HexStringLiteral(_) => Some(TsFieldType::String),
+        Value::DoubleQuotedString(_) => Some(TsFieldType::String),
+        Value::Boolean(_) => Some(TsFieldType::Boolean),
+        Value::Null => Some(TsFieldType::Null),
+        Value::UnQuotedString(_) => Some(TsFieldType::String),
+        Value::Placeholder(_) => None,
+    }
+}
 
 pub fn translate_data_type(data_type: &DataType) -> TsFieldType {
     match &data_type {

src/ts_generator/sql_parser/expressions/translate_expr.rs

@@ -1,5 +1,6 @@
 use crate::common::lazy::{CONFIG, DB_SCHEMA};
 use crate::ts_generator::errors::TsGeneratorError;
+use crate::ts_generator::sql_parser::expressions::translate_data_type::translate_value;
 use crate::ts_generator::sql_parser::expressions::translate_table_with_joins::translate_table_from_expr;
 use crate::ts_generator::sql_parser::expressions::{
     functions::is_string_function, translate_data_type::translate_data_type,
@@ -298,7 +299,14 @@ pub fn translate_expr(
             db_conn,
             is_selection,
         ),
-        Expr::Value(placeholder) => ts_query.insert_param(&TsFieldType::Boolean, &Some(placeholder.to_string())),
+        Expr::Value(placeholder) => {
+            let ts_field_type = translate_value(&placeholder);
+
+            if let Some(ts_field_type) = ts_field_type {
+                return ts_query.insert_result(alias, &[ts_field_type], is_selection, expr_for_logging);
+            }
+            ts_query.insert_param(&TsFieldType::Boolean, &Some(placeholder.to_string()))
+        }
         Expr::JsonAccess {
             left: _,
             operator: _,