Struct IntermediateType 

pub struct IntermediateType {

    pub name: String,
    pub fields: Vec<IntermediateField>,
    pub description: Option<String>,
    pub sql_source: Option<String>,
    pub implements: Vec<String>,
    pub requires_role: Option<String>,
    pub inject_params: IndexMap<String, String>,
    pub is_error: bool,
    pub is_input: bool,
    pub relay: bool,
    pub embedded: bool,
    pub subscribable_tables: Option<Vec<String>>,
    pub subscribable_pre_image: bool,
    pub relationships: Vec<IntermediateRelationship>,
    pub subscription_policy: Option<SubscriptionPolicy>,
}

Type definition in intermediate format

Fields

name: String

Type name (e.g., “User”)

fields: Vec<IntermediateField>

Type fields

description: Option<String>

Type description (from docstring)

sql_source: Option<String>

Type-level SQL source (backing table/view), e.g. v_organization.

Owned types bind their relation on the query that returns them, so this is normally absent. It is emitted by the authoring SDK only for an owner-split extend type … @key federation entity: a subgraph that does not own the entity exposes no root query returning it, so the federation _entities resolver has no query to source the backing relation from and would otherwise guess lower(typename) and resolve to null (#507). When present it flows through to TypeDefinition.sql_source and is used as the _entities fallback relation.

implements: Vec<String>

Interfaces this type implements (GraphQL spec §3.6)

requires_role: Option<String>

Role required to execute any operation returning this type.

Lowered onto every query and mutation whose return_type is this type when the compiled schema loads, so the runtime’s operation-level role gate enforces it — there is no separate type-level check to keep in step (#677). A gated type reachable as a field of a type that is not gated the same way is refused at load: operations returning the container carry no role, so the gated type would travel out ungated.

It also filters the REST /introspection route. It does not filter GraphQL __schema introspection.

inject_params: IndexMap<String, String>

Tenant/owner scoping declared on the type itself (#1142).

The counterpart to sql_source above: a type carrying one is an entity the _entities resolver reaches with no query behind it, so there is no operation to carry inject_params. Before this key, such a type could declare requires_role — honoured from the type since #1030 — but had nowhere to declare tenant scoping, and the compile succeeded with the annotation covering nothing.

Accepts the same two value shapes as the operation-level key (#806) and threads through to TypeDefinition.inject_params, where both _entities consumers read it behind the backing query. A type and its query declaring the same column from different sources is refused when the compiled schema loads.

is_error: bool

Whether this type is a mutation error type (tagged with @fraiseql.error).

is_input: bool

Whether the author declared this a GraphQL input object rather than an output type (is_input: true).

Four SDKs advertise this in their READMEs and emit it — Elixir (fraiseql_type "X", is_input: true), F# ([<GraphQLType(IsInput=…)>]), PHP (#[GraphQLType(isInput: true)]) and C# (GraphQLTypeAttribute.IsInput). There was no field here to receive it, so such a type compiled as an object type: a mutation argument referencing it produced a schema violating GraphQL §3.10 (“arguments must be input types”), which introspection-driven clients reject and federation composition fails on. fraiseql compile and fraiseql lint both exited 0 (#848).

The converter routes a type carrying this into input_types and omits it from types. That is what makes Elixir’s surface work at all: its exporter emits no input_types key whatsoever, so this flag is its only route to an input object.

relay: bool

Whether this type implements the Relay Node interface. When true, the compiler generates global node IDs (base64("TypeName:uuid")) and validates that pk_{entity} (BIGINT) is present in the view’s data JSONB.

embedded: bool

Whether the author declared this an embedded value object (@fraiseql.type(embedded=True), #687).

A value object has no independent identity and is always nested under a parent entity, so the compiler exempts it from cascade entity classification: no id: ID! enforcement, no auto-implements CascadeNode. Threaded verbatim to TypeDefinition.embedded — it is the author’s declaration, not something the compiler infers.

subscribable_tables: Option<Vec<String>>

@subscribable(tables=[...]) — the underlying base table(s) whose external writes should be captured onto the Change Spine (#366).

The compiler aggregates the set of (name, tables) for every type carrying this into CompiledSchema.subscribable, which the generate_capture_trigger_ddl generator turns into per-table capture triggers. None/absent (the default) when the type is not subscribable.

Example

{
  "name": "Post",
  "fields": [],
  "subscribable_tables": ["tb_post"]
}

subscribable_pre_image: bool

@subscribable(..., pre_image=True) — whether the capture triggers on this type’s tables also record the changed entity’s pre-image (OLD) into object_data_before, the out-of-band parity for a mutation’s changelog_pre_image. Only meaningful alongside subscribable_tables; false/absent (the default) captures the after-image only.

relationships: Vec<IntermediateRelationship>

Relationships to other types, the declarations REST resource embedding follows (#1266).

Threaded verbatim to TypeDefinition.relationships. Until this key existed the compiled field had no producer at all: every converter wrote the empty vector and deny_unknown_fields above turned an SDK that emitted the key into a refusal of the whole document — so ?select=posts(id,title), ?select=posts.count, ?posts.status=, the OpenAPI relationship properties and the generated relationships.* client modules were reachable only from a hand-written schema.compiled.json.

A relationship the embed executor could not follow — an undeclared target, a join column no field publishes, a target no list query returns — is refused at compile time and again when the compiled schema loads. That check is the durable half: #1230 was a join key the projection omitted, served as null under a 200.

subscription_policy: Option<SubscriptionPolicy>

Per-row visibility for this type’s subscription deliveries: a subscriber receives a row only when the row’s owner_path field equals its enriched identity_field, unless it holds one of bypass_roles. Threaded verbatim to TypeDefinition.subscription_policy; the owner field must be a single-level field of this type, checked at compile.

Trait Implementations

impl Clone for IntermediateType

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for IntermediateType

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

Formats the value using the given formatter.

impl Default for IntermediateType

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for IntermediateType

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for IntermediateType

impl PartialEq for IntermediateType

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for IntermediateType

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 IntermediateType