Struct IntermediateField 

pub struct IntermediateField {
    pub name: String,
    pub field_type: String,
    pub nullable: bool,
    pub description: Option<String>,
    pub directives: Option<Vec<IntermediateAppliedDirective>>,
    pub requires_scope: Option<String>,
    pub on_deny: Option<String>,
    pub hierarchy: Option<String>,
}

Field definition in intermediate format

NOTE: Uses type field (not field_type) This is the language-agnostic format. Rust conversion happens in converter.

Fields

name: String

Field name (e.g., “id”)

field_type: String

Field type name (e.g., “Int”, “String”, “User”)

Language-agnostic: All languages use “type”, not “field_type”

nullable: bool

Is field nullable?

description: Option<String>

Field description (from docstring)

directives: Option<Vec<IntermediateAppliedDirective>>

Applied directives (e.g., @deprecated)

requires_scope: Option<String>

Scope required to access this field (field-level access control)

When set, users must have this scope in their JWT to query this field. Supports patterns like “read:Type.field” or custom scopes like “hr:view_pii”.

Example

{
  "name": "salary",
  "type": "Int",
  "nullable": false,
  "requires_scope": "read:Employee.salary"
}

on_deny: Option<String>

Policy when the user lacks requires_scope: "reject" (default) or "mask".

hierarchy: Option<String>

Named hierarchy reference for ID-based ltree operators. References a key in the hierarchies config map.

Trait Implementations

impl Clone for IntermediateField

fn clone(&self) -> IntermediateField

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for IntermediateField

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for IntermediateField

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for IntermediateField

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for IntermediateField

impl StructuralPartialEq for IntermediateField