Design decision to name all structs Model ... why?

[tgrushka]

I fell in love with Ruby on Rails in 2010. It was so intuitive.

I mainly develop in Rust and Dart now, but have to inter-operate with TypeScript, because the world imposes it on us.

Why does sea-orm name all structs, Model? This is crazy. Everywhere they are constructed in code, we lose the wonderful typing of Rust.

Why not NewType or type alias, you ask?

Well, what if I derive ts::TS on the structs with --model-extra-derives?

There's no dynamic variables to interpolate with the struct name, so they all generate typescript interfaces named Model and overwrite each other!

That's horrendous in my opinion. How did this idea to name all structs get even one step past the drawing board?

So I wind up with this monstrosity (have to remove generated enums that were generated ... why? ... because I used predefined ones in the migrations anyway):

justfile recipe:

# Generate SeaORM entities from db schema. Replace generated enums with our static ones.
gen-entities:
    #!/usr/bin/env bash
    set -euo pipefail

    ENTITIES_PATH=models/src/entities

    sea-orm-cli generate entity \
        --with-serde both \
        --with-copy-enums \
        --model-extra-derives 'ts_rs::TS' \
        --model-extra-attributes 'ts(export)','serde(rename_all = "camelCase")' \
        --enum-extra-derives 'ts_rs::TS' \
        --enum-extra-attributes 'ts(export)','serde(rename_all = "snake_case")' \
        -o $ENTITIES_PATH

    # globstar important!
    shopt -s globstar
    sed -i '' 's/super::sea_orm_active_enums::Severity/crate::tools::Severity/g' $ENTITIES_PATH/**/*.rs
    sed -i '' 's/super::sea_orm_active_enums::ToolId/crate::tools::ToolId/g' $ENTITIES_PATH/**/*.rs
    sed -i '' 's/ :: /::/g' $ENTITIES_PATH/**/*.rs

    ACTIVE_ENUMS_FILE=$ENTITIES_PATH/sea_orm_active_enums.rs
    TEMPFILE=$(mktemp)

    cat $ACTIVE_ENUMS_FILE \
        | scripts/remove-generated-enums.awk -v enums_to_remove="Severity|ToolId" \
        | scripts/replace-serde-rename-all.awk -v new_casings="WcagLevel:UPPERCASE" \
        > $TEMPFILE && mv $TEMPFILE $ACTIVE_ENUMS_FILE

    for f in $ENTITIES_PATH/**/*.rs; do
        TEMPFILE=$(mktemp)
        cat "$f" | scripts/rename-ts-exports.awk > $TEMPFILE && mv $TEMPFILE "$f"
    done

rename-ts-exports.awk:

#!/usr/bin/awk -f

# This script finds #[ts(export)] and replaces it with #[ts(export, rename = "PascalCaseName")]
# where the name comes from the most recent table_name attribute

BEGIN {
    # Initialize state variables
    pending_export = 0
    current_table_name = ""
}

# Capture table_name from sea_orm attribute whenever we see it
/^[[:space:]]*#\[sea_orm\(table_name[[:space:]]*=[[:space:]]*\"[^\"]+\"\)\][[:space:]]*$/ {
    # Extract the table name using basic awk
    start = index($0, "table_name")
    if (start > 0) {
        quote_start = index(substr($0, start), "\"")
        if (quote_start > 0) {
            remaining = substr($0, start + quote_start)
            quote_end = index(remaining, "\"")
            if (quote_end > 0) {
                current_table_name = substr(remaining, 1, quote_end - 1)
                # Basic singularization rules
                if (current_table_name ~ /ies$/) {
                    sub(/ies$/, "y", current_table_name)
                }
                else if (current_table_name ~ /s$/) {
                    sub(/s$/, "", current_table_name)
                }
            }
        }
    }
    print
    next
}

# Found #[ts(export)] - mark as pending and print modified version if we have table_name
/^[[:space:]]*#\[ts\(export\)\][[:space:]]*$/ {
    if (current_table_name != "") {
        # Convert table_name to PascalCase
        name = ""
        split(current_table_name, parts, "_")
        for (i = 1; i <= length(parts); i++) {
            # Capitalize first letter, lowercase the rest
            first_char = toupper(substr(parts[i], 1, 1))
            rest = tolower(substr(parts[i], 2))
            name = name first_char rest
        }
        print "#[ts(export, rename = \"" name "\")]"
    } else {
        print
    }
    next
}

# Regular line processing
{
    print
}

Is this maintainable? No.

Is it real world? Yes. How many thousands of devs have even more complex projects than I do, and will have to write this kind of spaghetti just to fight the sea-orm entity generator?

[Expurple]

How did this idea to name all structs get even one step past the drawing board?

Utilizing module namespacing is idiomatic and common in Rust, just as it is in Python and many other languages. Think std::error::Error, std::fmt::Error, std::io::Error, anyhow::Error, thiserror::Error...

As a user, I don't think that FooModel would be a big improvent over foo::Model in my codebase.

But you found an interesting edge case with derive macros, as they don't have access to the name of the current module (AFAIK). Can you try researching this general problem or reporting it to ts? Perhaps, there are some existing solutions

[Jacob-32587]

I have recently run into this problem as well, however, I don't believe this is an issue with the ts_rs package or how sea_orm organizes its models. There does exist a small gap in tooling that we as developers get to solve! The unmaintainable awk solution presented is neither idiomatic nor the first thing that we should be reaching for when writing Rust code. I also don't think it's fair to use words like "horrendous" when maintainers pour countless hours into making amazing SQL tooling in a language that doesn't have a huge market for it (yet).

Rust provides an extremely powerful macro system that allows us to fill these gaps easily! Anyone not familiar with it should definitely learn the basics. I have shared the proc_macro_attribute that I am using in my application (I whipped this up in an hour so if there are any issues let me know). Hopefully, this helps someone else, cheers!

/// # Description
/// Adds a ts_export rename attribute in the format of: "{literal_name}Entity"
/// to the given entity. This macro assumes the `[sea_orm(table_name = "...")]` or
/// `[sea_orm(entity = "...")]`  attribute is present and will error if not found.
/// # Attribute Arguments
/// Optional string literal, if given the literal provided will be inserted after the
/// identified literal name instead of the default "Entity".
#[proc_macro_attribute]
pub fn ts_rs_export_sea_orm_entity_name(args: TokenStream, input: TokenStream) -> TokenStream {
    let derive_input = parse_macro_input!(input as DeriveInput);

    match ts_rs_export_sea_orm_entity_name::expand(derive_input, args) {
        Ok(token_stream) => token_stream.into(),
        Err(e) => e.to_compile_error().into(),
    }
}


pub(crate) fn expand(
    mut input: DeriveInput,
    args: TokenStream,
) -> syn::Result<proc_macro2::TokenStream> {
    let mut literal_name = None;

    // Append attribute argument or default value of "Entity"
    let entity_name_append = syn::parse::<Option<LitStr>>(args)?
        .map(|x| x.value())
        .unwrap_or(String::from("Entity"));

    input
        .attrs
        .iter()
        .filter(|attr| attr.path().is_ident("sea_orm"))
        .try_for_each(|attr| {
            attr.parse_nested_meta(|meta| {
                if meta.path.is_ident("table_name") || meta.path.is_ident("entity") {
                    literal_name = Some(meta.value()?.parse::<LitStr>()?);
                }
                Ok(())
            })
        })?;

    let literal_name = literal_name.ok_or(syn::Error::new(
        input.ident.span(),
        "Must provide a #[sea_orm(table_name = \"...\")] or #[sea_orm(entity = \"...\")] attribute",
    ))?;

    // Get the string value stored in the literal
    let ts_name = LitStr::new(
        &(convert_snake_to_pascal(&literal_name.value()) + &entity_name_append),
        literal_name.span(),
    );

    let mut attrs: Vec<Attribute> = vec![
        parse_quote_spanned!(input.ident.span() => #[derive(::ts_rs::TS)]),
        parse_quote_spanned!(literal_name.span() => #[ts(export, rename = #ts_name)]),
    ];

    let input_attrs: &mut Vec<Attribute> = input.attrs.as_mut();

    input_attrs.append(&mut attrs);

    Ok(quote!(#input))
}

/// #Description
/// Convert a snake case string to pascal case
pub fn convert_snake_to_pascal(input: &str) -> String {
    // We will over allocate here but not by much in most cases
    let mut ret = String::with_capacity(input.len());
    let mut chars = input.chars();

    // Ensure the first character is upper case
    if let Some(c) = chars.next() {
        ret.push_str(&c.to_uppercase().to_string());
    } else {
        return ret;
    };

    while let Some(c) = chars.next() {
        if c == '_' {
            if let Some(next_char) = chars.next() {
                ret.push_str(&next_char.to_uppercase().to_string())
            } else {
                break;
            }
        } else {
            ret.push(c)
        }
    }
    ret
}

[sidoshi]

I am using seaorm with Specta and I ran into the same issue as well.
Because every model is named Model, the type generated by specta is also called Model which ends up overriding each other.

I ended up solving this by having a small post processing script that modifies the codegen output:

generate-entities:
  #!/usr/bin/env sh
  sea-orm-cli generate entity \
    -u $DATABASE_URL \
    -o crates/seaorm-entities/src/entities \
    --with-serde both --model-extra-derives "specta::Type" \
    --enum-extra-derives "specta::Type" \
    --model-extra-attributes "specta(rename = \"___model_name___\")"
  
  for file in crates/seaorm-entities/src/entities/*.rs; do
    if [ -f "$file" ] && [ "$(basename "$file")" != "mod.rs" ] && [ "$(basename "$file")" != "prelude.rs" ] && [ "$(basename "$file")" != "sea_orm_active_enums.rs" ]; then
      table_name=$(basename "$file" .rs)
      # Convert snake_case to PascalCase for the specta rename
      pascal_name=$(echo "$table_name" | perl -pe 's/(^|_)([a-z])/\U$2/g')
      model_name=$(echo "$pascal_name"Model)
      echo "Adding specta rename for $table_name -> $model_name"
      perl -i -pe "s|(#\[specta\(rename = \"___model_name___\"\)\])|$1#[specta(rename = \"$model_name\")]|" "$file"
    fi
  done

[Jacob-32587]

I'm not sure why people are reaching for post processing scripts when Rust comes with the tools to do this (in a much more stable manner). Additionally it adds extra dependencies and confusion to your code base, why create more work for yourself?? I use docker to compile and host my Rust API's so it would be a lot more work to use an external tool like this, I believe my points are still relevant for anyone though.

I responded to this since I got an email notification, I do believe my previous response from June 20th should be marked as the solution.

[tyt2y3]

thank you for your input above. I guess it's hard to give a definitive answer to the original question as it's kind of broad.
there is an inter-operability issue between sea-orm and ts-rs, but I think there might be some easy wins we can do to make it work nicer. may be an extra option in the codegen or the macros?
can you describe the compilation issue caused by using sea-orm with ts-rs ?
we've recently added frontend-only model generation, do you think it will solve the problem? #2631

[Jacob-32587]

I don't think that solution would work in this case since the TS proc macro only knows about the current struct it is looking at.

Either way I don't believe that SeaORM should have an option to generate with a proc macro like the one that I created. Typescript is not the only front-end types you may want to generate SeaORM bindings for, an example would be swagger utopia (which I also use in my project and created a proc macro for). Of course this could lead to people expecting 'insert favorite front-end framework with types here' bindings to be on option in SeaORM.

The "issue" with SeaORM and ts-rs is a problem you will run into when writing any idiomatic rust code, that is use of modules for organizational purposes. When using the TS derive attribute on the generated entities the type name of "Model" is not sufficient enough to uniquely identify the type. But as shown SeaORM provides the developer with everything they need to generate unique type names.

[yaleman]

Can't you just use #[ts(rename = "..")]?