feat(code): add options "create-bytes" and "update-bytes"

Author: thwyr

src/bin/main.rs

@@ -1,7 +1,7 @@
 use clap::{CommandFactory, Parser, Subcommand, ValueEnum};
 use clap_complete::{generate, Shell};
 use dsync::{error::IOErrorToError, GenerationConfig, TableOptions};
-use dsync::{FileChangeStatus, StringType};
+use dsync::{BytesType, FileChangeStatus, StringType};
 use std::collections::HashMap;
 use std::io::{BufWriter, Write};
 use std::path::PathBuf;
@@ -98,6 +98,14 @@ pub struct MainOptions {
     #[arg(long = "update-str", default_value = "string")]
     pub update_str: StringTypeCli,
 
+    /// Set which bytes type to use for Create* structs
+    #[arg(long = "create-bytes", default_value = "vec")]
+    pub create_bytes: BytesTypeCli,
+
+    /// Set which bytes type to use for Update* structs
+    #[arg(long = "update-bytes", default_value = "vec")]
+    pub update_bytes: BytesTypeCli,
+
     /// Only Generate a single model file instead of a directory with "mod.rs" and "generated.rs"
     #[arg(long = "single-model-file")]
     pub single_model_file: bool,
@@ -140,6 +148,27 @@ impl From<StringTypeCli> for StringType {
     }
 }
 
+#[derive(Debug, ValueEnum, Clone, PartialEq, Default)]
+pub enum BytesTypeCli {
+    /// Use "String"
+    #[default]
+    Vec,
+    /// Use "&str"
+    Slice,
+    /// Use "Cow<str>"
+    Cow,
+}
+
+impl From<BytesTypeCli> for BytesType {
+    fn from(value: BytesTypeCli) -> Self {
+        match value {
+            BytesTypeCli::Vec => BytesType::Vec,
+            BytesTypeCli::Slice => BytesType::Slice,
+            BytesTypeCli::Cow => BytesType::Cow,
+        }
+    }
+}
+
 fn main() {
     let res = actual_main();
 
@@ -183,7 +212,9 @@ fn actual_main() -> dsync::Result<()> {
     let mut default_table_options = TableOptions::default()
         .autogenerated_columns(cols.iter().map(|t| t.as_str()).collect::<Vec<&str>>())
         .create_str_type(args.create_str.into())
-        .update_str_type(args.update_str.into());
+        .update_str_type(args.update_str.into())
+        .create_bytes_type(args.create_bytes.into())
+        .update_bytes_type(args.update_bytes.into());
 
     #[cfg(feature = "tsync")]
     if args.tsync {

src/code.rs

@@ -314,6 +314,12 @@ impl<'a> Struct<'a> {
                     StructType::Update => self.opts.get_update_str_type().as_str().to_string(),
                     StructType::Create => self.opts.get_create_str_type().as_str().to_string(),
                 }
+            } else if f.base_type == "Vec<u8>" {
+                f.base_type = match self.ty {
+                    StructType::Read => f.base_type,
+                    StructType::Update => self.opts.get_update_bytes_type().as_str().to_string(),
+                    StructType::Create => self.opts.get_create_bytes_type().as_str().to_string(),
+                }
             }
 
             let mut field_type = f.to_rust_type();

src/lib.rs

@@ -57,6 +57,38 @@ impl StringType {
     }
 }
 
+/// Available options for bytes types
+#[derive(Debug, Clone, Copy, PartialEq, Default)]
+pub enum BytesType {
+    /// Use `Vec<u8>`
+    #[default]
+    Vec,
+    /// Use `&[u8]`
+    Slice,
+    /// Use `Cow<[u8]>`
+    Cow,
+}
+
+impl BytesType {
+    /// Get the current [BytesType] as a rust type string
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            BytesType::Vec => "Vec<u8>",
+            BytesType::Slice => "&'a [u8]",
+            BytesType::Cow => "Cow<'a, [u8]>",
+        }
+    }
+
+    /// Get the lifetime used for the current [BytesType]
+    pub fn get_lifetime(&self) -> &'static str {
+        match self {
+            BytesType::Vec => "",
+            BytesType::Slice => "'a",
+            BytesType::Cow => "'a",
+        }
+    }
+}
+
 /// Options for a individual table
 #[derive(Debug, Clone)]
 pub struct TableOptions<'a> {
@@ -85,6 +117,12 @@ pub struct TableOptions<'a> {
     /// Determines which string type to use for Update* structs
     update_str_type: StringType,
 
+    /// Determines which bytes type to use for Create* structs
+    create_bytes_type: BytesType,
+
+    /// Determines which bytes type to use for Update* structs
+    update_bytes_type: BytesType,
+
     /// Only Generate a single model file instead of a directory with "mod.rs" and "generated.rs"
     single_model_file: bool,
 
@@ -123,6 +161,14 @@ impl<'a> TableOptions<'a> {
         self.update_str_type
     }
 
+    pub fn get_create_bytes_type(&self) -> BytesType {
+        self.create_bytes_type
+    }
+
+    pub fn get_update_bytes_type(&self) -> BytesType {
+        self.update_bytes_type
+    }
+
     pub fn get_autogenerated_columns(&self) -> &[&'_ str] {
         self.autogenerated_columns.as_deref().unwrap_or_default()
     }
@@ -193,6 +239,20 @@ impl<'a> TableOptions<'a> {
         }
     }
 
+    pub fn create_bytes_type(self, type_: BytesType) -> Self {
+        Self {
+            create_bytes_type: type_,
+            ..self
+        }
+    }
+
+    pub fn update_bytes_type(self, type_: BytesType) -> Self {
+        Self {
+            update_bytes_type: type_,
+            ..self
+        }
+    }
+
     pub fn set_read_only(&mut self, value: bool) {
         self.read_only = value;
     }
@@ -214,6 +274,8 @@ impl<'a> TableOptions<'a> {
             fns: self.fns || other.fns,
             create_str_type: other.create_str_type,
             update_str_type: other.update_str_type,
+            create_bytes_type: other.create_bytes_type,
+            update_bytes_type: other.update_bytes_type,
             single_model_file: self.single_model_file || other.single_model_file,
             read_only: self.read_only || other.read_only,
         }
@@ -233,6 +295,8 @@ impl<'a> Default for TableOptions<'a> {
             fns: true,
             create_str_type: Default::default(),
             update_str_type: Default::default(),
+            create_bytes_type: Default::default(),
+            update_bytes_type: Default::default(),
             single_model_file: false,
             read_only: false,
         }