fraiseql_core/compiler/

codegen.rs

//! Code generator - produces final `CompiledSchema` JSON.
//!
//! # Overview
//!
//! Takes validated IR and SQL templates, produces runtime-optimized
//! `CompiledSchema` ready for execution.

use std::collections::HashMap;

use super::ir::{
    AuthoringIR, IRArgument, IREnum, IREnumValue, IRField, IRInputField, IRInputType, IRInterface,
    IRMutation, IRUnion,
};
#[allow(unused_imports)] // Reason: used only in doc links for `# Errors` sections
use crate::error::FraiseQLError;
use crate::{
    error::Result,
    schema::{
        ArgumentDefinition, AutoParams as SchemaAutoParams, CompiledSchema, CursorType,
        DeprecationInfo, EnumDefinition, EnumValueDefinition, FieldDefinition, FieldDenyPolicy,
        FieldType, InputFieldDefinition, InputObjectDefinition, InterfaceDefinition,
        MutationDefinition, QueryDefinition, SubscriptionDefinition, TypeDefinition,
        UnionDefinition,
        domain_types::{SqlSource, TypeName},
    },
    validation::{CustomTypeDef, CustomTypeRegistry, CustomTypeRegistryConfig},
};

/// Code generator.
pub struct CodeGenerator {
    /// Enable SQL template optimization.
    ///
    /// **Reserved for a future SQL optimization pass** (constant folding,
    /// predicate push-down, redundant-join elimination, etc.).  The flag is
    /// stored and exposed via [`CodeGenerator::optimize`] so callers can
    /// configure it today; it is not yet branched upon inside
    /// [`CodeGenerator::generate`].  `sql_projection_hint` on each
    /// [`TypeDefinition`] is the placeholder populated by that future pass.
    optimize: bool,
}

impl CodeGenerator {
    /// Create new code generator.
    #[must_use]
    pub const fn new(optimize: bool) -> Self {
        Self { optimize }
    }

    /// Generate a compiled schema from the intermediate representation.
    ///
    /// # Architecture: Schema vs. Templates vs. Metadata
    ///
    /// FraiseQL separates schema definition from execution artifacts:
    ///
    /// ## What This Function Generates
    ///
    /// The `CompiledSchema` contains the **schema definition** - types, fields, enums,
    /// interfaces, unions, and query/mutation/subscription signatures. This is what
    /// GraphQL introspection tools query and what the runtime uses for query validation.
    ///
    /// ## What This Function Does NOT Generate
    ///
    /// ### 1. SQL Templates
    ///
    /// SQL templates are managed separately by the compilation pipeline.
    /// They are:
    /// - Generated in a separate compiler pass after schema validation
    /// - Kept separate to allow schema reuse across database backends
    /// - Passed to the runtime executor independently
    ///
    /// **Why**: Allows updating SQL generation strategy without recompiling schema
    /// definitions. For example, you could optimize SQL templates without changing
    /// type definitions.
    ///
    /// ### 2. Fact Tables
    ///
    /// Fact table metadata is populated by the compiler from `ir.fact_tables` in a
    /// separate initialization pass. This maintains:
    /// - Clean separation of concerns (schema def vs. analytics metadata)
    /// - Ability to update fact table configuration independently
    /// - Clear data flow through compilation pipeline
    ///
    /// **Why**: Fact tables are configuration-driven metadata. Keeping them separate
    /// allows analytics tuning without affecting core schema.
    ///
    /// # Parameters
    ///
    /// * `ir` - The intermediate representation generated by the compiler
    ///
    /// # Errors
    ///
    /// Returns a `Result` with compilation errors if schema validation fails.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use fraiseql_core::compiler::{CodeGenerator, AuthoringIR};
    /// # use fraiseql_core::error::Result;
    /// # fn example() -> Result<()> {
    /// let authoring_ir = AuthoringIR::new();
    /// let codegen = CodeGenerator::new(true);
    /// let compiled_schema = codegen.generate(&authoring_ir)?;
    /// // Runtime uses compiled_schema for query execution
    /// # Ok(())
    /// # }
    /// ```
    ///
    /// # See Also
    ///
    /// - (Compilation): SQL template generation
    /// - Compiler module documentation for pipeline overview
    ///
    /// # Errors
    ///
    /// Returns [`FraiseQLError::Validation`] if the IR contains invalid field types,
    /// unknown types, or conflicting definitions. Returns [`FraiseQLError::Internal`]
    /// for unexpected code-generation failures.
    pub fn generate(&self, ir: &AuthoringIR) -> Result<CompiledSchema> {
        let types = ir
            .types
            .iter()
            .map(|t| {
                TypeDefinition {
                    name:                TypeName::new(t.name.clone()),
                    sql_source:          SqlSource::new(
                        t.sql_source.clone().unwrap_or_else(|| t.name.clone()),
                    ),
                    jsonb_column:        "data".to_string(),
                    fields:              Self::map_fields(&t.fields),
                    description:         t.description.clone(),
                    sql_projection_hint: None, // Populated during optimization pass
                    implements:          Vec::new(), /* Note: IR doesn't have interface
                                                * implementation yet */
                    requires_role:       None,
                    is_error:            false,
                    relay:               false,
                    relationships:       Vec::new(),
                }
            })
            .collect();

        let queries = ir
            .queries
            .iter()
            .map(|q| {
                QueryDefinition {
                    name:                q.name.clone(),
                    return_type:         q.return_type.clone(),
                    returns_list:        q.returns_list,
                    nullable:            q.nullable,
                    arguments:           Self::map_arguments(&q.arguments),
                    sql_source:          q.sql_source.clone(),
                    description:         q.description.clone(),
                    auto_params:         SchemaAutoParams {
                        has_where:    q.auto_params.has_where,
                        has_order_by: q.auto_params.has_order_by,
                        has_limit:    q.auto_params.has_limit,
                        has_offset:   q.auto_params.has_offset,
                    },
                    deprecation:         None, // Note: IR doesn't have deprecation info yet
                    jsonb_column:        "data".to_string(), // Default to "data" column
                    relay:               false,
                    relay_cursor_column: None,
                    relay_cursor_type:   CursorType::default(),
                    inject_params:       indexmap::IndexMap::default(),
                    cache_ttl_seconds:   None,
                    additional_views:    vec![],
                    requires_role:       None,
                    rest_path:           None,
                    rest_method:         None,
                    native_columns:      HashMap::new(),
                }
            })
            .collect();

        let mutations = ir.mutations.iter().map(Self::map_mutation).collect();

        let subscriptions = ir
            .subscriptions
            .iter()
            .map(|s| {
                SubscriptionDefinition {
                    name:          s.name.clone(),
                    return_type:   s.return_type.clone(),
                    arguments:     Self::map_arguments(&s.arguments),
                    description:   s.description.clone(),
                    topic:         None, // Populated from decorator topic binding
                    filter:        None, // Populated from decorator filters
                    fields:        Vec::new(), // Populated from decorator field selection
                    filter_fields: Vec::new(), // Populated from decorator filter_fields
                    deprecation:   None, // Note: IR subscriptions don't have deprecation yet
                }
            })
            .collect();

        // Map enums
        let enums = ir.enums.iter().map(Self::map_enum).collect();

        // Map interfaces
        let interfaces = ir.interfaces.iter().map(Self::map_interface).collect();

        // Map unions
        let unions = ir.unions.iter().map(Self::map_union).collect();

        // Map input types
        let input_types = ir.input_types.iter().map(Self::map_input_type).collect();

        // Build custom type registry from IRScalars
        let custom_scalars = Self::build_custom_type_registry(&ir.scalars)?;

        let mut schema = CompiledSchema {
            types,
            enums,
            input_types,
            interfaces,
            unions,
            queries,
            mutations,
            subscriptions,
            // Directives are custom decorators applied to schema elements. The IR doesn't currently
            // have custom directive definitions. They will be populated when decorator support is
            // added.
            directives: Vec::new(),
            // Fact tables are populated by the compiler from ir.fact_tables in a separate pass.
            // This maintains clear separation between schema definition (type system) and analytics
            // metadata (fact table configuration). Empty initially; populated during post-codegen
            // pass.
            fact_tables: std::collections::HashMap::new(),
            // Observers are populated from ir.observers. Currently empty; will be populated
            // when observer support is added to the IR layer.
            observers: Vec::new(),
            // Federation metadata: populated if Apollo Federation is configured
            federation: None,
            // Security configuration: populated from fraiseql.toml
            security: None,
            // Raw schema SDL: populated for federation _service query
            observers_config: None,
            subscriptions_config: None,
            validation_config: None,
            debug_config: None,
            mcp_config: None,
            schema_sdl: None,
            // Embed the current format version so the server can detect compiler/runtime skew.
            schema_format_version: Some(crate::schema::CURRENT_SCHEMA_FORMAT_VERSION),
            // Custom scalar types registry
            custom_scalars,
            // Index fields are private; fill with defaults and build below.
            ..CompiledSchema::default()
        };
        schema.build_indexes();
        Ok(schema)
    }

    /// Map IR fields to compiled schema fields.
    fn map_fields(ir_fields: &[IRField]) -> Vec<FieldDefinition> {
        ir_fields
            .iter()
            .map(|f| {
                let field_type = FieldType::parse(&f.field_type);
                FieldDefinition {
                    name: f.name.clone().into(),
                    field_type,
                    nullable: f.nullable,
                    description: f.description.clone(),
                    default_value: None,  // Fields don't have defaults in GraphQL
                    vector_config: None,  // Would be set if field_type is Vector
                    alias: None,          // Aliases come from query, not schema
                    deprecation: None,    // Note: IR fields don't have deprecation yet
                    requires_scope: None, // Note: IR fields don't have scope requirements yet
                    on_deny: FieldDenyPolicy::default(),
                    encryption: None,
                }
            })
            .collect()
    }

    /// Map IR arguments to compiled schema arguments.
    fn map_arguments(ir_args: &[IRArgument]) -> Vec<ArgumentDefinition> {
        ir_args
            .iter()
            .map(|a| {
                let arg_type = FieldType::parse(&a.arg_type);
                ArgumentDefinition {
                    name: a.name.clone(),
                    arg_type,
                    nullable: a.nullable,
                    default_value: a.default_value.clone(),
                    description: a.description.clone(),
                    deprecation: None, // Note: IR args don't have deprecation yet
                }
            })
            .collect()
    }

    /// Map IR mutation to compiled schema mutation.
    fn map_mutation(m: &IRMutation) -> MutationDefinition {
        use super::ir::MutationOperation as IRMutationOp;
        use crate::schema::MutationOperation;

        // The compiled schema MutationOperation needs a table name for Insert/Update/Delete.
        // The IR doesn't carry a sql_source field, so we derive the table from the return type.
        // sql_source is set to the same value so the executor can locate the SQL function even
        // when the operation.table fallback path is not exercised.
        let operation = match m.operation {
            IRMutationOp::Create => MutationOperation::Insert {
                table: m.return_type.to_lowercase(), // Infer table from return type
            },
            IRMutationOp::Update => MutationOperation::Update {
                table: m.return_type.to_lowercase(),
            },
            IRMutationOp::Delete => MutationOperation::Delete {
                table: m.return_type.to_lowercase(),
            },
            IRMutationOp::Custom => MutationOperation::Custom,
        };

        let sql_source = match &operation {
            MutationOperation::Insert { table }
            | MutationOperation::Update { table }
            | MutationOperation::Delete { table }
                if !table.is_empty() =>
            {
                Some(table.clone())
            },
            _ => None,
        };

        MutationDefinition {
            name: m.name.clone(),
            return_type: m.return_type.clone(),
            arguments: Self::map_arguments(&m.arguments),
            description: m.description.clone(),
            operation,
            deprecation: None, // Note: IR mutations don't have deprecation yet
            sql_source,
            inject_params: indexmap::IndexMap::default(),
            invalidates_fact_tables: vec![],
            invalidates_views: vec![],
            rest_path: None,
            rest_method: None,
            upsert_function: None,
        }
    }

    /// Map IR enum to compiled schema enum.
    fn map_enum(e: &IREnum) -> EnumDefinition {
        EnumDefinition {
            name:        e.name.clone(),
            values:      e.values.iter().map(Self::map_enum_value).collect(),
            description: e.description.clone(),
        }
    }

    /// Map IR enum value to compiled schema enum value.
    fn map_enum_value(v: &IREnumValue) -> EnumValueDefinition {
        EnumValueDefinition {
            name:        v.name.clone(),
            description: v.description.clone(),
            deprecation: v.deprecation_reason.as_ref().map(|reason| DeprecationInfo {
                reason: Some(reason.clone()),
            }),
        }
    }

    /// Map IR interface to compiled schema interface.
    fn map_interface(i: &IRInterface) -> InterfaceDefinition {
        InterfaceDefinition {
            name:        i.name.clone(),
            fields:      Self::map_fields(&i.fields),
            description: i.description.clone(),
        }
    }

    /// Map IR union to compiled schema union.
    fn map_union(u: &IRUnion) -> UnionDefinition {
        UnionDefinition {
            name:         u.name.clone(),
            member_types: u.types.clone(),
            description:  u.description.clone(),
        }
    }

    /// Map IR input type to compiled schema input object.
    fn map_input_type(i: &IRInputType) -> InputObjectDefinition {
        InputObjectDefinition {
            name:        i.name.clone(),
            fields:      Self::map_input_fields(&i.fields),
            description: i.description.clone(),
            metadata:    None,
        }
    }

    /// Map IR input fields to compiled schema input fields.
    fn map_input_fields(ir_fields: &[IRInputField]) -> Vec<InputFieldDefinition> {
        ir_fields
            .iter()
            .map(|f| {
                InputFieldDefinition {
                    name:             f.name.clone(),
                    field_type:       f.field_type.clone(), /* InputFieldDefinition uses String,
                                                             * not FieldType */
                    description:      f.description.clone(),
                    default_value:    f.default_value.as_ref().map(|v| v.to_json().to_string()),
                    deprecation:      None, // Note: IR input fields don't have deprecation yet
                    validation_rules: Vec::new(), /* Validation rules set separately from @validate
                                             * directives */
                }
            })
            .collect()
    }

    /// Build custom type registry from `IRScalars`.
    fn build_custom_type_registry(
        ir_scalars: &[super::ir::IRScalar],
    ) -> Result<CustomTypeRegistry> {
        let registry = CustomTypeRegistry::new(CustomTypeRegistryConfig::default());

        for ir_scalar in ir_scalars {
            let def = CustomTypeDef {
                name:             ir_scalar.name.clone(),
                description:      ir_scalar.description.clone(),
                specified_by_url: ir_scalar.specified_by_url.clone(),
                validation_rules: ir_scalar.validation_rules.clone(),
                elo_expression:   None, // ELO expressions are handled separately
                base_type:        ir_scalar.base_type.clone(),
            };

            registry.register(ir_scalar.name.clone(), def)?;
        }

        Ok(registry)
    }

    /// Check if optimization is enabled.
    #[must_use]
    pub const fn optimize(&self) -> bool {
        self.optimize
    }
}

#[cfg(test)]
mod tests {
    #![allow(clippy::unwrap_used)] // Reason: test code, panics are acceptable

    use super::{
        super::ir::{AutoParams, IRArgument, IRField, IRQuery, IRSubscription, IRType},
        *,
    };
    use crate::schema::{CursorType, GraphQLValue};

    #[test]
    fn test_code_generator_new() {
        let generator = CodeGenerator::new(true);
        assert!(generator.optimize());

        let generator = CodeGenerator::new(false);
        assert!(!generator.optimize());
    }

    #[test]
    fn test_generate_empty_schema() {
        let generator = CodeGenerator::new(true);
        let ir = AuthoringIR::new();

        let schema = generator
            .generate(&ir)
            .unwrap_or_else(|e| panic!("generate empty schema should succeed: {e}"));
        assert!(schema.types.is_empty());
        assert!(schema.queries.is_empty());
    }

    #[test]
    fn test_generate_types_with_fields() {
        let generator = CodeGenerator::new(true);
        let mut ir = AuthoringIR::new();

        ir.types.push(IRType {
            name:        "User".to_string(),
            fields:      vec![
                IRField {
                    name:        "id".to_string(),
                    field_type:  "ID!".to_string(),
                    nullable:    false,
                    description: Some("User ID".to_string()),
                    sql_column:  Some("id".to_string()),
                },
                IRField {
                    name:        "name".to_string(),
                    field_type:  "String".to_string(),
                    nullable:    true,
                    description: None,
                    sql_column:  None,
                },
                IRField {
                    name:        "age".to_string(),
                    field_type:  "Int".to_string(),
                    nullable:    true,
                    description: None,
                    sql_column:  None,
                },
            ],
            sql_source:  Some("v_user".to_string()),
            description: Some("User type".to_string()),
        });

        let schema = generator
            .generate(&ir)
            .unwrap_or_else(|e| panic!("generate types with fields should succeed: {e}"));
        assert_eq!(schema.types.len(), 1);

        let user_type = &schema.types[0];
        assert_eq!(user_type.name, "User");
        assert_eq!(user_type.sql_source, "v_user");
        assert_eq!(user_type.fields.len(), 3);

        // Check field types were parsed correctly
        assert_eq!(user_type.fields[0].name, "id");
        assert_eq!(user_type.fields[0].field_type, FieldType::Id);
        assert!(!user_type.fields[0].nullable);

        assert_eq!(user_type.fields[1].name, "name");
        assert_eq!(user_type.fields[1].field_type, FieldType::String);

        assert_eq!(user_type.fields[2].name, "age");
        assert_eq!(user_type.fields[2].field_type, FieldType::Int);
    }

    #[test]
    fn test_generate_queries_with_arguments() {
        let generator = CodeGenerator::new(true);
        let mut ir = AuthoringIR::new();

        ir.types.push(IRType {
            name:        "User".to_string(),
            fields:      vec![],
            sql_source:  None,
            description: None,
        });

        ir.queries.push(IRQuery {
            name:         "user".to_string(),
            return_type:  "User".to_string(),
            returns_list: false,
            nullable:     true,
            arguments:    vec![IRArgument {
                name:          "id".to_string(),
                arg_type:      "ID!".to_string(),
                nullable:      false,
                default_value: None,
                description:   Some("User ID to fetch".to_string()),
            }],
            sql_source:   Some("v_user".to_string()),
            description:  Some("Fetch a single user".to_string()),
            auto_params:  AutoParams::default(),
        });

        ir.queries.push(IRQuery {
            name:         "users".to_string(),
            return_type:  "User".to_string(),
            returns_list: true,
            nullable:     false,
            arguments:    vec![IRArgument {
                name:          "limit".to_string(),
                arg_type:      "Int".to_string(),
                nullable:      true,
                default_value: Some(GraphQLValue::Int(10)),
                description:   None,
            }],
            sql_source:   Some("v_user".to_string()),
            description:  None,
            auto_params:  AutoParams {
                has_where:    true,
                has_order_by: true,
                has_limit:    true,
                has_offset:   true,
            },
        });

        let schema = generator
            .generate(&ir)
            .unwrap_or_else(|e| panic!("generate queries with arguments should succeed: {e}"));
        assert_eq!(schema.queries.len(), 2);

        // Check single user query
        let user_query = &schema.queries[0];
        assert_eq!(user_query.name, "user");
        assert!(!user_query.returns_list);
        assert!(user_query.nullable);
        assert_eq!(user_query.arguments.len(), 1);
        assert_eq!(user_query.arguments[0].name, "id");
        assert_eq!(user_query.arguments[0].arg_type, FieldType::Id);

        // Check users query with auto_params — assert all fields
        let users_query = &schema.queries[1];
        assert_eq!(users_query.name, "users");
        assert!(users_query.returns_list);
        assert_eq!(
            users_query.sql_source.as_deref(),
            Some("v_user"),
            "codegen must thread sql_source from IR"
        );
        assert!(users_query.auto_params.has_where);
        assert!(users_query.auto_params.has_order_by);
        assert_eq!(users_query.arguments[0].default_value, Some(GraphQLValue::Int(10)));
        assert_eq!(users_query.relay_cursor_type, CursorType::Int64);
        assert!(users_query.inject_params.is_empty());
        assert!(users_query.cache_ttl_seconds.is_none());
    }

    #[test]
    fn test_generate_mutations() {
        use super::super::ir::MutationOperation as IRMutationOp;

        let generator = CodeGenerator::new(true);
        let mut ir = AuthoringIR::new();

        ir.mutations.push(IRMutation {
            name:        "createUser".to_string(),
            return_type: "User".to_string(),
            nullable:    false,
            arguments:   vec![IRArgument {
                name:          "name".to_string(),
                arg_type:      "String!".to_string(),
                nullable:      false,
                default_value: None,
                description:   None,
            }],
            description: Some("Create a new user".to_string()),
            operation:   IRMutationOp::Create,
        });

        let schema = generator
            .generate(&ir)
            .unwrap_or_else(|e| panic!("generate mutations should succeed: {e}"));
        assert_eq!(schema.mutations.len(), 1);

        let mutation = &schema.mutations[0];
        assert_eq!(mutation.name, "createUser");
        // Insert operation should be inferred from Create
        assert!(matches!(
            &mutation.operation,
            crate::schema::MutationOperation::Insert { table } if table == "user"
        ));
        // sql_source must be populated from operation.table so the executor can call
        // the SQL function without the "has no sql_source configured" error (issue #53).
        assert_eq!(
            mutation.sql_source,
            Some("user".to_string()),
            "codegen must thread sql_source from IR"
        );
        assert_eq!(mutation.arguments.len(), 1);
        assert!(mutation.inject_params.is_empty());
        assert!(mutation.invalidates_fact_tables.is_empty());
        assert!(mutation.invalidates_views.is_empty());
    }

    #[test]
    fn test_generate_subscriptions() {
        let generator = CodeGenerator::new(true);
        let mut ir = AuthoringIR::new();

        ir.subscriptions.push(IRSubscription {
            name:        "userCreated".to_string(),
            return_type: "User".to_string(),
            arguments:   vec![IRArgument {
                name:          "tenantId".to_string(),
                arg_type:      "ID!".to_string(),
                nullable:      false,
                default_value: None,
                description:   None,
            }],
            description: Some("Subscribe to user creation events".to_string()),
        });

        let schema = generator
            .generate(&ir)
            .unwrap_or_else(|e| panic!("generate subscriptions should succeed: {e}"));
        assert_eq!(schema.subscriptions.len(), 1);

        let subscription = &schema.subscriptions[0];
        assert_eq!(subscription.name, "userCreated");
        assert_eq!(subscription.return_type, "User");
        assert_eq!(subscription.arguments.len(), 1);
        assert_eq!(subscription.arguments[0].name, "tenantId");
    }

    #[test]
    fn test_field_type_parsing_list_types() {
        let generator = CodeGenerator::new(true);
        let mut ir = AuthoringIR::new();

        ir.types.push(IRType {
            name:        "Post".to_string(),
            fields:      vec![
                IRField {
                    name:        "tags".to_string(),
                    field_type:  "[String]".to_string(),
                    nullable:    true,
                    description: None,
                    sql_column:  None,
                },
                IRField {
                    name:        "comments".to_string(),
                    field_type:  "[Comment!]!".to_string(),
                    nullable:    false,
                    description: None,
                    sql_column:  None,
                },
            ],
            sql_source:  None,
            description: None,
        });

        let schema = generator
            .generate(&ir)
            .unwrap_or_else(|e| panic!("generate list type fields should succeed: {e}"));
        let post_type = &schema.types[0];

        // [String] -> List(String)
        assert!(matches!(
            &post_type.fields[0].field_type,
            FieldType::List(inner) if **inner == FieldType::String
        ));

        // [Comment!]! -> List(Object("Comment"))
        assert!(matches!(
            &post_type.fields[1].field_type,
            FieldType::List(inner) if matches!(**inner, FieldType::Object(ref name) if name == "Comment")
        ));
    }

    #[test]
    fn test_generate_enums() {
        use super::super::ir::{IREnum, IREnumValue};

        let generator = CodeGenerator::new(true);
        let mut ir = AuthoringIR::new();

        ir.enums.push(IREnum {
            name:        "OrderStatus".to_string(),
            values:      vec![
                IREnumValue {
                    name:               "PENDING".to_string(),
                    description:        Some("Order is pending".to_string()),
                    deprecation_reason: None,
                },
                IREnumValue {
                    name:               "COMPLETED".to_string(),
                    description:        None,
                    deprecation_reason: None,
                },
                IREnumValue {
                    name:               "CANCELLED".to_string(),
                    description:        None,
                    deprecation_reason: Some("Use REJECTED instead".to_string()),
                },
            ],
            description: Some("Possible order statuses".to_string()),
        });

        let schema = generator
            .generate(&ir)
            .unwrap_or_else(|e| panic!("generate enums should succeed: {e}"));
        assert_eq!(schema.enums.len(), 1);

        let order_status = &schema.enums[0];
        assert_eq!(order_status.name, "OrderStatus");
        assert_eq!(order_status.values.len(), 3);
        assert_eq!(order_status.values[0].name, "PENDING");
        assert_eq!(order_status.values[0].description, Some("Order is pending".to_string()));
        assert!(order_status.values[2].deprecation.is_some());
    }

    #[test]
    fn test_generate_interfaces() {
        use super::super::ir::IRInterface;

        let generator = CodeGenerator::new(true);
        let mut ir = AuthoringIR::new();

        ir.interfaces.push(IRInterface {
            name:        "Node".to_string(),
            fields:      vec![IRField {
                name:        "id".to_string(),
                field_type:  "ID!".to_string(),
                nullable:    false,
                description: Some("Unique identifier".to_string()),
                sql_column:  None,
            }],
            description: Some("An object with an ID".to_string()),
        });

        let schema = generator
            .generate(&ir)
            .unwrap_or_else(|e| panic!("generate interfaces should succeed: {e}"));
        assert_eq!(schema.interfaces.len(), 1);

        let node = &schema.interfaces[0];
        assert_eq!(node.name, "Node");
        assert_eq!(node.fields.len(), 1);
        assert_eq!(node.fields[0].name, "id");
        assert_eq!(node.fields[0].field_type, FieldType::Id);
    }

    #[test]
    fn test_generate_unions() {
        use super::super::ir::IRUnion;

        let generator = CodeGenerator::new(true);
        let mut ir = AuthoringIR::new();

        ir.unions.push(IRUnion {
            name:        "SearchResult".to_string(),
            types:       vec![
                "User".to_string(),
                "Post".to_string(),
                "Comment".to_string(),
            ],
            description: Some("Possible search result types".to_string()),
        });

        let schema = generator
            .generate(&ir)
            .unwrap_or_else(|e| panic!("generate unions should succeed: {e}"));
        assert_eq!(schema.unions.len(), 1);

        let search_result = &schema.unions[0];
        assert_eq!(search_result.name, "SearchResult");
        assert_eq!(search_result.member_types.len(), 3);
        assert_eq!(search_result.member_types[0], "User");
    }

    #[test]
    fn test_generate_input_types() {
        use super::super::ir::{IRInputField, IRInputType};

        let generator = CodeGenerator::new(true);
        let mut ir = AuthoringIR::new();

        ir.input_types.push(IRInputType {
            name:        "CreateUserInput".to_string(),
            fields:      vec![
                IRInputField {
                    name:          "name".to_string(),
                    field_type:    "String!".to_string(),
                    nullable:      false,
                    default_value: None,
                    description:   Some("User's name".to_string()),
                },
                IRInputField {
                    name:          "age".to_string(),
                    field_type:    "Int".to_string(),
                    nullable:      true,
                    default_value: Some(GraphQLValue::Int(18)),
                    description:   None,
                },
            ],
            description: Some("Input for creating a user".to_string()),
        });

        let schema = generator
            .generate(&ir)
            .unwrap_or_else(|e| panic!("generate input types should succeed: {e}"));
        assert_eq!(schema.input_types.len(), 1);

        let create_user = &schema.input_types[0];
        assert_eq!(create_user.name, "CreateUserInput");
        assert_eq!(create_user.fields.len(), 2);
        assert_eq!(create_user.fields[0].name, "name");
        assert_eq!(create_user.fields[1].default_value, Some("18".to_string()));
    }

    #[test]
    fn test_generate_with_empty_scalars() {
        let generator = CodeGenerator::new(true);
        let mut ir = AuthoringIR::new();
        ir.scalars = vec![];

        let schema = generator
            .generate(&ir)
            .unwrap_or_else(|e| panic!("generate with empty scalars should succeed: {e}"));
        assert_eq!(schema.custom_scalars.count(), 0);
    }

    #[test]
    fn test_generate_with_single_custom_scalar() {
        use super::super::ir::IRScalar;

        let generator = CodeGenerator::new(true);
        let mut ir = AuthoringIR::new();

        ir.scalars.push(IRScalar {
            name:             "LibraryCode".to_string(),
            description:      Some("Unique library book identifier".to_string()),
            specified_by_url: None,
            validation_rules: vec![],
            base_type:        Some("String".to_string()),
        });

        let schema = generator
            .generate(&ir)
            .unwrap_or_else(|e| panic!("generate with single custom scalar should succeed: {e}"));
        assert_eq!(schema.custom_scalars.count(), 1);
        assert!(schema.custom_scalars.exists("LibraryCode"));

        let def = schema.custom_scalars.get("LibraryCode").unwrap();
        assert_eq!(def.name, "LibraryCode");
        assert_eq!(def.description, Some("Unique library book identifier".to_string()));
        assert_eq!(def.base_type, Some("String".to_string()));
    }

    #[test]
    fn test_generate_with_multiple_custom_scalars() {
        use super::super::ir::IRScalar;

        let generator = CodeGenerator::new(true);
        let mut ir = AuthoringIR::new();

        ir.scalars.push(IRScalar {
            name:             "LibraryCode".to_string(),
            description:      None,
            specified_by_url: None,
            validation_rules: vec![],
            base_type:        Some("String".to_string()),
        });

        ir.scalars.push(IRScalar {
            name:             "StudentID".to_string(),
            description:      Some("University student identifier".to_string()),
            specified_by_url: None,
            validation_rules: vec![],
            base_type:        None,
        });

        ir.scalars.push(IRScalar {
            name:             "PatientID".to_string(),
            description:      Some("Hospital patient identifier".to_string()),
            specified_by_url: Some("https://hl7.org/".to_string()),
            validation_rules: vec![],
            base_type:        Some("String".to_string()),
        });

        let schema = generator.generate(&ir).unwrap_or_else(|e| {
            panic!("generate with multiple custom scalars should succeed: {e}")
        });
        assert_eq!(schema.custom_scalars.count(), 3);

        // Verify all scalars are registered
        assert!(schema.custom_scalars.exists("LibraryCode"));
        assert!(schema.custom_scalars.exists("StudentID"));
        assert!(schema.custom_scalars.exists("PatientID"));

        // Verify metadata preserved
        let patient_id = schema.custom_scalars.get("PatientID").unwrap();
        assert_eq!(patient_id.specified_by_url, Some("https://hl7.org/".to_string()));
    }

    #[test]
    fn test_generate_preserves_scalar_description() {
        use super::super::ir::IRScalar;

        let generator = CodeGenerator::new(true);
        let mut ir = AuthoringIR::new();

        ir.scalars.push(IRScalar {
            name:             "Email".to_string(),
            description:      Some("RFC 5322 compliant email address".to_string()),
            specified_by_url: Some("https://tools.ietf.org/html/rfc5322".to_string()),
            validation_rules: vec![],
            base_type:        Some("String".to_string()),
        });

        let schema = generator.generate(&ir).unwrap_or_else(|e| {
            panic!("generate preserving scalar description should succeed: {e}")
        });
        let email_def = schema.custom_scalars.get("Email").unwrap();

        assert_eq!(email_def.description, Some("RFC 5322 compliant email address".to_string()));
        assert_eq!(
            email_def.specified_by_url,
            Some("https://tools.ietf.org/html/rfc5322".to_string())
        );
    }

    #[test]
    fn test_generate_scalars_with_validation_rules() {
        use super::super::ir::IRScalar;
        use crate::validation::ValidationRule;

        let generator = CodeGenerator::new(true);
        let mut ir = AuthoringIR::new();

        ir.scalars.push(IRScalar {
            name:             "StudentID".to_string(),
            description:      None,
            specified_by_url: None,
            validation_rules: vec![ValidationRule::Length {
                min: Some(5),
                max: Some(15),
            }],
            base_type:        Some("String".to_string()),
        });

        let schema = generator.generate(&ir).unwrap_or_else(|e| {
            panic!("generate scalars with validation rules should succeed: {e}")
        });
        let student_id = schema.custom_scalars.get("StudentID").unwrap();

        assert_eq!(student_id.validation_rules.len(), 1);
    }
}