Merge remote-tracking branch 'origin/elijah/many-to-many' into elijah/many-to-many

# Conflicts:
#	cot-macros/src/model.rs

Author: ElijahAhianyo

cot-codegen/src/model.rs

@@ -225,7 +225,7 @@ impl FieldOpts {
             }
             Err(_) => None,
         };
-        
+
         let is_primary_key = self.primary_key.is_present();
         let mut resolved_ty = self.ty.clone();
         symbol_resolver.resolve(&mut resolved_ty, self_reference);
@@ -325,8 +325,7 @@ impl TryFrom<syn::Type> for ForeignKeySpec {
     }
 }
 
-
-use syn::{Type, TypePath, TypeReference, TypeParen, TypeGroup};
+use syn::{Type, TypeGroup, TypeParen, TypePath, TypeReference};
 
 #[derive(Debug, Clone, FromMeta, Default, PartialEq, Eq, Hash)]
 pub struct ManyToManyOpts {
@@ -352,7 +351,10 @@ impl TryFrom<syn::Type> for ManyToManySpec {
 
     fn try_from(ty: syn::Type) -> Result<Self, Self::Error> {
         let syn::Type::Path(type_path) = &ty else {
-            return Err(syn::Error::new(ty.span(), "expected a path type for ManyToMany"));
+            return Err(syn::Error::new(
+                ty.span(),
+                "expected a path type for ManyToMany",
+            ));
         };
 
         let seg = type_path
@@ -384,22 +386,27 @@ impl TryFrom<syn::Type> for ManyToManySpec {
         let inner_ty = if let syn::GenericArgument::Type(inner_ty) = inner {
             inner_ty
         } else {
-            return Err(syn::Error::new(ty.span(), "expected a type generic argument"));
+            return Err(syn::Error::new(
+                ty.span(),
+                "expected a type generic argument",
+            ));
         };
 
         fn type_to_snake_name(ty: &Type) -> Option<String> {
             match ty {
-                Type::Path(TypePath { path, .. }) => {
-                    path.segments.last().map(|seg| seg.ident.to_string().to_snake_case())
-                }
+                Type::Path(TypePath { path, .. }) => path
+                    .segments
+                    .last()
+                    .map(|seg| seg.ident.to_string().to_snake_case()),
                 Type::Reference(TypeReference { elem, .. }) => type_to_snake_name(&*elem),
                 Type::Paren(TypeParen { elem, .. }) => type_to_snake_name(&*elem),
                 Type::Group(TypeGroup { elem, .. }) => type_to_snake_name(&*elem),
                 _ => None,
             }
         }
-        
-        let target_table_name = type_to_snake_name(inner_ty).expect("Could not determine target table name from ManyToMany inner type");
+
+        let target_table_name = type_to_snake_name(inner_ty)
+            .expect("Could not determine target table name from ManyToMany inner type");
 
         Ok(ManyToManySpec {
             to_model: inner_ty.clone(),

cot-macros/src/model.rs

@@ -1,9 +1,9 @@
-use proc_macro2::Literal;
 use cot_codegen::model::{Field, ManyToManySpec, Model, ModelArgs, ModelOpts, ModelType};
 use cot_codegen::symbol_resolver::{SymbolResolver, VisibleSymbol, VisibleSymbolKind};
 use darling::FromMeta;
 use darling::ast::NestedMeta;
 use heck::ToSnakeCase;
+use proc_macro2::Literal;
 use proc_macro2::{Ident, TokenStream};
 use quote::{ToTokens, TokenStreamExt, format_ident, quote};
 use syn::Token;
@@ -83,7 +83,7 @@ struct ModelBuilder {
     fields_as_update_from_db: Vec<TokenStream>,
     fields_as_get_values: Vec<TokenStream>,
     fields_as_field_refs: Vec<TokenStream>,
-    fields_as_m2m_consts: Vec<TokenStream>
+    fields_as_m2m_consts: Vec<TokenStream>,
 }
 
 impl ToTokens for ModelBuilder {
@@ -118,7 +118,7 @@ impl ModelBuilder {
             fields_as_update_from_db: Vec::with_capacity(field_count),
             fields_as_get_values: Vec::with_capacity(field_count),
             fields_as_field_refs: Vec::with_capacity(field_count),
-            fields_as_m2m_consts: Vec::with_capacity(field_count)
+            fields_as_m2m_consts: Vec::with_capacity(field_count),
         };
         for field in &model.fields {
             model_builder.push_field(field);
@@ -194,12 +194,9 @@ impl ModelBuilder {
         ));
     }
 
-    fn infer_m2m_names(
-        &self,
-        field: &Field,
-        m2m: &ManyToManySpec,
-    ) -> (String, String, String) {
-        let owner_table = self.table_name.clone();
+    fn infer_m2m_names(&self, field: &Field, m2m: &ManyToManySpec) -> (String, String, String) {
+        // owner table as available in ModelBuilder
+        let owner_table = self.table_name.clone(); // already snake-cased + app namespace if needed
         let owner_pk_col = self.pk_field.column_name.clone();
 
         let target_table = m2m.target_table_name.clone();

cot/src/db.rs

@@ -27,7 +27,9 @@ use derive_more::{Debug, Deref, Display};
 #[cfg(test)]
 use mockall::automock;
 use query::Query;
-pub use relations::{ForeignKey, ForeignKeyOnDeletePolicy, ForeignKeyOnUpdatePolicy, ManyToMany, ManyToManyField};
+pub use relations::{
+    ForeignKey, ForeignKeyOnDeletePolicy, ForeignKeyOnUpdatePolicy, ManyToMany, ManyToManyField,
+};
 use sea_query::{
     ColumnRef, Iden, IntoColumnRef, OnConflict, ReturningClause, SchemaStatementBuilder, SimpleExpr,
 };

cot/src/db/fields.rs

@@ -6,7 +6,10 @@ use crate::db::impl_mysql::MySqlValueRef;
 use crate::db::impl_postgres::PostgresValueRef;
 #[cfg(feature = "sqlite")]
 use crate::db::impl_sqlite::SqliteValueRef;
-use crate::db::{Auto, ColumnType, DatabaseError, DatabaseField, DbFieldValue, DbValue, ForeignKey, FromDbValue, LimitedString, ManyToMany, Model, PrimaryKey, Result, SqlxValueRef, ToDbFieldValue, ToDbValue};
+use crate::db::{
+    Auto, ColumnType, DatabaseError, DatabaseField, DbFieldValue, DbValue, ForeignKey, FromDbValue,
+    LimitedString, ManyToMany, Model, PrimaryKey, Result, SqlxValueRef, ToDbFieldValue, ToDbValue,
+};
 
 mod chrono_wrapper;
 

cot/src/db/relations.rs

@@ -208,7 +208,7 @@ impl<T: Model> Default for ManyToMany<T> {
         ManyToMany::PrimaryKeys(Vec::new())
     }
 }
-impl <T: Model> ManyToMany<T> {
+impl<T: Model> ManyToMany<T> {
     pub fn primary_keys(&self) -> Vec<&T::PrimaryKey> {
         match self {
             Self::PrimaryKeys(pks) => pks.iter().collect(),
@@ -232,7 +232,7 @@ pub struct ManyToManyField<T: Model, Owner: Model> {
     pub phantom: std::marker::PhantomData<(T, Owner)>,
 }
 
-impl <T: Model, Owner: Model> ManyToManyField<T, Owner> {
+impl<T: Model, Owner: Model> ManyToManyField<T, Owner> {
     pub const fn new(
         join_table: &'static str,
         owner_field: &'static str,