dbml_language_server/analysis/

parser.rs

// src/analysis/parser.rs
use super::token::{Token};
use crate::ast::*;
use chumsky::prelude::*;

type ParseError = Simple<Token>;

#[derive(Debug, Clone)]
#[allow(dead_code)]
pub enum Error {
    LexError(Simple<char>),
    ParseError(Simple<Token>),
}

pub fn parser() -> impl Parser<Token, Document, Error = ParseError> + Clone {
    let ident = select! {
        Token::Identifier(s) => s,
    }
    .map_with_span(|name, span| Ident { name, span });

    let string_lit = select! {
        Token::StringLiteral(s) => s,
    }
    .map_with_span(|value, span| StringLiteral { value, span });

    // Relationship type parser (used in both inline refs and standalone refs)
    let rel_type = choice((
        just(Token::Minus).to(RelationshipType::OneToOne),
        just(Token::Lt).to(RelationshipType::OneToMany),
        just(Token::Gt).to(RelationshipType::ManyToOne),
        just(Token::LtGt).to(RelationshipType::ManyToMany),
    ));

    // Referential action parser (for delete/update actions)
    let ref_action = choice((
        just(Token::Cascade).to(ReferentialAction::Cascade),
        just(Token::Restrict).to(ReferentialAction::Restrict),
        just(Token::NoAction).to(ReferentialAction::NoAction),
        just(Token::SetNull).to(ReferentialAction::SetNull),
        just(Token::SetDefault).to(ReferentialAction::SetDefault),
    ));

    // Inline reference parser (for column settings)
    let inline_ref = just(Token::Ref)
        .ignore_then(just(Token::Colon))
        .ignore_then(rel_type.clone())
        .then(ident.clone())
        .then_ignore(just(Token::Dot))
        .then(ident.clone())
        .map_with_span(|((relationship, target_table), target_column), span| {
            InlineRef {
                target_table,
                target_column,
                relationship,
                span,
            }
        });

    // Column settings
    let column_setting = choice((
        just(Token::Pk).to(ColumnSetting::PrimaryKey),
        just(Token::NotNull).to(ColumnSetting::NotNull),
        just(Token::Null).to(ColumnSetting::Null),
        just(Token::Unique).to(ColumnSetting::Unique),
        just(Token::Increment).to(ColumnSetting::Increment),
        just(Token::Default)
            .ignore_then(just(Token::Colon))
            .ignore_then(select! {
                Token::StringLiteral(s) => DefaultValue::String(s),
                Token::NumericLiteral(n) => DefaultValue::Number(n),
                Token::BoolLiteral(b) => DefaultValue::Boolean(b),
            })
            .map(ColumnSetting::Default),
        just(Token::Note)
            .ignore_then(just(Token::Colon))
            .ignore_then(string_lit.clone())
            .map(ColumnSetting::Note),
        inline_ref.clone().map(ColumnSetting::Ref),
    ));

    // Column definition
    let column_type = select! { Token::Identifier(s) => s }
        .then(
            // Optional type parameter like varchar(50)
            just(Token::LParen)
                .ignore_then(select! { Token::NumericLiteral(n) => n })
                .then_ignore(just(Token::RParen))
                .or_not()
        )
        .map(|(base_type, param)| match param {
            Some(p) => format!("{}({})", base_type, p),
            None => base_type,
        })
        .map_with_span(|type_str, span| (type_str, span));
    
    let column = ident
        .clone()
        .then(column_type)
        .then(
            column_setting
                .separated_by(just(Token::Comma))
                .allow_trailing()
                .delimited_by(just(Token::LBracket), just(Token::RBracket))
                .or_not()
                .map(|opt| opt.unwrap_or_default()),
        )
        .map_with_span(|((name, (col_type, col_type_span)), settings), span| Column {
            name,
            col_type,
            col_type_span,
            settings,
            span,
        });

    // Index definition
    let index_column = ident.clone().map(IndexColumn::Simple);

    let index_setting = choice((
        just(Token::Pk).to(IndexSetting::PrimaryKey),
        just(Token::Unique).to(IndexSetting::Unique),
    ));

    let index = just(Token::LParen)
        .ignore_then(index_column.separated_by(just(Token::Comma)))
        .then_ignore(just(Token::RParen))
        .then(
            index_setting
                .separated_by(just(Token::Comma))
                .allow_trailing()
                .delimited_by(just(Token::LBracket), just(Token::RBracket))
                .or_not()
                .map(|opt| opt.unwrap_or_default()),
        )
        .map_with_span(|(columns, settings), span| Index {
            columns,
            settings,
            span,
        });

    let indexes_block = just(Token::Indexes)
        .ignore_then(
            index
                .repeated()
                .at_least(1)
                .delimited_by(just(Token::LBrace), just(Token::RBrace)),
        )
        .map_with_span(|indexes, span| IndexesBlock { indexes, span });

    // Table items
    let table_item = column
        .map(TableItem::Column)
        .or(indexes_block.map(TableItem::Indexes))
        .or(just(Token::Note)
            .ignore_then(just(Token::Colon))
            .ignore_then(string_lit.clone())
            .map(TableItem::Note));

    // Table definition
    let table = just(Token::Table)
        .then(ident.clone())
        .then(just(Token::As).ignore_then(ident.clone()).or_not())
        .then(
            table_item
                .repeated()
                .delimited_by(just(Token::LBrace), just(Token::RBrace)),
        )
        .map_with_span(|(((_table_token, name), alias), items), span| Table {
            name,
            schema: None,
            alias,
            items,
            settings: vec![],
            span,
        });

    // Reference definition
    // Reference settings parser: [delete: action, update: action]
    let delete_setting = just(Token::Delete)
        .ignore_then(just(Token::Colon))
        .ignore_then(ref_action.clone())
        .map(|action| ("delete", action));
    
    let update_setting = just(Token::Update)
        .ignore_then(just(Token::Colon))
        .ignore_then(ref_action.clone())
        .map(|action| ("update", action));

    let ref_settings_block = delete_setting
        .or(update_setting)
        .separated_by(just(Token::Comma))
        .at_least(1)
        .delimited_by(just(Token::LBracket), just(Token::RBracket))
        .map(|settings: Vec<(&str, ReferentialAction)>| {
            let mut on_delete = None;
            let mut on_update = None;
            for (key, action) in settings {
                match key {
                    "delete" => on_delete = Some(action),
                    "update" => on_update = Some(action),
                    _ => {}
                }
            }
            (on_delete, on_update)
        });

    let ref_def = just(Token::Ref)
        .ignore_then(ident.clone().or_not())
        .then_ignore(just(Token::Colon))
        .then(ident.clone())
        .then_ignore(just(Token::Dot))
        .then(ident.clone())
        .then(rel_type.clone())
        .then(ident.clone())
        .then_ignore(just(Token::Dot))
        .then(ident.clone())
        .then(ref_settings_block.or_not())
        .map_with_span(
            |((((((name, from_table), from_col), relationship), to_table), to_col), settings), span| {
                let (on_delete, on_update) = settings.unwrap_or((None, None));
                Ref {
                    name,
                    from_table,
                    from_columns: vec![from_col],
                    to_table,
                    to_columns: vec![to_col],
                    relationship,
                    on_delete,
                    on_update,
                    span,
                }
            },
        );

    // Enum definition
    let enum_member = ident
        .clone()
        .then(
            just(Token::LBracket)
                .ignore_then(just(Token::Note))
                .ignore_then(just(Token::Colon))
                .ignore_then(string_lit.clone())
                .then_ignore(just(Token::RBracket))
                .or_not(),
        )
        .map_with_span(|(name, note), span| EnumMember { name, note, span });

    let enum_def = just(Token::Enum)
        .ignore_then(ident.clone())
        .then(
            enum_member
                .repeated()
                .at_least(1)
                .delimited_by(just(Token::LBrace), just(Token::RBrace)),
        )
        .map_with_span(|(name, members), span| Enum {
            name,
            members,
            span,
        });

    // Project definition
    let project_setting = just(Token::Note)
        .ignore_then(just(Token::Colon))
        .ignore_then(string_lit.clone())
        .map(|note| crate::ast::ProjectSetting::Note(note))
        .or(ident.clone()
            .then_ignore(just(Token::Colon))
            .then(string_lit.clone())
            .map(|(key, value)| {
                if key.name.to_lowercase() == "database_type" {
                    crate::ast::ProjectSetting::DatabaseType(value.value)
                } else {
                    // For other settings, store as database_type for now
                    // In a full implementation, you'd have a generic setting type
                    crate::ast::ProjectSetting::DatabaseType(format!("{}: {}", key.name, value.value))
                }
            })
        );

    let project = just(Token::Project)
        .ignore_then(ident.clone().or_not())
        .then(
            project_setting
                .repeated()
                .delimited_by(just(Token::LBrace), just(Token::RBrace)),
        )
        .map_with_span(|(name, settings), span| Project {
            name,
            settings,
            span,
        });

    // Document
    let document_item = table
        .map(DocumentItem::Table)
        .or(ref_def.map(DocumentItem::Ref))
        .or(enum_def.map(DocumentItem::Enum))
        .or(project.map(DocumentItem::Project));

    document_item
        .repeated()
        .then_ignore(end())
        .map_with_span(|items, span| Document { items, span })
}

pub fn parse(src: &str) -> Result<Document, Vec<Error>> {
    use super::lexer::lexer;
    use chumsky::Stream;

    let tokens = lexer().parse(src).map_err(|errs| {
        errs.into_iter().map(Error::LexError).collect::<Vec<_>>()
    })?;
    
    // Create a stream of (Token, Span) tuples
    let token_spans: Vec<(Token, Span)> = tokens
        .iter()
        .map(|st| (st.token.clone(), st.span.clone()))
        .collect();
    
    let len = src.len();
    let stream = Stream::from_iter(len..len+1, token_spans.into_iter());

    parser().parse(stream).map_err(|errs| {
        errs.into_iter().map(Error::ParseError).collect::<Vec<_>>()
    })
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_parse_table() {
        let input = r#"
            Table users {
                id int [pk]
                name varchar
            }
        "#;
        let result = parse(input);
        assert!(result.is_ok());
    }

    #[test]
    fn test_parse_enum() {
        let input = r#"
            Enum status {
                active
                inactive
            }
        "#;
        let result = parse(input);
        assert!(result.is_ok());
    }
}