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>,
    pub inject_params: IndexMap<String, InjectedParamSource>,
    pub invalidates_fact_tables: Vec<String>,
    pub invalidates_views: Vec<String>,
    pub rest_path: Option<String>,
    pub rest_method: Option<String>,
    pub upsert_function: 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::new("createUser", "User");

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.

inject_params: IndexMap<String, InjectedParamSource>

Server-side parameters injected from JWT claims at runtime.

Keys are SQL parameter names. Values describe where to source the runtime value. These params are NOT exposed as GraphQL arguments.

For mutations: injected params are appended to the positional function call args after client-provided arguments, in map insertion order. The SQL function signature must declare the injected parameters last.

Works on PostgreSQL, SQL Server, and MySQL. SQLite has no stored-routine mechanism and will return an error if inject is configured on a mutation.

invalidates_fact_tables: Vec<String>

Fact tables whose version counter should be bumped after this mutation succeeds.

When the mutation PostgreSQL function returns successfully, the runtime calls SELECT bump_tf_version($1) for each listed table, incrementing the version used in fact-table cache keys. This ensures that analytic/aggregate queries backed by FactTableVersionStrategy::VersionTable are automatically invalidated.

Each entry must be a valid SQL identifier validated at compile time.

Example

@fraiseql.mutation(
    sql_source="fn_create_order",
    invalidates_fact_tables=["tf_sales", "tf_order_count"],
)
def create_order(amount: Decimal) -> Order: ...

invalidates_views: Vec<String>

View names whose cached query results should be invalidated after this mutation succeeds.

When the CachedDatabaseAdapter is active, the runtime calls invalidate_views() with these names, clearing all cache entries that read from the specified views.

If empty and the mutation return type has a sql_source, the runtime infers the primary view from the return type.

Each entry must be a valid SQL identifier validated at compile time.

rest_path: Option<String>

Custom REST path override (e.g., "/users/{id}").

rest_method: Option<String>

REST HTTP method override (e.g., "POST", "PUT", "PATCH").

upsert_function: Option<String>

PostgreSQL upsert function name for PUT semantics (insert-or-update).

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 const 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