@typokit/plugin-axum 0.2.1

package/src/rust_codegen/database.rs

@@ -0,0 +1,898 @@
+use std::collections::{BTreeMap, HashMap};
+
+use typokit_transform_native::type_extractor::{PropertyMetadata, TypeMetadata};
+use super::GeneratedOutput;
+
+/// Generate the sqlx database layer from @table-annotated entities.
+///
+/// Produces:
+/// - `.typokit/db/mod.rs` — PgPool connection setup
+/// - `.typokit/db/repository.rs` — CRUD functions per @table entity
+/// - `.typokit/migrations/{timestamp}_create_{table}.sql` — CREATE TABLE migrations
+pub fn generate_database(type_map: &HashMap<String, TypeMetadata>) -> Vec<GeneratedOutput> {
+    let mut outputs = Vec::new();
+
+    // Filter to entities with @table annotation, sorted for determinism
+    let table_entities: BTreeMap<String, &TypeMetadata> = type_map
+        .iter()
+        .filter(|(_, meta)| is_table_entity(meta))
+        .map(|(name, meta)| (name.clone(), meta))
+        .collect();
+
+    // Always generate db/mod.rs
+    outputs.push(generate_db_mod());
+
+    // Generate repository only if there are table entities
+    if !table_entities.is_empty() {
+        outputs.push(generate_repository(&table_entities));
+    }
+
+    // Generate migration files
+    for (idx, (_name, meta)) in table_entities.iter().enumerate() {
+        outputs.push(generate_migration(meta, idx));
+    }
+
+    outputs
+}
+
+// ─────────────────────────── db/mod.rs ────────────────────────────────────────
+
+/// Generate the `.typokit/db/mod.rs` with PgPool connection setup.
+fn generate_db_mod() -> GeneratedOutput {
+    let content = r#"// AUTO-GENERATED by @typokit/transform-native — DO NOT EDIT
+
+pub mod repository;
+
+use sqlx::postgres::PgPool;
+
+/// Connect to PostgreSQL and return a connection pool.
+pub async fn connect(database_url: &str) -> PgPool {
+    PgPool::connect(database_url)
+        .await
+        .expect("Failed to connect to database")
+}
+"#;
+
+    GeneratedOutput {
+        path: ".typokit/db/mod.rs".to_string(),
+        content: content.to_string(),
+        overwrite: true,
+    }
+}
+
+// ─────────────────────────── db/repository.rs ─────────────────────────────────
+
+/// Generate the `.typokit/db/repository.rs` with CRUD functions per @table entity.
+fn generate_repository(table_entities: &BTreeMap<String, &TypeMetadata>) -> GeneratedOutput {
+    let mut output = String::new();
+
+    output.push_str("// AUTO-GENERATED by @typokit/transform-native — DO NOT EDIT\n\n");
+    output.push_str("use sqlx::postgres::PgPool;\n");
+
+    // Check if any entity has @generated uuid or now fields
+    let needs_uuid = table_entities.values().any(|meta| {
+        meta.properties.values().any(|p| is_generated_uuid(p))
+    });
+    let needs_chrono = table_entities.values().any(|meta| {
+        meta.properties.values().any(|p| is_generated_now(p))
+    });
+
+    if needs_uuid {
+        output.push_str("use uuid::Uuid;\n");
+    }
+    if needs_chrono {
+        output.push_str("use chrono::Utc;\n");
+    }
+
+    output.push_str("use crate::models;\n");
+    output.push('\n');
+
+    for (_name, meta) in table_entities {
+        output.push_str(&generate_entity_crud(meta));
+        output.push('\n');
+    }
+
+    GeneratedOutput {
+        path: ".typokit/db/repository.rs".to_string(),
+        content: output,
+        overwrite: true,
+    }
+}
+
+/// Generate CRUD functions for a single @table entity.
+fn generate_entity_crud(meta: &TypeMetadata) -> String {
+    let mut output = String::new();
+    let entity_name = &meta.name;
+    let entity_snake = to_snake_case(entity_name);
+    let table_name = get_table_name(meta);
+
+    let id_prop = find_id_property(meta);
+    let id_field_name = id_prop
+        .as_ref()
+        .map(|(name, _)| name.as_str())
+        .unwrap_or("id");
+    let id_column = id_field_name;
+    let id_rust_type = id_prop
+        .as_ref()
+        .map(|(_, prop)| sql_id_rust_type(prop))
+        .unwrap_or_else(|| "String".to_string());
+
+    // Sorted properties for deterministic output
+    let sorted_props = sorted_properties(meta);
+
+    // Properties for INSERT (exclude @generated fields)
+    let insert_props: Vec<(&str, &PropertyMetadata)> = sorted_props
+        .iter()
+        .filter(|(_, p)| !is_generated(p))
+        .copied()
+        .collect();
+
+    // Properties for UPDATE (exclude @id and @generated fields)
+    let update_props: Vec<(&str, &PropertyMetadata)> = sorted_props
+        .iter()
+        .filter(|(name, p)| !is_id_property(name, p) && !is_generated(p))
+        .copied()
+        .collect();
+
+    // Generated UUID fields
+    let generated_uuid_props: Vec<(&str, &PropertyMetadata)> = sorted_props
+        .iter()
+        .filter(|(_, p)| is_generated_uuid(p))
+        .copied()
+        .collect();
+
+    // Generated now fields
+    let generated_now_props: Vec<(&str, &PropertyMetadata)> = sorted_props
+        .iter()
+        .filter(|(_, p)| is_generated_now(p))
+        .copied()
+        .collect();
+
+    // ─── find_all ────────────────────────────────────────────────────────
+    output.push_str(&format!(
+        "/// List all {} with pagination.\n",
+        entity_snake
+    ));
+    output.push_str(&format!(
+        "pub async fn find_all_{entity_snake}(\n    pool: &PgPool,\n    page: u32,\n    page_size: u32,\n) -> sqlx::Result<Vec<models::{entity_name}>> {{\n"
+    ));
+    output.push_str(&format!(
+        "    let offset = (page.saturating_sub(1)) * page_size;\n"
+    ));
+    output.push_str(&format!(
+        "    sqlx::query_as::<_, models::{entity_name}>(\n        \"SELECT * FROM {table_name} ORDER BY {id_column} LIMIT $1 OFFSET $2\"\n    )\n"
+    ));
+    output.push_str("    .bind(page_size as i64)\n");
+    output.push_str("    .bind(offset as i64)\n");
+    output.push_str("    .fetch_all(pool)\n");
+    output.push_str("    .await\n");
+    output.push_str("}\n\n");
+
+    // ─── find_by_id ──────────────────────────────────────────────────────
+    output.push_str(&format!(
+        "/// Find a single {} by ID.\n",
+        entity_snake
+    ));
+    output.push_str(&format!(
+        "pub async fn find_{entity_snake}_by_id(\n    pool: &PgPool,\n    id: &{id_rust_type},\n) -> sqlx::Result<Option<models::{entity_name}>> {{\n"
+    ));
+    output.push_str(&format!(
+        "    sqlx::query_as::<_, models::{entity_name}>(\n        \"SELECT * FROM {table_name} WHERE {id_column} = $1\"\n    )\n"
+    ));
+    output.push_str("    .bind(id)\n");
+    output.push_str("    .fetch_optional(pool)\n");
+    output.push_str("    .await\n");
+    output.push_str("}\n\n");
+
+    // ─── create ──────────────────────────────────────────────────────────
+    // Build the column list: user-supplied INSERT columns + generated columns
+    let mut all_insert_columns: Vec<String> = Vec::new();
+    let mut all_insert_placeholders: Vec<String> = Vec::new();
+    let mut placeholder_idx: usize = 1;
+
+    // User-supplied columns
+    for (col_name, _) in &insert_props {
+        all_insert_columns.push(col_name.to_string());
+        all_insert_placeholders.push(format!("${}", placeholder_idx));
+        placeholder_idx += 1;
+    }
+
+    // @generated uuid columns
+    for (col_name, _) in &generated_uuid_props {
+        all_insert_columns.push(col_name.to_string());
+        all_insert_placeholders.push(format!("${}", placeholder_idx));
+        placeholder_idx += 1;
+    }
+
+    // @generated now columns
+    for (col_name, _) in &generated_now_props {
+        all_insert_columns.push(col_name.to_string());
+        all_insert_placeholders.push(format!("${}", placeholder_idx));
+        placeholder_idx += 1;
+    }
+
+    let columns_str = all_insert_columns.join(", ");
+    let placeholders_str = all_insert_placeholders.join(", ");
+
+    // Determine the input struct name — use the entity name without generated fields
+    // Use the type directly if it has an input variant; otherwise accept individual params
+    let input_struct = format!("{}WithoutId", entity_name);
+
+    output.push_str(&format!(
+        "/// Create a new {}.\n",
+        entity_snake
+    ));
+    output.push_str(&format!(
+        "pub async fn create_{entity_snake}(\n    pool: &PgPool,\n    input: &models::{input_struct},\n) -> sqlx::Result<models::{entity_name}> {{\n"
+    ));
+
+    // Generate UUID and now values for @generated fields
+    for (col_name, _) in &generated_uuid_props {
+        let field = to_snake_case(col_name);
+        output.push_str(&format!(
+            "    let {field} = Uuid::new_v4().to_string();\n"
+        ));
+    }
+    for (col_name, _) in &generated_now_props {
+        let field = to_snake_case(col_name);
+        output.push_str(&format!(
+            "    let {field} = Utc::now();\n"
+        ));
+    }
+
+    output.push_str(&format!(
+        "    sqlx::query_as::<_, models::{entity_name}>(\n        \"INSERT INTO {table_name} ({columns_str}) VALUES ({placeholders_str}) RETURNING *\"\n    )\n"
+    ));
+
+    // Bind user-supplied input fields
+    for (col_name, _) in &insert_props {
+        let field = to_snake_case(col_name);
+        output.push_str(&format!("    .bind(&input.{field})\n"));
+    }
+
+    // Bind generated fields
+    for (col_name, _) in &generated_uuid_props {
+        let field = to_snake_case(col_name);
+        output.push_str(&format!("    .bind(&{field})\n"));
+    }
+    for (col_name, _) in &generated_now_props {
+        let field = to_snake_case(col_name);
+        output.push_str(&format!("    .bind(&{field})\n"));
+    }
+
+    output.push_str("    .fetch_one(pool)\n");
+    output.push_str("    .await\n");
+    output.push_str("}\n\n");
+
+    // ─── update ──────────────────────────────────────────────────────────
+    if !update_props.is_empty() {
+        let set_clauses: Vec<String> = update_props
+            .iter()
+            .enumerate()
+            .map(|(i, (col_name, _))| format!("{} = ${}", col_name, i + 1))
+            .collect();
+        let set_str = set_clauses.join(", ");
+        let id_placeholder = format!("${}", update_props.len() + 1);
+
+        output.push_str(&format!(
+            "/// Update an existing {} by ID.\n",
+            entity_snake
+        ));
+        output.push_str(&format!(
+            "pub async fn update_{entity_snake}(\n    pool: &PgPool,\n    id: &{id_rust_type},\n    input: &models::{input_struct},\n) -> sqlx::Result<Option<models::{entity_name}>> {{\n"
+        ));
+        output.push_str(&format!(
+            "    sqlx::query_as::<_, models::{entity_name}>(\n        \"UPDATE {table_name} SET {set_str} WHERE {id_column} = {id_placeholder} RETURNING *\"\n    )\n"
+        ));
+
+        for (col_name, _) in &update_props {
+            let field = to_snake_case(col_name);
+            output.push_str(&format!("    .bind(&input.{field})\n"));
+        }
+        output.push_str("    .bind(id)\n");
+        output.push_str("    .fetch_optional(pool)\n");
+        output.push_str("    .await\n");
+        output.push_str("}\n\n");
+    }
+
+    // ─── delete ──────────────────────────────────────────────────────────
+    output.push_str(&format!(
+        "/// Delete a {} by ID.\n",
+        entity_snake
+    ));
+    output.push_str(&format!(
+        "pub async fn delete_{entity_snake}(\n    pool: &PgPool,\n    id: &{id_rust_type},\n) -> sqlx::Result<Option<models::{entity_name}>> {{\n"
+    ));
+    output.push_str(&format!(
+        "    sqlx::query_as::<_, models::{entity_name}>(\n        \"DELETE FROM {table_name} WHERE {id_column} = $1 RETURNING *\"\n    )\n"
+    ));
+    output.push_str("    .bind(id)\n");
+    output.push_str("    .fetch_optional(pool)\n");
+    output.push_str("    .await\n");
+    output.push_str("}\n");
+
+    output
+}
+
+// ─────────────────────────── migrations ───────────────────────────────────────
+
+/// Generate a SQL migration file for a @table entity.
+fn generate_migration(meta: &TypeMetadata, index: usize) -> GeneratedOutput {
+    let table_name = get_table_name(meta);
+    let entity_snake = to_snake_case(&meta.name);
+
+    // Use a sequential timestamp based on index for ordering
+    let timestamp = format!("00000000000{}", index + 1);
+
+    let mut sql = String::new();
+    sql.push_str(&format!(
+        "-- AUTO-GENERATED by @typokit/transform-native — DO NOT EDIT\n\n"
+    ));
+    sql.push_str(&format!(
+        "CREATE TABLE IF NOT EXISTS {} (\n",
+        table_name
+    ));
+
+    let sorted_props = sorted_properties(meta);
+    let unique_fields = collect_unique_fields(meta);
+
+    for (i, (col_name, prop)) in sorted_props.iter().enumerate() {
+        let pg_type = ts_type_to_postgres(&prop.type_str, col_name, &prop.jsdoc);
+        let not_null = if prop.optional { "" } else { " NOT NULL" };
+
+        let is_pk = is_id_property(col_name, prop);
+        let pk_suffix = if is_pk { " PRIMARY KEY" } else { "" };
+
+        let unique_suffix = if unique_fields.contains(&col_name.to_string()) && !is_pk {
+            " UNIQUE"
+        } else {
+            ""
+        };
+
+        let trailing = if i < sorted_props.len() - 1 { "," } else { "" };
+
+        sql.push_str(&format!(
+            "    {} {}{}{}{}{}\n",
+            col_name, pg_type, not_null, pk_suffix, unique_suffix, trailing
+        ));
+    }
+
+    sql.push_str(");\n");
+
+    GeneratedOutput {
+        path: format!(".typokit/migrations/{}_create_{}.sql", timestamp, entity_snake),
+        content: sql,
+        overwrite: true,
+    }
+}
+
+// ─────────────────────────── Helpers ──────────────────────────────────────────
+
+/// Check if a TypeMetadata has the @table JSDoc annotation.
+fn is_table_entity(meta: &TypeMetadata) -> bool {
+    meta.jsdoc
+        .as_ref()
+        .map(|j| j.contains_key("table"))
+        .unwrap_or(false)
+}
+
+/// Get the SQL table name from @table annotation value, or fall back to snake_case.
+fn get_table_name(meta: &TypeMetadata) -> String {
+    meta.jsdoc
+        .as_ref()
+        .and_then(|j| j.get("table"))
+        .filter(|v| !v.is_empty())
+        .map(|v| v.to_string())
+        .unwrap_or_else(|| to_snake_case(&meta.name) + "s")
+}
+
+/// Find the @id property of a type (or fall back to "id" by name convention).
+fn find_id_property(meta: &TypeMetadata) -> Option<(String, PropertyMetadata)> {
+    // First look for explicit @id annotation
+    for (name, prop) in &meta.properties {
+        if prop
+            .jsdoc
+            .as_ref()
+            .map(|j| j.contains_key("id"))
+            .unwrap_or(false)
+        {
+            return Some((name.clone(), prop.clone()));
+        }
+    }
+    // Fall back to property named "id"
+    meta.properties
+        .get("id")
+        .map(|p| ("id".to_string(), p.clone()))
+}
+
+/// Check if a property is the @id field.
+fn is_id_property(name: &str, prop: &PropertyMetadata) -> bool {
+    prop.jsdoc
+        .as_ref()
+        .map(|j| j.contains_key("id"))
+        .unwrap_or(false)
+        || name == "id"
+}
+
+/// Check if a property has @generated annotation.
+fn is_generated(prop: &PropertyMetadata) -> bool {
+    prop.jsdoc
+        .as_ref()
+        .map(|j| j.contains_key("generated"))
+        .unwrap_or(false)
+}
+
+/// Check if a property is a @generated uuid field.
+fn is_generated_uuid(prop: &PropertyMetadata) -> bool {
+    if let Some(jsdoc) = &prop.jsdoc {
+        if let Some(val) = jsdoc.get("generated") {
+            return val == "uuid" || (jsdoc.contains_key("id") && val.is_empty());
+        }
+        // @generated on an @id string field implies uuid
+        if jsdoc.contains_key("generated") && jsdoc.contains_key("id") {
+            return true;
+        }
+    }
+    false
+}
+
+/// Check if a property is a @generated now field (timestamp auto-fill).
+fn is_generated_now(prop: &PropertyMetadata) -> bool {
+    if let Some(jsdoc) = &prop.jsdoc {
+        if let Some(val) = jsdoc.get("generated") {
+            return val == "now";
+        }
+    }
+    false
+}
+
+/// Determine the Rust type for an @id field in function signatures.
+fn sql_id_rust_type(prop: &PropertyMetadata) -> String {
+    match prop.type_str.as_str() {
+        "string" => "str".to_string(),
+        "number" => "i64".to_string(),
+        _ => "str".to_string(),
+    }
+}
+
+/// Map a TypeScript type to a PostgreSQL column type.
+fn ts_type_to_postgres(
+    ts_type: &str,
+    prop_name: &str,
+    jsdoc: &Option<HashMap<String, String>>,
+) -> String {
+    // Check for @integer override or @id context
+    if let Some(j) = jsdoc {
+        if j.contains_key("id") && ts_type == "string" {
+            return "TEXT".to_string();
+        }
+        if j.contains_key("integer") {
+            return "BIGINT".to_string();
+        }
+    }
+
+    match ts_type {
+        "string" => "TEXT".to_string(),
+        "number" => {
+            // Pagination/count fields → INTEGER, general → DOUBLE PRECISION
+            match prop_name {
+                "page" | "pageSize" | "page_size" | "limit" | "offset" | "perPage"
+                | "per_page" | "total" | "totalPages" | "total_pages" | "count" | "size" => {
+                    "INTEGER".to_string()
+                }
+                _ => "DOUBLE PRECISION".to_string(),
+            }
+        }
+        "boolean" => "BOOLEAN".to_string(),
+        t if t == "Date" || t == "DateTime" => "TIMESTAMPTZ".to_string(),
+        // Array types → JSONB
+        t if t.ends_with("[]") || (t.starts_with("Array<") && t.ends_with('>')) => {
+            "JSONB".to_string()
+        }
+        // Fallback
+        _ => "TEXT".to_string(),
+    }
+}
+
+/// Collect field names that have @unique annotation.
+fn collect_unique_fields(meta: &TypeMetadata) -> Vec<String> {
+    meta.properties
+        .iter()
+        .filter(|(_, prop)| {
+            prop.jsdoc
+                .as_ref()
+                .map(|j| j.contains_key("unique"))
+                .unwrap_or(false)
+        })
+        .map(|(name, _)| name.clone())
+        .collect()
+}
+
+/// Return sorted properties as Vec for deterministic output.
+fn sorted_properties(meta: &TypeMetadata) -> Vec<(&str, &PropertyMetadata)> {
+    let mut props: Vec<(&str, &PropertyMetadata)> = meta
+        .properties
+        .iter()
+        .map(|(k, v)| (k.as_str(), v))
+        .collect();
+    props.sort_by_key(|(name, _)| name.to_string());
+    props
+}
+
+/// Convert a camelCase or PascalCase string to snake_case.
+fn to_snake_case(s: &str) -> String {
+    let mut result = String::new();
+    for (i, c) in s.chars().enumerate() {
+        if c.is_uppercase() {
+            if i > 0 {
+                result.push('_');
+            }
+            result.push(c.to_lowercase().next().unwrap());
+        } else {
+            result.push(c);
+        }
+    }
+    result
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use typokit_transform_native::type_extractor::{PropertyMetadata, TypeMetadata};
+
+    fn make_table_type(
+        name: &str,
+        table_name: &str,
+        props: Vec<(&str, &str, bool, Vec<(&str, &str)>)>,
+    ) -> TypeMetadata {
+        let mut properties = HashMap::new();
+        for (pname, ptype, optional, jsdoc_tags) in props {
+            let jsdoc = if jsdoc_tags.is_empty() {
+                None
+            } else {
+                let mut map = HashMap::new();
+                for (key, value) in jsdoc_tags {
+                    map.insert(key.to_string(), value.to_string());
+                }
+                Some(map)
+            };
+            properties.insert(
+                pname.to_string(),
+                PropertyMetadata {
+                    type_str: ptype.to_string(),
+                    optional,
+                    jsdoc,
+                },
+            );
+        }
+        let mut type_jsdoc = HashMap::new();
+        type_jsdoc.insert("table".to_string(), table_name.to_string());
+        TypeMetadata {
+            name: name.to_string(),
+            properties,
+            jsdoc: Some(type_jsdoc),
+        }
+    }
+
+    fn make_non_table_type(name: &str) -> TypeMetadata {
+        let mut properties = HashMap::new();
+        properties.insert(
+            "value".to_string(),
+            PropertyMetadata {
+                type_str: "string".to_string(),
+                optional: false,
+                jsdoc: None,
+            },
+        );
+        TypeMetadata {
+            name: name.to_string(),
+            properties,
+            jsdoc: None,
+        }
+    }
+
+    fn user_type() -> TypeMetadata {
+        make_table_type(
+            "User",
+            "users",
+            vec![
+                ("id", "string", false, vec![("id", ""), ("generated", "uuid")]),
+                ("email", "string", false, vec![("unique", ""), ("format", "email")]),
+                ("name", "string", false, vec![]),
+                ("createdAt", "Date", false, vec![("generated", "now")]),
+            ],
+        )
+    }
+
+    #[test]
+    fn test_is_table_entity() {
+        let user = user_type();
+        assert!(is_table_entity(&user));
+        assert!(!is_table_entity(&make_non_table_type("Config")));
+    }
+
+    #[test]
+    fn test_get_table_name() {
+        let user = user_type();
+        assert_eq!(get_table_name(&user), "users");
+
+        // Empty @table value falls back to snake_case + "s"
+        let mut meta = make_non_table_type("BlogPost");
+        let mut jsdoc = HashMap::new();
+        jsdoc.insert("table".to_string(), String::new());
+        meta.jsdoc = Some(jsdoc);
+        assert_eq!(get_table_name(&meta), "blog_posts");
+    }
+
+    #[test]
+    fn test_find_id_property() {
+        let user = user_type();
+        let id = find_id_property(&user);
+        assert!(id.is_some());
+        let (name, _) = id.unwrap();
+        assert_eq!(name, "id");
+    }
+
+    #[test]
+    fn test_is_generated_uuid() {
+        let prop = PropertyMetadata {
+            type_str: "string".to_string(),
+            optional: false,
+            jsdoc: Some({
+                let mut m = HashMap::new();
+                m.insert("id".to_string(), String::new());
+                m.insert("generated".to_string(), "uuid".to_string());
+                m
+            }),
+        };
+        assert!(is_generated_uuid(&prop));
+    }
+
+    #[test]
+    fn test_is_generated_now() {
+        let prop = PropertyMetadata {
+            type_str: "Date".to_string(),
+            optional: false,
+            jsdoc: Some({
+                let mut m = HashMap::new();
+                m.insert("generated".to_string(), "now".to_string());
+                m
+            }),
+        };
+        assert!(is_generated_now(&prop));
+        assert!(!is_generated_uuid(&prop));
+    }
+
+    #[test]
+    fn test_ts_type_to_postgres_mapping() {
+        assert_eq!(ts_type_to_postgres("string", "name", &None), "TEXT");
+        assert_eq!(ts_type_to_postgres("number", "age", &None), "DOUBLE PRECISION");
+        assert_eq!(ts_type_to_postgres("boolean", "active", &None), "BOOLEAN");
+        assert_eq!(ts_type_to_postgres("Date", "createdAt", &None), "TIMESTAMPTZ");
+        assert_eq!(ts_type_to_postgres("string[]", "tags", &None), "JSONB");
+
+        // Integer override
+        let jsdoc = Some({
+            let mut m = HashMap::new();
+            m.insert("integer".to_string(), String::new());
+            m
+        });
+        assert_eq!(ts_type_to_postgres("number", "score", &jsdoc), "BIGINT");
+
+        // Pagination heuristic
+        assert_eq!(ts_type_to_postgres("number", "page", &None), "INTEGER");
+    }
+
+    #[test]
+    fn test_generate_database_filters_non_table_entities() {
+        let mut type_map = HashMap::new();
+        type_map.insert("User".to_string(), user_type());
+        type_map.insert("Config".to_string(), make_non_table_type("Config"));
+
+        let outputs = generate_database(&type_map);
+
+        // Should have db/mod.rs, db/repository.rs, and one migration
+        assert!(outputs.iter().any(|o| o.path == ".typokit/db/mod.rs"));
+        assert!(outputs.iter().any(|o| o.path == ".typokit/db/repository.rs"));
+        assert!(outputs.iter().any(|o| o.path.contains("migrations") && o.path.contains("user")));
+        assert_eq!(outputs.len(), 3);
+    }
+
+    #[test]
+    fn test_generate_db_mod_content() {
+        let output = generate_db_mod();
+        assert_eq!(output.path, ".typokit/db/mod.rs");
+        assert!(output.overwrite);
+        assert!(output.content.contains("pub async fn connect(database_url: &str) -> PgPool"));
+        assert!(output.content.contains("pub mod repository;"));
+    }
+
+    #[test]
+    fn test_generate_repository_crud_functions() {
+        let mut type_map = HashMap::new();
+        type_map.insert("User".to_string(), user_type());
+
+        let table_entities: BTreeMap<String, &TypeMetadata> = type_map
+            .iter()
+            .filter(|(_, meta)| is_table_entity(meta))
+            .map(|(name, meta)| (name.clone(), meta))
+            .collect();
+
+        let output = generate_repository(&table_entities);
+        let content = &output.content;
+
+        assert!(content.contains("pub async fn find_all_user("));
+        assert!(content.contains("pub async fn find_user_by_id("));
+        assert!(content.contains("pub async fn create_user("));
+        assert!(content.contains("pub async fn update_user("));
+        assert!(content.contains("pub async fn delete_user("));
+    }
+
+    #[test]
+    fn test_repository_uses_correct_table_name() {
+        let mut type_map = HashMap::new();
+        type_map.insert("User".to_string(), user_type());
+
+        let table_entities: BTreeMap<String, &TypeMetadata> = type_map
+            .iter()
+            .filter(|(_, meta)| is_table_entity(meta))
+            .map(|(name, meta)| (name.clone(), meta))
+            .collect();
+
+        let output = generate_repository(&table_entities);
+        assert!(output.content.contains("FROM users"));
+    }
+
+    #[test]
+    fn test_repository_generated_uuid() {
+        let mut type_map = HashMap::new();
+        type_map.insert("User".to_string(), user_type());
+
+        let table_entities: BTreeMap<String, &TypeMetadata> = type_map
+            .iter()
+            .filter(|(_, meta)| is_table_entity(meta))
+            .map(|(name, meta)| (name.clone(), meta))
+            .collect();
+
+        let output = generate_repository(&table_entities);
+        assert!(output.content.contains("Uuid::new_v4().to_string()"));
+        assert!(output.content.contains("use uuid::Uuid;"));
+    }
+
+    #[test]
+    fn test_repository_generated_now() {
+        let mut type_map = HashMap::new();
+        type_map.insert("User".to_string(), user_type());
+
+        let table_entities: BTreeMap<String, &TypeMetadata> = type_map
+            .iter()
+            .filter(|(_, meta)| is_table_entity(meta))
+            .map(|(name, meta)| (name.clone(), meta))
+            .collect();
+
+        let output = generate_repository(&table_entities);
+        assert!(output.content.contains("Utc::now()"));
+        assert!(output.content.contains("use chrono::Utc;"));
+    }
+
+    #[test]
+    fn test_generate_migration_creates_table() {
+        let user = user_type();
+        let output = generate_migration(&user, 0);
+
+        assert!(output.path.contains("migrations"));
+        assert!(output.path.contains("create_user"));
+        assert!(output.overwrite);
+
+        let content = &output.content;
+        assert!(content.contains("CREATE TABLE IF NOT EXISTS users"));
+        assert!(content.contains("id TEXT NOT NULL PRIMARY KEY"));
+        assert!(content.contains("email TEXT NOT NULL UNIQUE"));
+        assert!(content.contains("name TEXT NOT NULL"));
+        assert!(content.contains("TIMESTAMPTZ"));
+    }
+
+    #[test]
+    fn test_migration_column_types() {
+        let meta = make_table_type(
+            "Product",
+            "products",
+            vec![
+                ("id", "string", false, vec![("id", "")]),
+                ("name", "string", false, vec![]),
+                ("price", "number", false, vec![]),
+                ("active", "boolean", false, vec![]),
+                ("createdAt", "Date", false, vec![]),
+                ("count", "number", false, vec![("integer", "")]),
+            ],
+        );
+
+        let output = generate_migration(&meta, 0);
+        let content = &output.content;
+
+        assert!(content.contains("id TEXT NOT NULL PRIMARY KEY"));
+        assert!(content.contains("name TEXT NOT NULL"));
+        assert!(content.contains("price DOUBLE PRECISION NOT NULL"));
+        assert!(content.contains("active BOOLEAN NOT NULL"));
+        assert!(content.contains("TIMESTAMPTZ NOT NULL"));
+        assert!(content.contains("count BIGINT NOT NULL"));
+    }
+
+    #[test]
+    fn test_generate_database_all_overwrite_true() {
+        let mut type_map = HashMap::new();
+        type_map.insert("User".to_string(), user_type());
+
+        let outputs = generate_database(&type_map);
+        for output in &outputs {
+            assert!(output.overwrite, "Expected overwrite: true for {}", output.path);
+        }
+    }
+
+    #[test]
+    fn test_generate_database_empty_type_map() {
+        let type_map = HashMap::new();
+        let outputs = generate_database(&type_map);
+
+        // Should still produce db/mod.rs
+        assert!(outputs.iter().any(|o| o.path == ".typokit/db/mod.rs"));
+        // No repository or migrations since there are no table entities
+        assert!(!outputs.iter().any(|o| o.path.contains("repository")));
+    }
+
+    #[test]
+    fn test_generate_database_deterministic() {
+        let mut type_map = HashMap::new();
+        type_map.insert("User".to_string(), user_type());
+        type_map.insert(
+            "Todo".to_string(),
+            make_table_type(
+                "Todo",
+                "todos",
+                vec![
+                    ("id", "string", false, vec![("id", ""), ("generated", "uuid")]),
+                    ("title", "string", false, vec![]),
+                    ("completed", "boolean", false, vec![]),
+                ],
+            ),
+        );
+
+        let output1 = generate_database(&type_map);
+        let output2 = generate_database(&type_map);
+
+        assert_eq!(output1.len(), output2.len());
+        for (a, b) in output1.iter().zip(output2.iter()) {
+            assert_eq!(a.path, b.path);
+            assert_eq!(a.content, b.content);
+        }
+    }
+
+    #[test]
+    fn test_find_all_pagination() {
+        let user = user_type();
+        let crud = generate_entity_crud(&user);
+        assert!(crud.contains("LIMIT $1 OFFSET $2"));
+        assert!(crud.contains("page: u32"));
+        assert!(crud.contains("page_size: u32"));
+    }
+
+    #[test]
+    fn test_create_excludes_generated_fields_from_input() {
+        let user = user_type();
+        let crud = generate_entity_crud(&user);
+
+        // The INSERT should include id and createdAt (via generated values)
+        // but the input struct should NOT have those fields bound from input
+        assert!(crud.contains("Uuid::new_v4()"));
+        assert!(crud.contains("Utc::now()"));
+    }
+
+    #[test]
+    fn test_delete_returns_optional() {
+        let user = user_type();
+        let crud = generate_entity_crud(&user);
+        assert!(crud.contains("delete_user"));
+        assert!(crud.contains("DELETE FROM users WHERE id = $1 RETURNING *"));
+        assert!(crud.contains("fetch_optional"));
+    }
+}