use std::collections::HashMap;
use std::fmt::Write;
use scythe_backend::manifest::BackendManifest;
use scythe_backend::naming::{
enum_type_name, enum_variant_name, fn_name, row_struct_name, to_camel_case, to_pascal_case,
};
use scythe_backend::types::resolve_type;
use scythe_core::analyzer::{AnalyzedQuery, CompositeInfo, EnumInfo};
use scythe_core::errors::{ErrorCode, ScytheError};
use scythe_core::parser::QueryCommand;
use crate::backend_options::reject_unknown_options;
use crate::backend_trait::{CodegenBackend, GroupedQueryFn, ResolvedColumn, ResolvedParam};
const DEFAULT_MANIFEST_PG: &str = include_str!("../../manifests/kotlin-exposed.toml");
pub struct KotlinExposedBackend {
manifest: BackendManifest,
}
impl KotlinExposedBackend {
pub fn new(engine: &str) -> Result<Self, ScytheError> {
let default_toml = match engine {
"postgresql" | "postgres" | "pg" => DEFAULT_MANIFEST_PG,
_ => {
return Err(ScytheError::new(
ErrorCode::InvalidConfig,
format!("unsupported engine '{}' for kotlin-exposed backend", engine),
));
}
};
let manifest = super::parse_manifest(default_toml)?;
Ok(Self { manifest })
}
}
fn exposed_column_fn(kotlin_type: &str) -> &str {
match kotlin_type {
"Boolean" => "bool",
"Byte" => "byte",
"Short" => "short",
"Int" => "integer",
"Long" => "long",
"Float" => "float",
"Double" => "double",
"String" => "text",
"ByteArray" => "binary",
_ if kotlin_type.contains("BigDecimal") => "decimal",
_ if kotlin_type.contains("LocalDate") => "date",
_ if kotlin_type.contains("LocalTime") => "time",
_ if kotlin_type.contains("OffsetTime") => "time",
_ if kotlin_type.contains("LocalDateTime") => "datetime",
_ if kotlin_type.contains("OffsetDateTime") => "timestampWithTimeZone",
_ if kotlin_type.contains("UUID") => "uuid",
_ => "text",
}
}
fn rs_getter(kotlin_type: &str) -> &str {
match kotlin_type {
"Boolean" => "getBoolean",
"Byte" => "getByte",
"Short" => "getShort",
"Int" => "getInt",
"Long" => "getLong",
"Float" => "getFloat",
"Double" => "getDouble",
"String" => "getString",
"ByteArray" => "getBytes",
_ if kotlin_type.contains("BigDecimal") => "getBigDecimal",
_ if kotlin_type.contains("LocalDate") => "getObject",
_ if kotlin_type.contains("LocalTime") => "getObject",
_ if kotlin_type.contains("OffsetTime") => "getObject",
_ if kotlin_type.contains("LocalDateTime") => "getObject",
_ if kotlin_type.contains("OffsetDateTime") => "getObject",
_ if kotlin_type.contains("UUID") => "getObject",
_ => "getObject",
}
}
fn exposed_column_type_class(kotlin_type: &str) -> &str {
match kotlin_type {
"Boolean" => "BooleanColumnType()",
"Byte" => "ByteColumnType()",
"Short" => "ShortColumnType()",
"Int" => "IntegerColumnType()",
"Long" => "LongColumnType()",
"Float" => "FloatColumnType()",
"Double" => "DoubleColumnType()",
"String" => "TextColumnType()",
"ByteArray" => "BinaryColumnType()",
_ if kotlin_type.contains("BigDecimal") => "DecimalColumnType(10, 2)",
_ if kotlin_type.contains("LocalDate") => "JavaLocalDateColumnType()",
_ if kotlin_type.contains("LocalTime") => "JavaLocalTimeColumnType()",
_ if kotlin_type.contains("OffsetTime") => "JavaLocalTimeColumnType()",
_ if kotlin_type.contains("LocalDateTime") => "JavaLocalDateTimeColumnType()",
_ if kotlin_type.contains("OffsetDateTime") => "JavaOffsetDateTimeColumnType()",
_ if kotlin_type.contains("UUID") => "UUIDColumnType()",
_ => "TextColumnType()",
}
}
impl CodegenBackend for KotlinExposedBackend {
fn name(&self) -> &str {
"kotlin-exposed"
}
fn manifest(&self) -> &scythe_backend::manifest::BackendManifest {
&self.manifest
}
fn manifest_mut(&mut self) -> &mut scythe_backend::manifest::BackendManifest {
&mut self.manifest
}
fn apply_options(&mut self, options: &HashMap<String, String>) -> Result<(), ScytheError> {
reject_unknown_options(&["field_case"], options)?;
if let Some(value) = options.get("field_case") {
super::apply_field_case_option(&mut self.manifest.naming, "kotlin-exposed", value)?;
}
Ok(())
}
fn supported_engines(&self) -> &[&str] {
&["postgresql"]
}
fn file_header(&self) -> String {
"import org.jetbrains.exposed.dao.id.IntIdTable\n\
import org.jetbrains.exposed.dao.id.LongIdTable\n\
import org.jetbrains.exposed.dao.id.UUIDTable\n\
import org.jetbrains.exposed.sql.BinaryColumnType\n\
import org.jetbrains.exposed.sql.BooleanColumnType\n\
import org.jetbrains.exposed.sql.ByteColumnType\n\
import org.jetbrains.exposed.sql.DecimalColumnType\n\
import org.jetbrains.exposed.sql.DoubleColumnType\n\
import org.jetbrains.exposed.sql.FloatColumnType\n\
import org.jetbrains.exposed.sql.IntegerColumnType\n\
import org.jetbrains.exposed.sql.LongColumnType\n\
import org.jetbrains.exposed.sql.ShortColumnType\n\
import org.jetbrains.exposed.sql.TextColumnType\n\
import org.jetbrains.exposed.sql.javatime.JavaLocalDateColumnType\n\
import org.jetbrains.exposed.sql.javatime.JavaLocalDateTimeColumnType\n\
import org.jetbrains.exposed.sql.javatime.JavaLocalTimeColumnType\n\
import org.jetbrains.exposed.sql.javatime.JavaOffsetDateTimeColumnType\n\
import org.jetbrains.exposed.sql.transactions.transaction\n"
.to_string()
}
fn generate_row_struct(&self, query_name: &str, columns: &[ResolvedColumn]) -> Result<String, ScytheError> {
let struct_name = row_struct_name(query_name, &self.manifest.naming);
let mut out = String::new();
let _ = writeln!(out, "data class {}(", struct_name);
for col in columns.iter() {
let _ = writeln!(out, " val {}: {},", col.field_name, col.full_type);
}
let _ = writeln!(out, ")");
Ok(out)
}
fn generate_model_struct(&self, table_name: &str, columns: &[ResolvedColumn]) -> Result<String, ScytheError> {
let name = to_pascal_case(table_name);
let table_obj_name = format!("{}Table", name);
let mut out = String::new();
let table_base = exposed_id_table_type(columns);
let _ = writeln!(out, "object {} : {}(\"{}\") {{", table_obj_name, table_base, table_name);
for col in columns.iter() {
let col_fn = exposed_column_fn(&col.lang_type);
let nullable_suffix = if col.nullable { ".nullable()" } else { "" };
let _ = writeln!(
out,
" val {} = {}(\"{}\"){}",
col.field_name, col_fn, col.name, nullable_suffix
);
}
let _ = writeln!(out, "}}");
Ok(out)
}
fn generate_query_fn(
&self,
analyzed: &AnalyzedQuery,
struct_name: &str,
columns: &[ResolvedColumn],
params: &[ResolvedParam],
) -> Result<String, ScytheError> {
let func_name = fn_name(&analyzed.name, &self.manifest.naming);
let sql = super::rewrite_pg_placeholders(
&super::clean_sql_oneline_with_optional(&analyzed.sql, &analyzed.optional_params, &analyzed.params),
|_| "?".to_string(),
);
let mut out = String::new();
let write_fn_sig = |out: &mut String, name: &str, ret: &str, params: &[ResolvedParam]| {
let inline_params: String = params
.iter()
.map(|p| format!("{}: {}", p.field_name, p.full_type))
.collect::<Vec<_>>()
.join(", ");
let sig = format!("fun {}({}){} =", name, inline_params, ret);
if sig.len() <= 100 {
let _ = writeln!(out, "{}", sig);
} else {
let _ = writeln!(out, "fun {}(", name);
for p in params {
let _ = writeln!(out, " {}: {},", p.field_name, p.full_type);
}
let _ = writeln!(out, "){} =", ret);
}
let _ = writeln!(out, " transaction {{");
};
let build_args = |params: &[ResolvedParam]| -> String {
if params.is_empty() {
return String::new();
}
let pairs: Vec<String> = params
.iter()
.map(|p| format!("{} to {}", exposed_column_type_class(&p.lang_type), p.field_name))
.collect();
format!(", listOf({})", pairs.join(", "))
};
match &analyzed.command {
QueryCommand::Exec => {
write_fn_sig(&mut out, &func_name, "", params);
let args = build_args(params);
let _ = writeln!(out, " exec(\"{}\"{})", sql, args);
let _ = writeln!(out, " }}");
}
QueryCommand::ExecResult | QueryCommand::ExecRows => {
write_fn_sig(&mut out, &func_name, ": Int", params);
let args = build_args(params);
let _ = writeln!(out, " exec(\"{}\"{}) ?: 0", sql, args);
let _ = writeln!(out, " }}");
}
QueryCommand::One | QueryCommand::Opt => {
let ret = format!(": {}?", struct_name);
write_fn_sig(&mut out, &func_name, &ret, params);
let args = build_args(params);
let _ = writeln!(out, " exec(\"{}\"{}) {{ rs ->", sql, args);
let _ = writeln!(out, " if (rs.next()) {{");
let _ = writeln!(out, " {}(", struct_name);
for col in columns.iter() {
let getter = rs_getter(&col.lang_type);
let _ = writeln!(
out,
" {} = rs.{}(\"{}\"),",
col.field_name, getter, col.name
);
}
let _ = writeln!(out, " )");
let _ = writeln!(out, " }} else {{");
let _ = writeln!(out, " null");
let _ = writeln!(out, " }}");
let _ = writeln!(out, " }}");
let _ = writeln!(out, " }}");
}
QueryCommand::Batch => {
let batch_fn_name = format!("{}Batch", func_name);
if params.len() > 1 {
let params_class_name = format!("{}BatchParams", to_pascal_case(&analyzed.name));
let _ = writeln!(out, "data class {}(", params_class_name);
for p in params {
let _ = writeln!(out, " val {}: {},", p.field_name, p.full_type);
}
let _ = writeln!(out, ")");
let _ = writeln!(out);
let _ = writeln!(out, "fun {}(items: List<{}>) =", batch_fn_name, params_class_name);
let _ = writeln!(out, " transaction {{");
let _ = writeln!(out, " for (item in items) {{");
let args: Vec<String> = params
.iter()
.map(|p| format!("{} to item.{}", exposed_column_type_class(&p.lang_type), p.field_name))
.collect();
let _ = writeln!(out, " exec(\"{}\", listOf({}))", sql, args.join(", "));
let _ = writeln!(out, " }}");
let _ = writeln!(out, " }}");
} else if params.len() == 1 {
let _ = writeln!(out, "fun {}(items: List<{}>) =", batch_fn_name, params[0].full_type);
let _ = writeln!(out, " transaction {{");
let _ = writeln!(out, " for (item in items) {{");
let _ = writeln!(
out,
" exec(\"{}\", listOf({} to item))",
sql,
exposed_column_type_class(¶ms[0].lang_type)
);
let _ = writeln!(out, " }}");
let _ = writeln!(out, " }}");
} else {
let _ = writeln!(out, "fun {}(count: Int) =", batch_fn_name);
let _ = writeln!(out, " transaction {{");
let _ = writeln!(out, " repeat(count) {{");
let _ = writeln!(out, " exec(\"{}\")", sql);
let _ = writeln!(out, " }}");
let _ = writeln!(out, " }}");
}
}
QueryCommand::Grouped => {
unreachable!("routed to generate_grouped_query_fn")
}
QueryCommand::Many => {
let ret = format!(": List<{}>", struct_name);
write_fn_sig(&mut out, &func_name, &ret, params);
let args = build_args(params);
let _ = writeln!(out, " val result = mutableListOf<{}>()", struct_name);
let _ = writeln!(out, " exec(\"{}\"{}) {{ rs ->", sql, args);
let _ = writeln!(out, " while (rs.next()) {{");
let _ = writeln!(out, " result.add(");
let _ = writeln!(out, " {}(", struct_name);
for col in columns.iter() {
let getter = rs_getter(&col.lang_type);
let _ = writeln!(
out,
" {} = rs.{}(\"{}\"),",
col.field_name, getter, col.name
);
}
let _ = writeln!(out, " ),");
let _ = writeln!(out, " )");
let _ = writeln!(out, " }}");
let _ = writeln!(out, " }}");
let _ = writeln!(out, " result");
let _ = writeln!(out, " }}");
}
}
Ok(out)
}
fn generate_enum_def(&self, enum_info: &EnumInfo) -> Result<String, ScytheError> {
let type_name = enum_type_name(&enum_info.sql_name, &self.manifest.naming);
let mut out = String::new();
let _ = writeln!(out, "enum class {}(val value: String) {{", type_name);
for (i, value) in enum_info.values.iter().enumerate() {
let variant = enum_variant_name(value, &self.manifest.naming);
let sep = if i + 1 < enum_info.values.len() { "," } else { ";" };
let _ = writeln!(out, " {}(\"{}\"){}", variant, value, sep);
}
let _ = writeln!(out, "}}");
Ok(out)
}
fn generate_composite_def(&self, composite: &CompositeInfo) -> Result<String, ScytheError> {
let name = to_pascal_case(&composite.sql_name);
let mut out = String::new();
let _ = writeln!(out, "data class {}(", name);
for field in composite.fields.iter() {
let field_name = to_camel_case(&field.name);
let field_type = resolve_type(&field.neutral_type, &self.manifest, false)
.map(|t| t.into_owned())
.unwrap_or_else(|_| "Any".to_string());
let _ = writeln!(out, " val {}: {},", field_name, field_type);
}
let _ = writeln!(out, ")");
Ok(out)
}
fn generate_grouped_structs(
&self,
parent_struct_name: &str,
child_struct_name: &str,
parent_columns: &[ResolvedColumn],
child_columns: &[ResolvedColumn],
_key_column: &str,
) -> Result<String, ScytheError> {
let mut out = String::new();
let _ = writeln!(out, "data class {}(", child_struct_name);
for col in child_columns {
let _ = writeln!(out, " val {}: {},", col.field_name, col.full_type);
}
let _ = writeln!(out, ")");
let _ = writeln!(out);
let _ = writeln!(out, "data class {}(", parent_struct_name);
for col in parent_columns {
let _ = writeln!(out, " val {}: {},", col.field_name, col.full_type);
}
let _ = writeln!(out, " val children: MutableList<{}>,", child_struct_name);
let _ = write!(out, ")");
Ok(out)
}
fn generate_grouped_query_fn(&self, request: &GroupedQueryFn<'_>) -> Result<String, ScytheError> {
let analyzed = request.analyzed;
let parent_struct_name = request.parent_struct_name;
let child_struct_name = request.child_struct_name;
let parent_columns = request.parent_columns;
let child_columns = request.child_columns;
let params = request.params;
let key_column = request.key_column;
let func_name = fn_name(&analyzed.name, &self.manifest.naming);
let sql = super::rewrite_pg_placeholders(
&super::clean_sql_oneline_with_optional(&analyzed.sql, &analyzed.optional_params, &analyzed.params),
|_| "?".to_string(),
);
let key_col = parent_columns
.iter()
.find(|c| c.name == key_column)
.unwrap_or(&parent_columns[0]);
let key_type = key_col.full_type.trim_end_matches('?');
let args = if params.is_empty() {
String::new()
} else {
let pairs: Vec<String> = params
.iter()
.map(|p| format!("{} to {}", exposed_column_type_class(&p.lang_type), p.field_name))
.collect();
format!(", listOf({})", pairs.join(", "))
};
let inline_params: String = params
.iter()
.map(|p| format!("{}: {}", p.field_name, p.full_type))
.collect::<Vec<_>>()
.join(", ");
let sig = format!("fun {}({}): List<{parent_struct_name}> =", func_name, inline_params);
let mut out = String::new();
if sig.len() <= 100 {
let _ = writeln!(out, "{sig}");
} else {
let _ = writeln!(out, "fun {}(", func_name);
for p in params {
let _ = writeln!(out, " {}: {},", p.field_name, p.full_type);
}
let _ = writeln!(out, "): List<{parent_struct_name}> =");
}
let _ = writeln!(out, " transaction {{");
let _ = writeln!(
out,
" val lookup = LinkedHashMap<{key_type}, {parent_struct_name}>()"
);
let _ = writeln!(out, " val result = mutableListOf<{parent_struct_name}>()");
let _ = writeln!(out, " exec(\"{sql}\"{args}) {{ rs ->");
let _ = writeln!(out, " while (rs.next()) {{");
let key_getter = rs_getter(&key_col.lang_type);
let _ = writeln!(out, " val key = rs.{key_getter}(\"{key_column}\")");
let _ = writeln!(out, " val child = {child_struct_name}(");
for col in child_columns {
let getter = rs_getter(&col.lang_type);
let _ = writeln!(
out,
" {} = rs.{}(\"{}\"),",
col.field_name, getter, col.name
);
}
let _ = writeln!(out, " )");
let _ = writeln!(out, " if (lookup.containsKey(key)) {{");
let _ = writeln!(out, " lookup[key]!!.children.add(child)");
let _ = writeln!(out, " }} else {{");
let _ = writeln!(out, " val parent = {parent_struct_name}(");
for col in parent_columns {
let getter = rs_getter(&col.lang_type);
let _ = writeln!(
out,
" {} = rs.{}(\"{}\"),",
col.field_name, getter, col.name
);
}
let _ = writeln!(out, " children = mutableListOf(child),");
let _ = writeln!(out, " )");
let _ = writeln!(out, " lookup[key] = parent");
let _ = writeln!(out, " result.add(parent)");
let _ = writeln!(out, " }}");
let _ = writeln!(out, " }}");
let _ = writeln!(out, " }}");
let _ = writeln!(out, " result");
let _ = write!(out, " }}");
Ok(out)
}
}
fn exposed_id_table_type(columns: &[ResolvedColumn]) -> &str {
let Some(id_column) = columns.iter().find(|column| column.name.eq_ignore_ascii_case("id")) else {
return "IntIdTable";
};
match id_column.lang_type.as_str() {
"Long" => "LongIdTable",
ty if ty.contains("UUID") => "UUIDTable",
_ => "IntIdTable",
}
}
#[cfg(test)]
mod tests {
use std::collections::HashMap;
use scythe_core::analyzer::{AnalyzedColumn, AnalyzedQuery, CompositeFieldInfo, CompositeInfo, GroupByConfig};
use scythe_core::parser::QueryCommand;
use super::KotlinExposedBackend;
use crate::backend_trait::CodegenBackend;
fn make_grouped_query() -> AnalyzedQuery {
let parent_cols = vec![
AnalyzedColumn {
name: "id".to_string(),
neutral_type: "int32".to_string(),
nullable: false,
..Default::default()
},
AnalyzedColumn {
name: "name".to_string(),
neutral_type: "string".to_string(),
nullable: false,
..Default::default()
},
];
let child_cols = vec![
AnalyzedColumn {
name: "order_id".to_string(),
neutral_type: "int32".to_string(),
nullable: false,
..Default::default()
},
AnalyzedColumn {
name: "total".to_string(),
neutral_type: "decimal".to_string(),
nullable: true,
..Default::default()
},
];
let all_cols = [parent_cols.clone(), child_cols.clone()].concat();
AnalyzedQuery::build(|aq| {
aq.name = "GetUsersWithOrders".to_string();
aq.command = QueryCommand::Grouped;
aq.sql = "SELECT u.id, u.name, o.id AS order_id, o.total FROM users u JOIN orders o ON o.user_id = u.id"
.to_string();
aq.columns = all_cols;
aq.params = vec![];
aq.deprecated = None;
aq.source_table = None;
aq.composites = vec![];
aq.enums = vec![];
aq.optional_params = vec![];
aq.group_by = Some(GroupByConfig {
table: "users".to_string(),
key_column: "id".to_string(),
parent_columns: parent_cols,
child_columns: child_cols,
});
aq.custom = vec![];
})
}
#[test]
fn test_grouped_kotlin_exposed_structs() {
let backend = crate::backends::get_backend("kotlin-exposed", "postgresql").unwrap();
let query = make_grouped_query();
let result = crate::generate_with_backend(&query, &*backend).unwrap();
let row_struct = result.row_struct.as_deref().unwrap();
assert!(
row_struct.contains("data class GetUsersWithOrdersChildRow"),
"missing child data class; got:\n{row_struct}"
);
assert!(
row_struct.contains("data class GetUsersWithOrdersRow"),
"missing parent data class; got:\n{row_struct}"
);
assert!(
row_struct.contains("val children: MutableList<GetUsersWithOrdersChildRow>"),
"parent missing children field; got:\n{row_struct}"
);
let child_pos = row_struct.find("data class GetUsersWithOrdersChildRow").unwrap();
let parent_pos = row_struct.find("data class GetUsersWithOrdersRow(").unwrap();
assert!(child_pos < parent_pos, "child must precede parent");
}
#[test]
fn test_grouped_kotlin_exposed_query_fn() {
let backend = crate::backends::get_backend("kotlin-exposed", "postgresql").unwrap();
let query = make_grouped_query();
let result = crate::generate_with_backend(&query, &*backend).unwrap();
let query_fn = result.query_fn.as_deref().unwrap();
assert!(
query_fn.contains("List<GetUsersWithOrdersRow>"),
"wrong return type; got:\n{query_fn}"
);
assert!(
query_fn.contains("transaction {"),
"must use transaction block; got:\n{query_fn}"
);
assert!(
query_fn.contains("LinkedHashMap"),
"must use LinkedHashMap for fold lookup; got:\n{query_fn}"
);
assert!(
query_fn.contains("lookup.containsKey(key)"),
"must fold with containsKey; got:\n{query_fn}"
);
assert!(
query_fn.contains("children.add(child)"),
"must append child; got:\n{query_fn}"
);
}
fn make_one_query_with_snake_case_columns() -> AnalyzedQuery {
AnalyzedQuery::build(|q| {
q.name = "GetSession".to_string();
q.command = QueryCommand::One;
q.sql = "SELECT id, user_id FROM sessions WHERE id = $1".to_string();
q.columns = vec![
AnalyzedColumn {
name: "id".to_string(),
neutral_type: "int32".to_string(),
nullable: false,
..Default::default()
},
AnalyzedColumn {
name: "user_id".to_string(),
neutral_type: "int32".to_string(),
nullable: false,
..Default::default()
},
];
q.params = vec![];
q.deprecated = None;
q.source_table = None;
q.composites = vec![];
q.enums = vec![];
q.optional_params = vec![];
q.group_by = None;
q.custom = vec![];
})
}
#[test]
fn test_field_case_camel_case_renames_field_but_keeps_raw_lookup_key() {
let mut backend = KotlinExposedBackend::new("postgresql").unwrap();
backend
.apply_options(&HashMap::from([("field_case".to_string(), "camelCase".to_string())]))
.unwrap();
let query = make_one_query_with_snake_case_columns();
let result = crate::generate_with_backend(&query, &backend).unwrap();
let row_struct = result.row_struct.as_deref().unwrap();
let query_fn = result.query_fn.as_deref().unwrap();
assert!(
row_struct.contains("val userId: Int"),
"field_case must rename the declared data class property; got:\n{row_struct}"
);
assert!(
!row_struct.contains("val user_id"),
"must not leave the raw SQL name in the declared property; got:\n{row_struct}"
);
assert!(
query_fn.contains("userId = rs.getInt(\"user_id\")"),
"the ResultSet lookup key must stay the raw SQL column name; got:\n{query_fn}"
);
assert!(
!query_fn.contains("rs.getInt(\"userId\")"),
"must never look the driver up by the renamed field; got:\n{query_fn}"
);
}
#[test]
fn test_field_case_option_rejects_invalid_value() {
let mut backend = KotlinExposedBackend::new("postgresql").unwrap();
let result = backend.apply_options(&HashMap::from([("field_case".to_string(), "PascalCase".to_string())]));
assert!(result.is_err(), "expected 'PascalCase' to be rejected");
}
fn make_composite_with_consecutive_capitals() -> CompositeInfo {
CompositeInfo {
sql_name: "CreateAPIKey".to_string(),
fields: vec![
CompositeFieldInfo {
name: "HTTPSUrl".to_string(),
neutral_type: "string".to_string(),
},
CompositeFieldInfo {
name: "internal_id".to_string(),
neutral_type: "int32".to_string(),
},
],
}
}
#[test]
fn test_composite_def_normalizes_consecutive_capitals() {
let backend = KotlinExposedBackend::new("postgresql").unwrap();
let composite = make_composite_with_consecutive_capitals();
let def = backend.generate_composite_def(&composite).unwrap();
assert!(
def.contains("data class CreateApiKey("),
"composite type name must normalize consecutive capitals; got:\n{def}"
);
assert!(
def.contains("val httpsUrl: String"),
"composite field name must normalize consecutive capitals; got:\n{def}"
);
assert!(
def.contains("val internalId: Int"),
"composite field name must still camelCase a plain snake_case field; got:\n{def}"
);
}
}