feat: generate type source and add default macros

LeadcodeDev · LeadcodeDev · commit 55f4e2ce5694 · 2026-02-26T10:19:19.000+01:00
diff --git a/README.md b/README.md
@@ -20,7 +20,7 @@ Supports **PostgreSQL**, **MySQL**, and **SQLite**. Introspects tables, views, e
 - Custom derives (`--derives Serialize,Deserialize`)
 - Type overrides (`--type-overrides jsonb=MyType`)
 - SQL views support (`--views`)
-- Table filtering (`--tables users,orders`)
+- Table filtering (`--tables users,orders`) and exclusion (`--exclude-tables _migrations`)
 - Single-file or multi-file output
 - Dry-run mode (preview on stdout)
 
@@ -52,6 +52,11 @@ sqlx-gen -u sqlite:./local.db -o src/models
 sqlx-gen -u postgres://... --derives Serialize,Deserialize -o src/models
 ```
 
+### Exclude specific tables
+```sh
+sqlx-gen -u postgres://... --exclude-tables _migrations,schema_versions -o src/models
+```
+
 ### Include SQL views
 ```sh
 sqlx-gen -u postgres://... --views -o src/models
@@ -72,6 +77,7 @@ sqlx-gen -u postgres://... --dry-run
 | `--derives` | | Additional derive macros (comma-separated) | none |
 | `--type-overrides` | | Type overrides `sql_type=RustType` (comma-separated) | none |
 | `--tables` | | Only generate these tables (comma-separated) | all |
+| `--exclude-tables` | | Exclude these tables/views (comma-separated) | none |
 | `--views` | | Also generate structs for SQL views | false |
 | `--single-file` | | Write everything to a single `models.rs` | false |
 | `--dry-run` | | Print to stdout, don't write files | false |
diff --git a/src/cli.rs b/src/cli.rs
@@ -33,6 +33,10 @@ pub struct Args {
     #[arg(long, value_delimiter = ',')]
     pub tables: Option<Vec<String>>,
 
+    /// Exclude these tables/views from generation (comma-separated)
+    #[arg(long, value_delimiter = ',')]
+    pub exclude_tables: Option<Vec<String>>,
+
     /// Also generate structs for SQL views
     #[arg(long)]
     pub views: bool,
@@ -89,6 +93,7 @@ mod tests {
             type_overrides: vec![],
             single_file: false,
             tables: None,
+            exclude_tables: None,
             views: false,
             dry_run: false,
         }
@@ -103,6 +108,7 @@ mod tests {
             type_overrides: overrides.into_iter().map(|s| s.to_string()).collect(),
             single_file: false,
             tables: None,
+            exclude_tables: None,
             views: false,
             dry_run: false,
         }
@@ -240,4 +246,20 @@ mod tests {
         let map = args.parse_type_overrides();
         assert_eq!(map.get("key").unwrap(), "");
     }
+
+    // ========== exclude_tables ==========
+
+    #[test]
+    fn test_exclude_tables_default_none() {
+        let args = make_args("postgres://localhost/db");
+        assert!(args.exclude_tables.is_none());
+    }
+
+    #[test]
+    fn test_exclude_tables_set() {
+        let mut args = make_args("postgres://localhost/db");
+        args.exclude_tables = Some(vec!["_migrations".to_string(), "schema_versions".to_string()]);
+        assert_eq!(args.exclude_tables.as_ref().unwrap().len(), 2);
+        assert!(args.exclude_tables.as_ref().unwrap().contains(&"_migrations".to_string()));
+    }
 }
diff --git a/src/codegen/composite_gen.rs b/src/codegen/composite_gen.rs
@@ -27,17 +27,27 @@ pub fn generate_composite(
         composite.schema_name, composite.name
     );
 
+    imports.insert("use serde::{Serialize, Deserialize};".to_string());
     let mut derive_tokens = vec![
         quote! { Debug },
         quote! { Clone },
+        quote! { PartialEq },
+        quote! { Eq },
+        quote! { Serialize },
+        quote! { Deserialize },
         quote! { sqlx::Type },
     ];
     for d in extra_derives {
         let ident = format_ident!("{}", d);
         derive_tokens.push(quote! { #ident });
     }
 
-    let pg_name = &composite.name;
+    // Schema-qualify the type name for non-public schemas so sqlx can find the type
+    let pg_name = if composite.schema_name != "public" {
+        format!("{}.{}", composite.schema_name, composite.name)
+    } else {
+        composite.name.clone()
+    };
     let type_attr = quote! { #[sqlx(type_name = #pg_name)] };
 
     let fields: Vec<TokenStream> = composite
@@ -169,6 +179,28 @@ mod tests {
         assert!(code.contains("sqlx(type_name = \"geo_point\")"));
     }
 
+    #[test]
+    fn test_non_public_schema_qualified_type_name() {
+        let c = CompositeTypeInfo {
+            schema_name: "geo".to_string(),
+            name: "point".to_string(),
+            fields: vec![make_field("x", "float8", false)],
+        };
+        let schema = SchemaInfo::default();
+        let (tokens, _) = generate_composite(&c, DatabaseKind::Postgres, &schema, &[], &HashMap::new());
+        let code = parse_and_format(&tokens);
+        assert!(code.contains("sqlx(type_name = \"geo.point\")"));
+    }
+
+    #[test]
+    fn test_public_schema_not_qualified() {
+        let c = make_composite("address", vec![make_field("x", "text", false)]);
+        let code = gen(&c);
+        assert!(code.contains("sqlx(type_name = \"address\")"));
+        // type_name should NOT be schema-qualified for public schema
+        assert!(!code.contains("type_name = \"public.address\""));
+    }
+
     // --- fields ---
 
     #[test]
diff --git a/src/codegen/enum_gen.rs b/src/codegen/enum_gen.rs
@@ -17,14 +17,18 @@ pub fn generate_enum(
     for imp in imports_for_derives(extra_derives) {
         imports.insert(imp);
     }
-    let enum_name = format_ident!("{}", enum_info.name.to_upper_camel_case());
 
+    let enum_name = format_ident!("{}", enum_info.name.to_upper_camel_case());
     let doc = format!("Enum: {}.{}", enum_info.schema_name, enum_info.name);
 
+    imports.insert("use serde::{Serialize, Deserialize};".to_string());
     let mut derive_tokens = vec![
         quote! { Debug },
         quote! { Clone },
         quote! { PartialEq },
+        quote! { Eq },
+        quote! { Serialize },
+        quote! { Deserialize },
         quote! { sqlx::Type },
     ];
     for d in extra_derives {
@@ -33,8 +37,13 @@ pub fn generate_enum(
     }
 
     // For PG, add #[sqlx(type_name = "...")]
+    // Schema-qualify the type name for non-public schemas so sqlx can find the type
     let type_attr = if db_kind == DatabaseKind::Postgres {
-        let pg_name = &enum_info.name;
+        let pg_name = if enum_info.schema_name != "public" {
+            format!("{}.{}", enum_info.schema_name, enum_info.name)
+        } else {
+            enum_info.name.clone()
+        };
         quote! { #[sqlx(type_name = #pg_name)] }
     } else {
         quote! {}
@@ -90,7 +99,11 @@ mod tests {
         parse_and_format(&tokens)
     }
 
-    fn gen_with_derives(info: &EnumInfo, db: DatabaseKind, derives: &[String]) -> (String, BTreeSet<String>) {
+    fn gen_with_derives(
+        info: &EnumInfo,
+        db: DatabaseKind,
+        derives: &[String],
+    ) -> (String, BTreeSet<String>) {
         let (tokens, imports) = generate_enum(info, db, derives);
         (parse_and_format(&tokens), imports)
     }
@@ -128,6 +141,27 @@ mod tests {
         assert!(code.contains("sqlx(type_name = \"user_status\")"));
     }
 
+    #[test]
+    fn test_postgres_non_public_schema_qualified_type_name() {
+        let e = EnumInfo {
+            schema_name: "auth".to_string(),
+            name: "role".to_string(),
+            variants: vec!["admin".to_string(), "user".to_string()],
+        };
+        let (tokens, _) = generate_enum(&e, DatabaseKind::Postgres, &[]);
+        let code = parse_and_format(&tokens);
+        assert!(code.contains("sqlx(type_name = \"auth.role\")"));
+    }
+
+    #[test]
+    fn test_postgres_public_schema_not_qualified() {
+        let e = make_enum("status", vec!["a"]);
+        let code = gen(&e, DatabaseKind::Postgres);
+        assert!(code.contains("sqlx(type_name = \"status\")"));
+        // type_name should NOT be schema-qualified for public schema
+        assert!(!code.contains("type_name = \"public.status\""));
+    }
+
     #[test]
     fn test_mysql_no_type_name() {
         let e = make_enum("status", vec!["a"]);
@@ -207,10 +241,10 @@ mod tests {
     // --- imports ---
 
     #[test]
-    fn test_no_derives_empty_imports() {
+    fn test_no_extra_derives_has_serde_import() {
         let e = make_enum("status", vec!["a"]);
         let (_, imports) = gen_with_derives(&e, DatabaseKind::Postgres, &[]);
-        assert!(imports.is_empty());
+        assert!(imports.iter().any(|i| i.contains("serde")));
     }
 
     #[test]
diff --git a/src/codegen/struct_gen.rs b/src/codegen/struct_gen.rs
@@ -23,9 +23,14 @@ pub fn generate_struct(
     let struct_name = format_ident!("{}", table.name.to_upper_camel_case());
 
     // Build derive list
+    imports.insert("use serde::{Serialize, Deserialize};".to_string());
     let mut derive_tokens = vec![
         quote! { Debug },
         quote! { Clone },
+        quote! { PartialEq },
+        quote! { Eq },
+        quote! { Serialize },
+        quote! { Deserialize },
         quote! { sqlx::FromRow },
     ];
     for d in extra_derives {
@@ -315,11 +320,12 @@ mod tests {
     }
 
     #[test]
-    fn test_int4_no_import() {
+    fn test_int4_only_serde_import() {
         let table = make_table("users", vec![make_col("id", "int4", false)]);
         let schema = SchemaInfo::default();
         let (_, imports) = gen_with(&table, &schema, DatabaseKind::Postgres, &[], &HashMap::new());
-        assert!(imports.is_empty());
+        assert_eq!(imports.len(), 1);
+        assert!(imports.iter().any(|i| i.contains("serde")));
     }
 
     #[test]
diff --git a/src/main.rs b/src/main.rs
@@ -40,11 +40,17 @@ async fn main() -> Result<()> {
         }
     };
 
-    // Filter tables if requested
+    // Filter tables if requested (whitelist)
     if let Some(ref filter) = args.tables {
         schema_info.tables.retain(|t| filter.contains(&t.name));
     }
 
+    // Exclude tables/views if requested (blacklist)
+    if let Some(ref exclude) = args.exclude_tables {
+        schema_info.tables.retain(|t| !exclude.contains(&t.name));
+        schema_info.views.retain(|v| !exclude.contains(&v.name));
+    }
+
     let table_count = schema_info.tables.len();
     let view_count = schema_info.views.len();
     let enum_count = schema_info.enums.len();
diff --git a/tests/e2e_sqlite.rs b/tests/e2e_sqlite.rs
@@ -135,3 +135,61 @@ async fn test_view_pascal_case_name() {
     let view_file = files.iter().find(|f| f.filename == "all_active_users.rs").unwrap();
     assert!(view_file.code.contains("pub struct AllActiveUsers"));
 }
+
+// --- exclude tables ---
+
+#[tokio::test]
+async fn test_exclude_table() {
+    let pool = setup_pool().await;
+    exec(&pool, "CREATE TABLE users (id INTEGER NOT NULL)").await;
+    exec(&pool, "CREATE TABLE _migrations (id INTEGER NOT NULL)").await;
+    let mut schema = introspect(&pool, false).await.unwrap();
+    let exclude = vec!["_migrations".to_string()];
+    schema.tables.retain(|t| !exclude.contains(&t.name));
+    let files = codegen::generate(&schema, DatabaseKind::Sqlite, &[], &HashMap::new(), false);
+    assert_eq!(files.len(), 1);
+    assert_eq!(files[0].filename, "users.rs");
+}
+
+#[tokio::test]
+async fn test_exclude_nonexistent_table() {
+    let pool = setup_pool().await;
+    exec(&pool, "CREATE TABLE users (id INTEGER NOT NULL)").await;
+    exec(&pool, "CREATE TABLE posts (id INTEGER NOT NULL)").await;
+    let mut schema = introspect(&pool, false).await.unwrap();
+    let exclude = vec!["nonexistent".to_string()];
+    schema.tables.retain(|t| !exclude.contains(&t.name));
+    assert_eq!(schema.tables.len(), 2);
+}
+
+#[tokio::test]
+async fn test_tables_include_then_exclude() {
+    let pool = setup_pool().await;
+    exec(&pool, "CREATE TABLE users (id INTEGER NOT NULL)").await;
+    exec(&pool, "CREATE TABLE posts (id INTEGER NOT NULL)").await;
+    exec(&pool, "CREATE TABLE comments (id INTEGER NOT NULL)").await;
+    let mut schema = introspect(&pool, false).await.unwrap();
+    // Simulate --tables users,posts
+    let include = vec!["users".to_string(), "posts".to_string()];
+    schema.tables.retain(|t| include.contains(&t.name));
+    // Simulate --exclude-tables posts
+    let exclude = vec!["posts".to_string()];
+    schema.tables.retain(|t| !exclude.contains(&t.name));
+    assert_eq!(schema.tables.len(), 1);
+    assert_eq!(schema.tables[0].name, "users");
+}
+
+#[tokio::test]
+async fn test_exclude_view() {
+    let pool = setup_pool().await;
+    exec(&pool, "CREATE TABLE users (id INTEGER NOT NULL)").await;
+    exec(&pool, "CREATE VIEW v1 AS SELECT id FROM users").await;
+    exec(&pool, "CREATE VIEW v2 AS SELECT id FROM users").await;
+    let mut schema = introspect(&pool, true).await.unwrap();
+    let exclude = vec!["v1".to_string()];
+    schema.views.retain(|v| !exclude.contains(&v.name));
+    let files = codegen::generate(&schema, DatabaseKind::Sqlite, &[], &HashMap::new(), false);
+    let view_files: Vec<_> = files.iter().filter(|f| f.origin.as_ref().is_some_and(|o| o.starts_with("View:"))).collect();
+    assert_eq!(view_files.len(), 1);
+    assert_eq!(view_files[0].filename, "v2.rs");
+}
