Struct CompiledSchema 

pub struct CompiledSchema {

    pub types: Vec<TypeDefinition>,
    pub enums: Vec<EnumDefinition>,
    pub input_types: Vec<InputObjectDefinition>,
    pub interfaces: Vec<InterfaceDefinition>,
    pub unions: Vec<UnionDefinition>,
    pub queries: Vec<QueryDefinition>,
    pub mutations: Vec<MutationDefinition>,
    pub subscriptions: Vec<SubscriptionDefinition>,
    pub directives: Vec<DirectiveDefinition>,
    pub fact_tables: HashMap<String, Value>,
    pub observers: Vec<ObserverDefinition>,
    pub federation: Option<Value>,
    pub security: Option<Value>,
    pub observers_config: Option<Value>,
    pub schema_sdl: Option<String>,
    pub custom_scalars: CustomTypeRegistry,
}

Complete compiled schema - all type information for serving.

This is the central type that holds the entire GraphQL schema after compilation from Python/TypeScript decorators.

Example

use fraiseql_core::schema::CompiledSchema;

let json = r#"{
    "types": [],
    "queries": [],
    "mutations": [],
    "subscriptions": []
}"#;

let schema = CompiledSchema::from_json(json).unwrap();
assert_eq!(schema.types.len(), 0);

Fields

types: Vec<TypeDefinition>

GraphQL object type definitions.

enums: Vec<EnumDefinition>

GraphQL enum type definitions.

input_types: Vec<InputObjectDefinition>

GraphQL input object type definitions.

interfaces: Vec<InterfaceDefinition>

GraphQL interface type definitions.

unions: Vec<UnionDefinition>

GraphQL union type definitions.

queries: Vec<QueryDefinition>

GraphQL query definitions.

mutations: Vec<MutationDefinition>

GraphQL mutation definitions.

subscriptions: Vec<SubscriptionDefinition>

GraphQL subscription definitions.

directives: Vec<DirectiveDefinition>

Custom directive definitions. These are user-defined directives beyond the built-in @skip, @include, @deprecated.

fact_tables: HashMap<String, Value>

Fact table metadata (for analytics queries). Key: table name (e.g., tf_sales)

observers: Vec<ObserverDefinition>

Observer definitions (database change event listeners).

federation: Option<Value>

Federation metadata for Apollo Federation v2 support.

security: Option<Value>

Security configuration (from fraiseql.toml).

observers_config: Option<Value>

Observers/event system configuration (from fraiseql.toml).

Contains backend connection settings (redis_url, nats_url, etc.) and event handler definitions compiled from the [observers] TOML section.

schema_sdl: Option<String>

Raw GraphQL schema as string (for SDL generation).

custom_scalars: CustomTypeRegistry

Custom scalar type registry.

Contains definitions for custom scalar types defined in the schema. Built during code generation from IRScalar definitions. Not serialized - populated at runtime from ir.scalars.

Implementations

impl CompiledSchema

pub fn new() -> Self

Create empty schema.

pub fn from_json(json: &str) -> Result<Self, Error>

Deserialize from JSON string.

This is the primary way to create a schema from Python/TypeScript. The authoring language compiles to JSON, Rust deserializes and owns it.

Errors

Returns error if JSON is malformed or doesn’t match schema structure.

Example

use fraiseql_core::schema::CompiledSchema;

let json = r#"{"types": [], "queries": [], "mutations": [], "subscriptions": []}"#;
let schema = CompiledSchema::from_json(json).unwrap();

pub fn to_json(&self) -> Result<String, Error>

Serialize to JSON string.

Errors

Returns error if serialization fails (should not happen for valid schema).

pub fn to_json_pretty(&self) -> Result<String, Error>

Serialize to pretty JSON string (for debugging/config files).

Errors

Returns error if serialization fails.

pub fn find_type(&self, name: &str) -> Option<&TypeDefinition>

Find a type definition by name.

pub fn find_enum(&self, name: &str) -> Option<&EnumDefinition>

Find an enum definition by name.

pub fn find_input_type(&self, name: &str) -> Option<&InputObjectDefinition>

Find an input object definition by name.

pub fn find_interface(&self, name: &str) -> Option<&InterfaceDefinition>

Find an interface definition by name.

pub fn find_implementors(&self, interface_name: &str) -> Vec<&TypeDefinition>

Find all types that implement a given interface.

pub fn find_union(&self, name: &str) -> Option<&UnionDefinition>

Find a union definition by name.

pub fn find_query(&self, name: &str) -> Option<&QueryDefinition>

Find a query definition by name.

pub fn find_mutation(&self, name: &str) -> Option<&MutationDefinition>

Find a mutation definition by name.

pub fn find_subscription(&self, name: &str) -> Option<&SubscriptionDefinition>

Find a subscription definition by name.

pub fn find_directive(&self, name: &str) -> Option<&DirectiveDefinition>

Find a custom directive definition by name.

pub fn operation_count(&self) -> usize

Get total number of operations (queries + mutations + subscriptions).

pub fn add_fact_table(&mut self, table_name: String, metadata: Value)

Register fact table metadata.

Arguments

• table_name - Fact table name (e.g., tf_sales)
• metadata - Serialized FactTableMetadata

pub fn get_fact_table(&self, name: &str) -> Option<&Value>

Get fact table metadata by name.

Arguments

• name - Fact table name

Returns

Fact table metadata if found

pub fn list_fact_tables(&self) -> Vec<&str>

List all fact table names.

Returns

Vector of fact table names

pub fn has_fact_tables(&self) -> bool

Check if schema contains any fact tables.

pub fn find_observer(&self, name: &str) -> Option<&ObserverDefinition>

Find an observer definition by name.

pub fn find_observers_for_entity( &self, entity: &str, ) -> Vec<&ObserverDefinition>

Get all observers for a specific entity type.

pub fn find_observers_for_event(&self, event: &str) -> Vec<&ObserverDefinition>

Get all observers for a specific event type (INSERT, UPDATE, DELETE).

pub fn has_observers(&self) -> bool

Check if schema contains any observers.

pub fn observer_count(&self) -> usize

Get total number of observers.

pub fn federation_metadata(&self) -> Option<FederationMetadata>

Get federation metadata from schema.

Returns

Federation metadata if configured in schema

pub fn security_config(&self) -> Option<SecurityConfig>

Get security configuration from schema.

Returns

Security configuration if present (includes role definitions)

pub fn find_role(&self, role_name: &str) -> Option<RoleDefinition>

Find a role definition by name.

Arguments

• role_name - Name of the role to find

Returns

Role definition if found

pub fn get_role_scopes(&self, role_name: &str) -> Vec<String>

Get scopes for a role.

Arguments

• role_name - Name of the role

Returns

Vector of scopes granted to the role

pub fn role_has_scope(&self, role_name: &str, scope: &str) -> bool

Check if a role has a specific scope.

Arguments

• role_name - Name of the role
• scope - Scope to check for

Returns

true if role has the scope, false otherwise

pub fn raw_schema(&self) -> String

Get raw GraphQL schema SDL.

Returns

Raw schema string if available, otherwise generates from type definitions

pub fn validate(&self) -> Result<(), Vec<String>>

Validate the schema for internal consistency.

Checks:

• All type references resolve to defined types
• No duplicate type/operation names
• Required fields have valid types

Errors

Returns list of validation errors if schema is invalid.

Trait Implementations

impl Clone for CompiledSchema

fn clone(&self) -> CompiledSchema

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CompiledSchema

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

Formats the value using the given formatter.

impl Default for CompiledSchema

fn default() -> CompiledSchema

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for CompiledSchema

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for CompiledSchema

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.