Enum Primitive 

#[non_exhaustive]
pub enum Primitive {
    AddModel(AddModel),
    RemoveModel(RemoveModel),
    RenameModel(RenameModel),
    AddField(AddField),
    RemoveField(RemoveField),
    RenameField(RenameField),
    ChangeFieldType(ChangeFieldType),
    ChangeFieldNullability(ChangeFieldNullability),
    AddRelation(AddRelation),
    RemoveRelation(RemoveRelation),
    UpdateAdmin(UpdateAdmin),
    CreateMigration(CreateMigration),
}

The complete set of operations the AI layer is allowed to perform on a RustIO project.

Marked #[non_exhaustive] so new primitives can land in a minor release without breaking external matchers. Consumers must include a wildcard arm and treat unknown variants as “refuse” rather than guess.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

AddModel(AddModel)

RemoveModel(RemoveModel)

RenameModel(RenameModel)

AddField(AddField)

RemoveField(RemoveField)

RenameField(RenameField)

ChangeFieldType(ChangeFieldType)

ChangeFieldNullability(ChangeFieldNullability)

AddRelation(AddRelation)

RemoveRelation(RemoveRelation)

UpdateAdmin(UpdateAdmin)

CreateMigration(CreateMigration)

Attach a raw SQL migration. Developer-only — this primitive bypasses the AI boundary’s “no free-form code” rule and is rejected by Plan::validate. Project maintainers can still emit migrations through this type directly; the AI executor must not.

Implementations

impl Primitive

pub fn is_developer_only(&self) -> bool

true if this primitive is permitted only from developer / tooling code, not from any AI-emitted Plan.

Today, only Primitive::CreateMigration qualifies: it accepts arbitrary SQL, which violates the AI boundary rule that every change must be expressible as a structured primitive. Plan::validate rejects any step for which this returns true.

Kept as a method (not a const) so future variants can opt in explicitly.

pub fn op_name(&self) -> &'static str

Stable short name of this variant, suitable for error messages. Matches the serde tag so callers can cross-reference the wire format.

Trait Implementations

impl Clone for Primitive

fn clone(&self) -> Primitive

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Primitive

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Primitive

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Primitive

fn eq(&self, other: &Primitive) -> 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 Primitive

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 Primitive