toasty 0.11.0

//! Internal types referenced by code generated by `#[derive(Model)]` and the
//! `create!` / `update!` / `query!` macros. Not part of the public API; the
//! contents may change between releases.

#![doc(hidden)]

pub mod auto;
pub mod index;
pub mod newtype;
pub mod shared_column;
pub mod storage;
pub mod version;
pub mod via;

pub use crate::schema::inventory;
pub use crate::{
    Db, Error, Executor, Result, Statement,
    schema::{
        Auto, Deferred, DiscoverItem, Document, Embed, EmbedCreate, Field, Load, Model, QueryMany,
        QueryOne, QueryOptionOne, RelationManyField, RelationOneField, Scalar, Scope, ViaMany,
        ViaManyField, ViaPath, ViaTarget, generate_unique_id,
    },
    stmt::CreateMany,
    stmt::{self, Assign, Expr, IntoExpr, IntoInsert, IntoStatement, List, Path},
    update_target::UpdateTarget,
};
#[cfg(feature = "serde")]
pub use serde_json;
pub use std::{clone::Clone, convert::Into, default::Default, option::Option};

pub use self::version::Version;
pub use toasty_core as core;

/// The expression-level type that a create/update setter accepts for a field
/// of type `F`. This is just [`Field::ExprTarget`], but naming it keeps the
/// long `<F as Field>::ExprTarget` projection out of generated setter
/// signatures (and out of the compiler errors they produce).
pub type FieldExprTarget<F> = <F as Field>::ExprTarget;

/// The field accessor for a singular relation declared as `F`, rooted at
/// `Origin`. Resolves to the target model's fields with the path target from
/// [`RelationOneField::Expr`], preserving optionality for eager and deferred
/// relations.
pub type RelationOnePath<F, Origin> =
    <<F as RelationOneField>::Target as Model>::OneField<Origin, <F as RelationOneField>::Expr>;

/// Internal constructors used by generated model field accessors.
pub trait ModelCodegen: Model {
    /// Construct the field accessor for a singular relation to this model.
    fn new_one_field<Origin, Target>(path: Path<Origin, Target>) -> Self::OneField<Origin, Target>;

    /// Encode referenced fields so the engine can resolve a relation key.
    fn to_relation_expr(&self, fields: &[&str]) -> core::stmt::Expr;
}

/// Infer the [`Scope`] type from a scope expression and return its fields
/// path.
///
/// The `create!` macro uses this in the scoped form (`in expr { ... }`) to
/// obtain the field struct for nested builders. Because the macro has no
/// type information, it cannot call `S::new_path_root()` directly — this function
/// lets Rust infer `S` from the scope argument.
pub fn scope_fields<S: Scope>(_scope: &S) -> S::Path<S::Item> {
    S::new_path_root()
}

/// Create a record inside a scoped create target.
pub fn create_in_scope<S: Scope>(scope: S) -> S::Create {
    S::create_in_scope(scope)
}

/// Convert a value into an untyped [`core::stmt::Expr`] via the typed
/// [`IntoExpr<T>`] trait.
///
/// Generated code (`#[derive(Model)]`, `#[derive(Embed)]`) splices this in
/// instead of inlining the `let expr: Expr<T> = value.into_expr(); expr.into()`
/// pattern at every field site. The explicit `T` type parameter
/// disambiguates which `IntoExpr` impl to use.
pub fn into_untyped_expr<T, V: IntoExpr<T>>(value: V) -> core::stmt::Expr {
    let expr: stmt::Expr<T> = value.into_expr();
    expr.into()
}

/// A value usable as the parent of an embedded relation in a write.
///
/// The trait parameter `F` is the relation field's *declared* type
/// (`M`, `Option<M>`, `Deferred<M>`, or `Deferred<Option<M>>`); the accepted value is the target
/// model itself (by value or reference) or a value of the declared shape.
/// Keying by `F` rather than by the model keeps inference working when the
/// setter receives `Deferred::default()` — the setter signature pins `F`, so
/// the deferred wrapper's inner type resolves uniquely.
///
/// `model_ref` resolves to the parent model when one is present: an unloaded
/// `Deferred` (or a loaded `Deferred<Option<M>>` holding `None`) resolves to
/// `None`, meaning the write has no parent value to take keys from and the
/// explicitly set key fields stand.
pub trait EmbeddedRelationValue<F> {
    type Model;

    fn model_ref(&self) -> Option<&Self::Model>;
}

macro_rules! impl_embedded_relation_value {
    ($field:ty) => {
        impl<M: Model> EmbeddedRelationValue<$field> for M {
            type Model = M;

            fn model_ref(&self) -> Option<&M> {
                Some(self)
            }
        }

        impl<M: Model> EmbeddedRelationValue<$field> for &M {
            type Model = M;

            fn model_ref(&self) -> Option<&M> {
                Some(self)
            }
        }

        impl<M: Model> EmbeddedRelationValue<$field> for &$field {
            type Model = M;

            fn model_ref(&self) -> Option<&M> {
                (*self).model_ref()
            }
        }
    };
}

impl_embedded_relation_value!(Deferred<M>);
impl_embedded_relation_value!(Deferred<Option<M>>);
impl_embedded_relation_value!(Option<M>);

impl<M: Model> EmbeddedRelationValue<M> for M {
    type Model = M;

    fn model_ref(&self) -> Option<&M> {
        Some(self)
    }
}

impl<M: Model> EmbeddedRelationValue<M> for &M {
    type Model = M;

    fn model_ref(&self) -> Option<&M> {
        Some(self)
    }
}

impl<M: Model> EmbeddedRelationValue<Option<M>> for Option<M> {
    type Model = M;

    fn model_ref(&self) -> Option<&M> {
        self.as_ref()
    }
}

impl<M: Model> EmbeddedRelationValue<Deferred<M>> for Deferred<M> {
    type Model = M;

    fn model_ref(&self) -> Option<&M> {
        if self.is_unloaded() {
            None
        } else {
            Some(self.get())
        }
    }
}

impl<M: Model> EmbeddedRelationValue<Deferred<Option<M>>> for Deferred<Option<M>> {
    type Model = M;

    fn model_ref(&self) -> Option<&M> {
        if self.is_unloaded() {
            None
        } else {
            self.get().as_ref()
        }
    }
}

/// Encode a loaded relation's key, leaving unloaded relations unset.
pub fn embedded_relation_value_expr<F, V>(value: &V, fields: &[&str]) -> core::stmt::Expr
where
    V: EmbeddedRelationValue<F>,
    V::Model: ModelCodegen,
{
    value
        .model_ref()
        .map_or_else(core::stmt::Expr::null, |model| {
            model.to_relation_expr(fields)
        })
}

/// Continue a `has_many` traversal from `query` along `path`.
///
/// If `query` was already scoped from a relation traversal, append
/// `field_offset` to that traversal's path so the result remains a single
/// chained association. Otherwise build a fresh `Association::many` rooted
/// at `query`. Used by generated `.field()` chain methods on the per-model
/// `Query<List<Source>>` for `has_many` relations.
pub fn chain_or_build_many<Source, Target>(
    mut query: stmt::Query<List<Source>>,
    field_offset: usize,
    path: stmt::Path<Source, List<Target>>,
) -> stmt::Association<List<Target>>
where
    Source: Model,
    Target: Model,
{
    match query.take_via_assoc() {
        Some(untyped) => stmt::Association::<List<Source>>::from_untyped(untyped)
            .chain_field::<Target>(field_offset),
        None => stmt::Association::many(query, path),
    }
}

/// Continue a `belongs_to` / `has_one` traversal from `query` along `path`.
///
/// Mirrors [`chain_or_build_many`] for singular relation steps: when no
/// existing traversal is present the fresh association is built via
/// [`stmt::Association::many_via_one`].
pub fn chain_or_build_many_via_one<Source, Target>(
    mut query: stmt::Query<List<Source>>,
    field_offset: usize,
    path: stmt::Path<Source, Target>,
) -> stmt::Association<List<Target>>
where
    Source: Model,
    Target: Model,
{
    match query.take_via_assoc() {
        Some(untyped) => stmt::Association::<List<Source>>::from_untyped(untyped)
            .chain_field::<Target>(field_offset),
        None => stmt::Association::many_via_one(query, path),
    }
}