WIP

lib/sqlxgentools_attrs/src/lib.rs

@@ -12,7 +12,7 @@ pub fn derive_sql_generator_model(_input: TokenStream) -> TokenStream {
     TokenStream::new()
 }
 
-#[proc_macro_derive(SqlGeneratorModelWithId, attributes(sql_generator_field))]
+#[proc_macro_derive(SqlGeneratorModelWithId)]
 pub fn derive_sql_generator_model_with_id(input: TokenStream) -> TokenStream {
     let input = parse_macro_input!(input as DeriveInput);
     let name = input.ident;

lib/sqlxgentools_cli/src/generators/repositories/base.rs

@@ -1,5 +1,5 @@
 use anyhow::Result;
-use proc_macro2::TokenStream;
+use proc_macro2::{TokenStream, Ident};
 use quote::{format_ident, quote};
 use syn::File;
 use heck::ToSnakeCase;
@@ -21,49 +21,42 @@ fn gen_get_all_method(model: &Model) -> TokenStream {
     }
 }
 
-fn gen_get_by_id_method(model: &Model) -> TokenStream {
+fn gen_get_by_field_method(model: &Model, query_field: &Field) -> TokenStream {
     let resource_ident = format_ident!("{}", &model.name);
-    let primary_key = &model.fields.iter()
-        .find(|f| f.is_primary)
-        .expect("A model must have at least one primary key")
-        .name;
-    let select_query = format!("SELECT * FROM {} WHERE {} = $1", model.table_name, primary_key);
+    let select_query = format!("SELECT * FROM {} WHERE {} = $1", model.table_name, query_field.name);
 
-    let func_name_ident = format_ident!("get_by_{}", primary_key);
+    let func_name_ident = format_ident!("get_by_{}", query_field.name);
 
     quote! {
-        pub async fn #func_name_ident(&self, item_id: &str) -> Result<#resource_ident, sqlx::Error> {
+        // FIXME: Value is not necesssarly a string, it can be an int or a bool
+        pub async fn #func_name_ident(&self, value: &str) -> Result<#resource_ident, sqlx::Error> {
             sqlx::query_as::<_, #resource_ident>(#select_query)
-                .bind(item_id)
+                .bind(value)
                 .fetch_one(&self.db.0)
                 .await
         }
     }
 }
 
-fn gen_get_many_by_id_method(model: &Model) -> TokenStream {
+fn gen_get_many_by_field_method(model: &Model, query_field: &Field) -> TokenStream {
     let resource_ident = format_ident!("{}", &model.name);
-    let primary_key = &model.fields.iter()
-        .find(|f| f.is_primary)
-        .expect("A model must have at least one primary key")
-        .name;
-    let select_query_tmpl = format!("SELECT * FROM {} WHERE {} IN ({{}})", model.table_name, primary_key);
+    let select_query_tmpl = format!("SELECT * FROM {} WHERE {} IN ({{}})", model.table_name, query_field.name);
 
-    let func_name_ident = format_ident!("get_many_by_{}", primary_key);
+    let func_name_ident = format_ident!("get_many_by_{}", query_field.name);
 
     quote! {
-        pub async fn #func_name_ident(&self, items_ids: &[&str]) -> Result<Vec<#resource_ident>, sqlx::Error> {
-            if items_ids.is_empty() {
+        pub async fn #func_name_ident(&self, values: &[&str]) -> Result<Vec<#resource_ident>, sqlx::Error> {
+            if values.is_empty() {
                 return Ok(vec![])
             }
-            let placeholder_params: String = (1..=(items_ids.len()))
+            let placeholder_params: String = (1..=(values.len()))
                 .map(|i| format!("${}", i))
                 .collect::<Vec<String>>()
                 .join(",");
             let query_sql = format!(#select_query_tmpl, placeholder_params);
             let mut query = sqlx::query_as::<_, #resource_ident>(&query_sql);
-            for id in items_ids {
-                query = query.bind(id)
+            for value in values {
+                query = query.bind(value)
             }
             query
                 .fetch_all(&self.db.0)
@@ -72,41 +65,57 @@ fn gen_get_many_by_id_method(model: &Model) -> TokenStream {
     }
 }
 
-fn get_mutation_fields(model: &Model) -> (Vec<proc_macro2::Ident>, Vec<proc_macro2::Ident>) {
-    let normal_field_names: Vec<proc_macro2::Ident> = model.fields.iter()
+fn get_mutation_fields(model: &Model) -> (Vec<&Field>, Vec<&Field>) {
+    let normal_field_names: Vec<&Field> = model.fields.iter()
         .filter(|f| match f.foreign_mode { FieldForeignMode::NotRef => true, FieldForeignMode::ForeignRef(_) => false })
-        .map(|f| format_ident!("{}", &f.name))
         .collect();
-    let foreign_keys_field_names: Vec<proc_macro2::Ident> = model.fields.iter()
+    let foreign_keys_field_names: Vec<&Field> = model.fields.iter()
+        .filter(|f| match f.foreign_mode { FieldForeignMode::NotRef => false, FieldForeignMode::ForeignRef(_) => true })
+        .collect();
+    (normal_field_names, foreign_keys_field_names)
+}
+
+fn get_mutation_fields_ident(model: &Model) -> (Vec<&Field>, Vec<&Field>) {
+    let normal_field_names: Vec<&Field> = model.fields.iter()
+        .filter(|f| match f.foreign_mode { FieldForeignMode::NotRef => true, FieldForeignMode::ForeignRef(_) => false })
+        .collect();
+    let foreign_keys_field_names: Vec<&Field> = model.fields.iter()
         .filter(|f| match f.foreign_mode { FieldForeignMode::NotRef => false, FieldForeignMode::ForeignRef(_) => true })
-        .map(|f| format_ident!("{}", &f.name))
         .collect();
     (normal_field_names, foreign_keys_field_names)
 }
 
 fn gen_insert_method(model: &Model) -> TokenStream {
     let resource_ident = format_ident!("{}", &model.name);
-    let sql_columns = model.fields.iter()
-        .map(|f| f.name.clone())
-        .collect::<Vec<String>>()
-        .join(", ");
+
     let value_templates = (1..(model.fields.len()+1))
         .map(|i| format!("${}", i))
         .collect::<Vec<String>>()
         .join(", ");
+    let (normal_fields, foreign_keys_fields) = get_mutation_fields(model);
+    let (normal_field_idents, foreign_keys_field_idents) = (
+        normal_fields.iter().map(|f| format_ident!("{}", &f.name)).collect::<Vec<Ident>>(),
+        foreign_keys_fields.iter().map(|f| format_ident!("{}", &f.name)).collect::<Vec<Ident>>()
+    );
+
+    let sql_columns = [normal_fields, foreign_keys_fields].concat()
+        .iter()
+        .map(|f| f.name.clone())
+        .collect::<Vec<String>>()
+        .join(", ");
     let insert_query = format!(
         "INSERT INTO {} ({}) VALUES ({})",
         model.table_name,
         sql_columns,
         value_templates
     );
-    let (normal_field_names, foreign_keys_field_names) = get_mutation_fields(model);
+    // foreign keys must be inserted first, we sort the columns so that foreign keys are first
 
     quote! {
         pub async fn insert(&self, entity: &#resource_ident) -> Result<(), sqlx::Error> {
             sqlx::query(#insert_query)
-                #( .bind( &entity.#normal_field_names ) )*
-                #( .bind( &entity.#foreign_keys_field_names.target_id) )*
+                #( .bind( &entity.#normal_field_idents ) )*
+                #( .bind( &entity.#foreign_keys_field_idents.target_id) )*
                 .execute(&self.db.0)
                 .await?;
 
@@ -126,7 +135,11 @@ fn gen_insert_many_method(model: &Model) -> TokenStream {
         model.table_name,
         sql_columns
     );
-    let (normal_field_names, foreign_keys_field_names) = get_mutation_fields(model);
+    let (normal_fields, foreign_keys_fields) = get_mutation_fields(model);
+    let (normal_field_idents, foreign_keys_field_idents) = (
+        normal_fields.iter().map(|f| format_ident!("{}", &f.name)).collect::<Vec<Ident>>(),
+        foreign_keys_fields.iter().map(|f| format_ident!("{}", &f.name)).collect::<Vec<Ident>>()
+    );
     let fields_count = model.fields.len();
 
     quote! {
@@ -149,8 +162,8 @@ fn gen_insert_many_method(model: &Model) -> TokenStream {
             let mut query = sqlx::query(&query_sql);
             for entity in entities {
                 query = query
-                    #( .bind( &entity.#normal_field_names ) )*
-                    #( .bind( &entity.#foreign_keys_field_names.target_id) )*;
+                    #( .bind( &entity.#normal_field_idents ) )*
+                    #( .bind( &entity.#foreign_keys_field_idents.target_id) )*;
             }
             query
                 .execute(&self.db.0)
@@ -168,26 +181,34 @@ fn gen_update_by_id_method(model: &Model) -> TokenStream {
         .find(|f| f.is_primary)
         .expect("A model must have at least one primary key")
         .name;
-    let set_statements = model.fields.iter().enumerate()
-        .map(|(i, field)| format!("{} = ${}", field.name, i+2))
+    let (normal_fields, foreign_keys_fields) = get_mutation_fields(model);
+    let (normal_field_idents, foreign_keys_field_idents) = (
+        normal_fields.iter().map(|f| format_ident!("{}", &f.name)).collect::<Vec<Ident>>(),
+        foreign_keys_fields.iter().map(|f| format_ident!("{}", &f.name)).collect::<Vec<Ident>>()
+    );
+    let sql_columns = [normal_fields, foreign_keys_fields].concat()
+        .iter()
+        .map(|f| f.name.clone())
+        .collect::<Vec<String>>();
+    let set_statements = sql_columns.iter()
+        .enumerate()
+        .map(|(i, column_name)| format!("{} = ${}", column_name, i+2))
         .collect::<Vec<String>>()
         .join(", ");
-
-    let func_name_ident = format_ident!("update_by_{}", primary_key);
     let update_query = format!(
         "UPDATE {} SET {} WHERE {} = $1",
         model.table_name,
         set_statements,
         primary_key
     );
-    let (normal_field_names, foreign_keys_field_names) = get_mutation_fields(model);
+    let func_name_ident = format_ident!("update_by_{}", primary_key);
 
     quote! {
         pub async fn #func_name_ident(&self, item_id: &str, entity: &#resource_ident) -> Result<(), sqlx::Error> {
             sqlx::query(#update_query)
                 .bind(item_id)
-                #( .bind( &entity.#normal_field_names ) )*
-                #( .bind( &entity.#foreign_keys_field_names.target_id) )*
+                #( .bind( &entity.#normal_field_idents ) )*
+                #( .bind( &entity.#foreign_keys_field_idents.target_id) )*
                 .execute(&self.db.0)
                 .await?;
 
@@ -231,14 +252,45 @@ pub fn generate_repository_file(all_models: &[Model], model: &Model) -> Result<S
     let repository_ident = format_ident!("{}Repository", resource_ident);
 
     let get_all_method_code = gen_get_all_method(model);
-    let get_by_id_method_code = gen_get_by_id_method(model);
-    let get_many_by_id_method_code = gen_get_many_by_id_method(model);
+    let get_by_id_method_code = gen_get_by_field_method(
+        model,
+        model.fields.iter()
+            .find(|f| f.is_primary == true)
+            .expect("Expected at least one primary key on the model.")
+    );
+    let get_many_by_id_method_code = gen_get_many_by_field_method(
+        model,
+        model.fields.iter()
+            .find(|f| f.is_primary == true)
+            .expect("Expected at least one primary key on the model.")
+    );
     let insert_method_code = gen_insert_method(model);
     let insert_many_method_code = gen_insert_many_method(model);
     let update_by_id_method_code = gen_update_by_id_method(model);
     let delete_by_id_method_code = gen_delete_by_id_method(model);
 
 
+    let query_by_field_methods: Vec<TokenStream> = 
+            model.fields.iter()
+                .filter(|f| f.is_query_entrypoint)
+                .map(|field|
+                    gen_get_by_field_method(
+                        model,
+                        &field
+                    )
+                )
+                .collect();
+    let query_many_by_field_methods: Vec<TokenStream> = 
+            model.fields.iter()
+                .filter(|f| f.is_query_entrypoint)
+                .map(|field|
+                    gen_get_many_by_field_method(
+                        model,
+                        &field
+                    )
+                )
+                .collect();
+
     let fields_with_foreign_refs: Vec<&Field> = model.fields.iter().filter(|f|
         match f.foreign_mode { FieldForeignMode::ForeignRef(_) => true, FieldForeignMode::NotRef => false }
     ).collect();
@@ -279,6 +331,10 @@ pub fn generate_repository_file(all_models: &[Model], model: &Model) -> Result<S
 
             #delete_by_id_method_code
 
+            #(#query_by_field_methods)*
+
+            #(#query_many_by_field_methods)*
+            
             #(#related_entity_methods_codes)*
 
             #(#related_entities_methods_codes)*

lib/sqlxgentools_cli/src/main.rs

@@ -24,7 +24,11 @@ pub struct SqlGeneratorModelAttr {
 pub struct SqlGeneratorFieldAttr {
     is_primary: Option<bool>,
     is_unique: Option<bool>,
-    reverse_relation_name: Option<String>
+    reverse_relation_name: Option<String>,
+    
+    /// to indicate that this field will be used to obtains entities
+    /// our framework will generate methods for all fields that is an entrypoint
+    is_query_entrypoint: Option<bool>
 }
 
 

lib/sqlxgentools_cli/src/models.rs

@@ -57,7 +57,7 @@ struct Field {
     is_nullable: bool,
     is_unique: bool,
     is_primary: bool,
-    foreign_mode: FieldForeignMode,
-    // is_foreign_ref: bool,
-    // reverse_relation_name: Option<String>
+    is_query_entrypoint: bool,
+    foreign_mode: FieldForeignMode
 }
+

lib/sqlxgentools_cli/src/parse_models.rs

@@ -127,7 +127,7 @@ fn parse_field_attribute(field: &syn::Field) -> Result<Option<SqlGeneratorFieldA
                 return Ok(Some(v));
             },
             Err(err) => {
-                return Err(anyhow!("Failed to parse sql_generator_field attribute macro: {}", err));
+                return Err(anyhow!("Failed to parse sql_generator_field attribute macro on field {:?}, {}", field, err));
             }
         };
     }
@@ -173,6 +173,7 @@ pub fn parse_models(source_code_path: &Path) -> Result<Vec<Model>> {
                         is_nullable: false,
                         is_primary: false,
                         is_unique: false,
+                        is_query_entrypoint: false,
                         foreign_mode: FieldForeignMode::NotRef
                     };
 
@@ -256,6 +257,7 @@ pub fn parse_models(source_code_path: &Path) -> Result<Vec<Model>> {
                     if let Some(field_attr) = field_attrs_opt {
                         output_field.is_primary = field_attr.is_primary.unwrap_or_default();
                         output_field.is_unique = field_attr.is_unique.unwrap_or_default();
+                        output_field.is_query_entrypoint = field_attr.is_query_entrypoint.unwrap_or_default();
                     }
 
                     fields.push(output_field);
@@ -279,6 +281,7 @@ fn parse_models_from_module_inner(module_path: &Path) -> Result<Vec<Model>> {
     let mut models: Vec<Model> = vec![];
 
     if module_path.is_file() {
+        println!("Parsing models from path {:?}.", module_path);
         models.extend(parse_models(module_path)?);
         return Ok(models);
     }