prax-codegen 0.10.0

//! `delete_many!` proc-macro entry point.
//!
//! Lowers `where:` to a non-unique `<Model>WhereInput`, then bridges
//! to the runtime IR via the `WhereInput::into_ir` lowering — the
//! `DeleteManyOperation` builder uses `.r#where(filter)` rather than
//! the typed-input extension method shared by other read operations.

use proc_macro2::{Span, TokenStream};
use quote::quote;
use syn::Token;
use syn::parse::Parser;

use crate::macros::accessor::parse_accessor;
use crate::macros::dsl::ast::{DslBlock, DslField, DslValue};
use crate::macros::lower::LowerCtx;
use crate::macros::lower::where_input::lower_where_input_only;
use crate::macros::schema_resolve::{resolve_schema, resolve_schema_path, track_schema_dep};
use crate::macros::validate::unknown_top_key_error;

const DELETE_MANY_KEYS: &[&str] = &["where"];

pub fn expand_delete_many(input: TokenStream) -> syn::Result<TokenStream> {
    let schema = resolve_schema()?;
    let schema_path = resolve_schema_path()?;
    let dep = track_schema_dep(&schema_path);

    let parser = move |s: syn::parse::ParseStream<'_>| -> syn::Result<TokenStream> {
        let (accessor, model) = parse_accessor(s, &schema)?;
        if s.peek(Token![,]) {
            let _: Token![,] = s.parse()?;
        }
        let block: DslBlock = s.parse()?;
        let ctx = LowerCtx::new(&schema, model);
        lower_delete_many(&accessor, &block, &ctx)
    };
    let body = Parser::parse2(parser, input)?;
    Ok(quote! {
        {
            #dep
            #body
        }
    })
}

fn lower_delete_many(
    accessor: &crate::macros::accessor::AccessorSpec,
    block: &DslBlock,
    ctx: &LowerCtx<'_>,
) -> syn::Result<TokenStream> {
    let mut where_tokens: Option<TokenStream> = None;

    for field in &block.fields {
        let DslField::Pair { key, value, .. } = field else {
            return Err(syn::Error::new(
                Span::call_site(),
                "`delete_many!` does not accept spread or conditional fields at the top level",
            ));
        };
        let key_str = key.to_string();
        match key_str.as_str() {
            "where" => {
                let DslValue::Block(b) = value else {
                    return Err(syn::Error::new(key.span(), "`where:` expects `{ ... }`"));
                };
                where_tokens = Some(lower_where_input_only(b, ctx)?);
            }
            _ => {
                return Err(unknown_top_key_error(
                    &key_str,
                    key.span(),
                    DELETE_MANY_KEYS,
                    "delete_many",
                ));
            }
        }
    }

    let accessor_expr = &accessor.accessor_expr;
    // Bridge to the runtime IR: `DeleteManyOperation` doesn't have a
    // `with_where_input` extension method, so call `into_ir()`
    // explicitly and feed the resulting `Filter` to `.r#where(...)`.
    let where_call = if let Some(w) = where_tokens {
        quote! {
            .r#where(
                <_ as ::prax_query::inputs::WhereInput>::into_ir(#w)
            )
        }
    } else {
        quote! {}
    };

    Ok(quote! {
        (#accessor_expr).delete_many() #where_call
    })
}