visitor_demo/

visitor_demo.rs

//! Example: Using the Visitor pattern to analyze schemas.
//!
//! This example demonstrates:
//! - Implementing custom visitors
//! - Traversing AST nodes
//! - Collecting information from schemas
//! - Building relationships between models
//!
//! Run with: cargo run --package nautilus-schema --example visitor_demo

use nautilus_schema::{
    ast::*,
    visitor::{walk_model, Visitor},
    Lexer, Parser, Result,
};
use std::collections::{HashMap, HashSet};

const SCHEMA: &str = r#"
datasource db {
  provider = "postgresql"
  url = env("DATABASE_URL")
}

enum Role {
  USER
  ADMIN
  MODERATOR
}

model User {
  id        Int      @id @default(autoincrement())
  email     String   @unique
  username  String   @unique
  role      Role     @default(USER)
  createdAt DateTime @default(now())
  
  posts     Post[]
  comments  Comment[]
  profile   Profile?
  
  @@map("users")
}

model Profile {
  id     Int    @id @default(autoincrement())
  userId Int    @unique
  bio    String?
  avatar String?
  
  user   User   @relation(fields: [userId], references: [id], onDelete: Cascade)
  
  @@map("profiles")
}

model Post {
  id        Int      @id @default(autoincrement())
  authorId  Int
  title     String
  content   String
  published Boolean  @default(false)
  createdAt DateTime @default(now())
  
  author    User     @relation(fields: [authorId], references: [id])
  comments  Comment[]
  
  @@map("posts")
  @@index([authorId])
}

model Comment {
  id        Int      @id @default(autoincrement())
  postId    Int
  authorId  Int
  content   String
  createdAt DateTime @default(now())
  
  post      Post     @relation(fields: [postId], references: [id], onDelete: Cascade)
  author    User     @relation(fields: [authorId], references: [id])
  
  @@map("comments")
  @@index([postId, authorId])
}
"#;

// Custom visitor 1: Collect statistics about the schema
#[derive(Default, Debug)]
struct SchemaStats {
    models: usize,
    enums: usize,
    total_fields: usize,
    unique_constraints: usize,
    indexes: usize,
    relations: usize,
    optional_fields: usize,
    array_fields: usize,
}

impl Visitor for SchemaStats {
    fn visit_model(&mut self, model: &ModelDecl) -> Result<()> {
        self.models += 1;
        self.total_fields += model.fields.len();

        // Count indexes
        for attr in &model.attributes {
            if let ModelAttribute::Index { .. } = attr {
                self.indexes += 1
            }
        }

        walk_model(self, model)
    }

    fn visit_enum(&mut self, _enum_decl: &EnumDecl) -> Result<()> {
        self.enums += 1;
        Ok(())
    }

    fn visit_field(&mut self, field: &FieldDecl) -> Result<()> {
        if field.is_optional() {
            self.optional_fields += 1;
        }
        if field.is_array() {
            self.array_fields += 1;
        }

        for attr in &field.attributes {
            match attr {
                FieldAttribute::Unique => self.unique_constraints += 1,
                FieldAttribute::Relation { .. } => self.relations += 1,
                _ => {}
            }
        }

        Ok(())
    }
}

// Custom visitor 2: Build a relationship graph
#[derive(Default)]
struct RelationshipGraph {
    // model_name -> [(related_model, field_name, is_required)]
    relationships: HashMap<String, Vec<(String, String, bool)>>,
}

impl Visitor for RelationshipGraph {
    fn visit_model(&mut self, model: &ModelDecl) -> Result<()> {
        let model_name = model.name.value.clone();

        for field in &model.fields {
            if let FieldType::UserType(related_type) = &field.field_type {
                if field.has_relation_attribute() || field.is_array() {
                    let is_required = !field.is_optional() && !field.is_array();

                    self.relationships
                        .entry(model_name.clone())
                        .or_default()
                        .push((related_type.clone(), field.name.value.clone(), is_required));
                }
            }
        }

        walk_model(self, model)
    }
}

impl RelationshipGraph {
    fn print(&self) {
        println!("🔗 Relationship Graph:");
        for (model, relations) in &self.relationships {
            println!("\n  {} has:", model);
            for (related, field_name, is_required) in relations {
                let cardinality = if *is_required { "one" } else { "zero or more" };
                println!(
                    "    - {} {} via field '{}'",
                    cardinality, related, field_name
                );
            }
        }
    }
}

// Custom visitor 3: Find all default values
#[derive(Default)]
struct DefaultValueCollector {
    // model.field -> default_expr
    defaults: HashMap<String, String>,
}

impl Visitor for DefaultValueCollector {
    fn visit_model(&mut self, model: &ModelDecl) -> Result<()> {
        let model_name = model.name.value.clone();

        for field in &model.fields {
            for attr in &field.attributes {
                if let FieldAttribute::Default(expr, _) = attr {
                    let key = format!("{}.{}", model_name, field.name.value);
                    let value = format!("{:?}", expr);
                    self.defaults.insert(key, value);
                }
            }
        }

        walk_model(self, model)
    }
}

// Custom visitor 4: Validate naming conventions
struct NamingValidator {
    errors: Vec<String>,
}

impl NamingValidator {
    fn new() -> Self {
        Self { errors: Vec::new() }
    }
}

impl Visitor for NamingValidator {
    fn visit_model(&mut self, model: &ModelDecl) -> Result<()> {
        // Models should start with uppercase
        if !model.name.value.chars().next().unwrap().is_uppercase() {
            self.errors.push(format!(
                "Model '{}' should start with uppercase",
                model.name.value
            ));
        }

        walk_model(self, model)
    }

    fn visit_field(&mut self, field: &FieldDecl) -> Result<()> {
        // Fields should start with lowercase
        if !field.name.value.chars().next().unwrap().is_lowercase() {
            self.errors.push(format!(
                "Field '{}' should start with lowercase",
                field.name.value
            ));
        }

        Ok(())
    }

    fn visit_enum(&mut self, enum_decl: &EnumDecl) -> Result<()> {
        // Enums should start with uppercase
        if !enum_decl.name.value.chars().next().unwrap().is_uppercase() {
            self.errors.push(format!(
                "Enum '{}' should start with uppercase",
                enum_decl.name.value
            ));
        }

        // Enum variants should be UPPERCASE
        for variant in &enum_decl.variants {
            if !variant
                .name
                .value
                .chars()
                .all(|c| c.is_uppercase() || c == '_')
            {
                self.errors.push(format!(
                    "Enum variant '{}' should be UPPERCASE",
                    variant.name.value
                ));
            }
        }

        Ok(())
    }
}

// Custom visitor 5: Find model dependencies for migration ordering
#[derive(Default)]
struct MigrationOrderer {
    // Models with their foreign key dependencies
    dependencies: HashMap<String, HashSet<String>>,
}

impl Visitor for MigrationOrderer {
    fn visit_model(&mut self, model: &ModelDecl) -> Result<()> {
        let model_name = model.name.value.clone();
        let mut deps = HashSet::new();

        for field in &model.fields {
            if let FieldType::UserType(related_type) = &field.field_type {
                // Only count as dependency if it's a foreign key (has @relation with fields)
                for attr in &field.attributes {
                    if let FieldAttribute::Relation {
                        fields: Some(_), ..
                    } = attr
                    {
                        deps.insert(related_type.clone());
                    }
                }
            }
        }

        self.dependencies.insert(model_name, deps);
        walk_model(self, model)
    }
}

impl MigrationOrderer {
    fn print(&self) {
        println!("📦 Migration Order (based on foreign key dependencies):");
        println!("  Models should be created in this order:\n");

        let mut remaining: HashSet<_> = self.dependencies.keys().cloned().collect();
        let mut order = Vec::new();

        while !remaining.is_empty() {
            // Find models with no unmet dependencies
            let can_create: Vec<_> = remaining
                .iter()
                .filter(|m| {
                    self.dependencies[*m]
                        .iter()
                        .all(|dep| order.contains(dep) || !remaining.contains(dep))
                })
                .cloned()
                .collect();

            if can_create.is_empty() {
                println!("  ⚠️  Circular dependency detected!");
                break;
            }

            for model in can_create {
                order.push(model.clone());
                remaining.remove(&model);

                let deps_list: Vec<_> = self.dependencies[&model].iter().collect();
                if deps_list.is_empty() {
                    println!("  {}. {} (no dependencies)", order.len(), model);
                } else {
                    println!(
                        "  {}. {} (depends on: {})",
                        order.len(),
                        model,
                        deps_list
                            .iter()
                            .map(|s| s.as_str())
                            .collect::<Vec<_>>()
                            .join(", ")
                    );
                }
            }
        }
    }
}

fn main() -> Result<()> {
    println!("=== Nautilus Schema Visitor Pattern Demo ===\n");

    // Parse the schema
    let mut lexer = Lexer::new(SCHEMA);
    let mut tokens = Vec::new();
    loop {
        let token = lexer.next_token()?;
        if matches!(token.kind, nautilus_schema::TokenKind::Eof) {
            tokens.push(token);
            break;
        }
        tokens.push(token);
    }
    let schema = Parser::new(&tokens, SCHEMA).parse_schema()?;

    println!(
        "Parsed schema with {} declarations\n",
        schema.declarations.len()
    );
    let separator = "=".repeat(60);
    println!("{}", separator);

    // Visitor 1: Collect statistics
    println!("\n1️⃣  Schema Statistics\n");
    let mut stats = SchemaStats::default();
    stats.visit_schema(&schema)?;
    println!("{:#?}", stats);

    println!("\n{}", separator);

    // Visitor 2: Build relationship graph
    println!("\n2️⃣  Relationship Analysis\n");
    let mut graph = RelationshipGraph::default();
    graph.visit_schema(&schema)?;
    graph.print();

    println!("\n{}", separator);

    // Visitor 3: Find default values
    println!("\n3️⃣  Default Values\n");
    let mut defaults = DefaultValueCollector::default();
    defaults.visit_schema(&schema)?;
    for (field, default) in &defaults.defaults {
        println!("  {} = {}", field, default);
    }

    println!("\n{}", separator);

    // Visitor 4: Validate naming conventions
    println!("\n4️⃣  Naming Convention Validation\n");
    let mut validator = NamingValidator::new();
    validator.visit_schema(&schema)?;
    if validator.errors.is_empty() {
        println!("  ✅ All names follow conventions!");
    } else {
        println!("  ⚠️  Found {} naming issues:", validator.errors.len());
        for error in &validator.errors {
            println!("    - {}", error);
        }
    }

    println!("\n{}", separator);

    // Visitor 5: Determine migration order
    println!("\n5️⃣  Migration Planning\n");
    let mut orderer = MigrationOrderer::default();
    orderer.visit_schema(&schema)?;
    orderer.print();

    println!("\n{}", separator);
    println!("\n✅ Visitor demo completed successfully!");

    Ok(())
}