Struct Plan 

pub struct Plan {
    pub steps: Vec<Primitive>,
}

A proposed set of primitives to apply in order.

The plan is the unit of validation for the AI boundary. Individual primitives can look sensible in isolation but fail as a sequence (e.g. add_field twice, or remove_model followed by add_field against the now-gone model). Plan::validate simulates the full sequence against a shadow copy of the target schema and fails fast.

The struct is intentionally tiny. 0.4.0 does not execute plans; it just defines the contract every 0.5.0 executor is built to.

Fields

steps: Vec<Primitive>

Implementations

impl Plan

pub fn new(steps: Vec<Primitive>) -> Self

pub fn is_empty(&self) -> bool

pub fn len(&self) -> usize

pub fn validate(&self, initial: &Schema) -> Result<(), PrimitiveError>

Validate the entire plan against an initial schema state. Every step is first checked structurally, then checked against the shadow-applied schema, then applied to the shadow before the next step is considered.

The shadow is pure in-memory data — no filesystem, no DB. This stays consistent with the 0.4.0 boundary rule: no execution.

Additionally, any step whose primitive returns true from Primitive::is_developer_only is rejected up front. Plans represent the AI boundary; developer-only primitives (currently CreateMigration) are reserved for direct tooling use and must never appear in an AI-emitted plan.

Trait Implementations

impl Clone for Plan

fn clone(&self) -> Plan

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Plan

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

Formats the value using the given formatter.

impl Default for Plan

fn default() -> Plan

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Plan

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Plan

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

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 Plan