Struct MutationDefinition 

pub struct MutationDefinition {
    pub name: String,
    pub return_type: String,
    pub arguments: Vec<ArgumentDefinition>,
    pub description: Option<String>,
    pub operation: MutationOperation,
    pub deprecation: Option<DeprecationInfo>,
    pub sql_source: Option<String>,
}

A mutation definition compiled from @fraiseql.mutation.

Mutations are declarative bindings to database functions. They describe which function to call, not arbitrary logic.

Example

use fraiseql_core::schema::{MutationDefinition, MutationOperation};

let mutation = MutationDefinition {
    name: "createUser".to_string(),
    return_type: "User".to_string(),
    arguments: vec![],
    description: Some("Create a new user".to_string()),
    operation: MutationOperation::Insert { table: "users".to_string() },
    deprecation: None,
};

Fields

name: String

Mutation name (e.g., “createUser”).

return_type: String

Return type name.

arguments: Vec<ArgumentDefinition>

Input arguments.

description: Option<String>

Description.

operation: MutationOperation

SQL operation type.

deprecation: Option<DeprecationInfo>

Deprecation information (from @deprecated directive). When set, this mutation is marked as deprecated in the schema.

sql_source: Option<String>

PostgreSQL function name to call for this mutation.

When set, the runtime calls SELECT * FROM {sql_source}($1, $2, ...) with the mutation arguments in ArgumentDefinition order, and parses the result as an app.mutation_response composite row.

Implementations

impl MutationDefinition

pub fn new(name: impl Into<String>, return_type: impl Into<String>) -> Self

Create a new mutation definition.

pub fn deprecated(self, reason: Option<String>) -> Self

Mark this mutation as deprecated.

Example

use fraiseql_core::schema::MutationDefinition;

let mutation = MutationDefinition::new("oldCreateUser", "User")
    .deprecated(Some("Use 'createUser' instead".to_string()));
assert!(mutation.is_deprecated());

pub fn is_deprecated(&self) -> bool

Check if this mutation is deprecated.

pub fn deprecation_reason(&self) -> Option<&str>

Get the deprecation reason if deprecated.

Trait Implementations

impl Clone for MutationDefinition

fn clone(&self) -> MutationDefinition

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for MutationDefinition

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for MutationDefinition

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for MutationDefinition

fn eq(&self, other: &MutationDefinition) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for MutationDefinition

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for MutationDefinition