Enum FieldTransform 

pub enum FieldTransform {
    RenameField {
        old_key: String,
        new_key: String,
    },
    DropField {
        key: String,
    },
    AddField {
        key: String,
        value: Value,
    },
    KeepFields {
        keys: Vec<String>,
    },
    ApplyExpr {
        key: String,
        expr: Expr,
        inverse: Option<Expr>,
        coercion_class: CoercionClass,
    },
    PathTransform {
        path: Vec<String>,
        inner: Box<Self>,
    },
    ComputeField {
        target_key: String,
        expr: Expr,
        inverse: Option<Expr>,
        coercion_class: CoercionClass,
    },
    Case {
        branches: Vec<CaseBranch>,
    },
    MapReferences {
        field: String,
        rename_map: HashMap<String, Option<String>>,
    },
}

A value-level transformation on a node’s extra_fields.

These are applied during wtype_restrict after structural operations (anchor remapping, vertex survival). They enable the instance pipeline to handle value-dependent migrations (attribute renames, drops, value transforms) that go beyond pure structural schema changes.

Variants

RenameField

Rename a field key: old_key → new_key.

Fields

old_key: String

The current field name.

new_key: String

The new field name.

DropField

Drop a field by key.

Fields

key: String

The field to remove.

AddField

Add a field with a constant default value.

Fields

key: String

The field name to add.

value: Value

The default value.

KeepFields

Keep only the specified fields (all others are dropped).

Fields

keys: Vec<String>

The field names to retain.

ApplyExpr

Apply an expression to a field’s value, storing the result.

Fields

key: String

The field whose value is transformed.

expr: Expr

The expression to evaluate (receives the field value as input).

inverse: Option<Expr>

Optional inverse expression for round-tripping.

coercion_class: CoercionClass

Round-trip classification of this transformation.

PathTransform

Apply a field transform at a nested path within the Value tree.

The path is a sequence of string keys navigating through nested Value::Unknown (object) structures. The inner transform is applied to the extra_fields map at the resolved path.

This generalizes flat field transforms to operate on the full Value algebra. A PathTransform with an empty path is equivalent to applying the inner transform directly.

Categorically, this is the action of a path functor on the endomorphism algebra of field transforms; it lifts a transform from a leaf to an inner node of the Value tree.

Fields

path: Vec<String>

Path to navigate (e.g., vec!["attrs"] for nested attrs objects).

inner: Box<Self>

The transform to apply at the resolved path.

ComputeField

Compute a field value from an expression with access to the full fiber over the parent vertex.

Unlike ApplyExpr which binds a single field, ComputeField binds all extra_fields, nested attrs, AND scalar values from immediate child nodes (the dependent-sum projection) as variables, evaluates the expression, and stores the result in the target field.

This means ComputeField can access any scalar property of the parent object, whether it was parsed as an extra field or as a schema-defined child vertex (e.g., a string field with a "format" annotation like "at-uri"). Computed results are always written to extra_fields, making them available to subsequent transforms and to to_json serialization (where extra_fields overwrite child values with the same key).

Computed fields are classified by coercion_class:

• Iso: the computation is invertible via inverse; the lens law PutGet holds for modifications to the computed field.
• Opaque: no inverse exists; the complement stores the entire original value. Modifications to the computed field in the view are not independently round-trippable. This is analogous to SQL computed columns: the lens law holds for the independent (non-derived) components of the view, and the derived components are re-computed deterministically.

This enables template name computation like target_key: “name”, expr: (concat "h" (int_to_str attrs.level)) which computes “h1”, “h2”, etc. from the level attribute, as well as AT-URI decomposition where the repo field is a schema-defined child vertex.

Fields

target_key: String

The field to store the computed result in.

expr: Expr

The expression, with all extra_fields bound as variables.

inverse: Option<Expr>

Optional inverse expression for round-tripping.

coercion_class: CoercionClass

Round-trip classification of this transformation.

Case

Case analysis on node values: the coproduct eliminator for the field transform algebra.

Each branch is a (predicate, transforms) pair. Branches are evaluated in order with the node’s extra_fields (and nested attrs.* keys) bound as expression variables. The first branch whose predicate evaluates to true has its transforms applied. If no branch matches, the node passes through unchanged.

This is the dependent function space lift of field transforms: Π(x : Value). FieldTransform, a transform that depends on the runtime value of the node, not just its schema vertex. It composes naturally with all other transform variants (including nesting inside PathTransform).

Use cases:

• matchAttrs: “if level == 1 then rename to h1, if level == 2 then rename to h2”, where each heading level is a branch.
• Conditional attribute injection: “if list == 'ordered' then add type: ol, else add type: ul”.

Fields

branches: Vec<CaseBranch>

Ordered branches: first matching predicate wins.

MapReferences

Update string values that reference vertex names.

When vertices are renamed or dropped during migration, string fields that reference those vertices by name must be updated to reflect the new names. This is the functorial action of the vertex rename map on the name-reference algebra.

For each field value:

• If the value is a Value::Str matching a key in rename_map, it is replaced with the mapped value (or removed if mapped to None).
• If the value is a Value::List, each string element is checked and the list is rebuilt with renames applied and drops removed.

This handles parent reference arrays, cross-annotation links, and any other string fields that carry vertex identity.

Fields

field: String

The field containing references (e.g., “parents”).

rename_map: HashMap<String, Option<String>>

Map from old name to new name (None = remove the reference).

Implementations

impl FieldTransform

pub fn coercion_class(&self) -> CoercionClass

Compute the coercion class of this field transform.

The class describes the round-trip properties: whether the transform is lossless (Iso), has a left inverse (Retraction), is a deterministic derivation (Projection), or has no structural round-trip property (Opaque).

Trait Implementations

impl Clone for FieldTransform

fn clone(&self) -> FieldTransform

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FieldTransform

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for FieldTransform

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for FieldTransform

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

where __S: Serializer,

Serialize this value into the given Serde serializer.