Add support for generating insertable structs in diesel_ext

- Updated README.md to reflect the addition of insertable options.
- Modified main.rs to include command-line options for generating insertable structs.
- Enhanced parse.rs to handle insertable struct generation logic.
- Created expected output for insertable structs in schema_insertable.rs.

Author: abbychau

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "diesel_cli_ext"
-version = "0.3.16"
+version = "0.3.17"
 authors = ["Abby <i@abby.md>"]
 license = "MIT OR Apache-2.0"
 description = "Provides different tools for projects using the diesel_cli."

README.md

@@ -6,10 +6,11 @@ Diesel CLI Extension is a tool-belt that aids Diesel CLI after it built schema.r
 [![Crates.io](https://img.shields.io/crates/v/diesel_cli_ext.svg)](https://crates.io/crates/diesel_cli_ext)
 <!-- [![Coverage Status](https://coveralls.io/repos/github/abbychau/diesel_cli_ext/badge.svg?branch=master)](https://coveralls.io/github/abbychau/diesel_cli_ext?branch=master) -->
 
-It contains 4 functions at this moment.
+It contains 5 functions at this moment.
 1. Generate protobuf file.(`diesel_ext proto`)
 2. Generate model rust structs.(`diesel_ext model`)
-3. Generate conversion implementations.(`diesel_ext into_proto`, and `diesel_ext from_proto`)
+3. Generate insertable rust structs.(`diesel_ext insertable`)
+4. Generate conversion implementations.(`diesel_ext into_proto`, and `diesel_ext from_proto`)
 
 ## Installation
 `cargo install diesel_cli_ext`
@@ -40,16 +41,36 @@ Model Options:
                         (NOT ready)This field adds derives for certain tables.
                         (can be set multiple times) e.g. --derive-mod
                         "table_name +Debug" --derive-mod "table_name2 -Debug"
+    -n, --struct-name-override "STRUCT NAME OVERRIDE"
+                        This field overrides the generated struct name for
+                        certain tables. (can be set multiple times)
+
+Insertable Options:
     -d, --derive DERIVES
                         set struct derives
+    -t, --add-table-name 
+                        Add #[table_name = x] before structs
     -r, --rust_styled_model_fields
                         set struct field names to be styled according to Rust guidelines
+    -g, --insertable    Generate insertable structs for database inserts
+                        (omits auto-increment/default fields)
+    -S, --skip-fields "FIELD_NAME"
+                        Fields to skip in insertable structs (can be set
+                        multiple times) e.g. --skip-fields "id"
+    -O, --optional-fields "FIELD_NAME"
+                        Fields to make optional in insertable structs even if
+                        NOT NULL (can be set multiple times)
+    -P, --insertable-prefix PREFIX
+                        Prefix for insertable struct names (default: New)
 
 Proto Options:
-    -t, --add-table-name 
-                        Add #[table_name = x] before structs
     -p, --proto         Set as proto output
     -i, --into_proto    Set as into_proto output
+    -f, --from_proto    Set as from_proto output
+    -c, --class_name CLASS_NAME
+                        Set proto class name
+    -v, --diesel_version 1 or 2
+                        Set diesel version (default:2)
 ```
 
 (You can see it again by `diesel_ext --help`)
@@ -80,6 +101,54 @@ pub struct Order {
 }
 ```
 
+### To generate insertable structs:
+`diesel_ext -g > src/insertable.rs`, `diesel_ext --insertable > src/insertable.rs`
+
+Insertable structs are perfect for database inserts as they omit auto-increment and default value columns. This follows Diesel's recommended pattern of using separate structs for querying and inserting data.
+
+**Key Features:**
+- Automatically skips common auto-generated fields (`id`, `created_at`, `updated_at`)
+- Uses string references (`&'a str`) for better performance
+- Supports custom field skipping and optional field configuration
+- Generates proper `#[derive(Insertable)]` annotations
+
+**Basic usage:**
+```bash
+diesel_ext -g -s schema.rs
+```
+
+**Advanced usage:**
+```bash
+# Skip custom fields
+diesel_ext -g -s schema.rs -S user_id -S account_id
+
+# Make fields optional (useful for database defaults)
+diesel_ext -g -s schema.rs -O status -O version
+
+# Custom struct name prefix
+diesel_ext -g -s schema.rs -P Create  # generates CreateUser instead of NewUser
+```
+
+Sample output:
+``` rust
+#[derive(Insertable)]
+#[diesel(table_name = users)]
+pub struct NewUser<'a> {
+    pub name: &'a str,
+    pub email: &'a str,
+    pub status: Option<&'a str>,  // Made optional with -O
+    // id, created_at, updated_at automatically skipped
+}
+
+#[derive(Insertable)]
+#[diesel(table_name = orders)]
+pub struct NewOrder<'a> {
+    pub user_id: i64,
+    pub amount: BigDecimal,
+    pub description: Option<&'a str>,
+}
+```
+
 ### To generate prelimiting proto file:
 `diesel_ext -p > myproto.proto`, `diesel_ext --proto > myproto.proto`
 

src/main.rs

@@ -14,11 +14,12 @@ pub fn custom_opts_usage(iopts: Options, brief: &str) -> String {
     iopts.usage_with_format(|opts| {
         let full_param = opts.collect::<Vec<String>>();
         format!(
-            "{}\n\nCommon Options:\n{}\n\nModel Options:\n{}\n\nProto Options:\n{}\n",
+            "{}\n\nCommon Options:\n{}\n\nModel Options:\n{}\n\nInsertable Options:\n{}\n\nProto Options:\n{}\n",
             brief,
             full_param[0..2].join("\n"),
             full_param[2..7].join("\n"),
-            full_param[7..10].join("\n"),
+            full_param[7..14].join("\n"),
+            full_param[14..19].join("\n"),
         )
     })
 }
@@ -135,6 +136,31 @@ fn main() {
         "rust_styled_model_fields",
         "When creating models fields, will use rust styled names instead of database styled names",
     );
+    
+    // Insertable struct options
+    opts.optflag(
+        "g",
+        "insertable",
+        "Generate insertable structs for database inserts (omits auto-increment/default fields)",
+    );
+    opts.optmulti(
+        "S",
+        "skip-fields",
+        "Fields to skip in insertable structs (can be set multiple times) e.g. --skip-fields \"id\" --skip-fields \"created_at\"",
+        "\"FIELD_NAME\"",
+    );
+    opts.optmulti(
+        "O",
+        "optional-fields",
+        "Fields to make optional in insertable structs even if NOT NULL (can be set multiple times) e.g. --optional-fields \"status\"",
+        "\"FIELD_NAME\"",
+    );
+    opts.optopt(
+        "P",
+        "insertable-prefix",
+        "Prefix for insertable struct names (default: New)",
+        "PREFIX",
+    );
 
     opts.optflag("p", "proto", "Set as proto output");
     opts.optflag("i", "into_proto", "Set as into_proto output");
@@ -180,9 +206,27 @@ fn main() {
     if diesel_version != "1" && diesel_version != "2" {
         panic!("diesel_version must be 1 or 2");
     }
+    // Parse insertable struct options
+    let skip_fields: Vec<String> = if matches.opt_present("S") {
+        matches.opt_strs("S")
+    } else {
+        vec!["id".to_string(), "created_at".to_string(), "updated_at".to_string()]
+    };
+    
+    let optional_fields: Vec<String> = if matches.opt_present("O") {
+        matches.opt_strs("O")
+    } else {
+        vec![]
+    };
+    
+    let insertable_prefix = matches.opt_str("P").unwrap_or("New".to_string());
+    
     let action = if matches.opt_present("m") {
         model_derives = matches.opt_str("d");
         "model"
+    } else if matches.opt_present("g") {
+        model_derives = matches.opt_str("d");
+        "insertable"
     } else if matches.opt_present("i") {
         class_name = matches
             .opt_str("c")
@@ -242,6 +286,9 @@ fn main() {
         diesel_version,
         rust_styled_fields,
         struct_name_override,
+        skip_fields,
+        optional_fields,
+        insertable_prefix,
     });
 
     //imported types
@@ -270,6 +317,19 @@ fn main() {
             print_normal_dependencies(&parse_output);
             println!("{}", parse_output.str_model);
         }
+        "insertable" => {
+            println!("// Generated by diesel_ext (insertable structs)\n");
+
+            println!("#![allow(unused)]");
+            println!("#![allow(clippy::all)]\n");
+
+            println!("{}", import_type_string);
+            print_normal_dependencies(&parse_output);
+            if parse_output.diesel_macro_use {
+                println!("use diesel::prelude::*;");
+            }
+            println!("{}", parse_output.str_insertable);
+        }
         "from_proto" => {
             print_conversion_dependencies();
             print_conversion_methods(&parse_output);