feat: add more enum context

Author: LeadcodeDev

Cargo.lock

@@ -146,6 +146,18 @@ The `--entities-module` (`-e`) option is **optional**. When omitted, the module
 
 Views are automatically detected via the `#[sqlx_gen(kind = "view")]` annotation — write methods (`insert`, `update`, `delete`) are never generated for views even if requested.
 
+### Pool field visibility
+
+By default, the `pool` field in generated repositories is private. Use `--pool-visibility` (`-p`) to change it:
+
+```sh
+# Public pool field
+sqlx-gen generate crud -f src/models/users.rs -d postgres -m '*' -p pub
+
+# Crate-visible pool field
+sqlx-gen generate crud -f src/models/users.rs -d postgres -m '*' -p 'pub(crate)'
+```
+
 ### Compile-time checked macros
 
 By default, the CRUD generator uses `sqlx::query_as::<_, T>()` with `.bind()` chains (runtime). Pass `--query-macro` (`-q`) to generate `sqlx::query_as!()` / `sqlx::query!()` macros instead, which are checked at compile time (requires `DATABASE_URL` at build time).
@@ -180,6 +192,7 @@ Generated files are automatically formatted with `rustfmt`. The Rust edition is
 | `--output-dir` | `-o` | Output directory | `src/crud` |
 | `--methods` | `-m` | Methods to generate (comma-separated): `*`, `get_all`, `paginate`, `get`, `insert`, `update`, `delete` | required |
 | `--query-macro` | `-q` | Use `sqlx::query_as!()` macros (compile-time checked) | `false` |
+| `--pool-visibility` | `-p` | Visibility of the `pool` field: `private`, `pub`, `pub(crate)` | `private` |
 | `--dry-run` | `-n` | Print to stdout, don't write files | `false` |
 
 ## Example Output

README.md

@@ -1,6 +1,6 @@
 [package]
 name = "sqlx-gen"
-version = "0.4.3"
+version = "0.4.4"
 edition = "2021"
 description = "Generate Rust structs from database schema introspection"
 license = "MIT"

crates/sqlx_gen/Cargo.toml

@@ -132,6 +132,10 @@ pub struct CrudArgs {
     #[arg(short = 'q', long)]
     pub query_macro: bool,
 
+    /// Visibility of the pool field in generated repository structs: private, pub, pub(crate)
+    #[arg(short = 'p', long, default_value = "private")]
+    pub pool_visibility: PoolVisibility,
+
     /// Print to stdout without writing files
     #[arg(short = 'n', long)]
     pub dry_run: bool,
@@ -191,6 +195,30 @@ pub enum DatabaseKind {
     Sqlite,
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub enum PoolVisibility {
+    #[default]
+    Private,
+    Pub,
+    PubCrate,
+}
+
+impl std::str::FromStr for PoolVisibility {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "private" => Ok(Self::Private),
+            "pub" => Ok(Self::Pub),
+            "pub(crate)" => Ok(Self::PubCrate),
+            other => Err(format!(
+                "Unknown pool visibility '{}'. Expected: private, pub, pub(crate)",
+                other
+            )),
+        }
+    }
+}
+
 /// Which CRUD methods to generate. All fields default to `false`.
 /// Use `Methods::from_list` to parse from CLI input.
 #[derive(Debug, Clone, Default)]

crates/sqlx_gen/src/cli.rs

@@ -3,7 +3,7 @@ use std::collections::BTreeSet;
 use proc_macro2::TokenStream;
 use quote::{format_ident, quote};
 
-use crate::cli::{DatabaseKind, Methods};
+use crate::cli::{DatabaseKind, Methods, PoolVisibility};
 use crate::codegen::entity_parser::{ParsedEntity, ParsedField};
 
 pub fn generate_crud_from_parsed(
@@ -12,6 +12,7 @@ pub fn generate_crud_from_parsed(
     entity_module_path: &str,
     methods: &Methods,
     query_macro: bool,
+    pool_visibility: PoolVisibility,
 ) -> (TokenStream, BTreeSet<String>) {
     let mut imports = BTreeSet::new();
 
@@ -502,11 +503,17 @@ pub fn generate_crud_from_parsed(
         method_tokens.push(method);
     }
 
+    let pool_vis: TokenStream = match pool_visibility {
+        PoolVisibility::Private => quote! {},
+        PoolVisibility::Pub => quote! { pub },
+        PoolVisibility::PubCrate => quote! { pub(crate) },
+    };
+
     let tokens = quote! {
         #(#param_structs)*
 
         pub struct #repo_ident {
-            pool: #pool_type,
+            #pool_vis pool: #pool_type,
         }
 
         impl #repo_ident {
@@ -742,18 +749,18 @@ mod tests {
 
     fn gen(entity: &ParsedEntity, db: DatabaseKind) -> String {
         let skip = Methods::all();
-        let (tokens, _) = generate_crud_from_parsed(entity, db, "crate::models::users", &skip, false);
+        let (tokens, _) = generate_crud_from_parsed(entity, db, "crate::models::users", &skip, false, PoolVisibility::Private);
         parse_and_format(&tokens)
     }
 
     fn gen_macro(entity: &ParsedEntity, db: DatabaseKind) -> String {
         let skip = Methods::all();
-        let (tokens, _) = generate_crud_from_parsed(entity, db, "crate::models::users", &skip, true);
+        let (tokens, _) = generate_crud_from_parsed(entity, db, "crate::models::users", &skip, true, PoolVisibility::Private);
         parse_and_format(&tokens)
     }
 
     fn gen_with_methods(entity: &ParsedEntity, db: DatabaseKind, methods: &Methods) -> String {
-        let (tokens, _) = generate_crud_from_parsed(entity, db, "crate::models::users", methods, false);
+        let (tokens, _) = generate_crud_from_parsed(entity, db, "crate::models::users", methods, false, PoolVisibility::Private);
         parse_and_format(&tokens)
     }
 
@@ -777,6 +784,30 @@ mod tests {
         assert!(code.contains("pool: sqlx::PgPool") || code.contains("pool: sqlx :: PgPool"));
     }
 
+    #[test]
+    fn test_repo_pool_field_pub() {
+        let skip = Methods::all();
+        let (tokens, _) = generate_crud_from_parsed(&standard_entity(), DatabaseKind::Postgres, "crate::models::users", &skip, false, PoolVisibility::Pub);
+        let code = parse_and_format(&tokens);
+        assert!(code.contains("pub pool: sqlx::PgPool") || code.contains("pub pool: sqlx :: PgPool"));
+    }
+
+    #[test]
+    fn test_repo_pool_field_pub_crate() {
+        let skip = Methods::all();
+        let (tokens, _) = generate_crud_from_parsed(&standard_entity(), DatabaseKind::Postgres, "crate::models::users", &skip, false, PoolVisibility::PubCrate);
+        let code = parse_and_format(&tokens);
+        assert!(code.contains("pub(crate) pool: sqlx::PgPool") || code.contains("pub(crate) pool: sqlx :: PgPool"));
+    }
+
+    #[test]
+    fn test_repo_pool_field_private() {
+        let code = gen(&standard_entity(), DatabaseKind::Postgres);
+        // Should NOT have `pub pool` or `pub(crate) pool`
+        assert!(!code.contains("pub pool"));
+        assert!(!code.contains("pub(crate) pool"));
+    }
+
     #[test]
     fn test_repo_pool_field_mysql() {
         let code = gen(&standard_entity(), DatabaseKind::Mysql);
@@ -1117,14 +1148,14 @@ mod tests {
     #[test]
     fn test_no_pool_import() {
         let skip = Methods::all();
-        let (_, imports) = generate_crud_from_parsed(&standard_entity(), DatabaseKind::Postgres, "crate::models::users", &skip, false);
+        let (_, imports) = generate_crud_from_parsed(&standard_entity(), DatabaseKind::Postgres, "crate::models::users", &skip, false, PoolVisibility::Private);
         assert!(!imports.iter().any(|i| i.contains("PgPool")));
     }
 
     #[test]
     fn test_imports_contain_entity() {
         let skip = Methods::all();
-        let (_, imports) = generate_crud_from_parsed(&standard_entity(), DatabaseKind::Postgres, "crate::models::users", &skip, false);
+        let (_, imports) = generate_crud_from_parsed(&standard_entity(), DatabaseKind::Postgres, "crate::models::users", &skip, false, PoolVisibility::Private);
         assert!(imports.iter().any(|i| i.contains("crate::models::users::Users")));
     }
 
@@ -1214,15 +1245,15 @@ mod tests {
             ],
         };
         let skip = Methods::all();
-        let (_, imports) = generate_crud_from_parsed(&entity, DatabaseKind::Postgres, "crate::models::users", &skip, false);
+        let (_, imports) = generate_crud_from_parsed(&entity, DatabaseKind::Postgres, "crate::models::users", &skip, false, PoolVisibility::Private);
         assert!(imports.iter().any(|i| i.contains("chrono")));
         assert!(imports.iter().any(|i| i.contains("uuid")));
     }
 
     #[test]
     fn test_entity_imports_empty_when_no_imports() {
         let skip = Methods::all();
-        let (_, imports) = generate_crud_from_parsed(&standard_entity(), DatabaseKind::Postgres, "crate::models::users", &skip, false);
+        let (_, imports) = generate_crud_from_parsed(&standard_entity(), DatabaseKind::Postgres, "crate::models::users", &skip, false, PoolVisibility::Private);
         // Should only have pool + entity imports, no chrono/uuid
         assert!(!imports.iter().any(|i| i.contains("chrono")));
         assert!(!imports.iter().any(|i| i.contains("uuid")));
@@ -1343,7 +1374,7 @@ mod tests {
 
     fn gen_macro_array(entity: &ParsedEntity, db: DatabaseKind) -> String {
         let skip = Methods::all();
-        let (tokens, _) = generate_crud_from_parsed(entity, db, "crate::models::agent_connector", &skip, true);
+        let (tokens, _) = generate_crud_from_parsed(entity, db, "crate::models::agent_connector", &skip, true, PoolVisibility::Private);
         parse_and_format(&tokens)
     }
 
@@ -1426,7 +1457,7 @@ mod tests {
     #[test]
     fn test_sql_enum_macro_uses_runtime() {
         let skip = Methods::all();
-        let (tokens, _) = generate_crud_from_parsed(&entity_with_sql_enum(), DatabaseKind::Postgres, "crate::models::task", &skip, true);
+        let (tokens, _) = generate_crud_from_parsed(&entity_with_sql_enum(), DatabaseKind::Postgres, "crate::models::task", &skip, true, PoolVisibility::Private);
         let code = parse_and_format(&tokens);
         // SELECT queries should use runtime query_as, not macro
         assert!(code.contains("query_as::<"));
@@ -1436,7 +1467,7 @@ mod tests {
     #[test]
     fn test_sql_enum_macro_delete_still_uses_macro() {
         let skip = Methods::all();
-        let (tokens, _) = generate_crud_from_parsed(&entity_with_sql_enum(), DatabaseKind::Postgres, "crate::models::task", &skip, true);
+        let (tokens, _) = generate_crud_from_parsed(&entity_with_sql_enum(), DatabaseKind::Postgres, "crate::models::task", &skip, true, PoolVisibility::Private);
         let code = parse_and_format(&tokens);
         // DELETE still uses query! macro
         assert!(code.contains("query!"));
@@ -1489,15 +1520,15 @@ mod tests {
     #[test]
     fn test_vec_string_macro_insert_uses_as_slice() {
         let skip = Methods::all();
-        let (tokens, _) = generate_crud_from_parsed(&entity_with_vec_string(), DatabaseKind::Postgres, "crate::models::prompt_history", &skip, true);
+        let (tokens, _) = generate_crud_from_parsed(&entity_with_vec_string(), DatabaseKind::Postgres, "crate::models::prompt_history", &skip, true, PoolVisibility::Private);
         let code = parse_and_format(&tokens);
         assert!(code.contains("as_slice()"));
     }
 
     #[test]
     fn test_vec_string_macro_update_uses_as_slice() {
         let skip = Methods::all();
-        let (tokens, _) = generate_crud_from_parsed(&entity_with_vec_string(), DatabaseKind::Postgres, "crate::models::prompt_history", &skip, true);
+        let (tokens, _) = generate_crud_from_parsed(&entity_with_vec_string(), DatabaseKind::Postgres, "crate::models::prompt_history", &skip, true, PoolVisibility::Private);
         let code = parse_and_format(&tokens);
         // Should have as_slice() for both insert and update
         let count = code.matches("as_slice()").count();
@@ -1507,7 +1538,7 @@ mod tests {
     #[test]
     fn test_vec_string_non_macro_no_as_slice() {
         let skip = Methods::all();
-        let (tokens, _) = generate_crud_from_parsed(&entity_with_vec_string(), DatabaseKind::Postgres, "crate::models::prompt_history", &skip, false);
+        let (tokens, _) = generate_crud_from_parsed(&entity_with_vec_string(), DatabaseKind::Postgres, "crate::models::prompt_history", &skip, false, PoolVisibility::Private);
         let code = parse_and_format(&tokens);
         // Runtime mode uses .bind() so no as_slice needed
         assert!(!code.contains("as_slice()"));
@@ -1530,7 +1561,7 @@ mod tests {
         "#;
         let entity = parse_entity_source(source).unwrap();
         let skip = Methods::all();
-        let (tokens, _) = generate_crud_from_parsed(&entity, DatabaseKind::Postgres, "crate::models::prompt_history", &skip, true);
+        let (tokens, _) = generate_crud_from_parsed(&entity, DatabaseKind::Postgres, "crate::models::prompt_history", &skip, true, PoolVisibility::Private);
         let code = parse_and_format(&tokens);
         assert!(code.contains("as_slice()"), "Expected as_slice() in generated code:\n{}", code);
     }

crates/sqlx_gen/src/codegen/crud_gen.rs

@@ -85,10 +85,13 @@ pub fn generate_enum(
         quote! {}
     };
 
+    let schema_name_str = &enum_info.schema_name;
+    let enum_name_str = &enum_info.name;
+
     let tokens = quote! {
         #[doc = #doc]
         #[derive(#(#derive_tokens),*)]
-        #[sqlx_gen(kind = "enum")]
+        #[sqlx_gen(kind = "enum", schema = #schema_name_str, name = #enum_name_str)]
         #type_attr
         pub enum #enum_name {
             #(#variants)*
@@ -152,6 +155,25 @@ mod tests {
         assert!(code.contains("Enum: public.status"));
     }
 
+    #[test]
+    fn test_sqlx_gen_attr_has_schema_and_name() {
+        let e = make_enum("status", vec!["a"]);
+        let code = gen(&e, DatabaseKind::Postgres);
+        assert!(code.contains("sqlx_gen(kind = \"enum\", schema = \"public\", name = \"status\")"));
+    }
+
+    #[test]
+    fn test_sqlx_gen_attr_non_public_schema() {
+        let e = EnumInfo {
+            schema_name: "auth".to_string(),
+            name: "role".to_string(),
+            variants: vec!["admin".to_string(), "user".to_string()],
+            default_variant: None,
+        };
+        let code = gen(&e, DatabaseKind::Postgres);
+        assert!(code.contains("sqlx_gen(kind = \"enum\", schema = \"auth\", name = \"role\")"));
+    }
+
     // --- sqlx attributes ---
 
     #[test]

crates/sqlx_gen/src/codegen/enum_gen.rs

@@ -139,6 +139,7 @@ fn run_crud(args: CrudArgs) -> Result<()> {
         &entities_module,
         &methods,
         args.query_macro,
+        args.pool_visibility,
     );
 
     let code = codegen::format_tokens_with_imports(&tokens, &imports);

crates/sqlx_gen/src/main.rs

@@ -1,6 +1,6 @@
 [package]
 name = "sqlx-gen-macros"
-version = "0.4.3"
+version = "0.4.4"
 edition = "2021"
 description = "No-op attribute macros for sqlx-gen generated code"
 license = "MIT"