From 02195fa91cb6bae51d55ddae1809a7ec1c7ef771 Mon Sep 17 00:00:00 2001
From: Panagiotis <panagiotiskaratakis@gmail.com>
Date: Mon, 18 Nov 2024 12:53:07 +0200
Subject: [PATCH 1/4] feat: Add `StaticConfig` and `RuntimeConfig` types

---
 src/core/blueprint/cors.rs                    |   6 +-
 src/core/blueprint/server.rs                  |   8 +-
 src/core/blueprint/telemetry.rs               |  14 +-
 src/core/config/config.rs                     |   9 -
 src/core/config/config_module.rs              |  25 +-
 src/core/config/directives/link.rs            |  26 +-
 src/core/config/directives/server.rs          |  52 +--
 src/core/config/directives/telemetry.rs       |  80 +---
 src/core/config/directives/upstream.rs        |  28 +-
 src/core/config/mod.rs                        |  16 +-
 src/core/config/runtime_config/mod.rs         |   8 +
 .../config/runtime_config/runtime_config.rs   |   7 +
 .../config/runtime_config/server_runtime.rs   | 248 ++++++++++++
 .../server_runtime/auth_runtime.rs            | 169 ++++++++
 .../server_runtime/cors_runtime.rs            | 245 +++++++++++
 .../runtime_config/telemetry_runtime.rs       | 128 ++++++
 .../config/runtime_config/upstream_runtime.rs | 104 +++++
 src/core/config/static_config/link.rs         |  79 ++++
 src/core/config/static_config/mod.rs          |  10 +
 .../config/static_config/server_static.rs     | 382 ++++++++++++++++++
 .../server_static/cors_static.rs}             |   3 +-
 .../server_static/headers_static.rs}          |  19 +-
 .../server_static}/key_values.rs              |   0
 .../server_static/routes_static.rs            |  29 ++
 .../config/static_config/static_config.rs     |  87 ++++
 .../config/static_config/telemetry_static.rs  | 221 ++++++++++
 .../telemetry_static/apollo_static.rs}        |  17 +-
 .../telemetry_static}/reader_context.rs       |   0
 .../config/static_config/upstream_static.rs   | 260 ++++++++++++
 .../static_config/upstream_static/batch.rs    |  38 ++
 src/core/config/utils/encoding.rs             |  10 +
 src/core/config/utils/mod.rs                  |   6 +
 src/core/config/utils/private_key.rs          |  24 ++
 src/core/config/utils/source.rs               |  89 ++++
 34 files changed, 2202 insertions(+), 245 deletions(-)
 create mode 100644 src/core/config/runtime_config/mod.rs
 create mode 100644 src/core/config/runtime_config/runtime_config.rs
 create mode 100644 src/core/config/runtime_config/server_runtime.rs
 create mode 100644 src/core/config/runtime_config/server_runtime/auth_runtime.rs
 create mode 100644 src/core/config/runtime_config/server_runtime/cors_runtime.rs
 create mode 100644 src/core/config/runtime_config/telemetry_runtime.rs
 create mode 100644 src/core/config/runtime_config/upstream_runtime.rs
 create mode 100644 src/core/config/static_config/link.rs
 create mode 100644 src/core/config/static_config/mod.rs
 create mode 100644 src/core/config/static_config/server_static.rs
 rename src/core/config/{cors.rs => static_config/server_static/cors_static.rs} (98%)
 rename src/core/config/{headers.rs => static_config/server_static/headers_static.rs} (75%)
 rename src/core/config/{ => static_config/server_static}/key_values.rs (100%)
 create mode 100644 src/core/config/static_config/server_static/routes_static.rs
 create mode 100644 src/core/config/static_config/static_config.rs
 create mode 100644 src/core/config/static_config/telemetry_static.rs
 rename src/core/config/{apollo.rs => static_config/telemetry_static/apollo_static.rs} (83%)
 rename src/core/config/{ => static_config/telemetry_static}/reader_context.rs (100%)
 create mode 100644 src/core/config/static_config/upstream_static.rs
 create mode 100644 src/core/config/static_config/upstream_static/batch.rs
 create mode 100644 src/core/config/utils/encoding.rs
 create mode 100644 src/core/config/utils/mod.rs
 create mode 100644 src/core/config/utils/private_key.rs
 create mode 100644 src/core/config/utils/source.rs

diff --git a/src/core/blueprint/cors.rs b/src/core/blueprint/cors.rs
index b871d1905e..c73aa11ff4 100644
--- a/src/core/blueprint/cors.rs
+++ b/src/core/blueprint/cors.rs
@@ -6,7 +6,7 @@ use http::header::{HeaderName, HeaderValue};
 use http::request::Parts;
 use tailcall_valid::ValidationError;
 
-use crate::core::config;
+use crate::core::config::cors_static::CorsStatic;
 
 #[derive(Clone, Debug, Setters, Default)]
 pub struct Cors {
@@ -161,10 +161,10 @@ fn to_validation_err<T: Display>(err: T) -> ValidationError<String> {
     ValidationError::new(err.to_string())
 }
 
-impl TryFrom<config::cors::Cors> for Cors {
+impl TryFrom<CorsStatic> for Cors {
     type Error = ValidationError<String>;
 
-    fn try_from(value: config::cors::Cors) -> Result<Self, ValidationError<String>> {
+    fn try_from(value: CorsStatic) -> Result<Self, ValidationError<String>> {
         let cors = Cors {
             allow_credentials: value.allow_credentials.unwrap_or_default(),
             allow_headers: (!value.allow_headers.is_empty()).then_some(
diff --git a/src/core/blueprint/server.rs b/src/core/blueprint/server.rs
index e8e0f54acd..0d2a34a151 100644
--- a/src/core/blueprint/server.rs
+++ b/src/core/blueprint/server.rs
@@ -9,8 +9,8 @@ use rustls_pki_types::CertificateDer;
 use tailcall_valid::{Valid, ValidationError, Validator};
 
 use super::Auth;
-use crate::core::blueprint::Cors;
-use crate::core::config::{self, ConfigModule, HttpVersion, PrivateKey, Routes};
+use crate::core::config::cors_static::CorsStatic;
+use crate::core::config::{self, ConfigModule, CorsRuntime, HttpVersion, PrivateKey, Routes};
 
 #[derive(Clone, Debug, Setters)]
 pub struct Server {
@@ -32,7 +32,7 @@ pub struct Server {
     pub http: Http,
     pub pipeline_flush: bool,
     pub script: Option<Script>,
-    pub cors: Option<Cors>,
+    pub cors: Option<CorsRuntime>,
     pub experimental_headers: HashSet<HeaderName>,
     pub auth: Option<Auth>,
     pub routes: Routes,
@@ -174,7 +174,7 @@ fn to_script(config_module: &crate::core::config::ConfigModule) -> Valid<Option<
     )
 }
 
-fn validate_cors(cors: Option<config::cors::Cors>) -> Valid<Option<Cors>, String> {
+fn validate_cors(cors: Option<CorsStatic>) -> Valid<Option<CorsRuntime>, String> {
     Valid::from(cors.map(|cors| cors.try_into()).transpose())
         .trace("cors")
         .trace("headers")
diff --git a/src/core/blueprint/telemetry.rs b/src/core/blueprint/telemetry.rs
index f7b131c2ec..ac628c3082 100644
--- a/src/core/blueprint/telemetry.rs
+++ b/src/core/blueprint/telemetry.rs
@@ -6,7 +6,7 @@ use url::Url;
 
 use super::TryFoldConfig;
 use crate::core::config::{
-    self, Apollo, ConfigModule, KeyValue, PrometheusExporter, StdoutExporter,
+    self, ApolloTelemetry, ConfigModule, KeyValue, PrometheusExporter, StdoutExporter
 };
 use crate::core::directive::DirectiveCodec;
 use crate::core::try_fold::TryFold;
@@ -22,7 +22,7 @@ pub enum TelemetryExporter {
     Stdout(StdoutExporter),
     Otlp(OtlpExporter),
     Prometheus(PrometheusExporter),
-    Apollo(Apollo),
+    Apollo(ApolloTelemetry),
 }
 
 #[derive(Debug, Default, Clone)]
@@ -54,17 +54,17 @@ pub fn to_opentelemetry<'a>() -> TryFold<'a, ConfigModule, Telemetry, String> {
     TryFoldConfig::<Telemetry>::new(|config, up| {
         if let Some(export) = config.telemetry.export.as_ref() {
             let export = match export {
-                config::TelemetryExporter::Stdout(config) => {
+                config::TelemetryExporterConfig::Stdout(config) => {
                     Valid::succeed(TelemetryExporter::Stdout(config.clone()))
                 }
-                config::TelemetryExporter::Otlp(config) => to_url(&config.url)
+                config::TelemetryExporterConfig::Otlp(config) => to_url(&config.url)
                     .zip(to_headers(config.headers.clone()))
                     .map(|(url, headers)| TelemetryExporter::Otlp(OtlpExporter { url, headers }))
                     .trace("otlp"),
-                config::TelemetryExporter::Prometheus(config) => {
+                config::TelemetryExporterConfig::Prometheus(config) => {
                     Valid::succeed(TelemetryExporter::Prometheus(config.clone()))
                 }
-                config::TelemetryExporter::Apollo(apollo) => validate_apollo(apollo.clone())
+                config::TelemetryExporterConfig::Apollo(apollo) => validate_apollo(apollo.clone())
                     .and_then(|apollo| Valid::succeed(TelemetryExporter::Apollo(apollo))),
             };
 
@@ -80,7 +80,7 @@ pub fn to_opentelemetry<'a>() -> TryFold<'a, ConfigModule, Telemetry, String> {
     })
 }
 
-fn validate_apollo(apollo: Apollo) -> Valid<Apollo, String> {
+fn validate_apollo(apollo: ApolloTelemetry) -> Valid<ApolloTelemetry, String> {
     validate_graph_ref(&apollo.graph_ref)
         .map(|_| apollo)
         .trace("apollo.graph_ref")
diff --git a/src/core/config/config.rs b/src/core/config/config.rs
index 070ec7499b..9692420573 100644
--- a/src/core/config/config.rs
+++ b/src/core/config/config.rs
@@ -679,15 +679,6 @@ impl Config {
     }
 }
 
-#[derive(
-    Clone, Debug, Serialize, Deserialize, PartialEq, Eq, Hash, Default, schemars::JsonSchema,
-)]
-pub enum Encoding {
-    #[default]
-    ApplicationJson,
-    ApplicationXWwwFormUrlencoded,
-}
-
 #[cfg(test)]
 mod tests {
     use pretty_assertions::assert_eq;
diff --git a/src/core/config/config_module.rs b/src/core/config/config_module.rs
index b7c617ca84..c5d01076f5 100644
--- a/src/core/config/config_module.rs
+++ b/src/core/config/config_module.rs
@@ -3,7 +3,7 @@ use std::ops::Deref;
 
 use jsonwebtoken::jwk::JwkSet;
 use prost_reflect::prost_types::{FileDescriptorProto, FileDescriptorSet};
-use rustls_pki_types::{CertificateDer, PrivateKeyDer};
+use rustls_pki_types::CertificateDer;
 use tailcall_valid::{Valid, Validator};
 
 use crate::core::config::Config;
@@ -13,6 +13,8 @@ use crate::core::proto_reader::ProtoMetadata;
 use crate::core::rest::{EndpointSet, Unchecked};
 use crate::core::Transform;
 
+use super::PrivateKey;
+
 mod merge;
 
 /// A wrapper on top of Config that contains all the resolved extensions and
@@ -103,27 +105,6 @@ impl<A> Deref for Content<A> {
     }
 }
 
-#[derive(Debug)]
-pub struct PrivateKey(PrivateKeyDer<'static>);
-
-impl Clone for PrivateKey {
-    fn clone(&self) -> Self {
-        Self(self.0.clone_key())
-    }
-}
-
-impl From<PrivateKeyDer<'static>> for PrivateKey {
-    fn from(value: PrivateKeyDer<'static>) -> Self {
-        Self(value)
-    }
-}
-
-impl PrivateKey {
-    pub fn into_inner(self) -> PrivateKeyDer<'static> {
-        self.0
-    }
-}
-
 /// Extensions are meta-information required before we can generate the
 /// blueprint. Typically, this information cannot be inferred without performing
 /// an IO operation, i.e., reading a file, making an HTTP call, etc.
diff --git a/src/core/config/directives/link.rs b/src/core/config/directives/link.rs
index c9f2a372e0..650c1a08ad 100644
--- a/src/core/config/directives/link.rs
+++ b/src/core/config/directives/link.rs
@@ -1,33 +1,9 @@
 use serde::{Deserialize, Serialize};
 use tailcall_macros::DirectiveDefinition;
 
-use crate::core::config::KeyValue;
+use crate::core::config::{KeyValue, LinkType};
 use crate::core::is_default;
 
-#[derive(
-    Default,
-    Serialize,
-    Deserialize,
-    PartialEq,
-    Eq,
-    Debug,
-    Clone,
-    schemars::JsonSchema,
-    strum_macros::Display,
-)]
-pub enum LinkType {
-    #[default]
-    Config,
-    Protobuf,
-    Script,
-    Cert,
-    Key,
-    Operation,
-    Htpasswd,
-    Jwks,
-    Grpc,
-}
-
 /// The @link directive allows you to import external resources, such as
 /// configuration – which will be merged into the config importing it –,
 /// or a .proto file – which will be later used by `@grpc` directive –.
diff --git a/src/core/config/directives/server.rs b/src/core/config/directives/server.rs
index ec006e2023..768f6c6cf4 100644
--- a/src/core/config/directives/server.rs
+++ b/src/core/config/directives/server.rs
@@ -1,12 +1,9 @@
 use std::collections::{BTreeMap, BTreeSet};
 
-use derive_getters::Getters;
-use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use tailcall_macros::DirectiveDefinition;
 
-use crate::core::config::headers::Headers;
-use crate::core::config::{merge_key_value_vecs, KeyValue};
+use crate::core::config::{merge_key_value_vecs, Headers, HttpVersion, KeyValue, Routes, ScriptOptions};
 use crate::core::is_default;
 use crate::core::macros::MergeRight;
 
@@ -127,58 +124,11 @@ pub struct Server {
     pub routes: Option<Routes>,
 }
 
-#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, MergeRight, JsonSchema, Getters)]
-pub struct Routes {
-    #[serde(default = "default_status")]
-    status: String,
-    #[serde(rename = "graphQL", default = "default_graphql")]
-    graphql: String,
-}
-
-fn default_status() -> String {
-    "/status".into()
-}
-
-fn default_graphql() -> String {
-    "/graphql".into()
-}
-
-impl Default for Routes {
-    fn default() -> Self {
-        Self { status: "/status".into(), graphql: "/graphql".into() }
-    }
-}
-
-impl Routes {
-    pub fn with_status<T: Into<String>>(self, status: T) -> Self {
-        Self { graphql: self.graphql, status: status.into() }
-    }
-
-    pub fn with_graphql<T: Into<String>>(self, graphql: T) -> Self {
-        Self { status: self.status, graphql: graphql.into() }
-    }
-}
-
 fn merge_right_vars(mut left: Vec<KeyValue>, right: Vec<KeyValue>) -> Vec<KeyValue> {
     left = merge_key_value_vecs(&left, &right);
     left
 }
 
-#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, schemars::JsonSchema, MergeRight)]
-#[serde(rename_all = "camelCase")]
-pub struct ScriptOptions {
-    pub timeout: Option<u64>,
-}
-
-#[derive(
-    Deserialize, Serialize, Debug, PartialEq, Eq, Clone, Default, schemars::JsonSchema, MergeRight,
-)]
-pub enum HttpVersion {
-    #[default]
-    HTTP1,
-    HTTP2,
-}
-
 impl Server {
     pub fn enable_apollo_tracing(&self) -> bool {
         self.apollo_tracing.unwrap_or(false)
diff --git a/src/core/config/directives/telemetry.rs b/src/core/config/directives/telemetry.rs
index 108ff2aab3..dd0983dd0d 100644
--- a/src/core/config/directives/telemetry.rs
+++ b/src/core/config/directives/telemetry.rs
@@ -3,70 +3,12 @@ use serde::{Deserialize, Serialize};
 use tailcall_macros::{DirectiveDefinition, InputDefinition};
 use tailcall_valid::Validator;
 
-use crate::core::config::{Apollo, ConfigReaderContext, KeyValue};
+use crate::core::config::{ConfigReaderContext, KeyValue, TelemetryExporterConfig};
 use crate::core::helpers::headers::to_mustache_headers;
 use crate::core::is_default;
-use crate::core::macros::MergeRight;
 use crate::core::merge_right::MergeRight;
 use crate::core::mustache::Mustache;
 
-mod defaults {
-    pub mod prometheus {
-        pub fn path() -> String {
-            "/metrics".to_owned()
-        }
-    }
-}
-
-/// Output the opentelemetry data to the stdout. Mostly used for debug purposes
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, schemars::JsonSchema, MergeRight)]
-#[serde(rename_all = "camelCase")]
-pub struct StdoutExporter {
-    /// Output to stdout in pretty human-readable format
-    #[serde(default, skip_serializing_if = "is_default")]
-    pub pretty: bool,
-}
-
-/// Output the opentelemetry data to otlp collector
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, schemars::JsonSchema, MergeRight)]
-#[serde(rename_all = "camelCase")]
-pub struct OtlpExporter {
-    pub url: String,
-    #[serde(default, skip_serializing_if = "is_default")]
-    pub headers: Vec<KeyValue>,
-}
-
-/// Output format for prometheus data
-#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq, schemars::JsonSchema)]
-#[serde(rename_all = "camelCase")]
-pub enum PrometheusFormat {
-    #[default]
-    Text,
-    Protobuf,
-}
-
-/// Output the telemetry metrics data to prometheus server
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, schemars::JsonSchema)]
-#[serde(rename_all = "camelCase")]
-pub struct PrometheusExporter {
-    #[serde(
-        default = "defaults::prometheus::path",
-        skip_serializing_if = "is_default"
-    )]
-    pub path: String,
-    #[serde(default, skip_serializing_if = "is_default")]
-    pub format: PrometheusFormat,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, schemars::JsonSchema, MergeRight)]
-#[serde(rename_all = "camelCase")]
-pub enum TelemetryExporter {
-    Stdout(StdoutExporter),
-    Otlp(OtlpExporter),
-    Prometheus(PrometheusExporter),
-    Apollo(Apollo),
-}
-
 #[derive(
     Debug,
     Default,
@@ -87,7 +29,7 @@ pub enum TelemetryExporter {
 /// by Tailcall.  By leveraging this directive, developers gain access to
 /// valuable insights into the performance and behavior of their applications.
 pub struct Telemetry {
-    pub export: Option<TelemetryExporter>,
+    pub export: Option<TelemetryExporterConfig>,
     /// The list of headers that will be sent as additional attributes to
     /// telemetry exporters Be careful about **leaking sensitive
     /// information** from requests when enabling the headers that may
@@ -111,7 +53,7 @@ impl Telemetry {
 
     pub fn render_mustache(&mut self, reader_ctx: &ConfigReaderContext) -> Result<()> {
         match &mut self.export {
-            Some(TelemetryExporter::Otlp(otlp)) => {
+            Some(TelemetryExporterConfig::Otlp(otlp)) => {
                 let url_tmpl = Mustache::parse(&otlp.url);
                 otlp.url = url_tmpl.render(reader_ctx);
 
@@ -122,7 +64,7 @@ impl Telemetry {
                     .map(|(key, value)| KeyValue { key, value })
                     .collect();
             }
-            Some(TelemetryExporter::Apollo(apollo)) => apollo.render_mustache(reader_ctx)?,
+            Some(TelemetryExporterConfig::Apollo(apollo)) => apollo.render_mustache(reader_ctx)?,
             _ => {}
         }
 
@@ -132,38 +74,40 @@ impl Telemetry {
 
 #[cfg(test)]
 mod tests {
+    use crate::core::config::{OtlpExporterConfig, PrometheusExporter, PrometheusFormat, StdoutExporter};
+
     use super::*;
 
     #[test]
     fn merge_right() {
         let exporter_none = Telemetry { export: None, ..Default::default() };
         let exporter_stdout = Telemetry {
-            export: Some(TelemetryExporter::Stdout(StdoutExporter { pretty: true })),
+            export: Some(TelemetryExporterConfig::Stdout(StdoutExporter { pretty: true })),
             ..Default::default()
         };
         let exporter_otlp_1 = Telemetry {
-            export: Some(TelemetryExporter::Otlp(OtlpExporter {
+            export: Some(TelemetryExporterConfig::Otlp(OtlpExporterConfig {
                 url: "test-url".to_owned(),
                 headers: vec![KeyValue { key: "header_a".to_owned(), value: "a".to_owned() }],
             })),
             request_headers: vec!["Api-Key-A".to_owned()],
         };
         let exporter_otlp_2 = Telemetry {
-            export: Some(TelemetryExporter::Otlp(OtlpExporter {
+            export: Some(TelemetryExporterConfig::Otlp(OtlpExporterConfig {
                 url: "test-url-2".to_owned(),
                 headers: vec![KeyValue { key: "header_b".to_owned(), value: "b".to_owned() }],
             })),
             request_headers: vec!["Api-Key-B".to_owned()],
         };
         let exporter_prometheus_1 = Telemetry {
-            export: Some(TelemetryExporter::Prometheus(PrometheusExporter {
+            export: Some(TelemetryExporterConfig::Prometheus(PrometheusExporter {
                 path: "/metrics".to_owned(),
                 format: PrometheusFormat::Text,
             })),
             ..Default::default()
         };
         let exporter_prometheus_2 = Telemetry {
-            export: Some(TelemetryExporter::Prometheus(PrometheusExporter {
+            export: Some(TelemetryExporterConfig::Prometheus(PrometheusExporter {
                 path: "/prom".to_owned(),
                 format: PrometheusFormat::Protobuf,
             })),
@@ -198,7 +142,7 @@ mod tests {
         assert_eq!(
             exporter_otlp_1.clone().merge_right(exporter_otlp_2.clone()),
             Telemetry {
-                export: Some(TelemetryExporter::Otlp(OtlpExporter {
+                export: Some(TelemetryExporterConfig::Otlp(OtlpExporterConfig {
                     url: "test-url-2".to_owned(),
                     headers: vec![KeyValue { key: "header_b".to_owned(), value: "b".to_owned() }]
                 })),
diff --git a/src/core/config/directives/upstream.rs b/src/core/config/directives/upstream.rs
index 0beeb99d42..883632447d 100644
--- a/src/core/config/directives/upstream.rs
+++ b/src/core/config/directives/upstream.rs
@@ -4,36 +4,10 @@ use derive_setters::Setters;
 use serde::{Deserialize, Serialize};
 use tailcall_macros::{DirectiveDefinition, InputDefinition};
 
+use crate::core::config::{Batch, Proxy, DEFAULT_MAX_SIZE};
 use crate::core::macros::MergeRight;
 use crate::core::{default_verify_ssl, is_default, verify_ssl_is_default};
 
-const DEFAULT_MAX_SIZE: usize = 100;
-
-#[derive(
-    Serialize, Deserialize, PartialEq, Eq, Clone, Debug, Setters, schemars::JsonSchema, MergeRight,
-)]
-#[serde(rename_all = "camelCase", default)]
-pub struct Batch {
-    pub delay: usize,
-    pub headers: BTreeSet<String>,
-    #[serde(default, skip_serializing_if = "is_default")]
-    pub max_size: Option<usize>,
-}
-impl Default for Batch {
-    fn default() -> Self {
-        Batch {
-            max_size: Some(DEFAULT_MAX_SIZE),
-            delay: 0,
-            headers: BTreeSet::new(),
-        }
-    }
-}
-
-#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug, schemars::JsonSchema, MergeRight)]
-pub struct Proxy {
-    pub url: String,
-}
-
 #[derive(
     Serialize,
     Deserialize,
diff --git a/src/core/config/mod.rs b/src/core/config/mod.rs
index 8236e783ce..8001369473 100644
--- a/src/core/config/mod.rs
+++ b/src/core/config/mod.rs
@@ -1,29 +1,25 @@
-pub use apollo::*;
 pub use config::*;
 pub use config_module::*;
 pub use directive::Directive;
 pub use directives::*;
-pub use key_values::*;
 pub use npo::QueryPath;
-pub use reader_context::*;
 pub use resolver::*;
-pub use source::*;
 pub use url_query::*;
-mod apollo;
 mod config;
 mod config_module;
-pub mod cors;
 mod directive;
 pub mod directives;
 mod from_document;
 pub mod group_by;
-mod headers;
 mod into_document;
-mod key_values;
 mod npo;
 pub mod reader;
-pub mod reader_context;
 mod resolver;
-mod source;
 pub mod transformer;
 mod url_query;
+pub mod utils;
+pub mod static_config;
+pub mod runtime_config;
+pub use utils::*;
+pub use static_config::*;
+pub use runtime_config::*;
diff --git a/src/core/config/runtime_config/mod.rs b/src/core/config/runtime_config/mod.rs
new file mode 100644
index 0000000000..904b5e8aca
--- /dev/null
+++ b/src/core/config/runtime_config/mod.rs
@@ -0,0 +1,8 @@
+pub mod server_runtime;
+pub use server_runtime::*;
+pub mod telemetry_runtime;
+pub use telemetry_runtime::*;
+pub mod upstream_runtime;
+pub use upstream_runtime::*;
+pub mod runtime_config;
+pub use runtime_config::*;
diff --git a/src/core/config/runtime_config/runtime_config.rs b/src/core/config/runtime_config/runtime_config.rs
new file mode 100644
index 0000000000..90ce3ab96b
--- /dev/null
+++ b/src/core/config/runtime_config/runtime_config.rs
@@ -0,0 +1,7 @@
+use super::{ServerRuntime, TelemetryRuntime, UpstreamRuntime};
+
+pub struct RuntimeConfig {
+    pub server: ServerRuntime,
+    pub upstream: UpstreamRuntime,
+    pub telemetry: TelemetryRuntime,
+}
diff --git a/src/core/config/runtime_config/server_runtime.rs b/src/core/config/runtime_config/server_runtime.rs
new file mode 100644
index 0000000000..c6fe945a60
--- /dev/null
+++ b/src/core/config/runtime_config/server_runtime.rs
@@ -0,0 +1,248 @@
+use std::collections::{BTreeMap, BTreeSet, HashSet};
+use std::net::{AddrParseError, IpAddr};
+use std::str::FromStr;
+use std::time::Duration;
+
+use derive_setters::Setters;
+use http::header::{HeaderMap, HeaderName, HeaderValue};
+use rustls_pki_types::CertificateDer;
+use tailcall_valid::{Valid, ValidationError, Validator};
+
+use crate::core::config::cors_static::CorsStatic;
+use crate::core::config::Routes;
+use crate::core::config::{self, ConfigModule, HttpVersion, PrivateKey};
+
+pub mod auth_runtime;
+pub use auth_runtime::*;
+pub mod cors_runtime;
+pub use cors_runtime::*;
+
+#[derive(Clone, Debug, Setters)]
+pub struct ServerRuntime {
+    pub enable_jit: bool,
+    pub enable_apollo_tracing: bool,
+    pub enable_cache_control_header: bool,
+    pub enable_set_cookie_header: bool,
+    pub enable_introspection: bool,
+    pub enable_query_validation: bool,
+    pub enable_response_validation: bool,
+    pub enable_batch_requests: bool,
+    pub enable_showcase: bool,
+    pub global_response_timeout: i64,
+    pub worker: usize,
+    pub port: u16,
+    pub hostname: IpAddr,
+    pub vars: BTreeMap<String, String>,
+    pub response_headers: HeaderMap,
+    pub http: HttpVersionRuntime,
+    pub pipeline_flush: bool,
+    pub script: Option<ScriptRuntime>,
+    pub cors: Option<CorsRuntime>,
+    pub experimental_headers: HashSet<HeaderName>,
+    pub auth: Option<AuthRuntime>,
+    pub routes: Routes,
+}
+
+/// Mimic of mini_v8::Script that's wasm compatible
+#[derive(Clone, Debug)]
+pub struct ScriptRuntime {
+    pub source: String,
+    pub timeout: Option<Duration>,
+}
+
+#[derive(Clone, Debug)]
+pub enum HttpVersionRuntime {
+    HTTP1,
+    HTTP2 {
+        cert: Vec<CertificateDer<'static>>,
+        key: PrivateKey,
+    },
+}
+
+impl Default for ServerRuntime {
+    fn default() -> Self {
+        // NOTE: Using unwrap because try_from default will never fail
+        ServerRuntime::try_from(ConfigModule::default()).unwrap()
+    }
+}
+
+impl ServerRuntime {
+    pub fn get_enable_http_validation(&self) -> bool {
+        self.enable_response_validation
+    }
+    pub fn get_enable_cache_control(&self) -> bool {
+        self.enable_cache_control_header
+    }
+
+    pub fn get_enable_introspection(&self) -> bool {
+        self.enable_introspection
+    }
+
+    pub fn get_enable_query_validation(&self) -> bool {
+        self.enable_query_validation
+    }
+
+    pub fn get_experimental_headers(&self) -> HashSet<HeaderName> {
+        self.experimental_headers.clone()
+    }
+}
+
+impl TryFrom<crate::core::config::ConfigModule> for ServerRuntime {
+    type Error = ValidationError<String>;
+
+    fn try_from(config_module: config::ConfigModule) -> Result<Self, Self::Error> {
+        let config_server = config_module.server.clone();
+
+        let http_server = match config_server.clone().get_version() {
+            HttpVersion::HTTP2 => {
+                if config_module.extensions().cert.is_empty() {
+                    return Valid::fail("Certificate is required for HTTP2".to_string())
+                        .to_result();
+                }
+
+                let cert = config_module.extensions().cert.clone();
+
+                let key = config_module
+                    .extensions()
+                    .keys
+                    .first()
+                    .ok_or_else(|| ValidationError::new("Key is required for HTTP2".to_string()))?
+                    .clone();
+
+                Valid::succeed(HttpVersionRuntime::HTTP2 { cert, key })
+            }
+            _ => Valid::succeed(HttpVersionRuntime::HTTP1),
+        };
+
+        validate_hostname((config_server).get_hostname().to_lowercase())
+            .fuse(http_server)
+            .fuse(handle_response_headers(
+                (config_server).get_response_headers(),
+            ))
+            .fuse(to_script(&config_module))
+            .fuse(handle_experimental_headers(
+                (config_server).get_experimental_headers(),
+            ))
+            .fuse(validate_cors(
+                config_server
+                    .headers
+                    .as_ref()
+                    .and_then(|headers| headers.get_cors()),
+            ))
+            .fuse(AuthRuntime::make(&config_module))
+            .map(
+                |(hostname, http, response_headers, script, experimental_headers, cors, auth)| {
+                    ServerRuntime {
+                        enable_jit: (config_server).enable_jit(),
+                        enable_apollo_tracing: (config_server).enable_apollo_tracing(),
+                        enable_cache_control_header: (config_server).enable_cache_control(),
+                        enable_set_cookie_header: (config_server).enable_set_cookies(),
+                        enable_introspection: (config_server).enable_introspection(),
+                        enable_query_validation: (config_server).enable_query_validation(),
+                        enable_response_validation: (config_server).enable_http_validation(),
+                        enable_batch_requests: (config_server).enable_batch_requests(),
+                        enable_showcase: (config_server).enable_showcase(),
+                        experimental_headers,
+                        global_response_timeout: (config_server).get_global_response_timeout(),
+                        http,
+                        worker: (config_server).get_workers(),
+                        port: (config_server).get_port(),
+                        hostname,
+                        vars: (config_server).get_vars(),
+                        pipeline_flush: (config_server).get_pipeline_flush(),
+                        response_headers,
+                        script,
+                        cors,
+                        auth,
+                        routes: config_server.get_routes(),
+                    }
+                },
+            )
+            .to_result()
+    }
+}
+
+fn to_script(config_module: &crate::core::config::ConfigModule) -> Valid<Option<ScriptRuntime>, String> {
+    config_module.extensions().script.as_ref().map_or_else(
+        || Valid::succeed(None),
+        |script| {
+            Valid::succeed(Some(ScriptRuntime {
+                source: script.clone(),
+                timeout: config_module
+                    .server
+                    .script
+                    .clone()
+                    .map_or_else(|| None, |script| script.timeout)
+                    .map(Duration::from_millis),
+            }))
+        },
+    )
+}
+
+fn validate_cors(cors: Option<CorsStatic>) -> Valid<Option<CorsRuntime>, String> {
+    Valid::from(cors.map(|cors| cors.try_into()).transpose())
+}
+
+fn validate_hostname(hostname: String) -> Valid<IpAddr, String> {
+    if hostname == "localhost" {
+        Valid::succeed(IpAddr::from([127, 0, 0, 1]))
+    } else {
+        Valid::from(hostname.parse().map_err(|e: AddrParseError| {
+            ValidationError::new(format!("Parsing failed because of {}", e))
+        }))
+        .trace("hostname")
+        .trace("@server")
+        .trace("schema")
+    }
+}
+
+fn handle_response_headers(resp_headers: Vec<(String, String)>) -> Valid<HeaderMap, String> {
+    Valid::from_iter(resp_headers.iter(), |(k, v)| {
+        let name = Valid::from(
+            HeaderName::from_bytes(k.as_bytes())
+                .map_err(|e| ValidationError::new(format!("Parsing failed because of {}", e))),
+        );
+        let value = Valid::from(
+            HeaderValue::from_str(v.as_str())
+                .map_err(|e| ValidationError::new(format!("Parsing failed because of {}", e))),
+        );
+        name.zip(value)
+    })
+    .map(|headers| headers.into_iter().collect::<HeaderMap>())
+    .trace("custom")
+    .trace("headers")
+    .trace("@server")
+    .trace("schema")
+}
+
+fn handle_experimental_headers(headers: BTreeSet<String>) -> Valid<HashSet<HeaderName>, String> {
+    Valid::from_iter(headers.iter(), |h| {
+        if !h.to_lowercase().starts_with("x-") {
+            Valid::fail(
+                format!(
+                    "Experimental headers must start with 'x-' or 'X-'. Got: '{}'",
+                    h
+                )
+                .to_string(),
+            )
+        } else {
+            Valid::from(HeaderName::from_str(h).map_err(|e| ValidationError::new(e.to_string())))
+        }
+    })
+    .map(HashSet::from_iter)
+    .trace("experimental")
+    .trace("headers")
+    .trace("@server")
+    .trace("schema")
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::core::config::ConfigModule;
+
+    #[test]
+    fn test_try_from_default() {
+        let actual = super::ServerRuntime::try_from(ConfigModule::default());
+        assert!(actual.is_ok())
+    }
+}
diff --git a/src/core/config/runtime_config/server_runtime/auth_runtime.rs b/src/core/config/runtime_config/server_runtime/auth_runtime.rs
new file mode 100644
index 0000000000..988f47c2f3
--- /dev/null
+++ b/src/core/config/runtime_config/server_runtime/auth_runtime.rs
@@ -0,0 +1,169 @@
+use std::collections::HashSet;
+use std::fmt::Debug;
+
+use jsonwebtoken::jwk::JwkSet;
+use tailcall_valid::Valid;
+
+use crate::core::config::ConfigModule;
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum AuthRuntime {
+    Provider(AuthProviderRuntime),
+    And(Box<AuthRuntime>, Box<AuthRuntime>),
+    Or(Box<AuthRuntime>, Box<AuthRuntime>),
+}
+
+impl AuthRuntime {
+    pub fn make(config_module: &ConfigModule) -> Valid<Option<AuthRuntime>, String> {
+        let htpasswd = config_module.extensions().htpasswd.iter().map(|htpasswd| {
+            AuthRuntime::Provider(AuthProviderRuntime::Basic(BasicRuntime {
+                htpasswd: htpasswd.content.clone(),
+            }))
+        });
+
+        let jwks = config_module.extensions().jwks.iter().map(|jwks| {
+            AuthRuntime::Provider(AuthProviderRuntime::Jwt(JwtRuntime {
+                jwks: jwks.content.clone(),
+                // TODO: read those options from link instead of using defaults
+                issuer: Default::default(),
+                audiences: Default::default(),
+                optional_kid: Default::default(),
+            }))
+        });
+
+        let auth = htpasswd.chain(jwks).reduce(|left, right| left.or(right));
+
+        Valid::succeed(auth)
+    }
+
+    pub fn and(self, other: Self) -> Self {
+        AuthRuntime::And(Box::new(self), Box::new(other))
+    }
+
+    pub fn or(self, other: Self) -> Self {
+        AuthRuntime::Or(Box::new(self), Box::new(other))
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct BasicRuntime {
+    pub htpasswd: String,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct JwtRuntime {
+    pub issuer: Option<String>,
+    pub audiences: HashSet<String>,
+    pub optional_kid: bool,
+    pub jwks: JwkSet,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum AuthProviderRuntime {
+    Basic(BasicRuntime),
+    Jwt(JwtRuntime),
+}
+
+#[cfg(test)]
+mod tests {
+    use once_cell::sync::Lazy;
+
+    use super::*;
+
+    pub static JWK_SET: Lazy<JwkSet> = Lazy::new(|| {
+        let value = serde_json::json!({
+          "keys": [
+            {
+              "kty": "RSA",
+              "use": "sig",
+              "alg": "RS256",
+              "kid": "I48qMJp566SSKQogYXYtHBo9q6ZcEKHixNPeNoxV1c8",
+              "n": "ksMb5oMlhJ_HzAebCuBG6-v5Qc4J111ur7Aux6-8SbxzqFONsf2Bw6ATG8pAfNeZ-USA3_T1mGkYTDvfoggXnxsduWV_lePZKKOq_Qp_EDdzic1bVTJQDad3CXldR3wV6UFDtMx6cCLXxPZM5n76e7ybPt0iNgwoGpJE28emMZJXrnEUFzxwFMq61UlzWEumYqW3uOUVp7r5XAF5jQ_1nQAnpHBnRFzdNPVb3E6odMGu3jgp8mkPbPMP16Fund4LVplLz8yrsE9TdVrSdYJThylRWn_BwvJ0DjUcp8ibJya86iClUlixAmBwR9NdStHwQqHwmMXMKkTXo-ytRmSUobzxX9T8ESkij6iBhQpmDMD3FbkK30Y7pUVEBBOyDfNcWOhholjOj9CRrxu9to5rc2wvufe24VlbKb9wngS_uGfK4AYvVyrcjdYMFkdqw-Mft14HwzdO2BTS0TeMDZuLmYhj_bu5_g2Zu6PH5OpIXF6Fi8_679pCG8wWAcFQrFrM0eA70wD_SqD_BXn6pWRpFXlcRy_7PWTZ3QmC7ycQFR6Wc6Px44y1xDUoq3rH0RlZkeicfvP6FRlpjFU7xF6LjAfd9ciYBZfJll6PE7zf-i_ZXEslv-tJ5-30-I4Slwj0tDrZ2Z54OgAg07AIwAiI5o4y-0vmuhUscNpfZsGAGhE",
+              "e": "AQAB"
+            },
+            {
+              "kty": "RSA",
+              "n": "u1SU1LfVLPHCozMxH2Mo4lgOEePzNm0tRgeLezV6ffAt0gunVTLw7onLRnrq0_IzW7yWR7QkrmBL7jTKEn5u-qKhbwKfBstIs-bMY2Zkp18gnTxKLxoS2tFczGkPLPgizskuemMghRniWaoLcyehkd3qqGElvW_VDL5AaWTg0nLVkjRo9z-40RQzuVaE8AkAFmxZzow3x-VJYKdjykkJ0iT9wCS0DRTXu269V264Vf_3jvredZiKRkgwlL9xNAwxXFg0x_XFw005UWVRIkdgcKWTjpBP2dPwVZ4WWC-9aGVd-Gyn1o0CLelf4rEjGoXbAAEgAqeGUxrcIlbjXfbcmw",
+              "e": "AQAB",
+              "alg": "RS256"
+            }
+          ]
+        });
+
+        serde_json::from_value(value).unwrap()
+    });
+
+    impl JwtRuntime {
+        fn test_value() -> Self {
+            Self {
+                issuer: Default::default(),
+                audiences: Default::default(),
+                optional_kid: false,
+                jwks: JWK_SET.clone(),
+            }
+        }
+    }
+
+    fn test_basic_provider_1() -> AuthProviderRuntime {
+        AuthProviderRuntime::Basic(BasicRuntime { htpasswd: "1".into() })
+    }
+
+    fn test_basic_provider_2() -> AuthProviderRuntime {
+        AuthProviderRuntime::Basic(BasicRuntime { htpasswd: "2".into() })
+    }
+
+    fn test_jwt_provider() -> AuthProviderRuntime {
+        AuthProviderRuntime::Jwt(JwtRuntime::test_value())
+    }
+
+    #[test]
+    fn and_basic_with_basic() {
+        let basic_provider_1 = test_basic_provider_1();
+        let basic_provider_2 = test_basic_provider_2();
+
+        assert_eq!(
+            AuthRuntime::Provider(basic_provider_1.clone()).and(AuthRuntime::Provider(basic_provider_2.clone())),
+            AuthRuntime::And(
+                AuthRuntime::Provider(basic_provider_1).into(),
+                AuthRuntime::Provider(basic_provider_2).into()
+            )
+        );
+    }
+
+    #[test]
+    fn and_basic_with_jwt() {
+        let basic_provider = test_basic_provider_1();
+        let jwt_provider = test_jwt_provider();
+
+        assert_eq!(
+            AuthRuntime::Provider(basic_provider.clone()).and(AuthRuntime::Provider(jwt_provider.clone())),
+            AuthRuntime::And(
+                AuthRuntime::Provider(basic_provider).into(),
+                AuthRuntime::Provider(jwt_provider).into()
+            )
+        );
+    }
+
+    #[test]
+    fn and_nested_and_with_jwt() {
+        let basic_provider_1 = test_basic_provider_1();
+        let basic_provider_2 = test_basic_provider_2();
+        let jwt_provider = test_jwt_provider();
+
+        assert_eq!(
+            AuthRuntime::And(
+                AuthRuntime::Provider(basic_provider_1.clone()).into(),
+                AuthRuntime::Provider(basic_provider_2.clone()).into()
+            )
+            .and(AuthRuntime::Provider(jwt_provider.clone())),
+            AuthRuntime::And(
+                AuthRuntime::And(
+                    AuthRuntime::Provider(basic_provider_1).into(),
+                    AuthRuntime::Provider(basic_provider_2).into()
+                )
+                .into(),
+                AuthRuntime::Provider(jwt_provider).into()
+            )
+        );
+    }
+}
diff --git a/src/core/config/runtime_config/server_runtime/cors_runtime.rs b/src/core/config/runtime_config/server_runtime/cors_runtime.rs
new file mode 100644
index 0000000000..156356adc7
--- /dev/null
+++ b/src/core/config/runtime_config/server_runtime/cors_runtime.rs
@@ -0,0 +1,245 @@
+use std::fmt::Display;
+
+use derive_setters::Setters;
+use http::header;
+use http::header::{HeaderName, HeaderValue};
+use http::request::Parts;
+use tailcall_valid::ValidationError;
+
+use crate::core::config::cors_static::CorsStatic;
+
+#[derive(Clone, Debug, Setters, Default)]
+pub struct CorsRuntime {
+    pub allow_credentials: bool,
+    pub allow_headers: Option<HeaderValue>,
+    pub allow_methods: Option<HeaderValue>,
+    pub allow_origins: Vec<HeaderValue>,
+    pub allow_private_network: bool,
+    pub expose_headers: Option<HeaderValue>,
+    pub max_age: Option<HeaderValue>,
+    pub vary: Vec<HeaderValue>,
+}
+
+impl CorsRuntime {
+    pub fn allow_origin_to_header(
+        &self,
+        origin: Option<&HeaderValue>,
+    ) -> Option<(HeaderName, HeaderValue)> {
+        if self.allow_origins.iter().any(is_wildcard) {
+            Some((header::ACCESS_CONTROL_ALLOW_ORIGIN, origin.cloned()?))
+        } else {
+            let allow_origin = origin.filter(|o| self.allow_origins.contains(o))?.clone();
+            Some((header::ACCESS_CONTROL_ALLOW_ORIGIN, allow_origin))
+        }
+    }
+
+    pub fn allow_credentials_to_header(&self) -> Option<(HeaderName, HeaderValue)> {
+        self.allow_credentials.then(|| {
+            (
+                header::ACCESS_CONTROL_ALLOW_CREDENTIALS,
+                HeaderValue::from_static("true"),
+            )
+        })
+    }
+
+    pub fn allow_private_network_to_header(
+        &self,
+        parts: &Parts,
+    ) -> Option<(HeaderName, HeaderValue)> {
+        #[allow(clippy::declare_interior_mutable_const)]
+        const REQUEST_PRIVATE_NETWORK: HeaderName =
+            HeaderName::from_static("access-control-request-private-network");
+
+        #[allow(clippy::declare_interior_mutable_const)]
+        const ALLOW_PRIVATE_NETWORK: HeaderName =
+            HeaderName::from_static("access-control-allow-private-network");
+
+        #[allow(clippy::declare_interior_mutable_const)]
+        const TRUE: HeaderValue = HeaderValue::from_static("true");
+
+        if !self.allow_private_network {
+            return None;
+        }
+
+        // Access-Control-Allow-Private-Network is only relevant if the request
+        // has the Access-Control-Request-Private-Network header set, else skip
+        #[allow(clippy::borrow_interior_mutable_const)]
+        if parts.headers.get(REQUEST_PRIVATE_NETWORK) != Some(&TRUE) {
+            return None;
+        }
+
+        self.allow_private_network
+            .then_some((ALLOW_PRIVATE_NETWORK, TRUE))
+    }
+
+    pub fn allow_methods_to_header(&self) -> Option<(HeaderName, HeaderValue)> {
+        Some((
+            header::ACCESS_CONTROL_ALLOW_METHODS,
+            self.allow_methods.clone()?,
+        ))
+    }
+
+    pub fn allow_headers_to_header(&self) -> Option<(HeaderName, HeaderValue)> {
+        Some((
+            header::ACCESS_CONTROL_ALLOW_HEADERS,
+            self.allow_headers.clone()?,
+        ))
+    }
+
+    pub fn max_age_to_header(&self) -> Option<(HeaderName, HeaderValue)> {
+        Some((
+            header::ACCESS_CONTROL_MAX_AGE,
+            self.max_age.as_ref()?.clone(),
+        ))
+    }
+
+    pub fn expose_headers_to_header(&self) -> Option<(HeaderName, HeaderValue)> {
+        Some((
+            header::ACCESS_CONTROL_EXPOSE_HEADERS,
+            self.expose_headers.as_ref()?.clone(),
+        ))
+    }
+
+    pub fn vary_to_header(&self) -> Option<(HeaderName, HeaderValue)> {
+        let values = &self.vary;
+        let mut res = values.first()?.as_bytes().to_owned();
+        for val in &values[1..] {
+            res.extend_from_slice(b", ");
+            res.extend_from_slice(val.as_bytes());
+        }
+
+        let header_val = HeaderValue::from_bytes(&res).ok()?;
+        Some((header::VARY, header_val))
+    }
+
+    #[allow(clippy::borrow_interior_mutable_const)]
+    pub fn expose_headers_is_wildcard(&self) -> bool {
+        matches!(&self.expose_headers, Some(v) if v == WILDCARD)
+    }
+}
+
+fn ensure_usable_cors_rules(layer: &CorsRuntime) -> Result<(), ValidationError<String>> {
+    if layer.allow_credentials {
+        let allowing_all_headers = layer
+            .allow_headers
+            .as_ref()
+            .filter(|val| is_wildcard(val))
+            .is_some();
+
+        if allowing_all_headers {
+            Err(ValidationError::new("Invalid CORS configuration: Cannot combine `Access-Control-Allow-Credentials: true` \
+                with `Access-Control-Allow-Headers: *`".into()))?
+        }
+
+        let allowing_all_methods = layer
+            .allow_methods
+            .as_ref()
+            .filter(|val| is_wildcard(val))
+            .is_some();
+
+        if allowing_all_methods {
+            Err(ValidationError::new("Invalid CORS configuration: Cannot combine `Access-Control-Allow-Credentials: true` \
+                with `Access-Control-Allow-Methods: *`".into()))?
+        }
+
+        let allowing_all_origins = layer.allow_origins.iter().any(is_wildcard);
+
+        if allowing_all_origins {
+            Err(ValidationError::new("Invalid CORS configuration: Cannot combine `Access-Control-Allow-Credentials: true` \
+             with `Access-Control-Allow-Origin: *`".into()))?
+        }
+
+        if layer.expose_headers_is_wildcard() {
+            Err(ValidationError::new("Invalid CORS configuration: Cannot combine `Access-Control-Allow-Credentials: true` \
+             with `Access-Control-Expose-Headers: *`".into()))?
+        }
+    }
+    Ok(())
+}
+
+fn to_validation_err<T: Display>(err: T) -> ValidationError<String> {
+    ValidationError::new(err.to_string())
+}
+
+impl TryFrom<CorsStatic> for CorsRuntime {
+    type Error = ValidationError<String>;
+
+    fn try_from(value: CorsStatic) -> Result<Self, ValidationError<String>> {
+        let cors = CorsRuntime {
+            allow_credentials: value.allow_credentials.unwrap_or_default(),
+            allow_headers: (!value.allow_headers.is_empty()).then_some(
+                value
+                    .allow_headers
+                    .join(", ")
+                    .parse()
+                    .map_err(to_validation_err)?,
+            ),
+            allow_methods: {
+                Some(if value.allow_methods.is_empty() {
+                    "*".parse().map_err(to_validation_err)?
+                } else {
+                    value
+                        .allow_methods
+                        .into_iter()
+                        .map(|val| val.to_string())
+                        .collect::<Vec<String>>()
+                        .join(", ")
+                        .parse()
+                        .map_err(to_validation_err)?
+                })
+            },
+            allow_origins: value
+                .allow_origins
+                .into_iter()
+                .map(|val| val.parse().map_err(to_validation_err))
+                .collect::<Result<_, ValidationError<String>>>()?,
+            allow_private_network: value.allow_private_network.unwrap_or_default(),
+            expose_headers: Some(
+                value
+                    .expose_headers
+                    .join(", ")
+                    .parse()
+                    .map_err(to_validation_err)?,
+            ),
+            max_age: value.max_age.map(|val| val.into()),
+            vary: value
+                .vary
+                .iter()
+                .map(|val| val.parse().map_err(to_validation_err))
+                .collect::<Result<_, ValidationError<String>>>()?,
+        };
+        ensure_usable_cors_rules(&cors)?;
+        Ok(cors)
+    }
+}
+
+#[allow(clippy::declare_interior_mutable_const)]
+const WILDCARD: HeaderValue = HeaderValue::from_static("*");
+
+#[allow(clippy::borrow_interior_mutable_const)]
+pub fn is_wildcard(header_value: &HeaderValue) -> bool {
+    header_value == WILDCARD
+}
+
+#[cfg(test)]
+mod tests {
+    use http::header::HeaderValue;
+
+    use super::*;
+
+    #[test]
+    fn test_allow_origin_to_header() {
+        let cors = CorsRuntime {
+            allow_origins: vec![HeaderValue::from_static("https://example.com")],
+            ..std::default::Default::default()
+        };
+        let origin = Some(HeaderValue::from_static("https://example.com"));
+        assert_eq!(
+            cors.allow_origin_to_header(origin.as_ref()),
+            Some((
+                header::ACCESS_CONTROL_ALLOW_ORIGIN,
+                HeaderValue::from_static("https://example.com")
+            ))
+        );
+    }
+}
diff --git a/src/core/config/runtime_config/telemetry_runtime.rs b/src/core/config/runtime_config/telemetry_runtime.rs
new file mode 100644
index 0000000000..19ec1185a1
--- /dev/null
+++ b/src/core/config/runtime_config/telemetry_runtime.rs
@@ -0,0 +1,128 @@
+use std::str::FromStr;
+
+use http::header::{HeaderMap, HeaderName, HeaderValue};
+use tailcall_valid::{Valid, ValidationError, Validator};
+use url::Url;
+
+use crate::core::blueprint::TryFoldConfig;
+use crate::core::config::{
+    ApolloTelemetry, ConfigModule, KeyValue, PrometheusExporter, StdoutExporter,
+    TelemetryExporterConfig,
+};
+use crate::core::try_fold::TryFold;
+
+#[derive(Debug, Default, Clone)]
+pub struct TelemetryRuntime {
+    pub export: Option<TelemetryExporterRuntime>,
+    pub request_headers: Vec<String>,
+}
+
+#[derive(Debug, Clone)]
+pub struct OtlpExporterRuntime {
+    pub url: Url,
+    pub headers: HeaderMap,
+}
+
+#[derive(Debug, Clone)]
+pub enum TelemetryExporterRuntime {
+    Stdout(StdoutExporter),
+    Otlp(OtlpExporterRuntime),
+    Prometheus(PrometheusExporter),
+    Apollo(ApolloTelemetry),
+}
+
+fn to_url(url: &str) -> Valid<Url, String> {
+    Valid::from(Url::parse(url).map_err(|e| ValidationError::new(e.to_string()))).trace("url")
+}
+
+fn to_headers(headers: Vec<KeyValue>) -> Valid<HeaderMap, String> {
+    Valid::from_iter(headers.iter(), |key_value| {
+        Valid::from(
+            HeaderName::from_str(&key_value.key)
+                .map_err(|err| ValidationError::new(err.to_string())),
+        )
+        .zip(Valid::from(
+            HeaderValue::from_str(&key_value.value)
+                .map_err(|err| ValidationError::new(err.to_string())),
+        ))
+    })
+    .map(HeaderMap::from_iter)
+    .trace("headers")
+}
+
+pub fn to_opentelemetry<'a>() -> TryFold<'a, ConfigModule, TelemetryRuntime, String> {
+    TryFoldConfig::<TelemetryRuntime>::new(|config, up| {
+        if let Some(export) = config.telemetry.export.as_ref() {
+            let export = match export {
+                TelemetryExporterConfig::Stdout(config) => {
+                    Valid::succeed(TelemetryExporterRuntime::Stdout(config.clone()))
+                }
+                TelemetryExporterConfig::Otlp(config) => to_url(&config.url)
+                    .zip(to_headers(config.headers.clone()))
+                    .map(|(url, headers)| {
+                        TelemetryExporterRuntime::Otlp(OtlpExporterRuntime { url, headers })
+                    })
+                    .trace("otlp"),
+                TelemetryExporterConfig::Prometheus(config) => {
+                    Valid::succeed(TelemetryExporterRuntime::Prometheus(config.clone()))
+                }
+                TelemetryExporterConfig::Apollo(apollo) => validate_apollo(apollo.clone())
+                    .and_then(|apollo| Valid::succeed(TelemetryExporterRuntime::Apollo(apollo))),
+            };
+
+            export.map(|export| TelemetryRuntime {
+                export: Some(export),
+                request_headers: config.telemetry.request_headers.clone(),
+            })
+        } else {
+            Valid::succeed(up)
+        }
+    })
+}
+
+fn validate_apollo(apollo: ApolloTelemetry) -> Valid<ApolloTelemetry, String> {
+    validate_graph_ref(&apollo.graph_ref)
+        .map(|_| apollo)
+        .trace("apollo.graph_ref")
+}
+
+fn validate_graph_ref(graph_ref: &str) -> Valid<(), String> {
+    let is_valid = regex::Regex::new(r"^[A-Za-z0-9-_]+@[A-Za-z0-9-_]+$")
+        .unwrap()
+        .is_match(graph_ref);
+    if is_valid {
+        Valid::succeed(())
+    } else {
+        Valid::fail(format!("`graph_ref` should be in the format <graph_id>@<variant> where `graph_id` and `variant` can only contain letters, numbers, '-' and '_'. Found {graph_ref}").to_string())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use tailcall_valid::Valid;
+
+    use super::validate_graph_ref;
+
+    #[test]
+    fn test_validate_graph_ref() {
+        let success = || Valid::succeed(());
+        let failure = |graph_ref| {
+            Valid::fail(format!("`graph_ref` should be in the format <graph_id>@<variant> where `graph_id` and `variant` can only contain letters, numbers, '-' and '_'. Found {graph_ref}").to_string())
+        };
+
+        assert_eq!(validate_graph_ref("graph_id@variant"), success());
+        assert_eq!(
+            validate_graph_ref("gr@ph_id@variant"),
+            failure("gr@ph_id@variant")
+        );
+        assert_eq!(validate_graph_ref("graph-Id@variant"), success());
+        assert_eq!(
+            validate_graph_ref("graph$id@variant1"),
+            failure("graph$id@variant1")
+        );
+        assert_eq!(
+            validate_graph_ref("gr@ph_id@variant"),
+            failure("gr@ph_id@variant")
+        );
+    }
+}
diff --git a/src/core/config/runtime_config/upstream_runtime.rs b/src/core/config/runtime_config/upstream_runtime.rs
new file mode 100644
index 0000000000..c89f95c7e1
--- /dev/null
+++ b/src/core/config/runtime_config/upstream_runtime.rs
@@ -0,0 +1,104 @@
+use std::collections::BTreeSet;
+
+use derive_setters::Setters;
+use tailcall_valid::{Valid, ValidationError, Validator};
+
+use crate::core::config::{Batch, ConfigModule, Proxy, UpstreamStatic};
+
+#[derive(PartialEq, Eq, Clone, Debug, Setters, schemars::JsonSchema)]
+pub struct UpstreamRuntime {
+    pub pool_idle_timeout: u64,
+    pub pool_max_idle_per_host: usize,
+    pub keep_alive_interval: u64,
+    pub keep_alive_timeout: u64,
+    pub keep_alive_while_idle: bool,
+    pub proxy: Option<Proxy>,
+    pub connect_timeout: u64,
+    pub timeout: u64,
+    pub tcp_keep_alive: u64,
+    pub user_agent: String,
+    pub allowed_headers: BTreeSet<String>,
+    pub http_cache: u64,
+    pub batch: Option<Batch>,
+    pub http2_only: bool,
+    pub on_request: Option<String>,
+    pub verify_ssl: bool,
+}
+
+impl UpstreamRuntime {
+    /// If the delay is set to 0, then batching is disabled. By default delay is
+    /// set to 0.
+    pub fn is_batching_enabled(&self) -> bool {
+        if let Some(batch) = self.batch.as_ref() {
+            batch.delay >= 1
+        } else {
+            false
+        }
+    }
+}
+
+impl Default for UpstreamRuntime {
+    fn default() -> Self {
+        // NOTE: Using unwrap because try_from default will never fail
+        UpstreamRuntime::try_from(&ConfigModule::default()).unwrap()
+    }
+}
+
+impl TryFrom<&ConfigModule> for UpstreamRuntime {
+    type Error = ValidationError<String>;
+
+    fn try_from(config_module: &ConfigModule) -> Result<Self, Self::Error> {
+        let config_upstream = config_module.upstream.clone();
+
+        let mut allowed_headers = config_upstream.get_allowed_headers();
+
+        if config_module.extensions().has_auth() {
+            // force add auth specific headers to use it to make actual validation
+            allowed_headers.insert(http::header::AUTHORIZATION.to_string());
+        }
+
+        let upstream_static = UpstreamStatic::from(config_upstream.clone());
+        get_batch(&upstream_static)
+            .fuse(get_proxy(&upstream_static))
+            .map(|(batch, proxy)| UpstreamRuntime {
+                pool_idle_timeout: (config_upstream).get_pool_idle_timeout(),
+                pool_max_idle_per_host: (config_upstream).get_pool_max_idle_per_host(),
+                keep_alive_interval: (config_upstream).get_keep_alive_interval(),
+                keep_alive_timeout: (config_upstream).get_keep_alive_timeout(),
+                keep_alive_while_idle: (config_upstream).get_keep_alive_while_idle(),
+                proxy,
+                connect_timeout: (config_upstream).get_connect_timeout(),
+                timeout: (config_upstream).get_timeout(),
+                tcp_keep_alive: (config_upstream).get_tcp_keep_alive(),
+                user_agent: (config_upstream).get_user_agent(),
+                allowed_headers,
+                http_cache: (config_upstream).get_http_cache_size(),
+                batch,
+                http2_only: (config_upstream).get_http_2_only(),
+                on_request: (config_upstream).get_on_request(),
+                verify_ssl: (config_upstream).get_verify_ssl(),
+            })
+            .to_result()
+    }
+}
+
+fn get_batch(upstream: &UpstreamStatic) -> Valid<Option<Batch>, String> {
+    upstream.batch.as_ref().map_or_else(
+        || Valid::succeed(None),
+        |batch| {
+            Valid::succeed(Some(Batch {
+                max_size: Some((upstream).get_max_size()),
+                delay: (upstream).get_delay(),
+                headers: batch.headers.clone(),
+            }))
+        },
+    )
+}
+
+fn get_proxy(upstream: &UpstreamStatic) -> Valid<Option<Proxy>, String> {
+    if let Some(ref proxy) = upstream.proxy {
+        Valid::succeed(Some(Proxy { url: proxy.url.clone() }))
+    } else {
+        Valid::succeed(None)
+    }
+}
diff --git a/src/core/config/static_config/link.rs b/src/core/config/static_config/link.rs
new file mode 100644
index 0000000000..bc9134eb67
--- /dev/null
+++ b/src/core/config/static_config/link.rs
@@ -0,0 +1,79 @@
+use serde::{Deserialize, Serialize};
+
+use crate::core::config::{KeyValue, Link};
+use crate::core::is_default;
+
+#[derive(
+    Default,
+    Serialize,
+    Deserialize,
+    PartialEq,
+    Eq,
+    Debug,
+    Clone,
+    schemars::JsonSchema,
+    strum_macros::Display,
+)]
+/// The acceptable types of linked files that can be loaded on bootstrap.
+pub enum LinkType {
+    #[default]
+    Config,
+    Protobuf,
+    Script,
+    Cert,
+    Key,
+    Operation,
+    Htpasswd,
+    Jwks,
+    Grpc,
+}
+
+/// Used to represent external resources, such as
+/// configuration – which will be merged into the config importing it –,
+/// or a .proto file – which will be later used by `@grpc` directive –.
+#[derive(
+    Default,
+    Serialize,
+    Deserialize,
+    PartialEq,
+    Eq,
+    Debug,
+    Clone,
+    schemars::JsonSchema,
+)]
+#[serde(deny_unknown_fields)]
+pub struct LinkStatic {
+    ///
+    /// The id of the link. It is used to reference the link in the schema.
+    #[serde(default, skip_serializing_if = "is_default")]
+    pub id: Option<String>,
+    ///
+    /// The source of the link. It can be a URL or a path to a file.
+    /// If a path is provided, it is relative to the file that imports the link.
+    #[serde(default, skip_serializing_if = "is_default")]
+    pub src: String,
+    ///
+    /// The type of the link. It can be `Config`, or `Protobuf`.
+    #[serde(default, skip_serializing_if = "is_default", rename = "type")]
+    pub type_of: LinkType,
+    ///
+    /// Custom headers for gRPC reflection server.
+    #[serde(default, skip_serializing_if = "is_default")]
+    pub headers: Option<Vec<KeyValue>>,
+    ///
+    /// Additional metadata pertaining to the linked resource.
+    #[serde(default, skip_serializing_if = "is_default")]
+    pub meta: Option<serde_json::Value>,
+}
+
+impl From<Link> for LinkStatic {
+    fn from(link: Link) -> Self {
+        Self {
+            id: link.id,
+            src: link.src,
+            type_of: link.type_of,
+            headers: link.headers,
+            meta: link.meta,
+        }
+    }
+}
diff --git a/src/core/config/static_config/mod.rs b/src/core/config/static_config/mod.rs
new file mode 100644
index 0000000000..702974a434
--- /dev/null
+++ b/src/core/config/static_config/mod.rs
@@ -0,0 +1,10 @@
+pub mod server_static;
+pub mod upstream_static;
+pub mod link;
+pub mod telemetry_static;
+pub use telemetry_static::*;
+pub use link::*;
+pub use upstream_static::*;
+pub use server_static::*;
+pub mod static_config;
+pub use static_config::*;
\ No newline at end of file
diff --git a/src/core/config/static_config/server_static.rs b/src/core/config/static_config/server_static.rs
new file mode 100644
index 0000000000..a512778fb5
--- /dev/null
+++ b/src/core/config/static_config/server_static.rs
@@ -0,0 +1,382 @@
+pub mod headers_static;
+pub mod routes_static;
+pub mod cors_static;
+pub mod key_values;
+pub use headers_static::*;
+pub use routes_static::*;
+pub use key_values::*;
+
+use std::collections::{BTreeMap, BTreeSet};
+
+use derive_getters::Getters;
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use crate::core::config::Server;
+use crate::core::is_default;
+use crate::core::macros::MergeRight;
+
+#[derive(
+    Serialize,
+    Deserialize,
+    Clone,
+    Default,
+    Debug,
+    Getters,
+    PartialEq,
+    Eq,
+    JsonSchema,
+    MergeRight,
+)]
+/// This structure offers a comprehensive set of server configurations.
+/// It dictates how the server behaves and helps tune tailcall for various
+/// use-cases.
+#[serde(deny_unknown_fields)]
+pub struct ServerStatic {
+    /// The `enable_jit` option activates Just-In-Time (JIT) compilation. When set to true, it
+    /// optimizes execution of each incoming request independently, resulting in significantly
+    /// better performance in most cases, it's enabled by default.
+    #[serde(default, skip_serializing_if = "is_default")]
+    pub enable_jit: Option<bool>,
+
+    /// `apollo_tracing` exposes GraphQL query performance data, including
+    /// execution time of queries and individual resolvers.
+    #[serde(default, skip_serializing_if = "is_default")]
+    pub apollo_tracing: Option<bool>,
+
+    /// `batch_requests` combines multiple requests into one, improving
+    /// performance but potentially introducing latency and complicating
+    /// debugging. Use judiciously. @default `false`.
+    #[serde(default, skip_serializing_if = "is_default")]
+    pub batch_requests: Option<bool>,
+
+    /// `headers` contains key-value pairs that are included as default headers
+    /// in server responses, allowing for consistent header management across
+    /// all responses.
+    #[serde(default, skip_serializing_if = "is_default")]
+    pub headers: Option<Headers>,
+
+    /// `global_response_timeout` sets the maximum query duration before
+    /// termination, acting as a safeguard against long-running queries.
+    #[serde(default, skip_serializing_if = "is_default")]
+    pub global_response_timeout: Option<i64>,
+
+    /// `hostname` sets the server hostname.
+    #[serde(default, skip_serializing_if = "is_default")]
+    pub hostname: Option<String>,
+
+    /// `introspection` allows clients to fetch schema information directly,
+    /// aiding tools and applications in understanding available types, fields,
+    /// and operations. @default `true`.
+    #[serde(default, skip_serializing_if = "is_default")]
+    pub introspection: Option<bool>,
+
+    /// `enable_federation` enables functionality to Tailcall server to act
+    /// as a federation subgraph.
+    #[serde(default, skip_serializing_if = "is_default")]
+    pub enable_federation: Option<bool>,
+
+    /// `pipeline_flush` allows to control flushing behavior of the server
+    /// pipeline.
+    #[serde(default, skip_serializing_if = "is_default")]
+    pub pipeline_flush: Option<bool>,
+
+    /// `port` sets the Tailcall running port. @default `8000`.
+    #[serde(default, skip_serializing_if = "is_default")]
+    pub port: Option<u16>,
+
+    /// `query_validation` checks incoming GraphQL queries against the schema,
+    /// preventing errors from invalid queries. Can be disabled for performance.
+    /// @default `false`.
+    #[serde(default, skip_serializing_if = "is_default")]
+    pub query_validation: Option<bool>,
+
+    /// `response_validation` Tailcall automatically validates responses from
+    /// upstream services using inferred schema. @default `false`.
+    #[serde(default, skip_serializing_if = "is_default")]
+    pub response_validation: Option<bool>,
+
+    /// A link to an external JS file that listens on every HTTP request
+    /// response event.
+    #[serde(default, skip_serializing_if = "is_default")]
+    pub script: Option<ScriptOptions>,
+
+    /// `showcase` enables the /showcase/graphql endpoint.
+    #[serde(default, skip_serializing_if = "is_default")]
+    pub showcase: Option<bool>,
+
+    #[merge_right(merge_right_fn = "merge_right_vars")]
+    /// This configuration defines local variables for server operations. Useful
+    /// for storing constant configurations, secrets, or shared information.
+    #[serde(default, skip_serializing_if = "is_default")]
+    pub vars: Vec<KeyValue>,
+
+    /// `version` sets the HTTP version for the server. Options are `HTTP1` and
+    /// `HTTP2`. @default `HTTP1`.
+    #[serde(default, skip_serializing_if = "is_default")]
+    pub version: Option<HttpVersion>,
+
+    /// `workers` sets the number of worker threads. @default the number of
+    /// system cores.
+    #[serde(default, skip_serializing_if = "is_default")]
+    pub workers: Option<usize>,
+
+    /// `routes` allows customization of server endpoint paths.
+    /// It provides options to change the default paths for status and GraphQL
+    /// endpoints. Default values are:
+    /// - status: "/status"
+    /// - graphQL: "/graphql" If not specified, these default values will be
+    ///   used.
+    #[serde(default, skip_serializing_if = "is_default")]
+    pub routes: Option<Routes>,
+}
+
+fn merge_right_vars(mut left: Vec<KeyValue>, right: Vec<KeyValue>) -> Vec<KeyValue> {
+    left = merge_key_value_vecs(&left, &right);
+    left
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, schemars::JsonSchema, MergeRight)]
+pub struct ScriptOptions {
+    pub timeout: Option<u64>,
+}
+
+#[derive(
+    Deserialize, Serialize, Debug, PartialEq, Eq, Clone, Default, schemars::JsonSchema, MergeRight,
+)]
+pub enum HttpVersion {
+    #[default]
+    HTTP1,
+    HTTP2,
+}
+
+impl ServerStatic {
+    pub fn enable_apollo_tracing(&self) -> bool {
+        self.apollo_tracing.unwrap_or(false)
+    }
+
+    pub fn get_global_response_timeout(&self) -> i64 {
+        self.global_response_timeout.unwrap_or(0)
+    }
+
+    pub fn get_workers(&self) -> usize {
+        self.workers.unwrap_or(num_cpus::get())
+    }
+
+    pub fn get_port(&self) -> u16 {
+        self.port.unwrap_or(8000)
+    }
+    pub fn enable_http_validation(&self) -> bool {
+        self.response_validation.unwrap_or(false)
+    }
+    pub fn enable_cache_control(&self) -> bool {
+        self.headers
+            .as_ref()
+            .map(|h| h.enable_cache_control())
+            .unwrap_or(false)
+    }
+    pub fn enable_set_cookies(&self) -> bool {
+        self.headers
+            .as_ref()
+            .map(|h| h.set_cookies())
+            .unwrap_or(false)
+    }
+    pub fn enable_introspection(&self) -> bool {
+        self.introspection.unwrap_or(true)
+    }
+    pub fn enable_query_validation(&self) -> bool {
+        self.query_validation.unwrap_or(false)
+    }
+    pub fn enable_batch_requests(&self) -> bool {
+        self.batch_requests.unwrap_or(false)
+    }
+    pub fn enable_showcase(&self) -> bool {
+        self.showcase.unwrap_or(false)
+    }
+
+    pub fn get_hostname(&self) -> String {
+        self.hostname.clone().unwrap_or("127.0.0.1".to_string())
+    }
+
+    pub fn get_vars(&self) -> BTreeMap<String, String> {
+        self.vars
+            .clone()
+            .iter()
+            .map(|kv| (kv.key.clone(), kv.value.clone()))
+            .collect()
+    }
+
+    pub fn get_response_headers(&self) -> Vec<(String, String)> {
+        self.headers
+            .as_ref()
+            .map(|h| h.custom.clone())
+            .map_or(Vec::new(), |headers| {
+                headers
+                    .iter()
+                    .map(|kv| (kv.key.clone(), kv.value.clone()))
+                    .collect()
+            })
+    }
+
+    pub fn get_experimental_headers(&self) -> BTreeSet<String> {
+        self.headers
+            .as_ref()
+            .map(|h| h.experimental.clone().unwrap_or_default())
+            .unwrap_or_default()
+    }
+
+    pub fn get_version(self) -> HttpVersion {
+        self.version.unwrap_or(HttpVersion::HTTP1)
+    }
+
+    pub fn get_pipeline_flush(&self) -> bool {
+        self.pipeline_flush.unwrap_or(true)
+    }
+
+    pub fn get_enable_jit(&self) -> bool {
+        self.enable_jit.unwrap_or(true)
+    }
+
+    pub fn get_routes(&self) -> Routes {
+        self.routes.clone().unwrap_or_default()
+    }
+
+    pub fn get_enable_federation(&self) -> bool {
+        self.enable_federation.unwrap_or(false)
+    }
+}
+
+impl From<Server> for ServerStatic {
+    fn from(server: Server) -> Self {
+        Self {
+            enable_jit: server.enable_jit,
+            apollo_tracing: server.apollo_tracing,
+            batch_requests: server.batch_requests,
+            headers: server.headers,
+            global_response_timeout: server.global_response_timeout,
+            hostname: server.hostname,
+            introspection: server.introspection,
+            enable_federation: server.enable_federation,
+            pipeline_flush: server.pipeline_flush,
+            port: server.port,
+            query_validation: server.query_validation,
+            response_validation: server.response_validation,
+            script: server.script,
+            showcase: server.showcase,
+            vars: server.vars,
+            version: server.version,
+            workers: server.workers,
+            routes: server.routes.map(Routes::from),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::core::config::ScriptOptions;
+    use crate::core::merge_right::MergeRight;
+
+    fn server_with_script_options(so: ScriptOptions) -> ServerStatic {
+        ServerStatic { script: Some(so), ..Default::default() }
+    }
+
+    #[test]
+    fn script_options_merge_both() {
+        let a = server_with_script_options(ScriptOptions { timeout: Some(100) });
+        let b = server_with_script_options(ScriptOptions { timeout: Some(200) });
+        let merged = a.merge_right(b);
+        let expected = ScriptOptions { timeout: Some(200) };
+        assert_eq!(merged.script, Some(expected));
+    }
+
+    #[test]
+    fn script_options_merge_first() {
+        let a = server_with_script_options(ScriptOptions { timeout: Some(100) });
+        let b = server_with_script_options(ScriptOptions { timeout: None });
+        let merged = a.merge_right(b);
+        let expected = ScriptOptions { timeout: Some(100) };
+        assert_eq!(merged.script, Some(expected));
+    }
+
+    #[test]
+    fn script_options_merge_second() {
+        let a = server_with_script_options(ScriptOptions { timeout: None });
+        let b = server_with_script_options(ScriptOptions { timeout: Some(100) });
+        let merged = a.merge_right(b);
+        let expected = ScriptOptions { timeout: Some(100) };
+        assert_eq!(merged.script, Some(expected));
+    }
+
+    #[test]
+    fn script_options_merge_second_default() {
+        let a = server_with_script_options(ScriptOptions { timeout: Some(100) });
+        let b = ServerStatic::default();
+        let merged = a.merge_right(b);
+        let expected = ScriptOptions { timeout: Some(100) };
+        assert_eq!(merged.script, Some(expected));
+    }
+
+    #[test]
+    fn script_options_merge_first_default() {
+        let a = ServerStatic::default();
+        let b = server_with_script_options(ScriptOptions { timeout: Some(100) });
+        let merged = a.merge_right(b);
+        let expected = ScriptOptions { timeout: Some(100) };
+        assert_eq!(merged.script, Some(expected));
+    }
+
+    fn get_default_left_vec() -> Vec<KeyValue> {
+        [
+            KeyValue { key: "left".to_string(), value: "From Left".to_string() },
+            KeyValue { key: "1".to_string(), value: "1, Left".to_string() },
+            KeyValue { key: "2".to_string(), value: "2, Left".to_string() },
+        ]
+        .to_vec()
+    }
+
+    fn get_default_right_vec() -> Vec<KeyValue> {
+        [
+            KeyValue { key: "right".to_string(), value: "From Right".to_string() },
+            KeyValue { key: "1".to_string(), value: "1, Right".to_string() },
+            KeyValue { key: "2".to_string(), value: "2, Right".to_string() },
+        ]
+        .to_vec()
+    }
+
+    fn get_sorted_expected_merge_value() -> Vec<KeyValue> {
+        let mut res = [
+            KeyValue { key: "right".to_string(), value: "From Right".to_string() },
+            KeyValue { key: "left".to_string(), value: "From Left".to_string() },
+            KeyValue { key: "1".to_string(), value: "1, Right".to_string() },
+            KeyValue { key: "2".to_string(), value: "2, Right".to_string() },
+        ]
+        .to_vec();
+        res.sort_by(|a, b| a.key.cmp(&b.key));
+        res
+    }
+
+    #[test]
+    fn check_merge_vec_fn() {
+        let left_vec = get_default_left_vec();
+        let right_vec = get_default_right_vec();
+        let expected_vec = get_sorted_expected_merge_value();
+
+        let mut merge_vec = merge_key_value_vecs(&left_vec, &right_vec);
+        merge_vec.sort_by(|a, b| a.key.cmp(&b.key));
+
+        assert_eq!(merge_vec, expected_vec)
+    }
+
+    #[test]
+    fn check_merge_right_fn() {
+        let left_vec = get_default_left_vec();
+        let right_vec = get_default_right_vec();
+        let expected_vec = get_sorted_expected_merge_value();
+
+        let mut merge_vec = merge_right_vars(left_vec, right_vec);
+
+        merge_vec.sort_by(|a, b| a.key.cmp(&b.key));
+
+        assert_eq!(merge_vec, expected_vec)
+    }
+}
diff --git a/src/core/config/cors.rs b/src/core/config/static_config/server_static/cors_static.rs
similarity index 98%
rename from src/core/config/cors.rs
rename to src/core/config/static_config/server_static/cors_static.rs
index f68678ec5c..fb1ce2b416 100644
--- a/src/core/config/cors.rs
+++ b/src/core/config/static_config/server_static/cors_static.rs
@@ -9,8 +9,7 @@ use crate::core::macros::MergeRight;
 #[derive(
     Serialize, Deserialize, Clone, Debug, Default, PartialEq, Eq, schemars::JsonSchema, MergeRight,
 )]
-#[serde(rename_all = "camelCase")]
-pub struct Cors {
+pub struct CorsStatic {
     /// Indicates whether the server allows credentials (e.g., cookies,
     /// authorization headers) to be sent in cross-origin requests.
     #[serde(default, skip_serializing_if = "is_default")]
diff --git a/src/core/config/headers.rs b/src/core/config/static_config/server_static/headers_static.rs
similarity index 75%
rename from src/core/config/headers.rs
rename to src/core/config/static_config/server_static/headers_static.rs
index adf2767bb0..00e8458728 100644
--- a/src/core/config/headers.rs
+++ b/src/core/config/static_config/server_static/headers_static.rs
@@ -1,25 +1,24 @@
 use std::collections::BTreeSet;
 
+use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
-use crate::core::config::cors::Cors;
 use crate::core::config::KeyValue;
 use crate::core::is_default;
 use crate::core::macros::MergeRight;
 
-#[derive(
-    Serialize, Deserialize, Clone, Debug, Default, PartialEq, Eq, schemars::JsonSchema, MergeRight,
-)]
-#[serde(rename_all = "camelCase")]
+use super::cors_static::CorsStatic;
+
+#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq, Eq, JsonSchema, MergeRight)]
 pub struct Headers {
     #[serde(default, skip_serializing_if = "is_default")]
-    /// `cacheControl` sends `Cache-Control` headers in responses when
+    /// `cache_control` sends `Cache-Control` headers in responses when
     /// activated. The `max-age` value is the least of the values received from
     /// upstream services. @default `false`.
     pub cache_control: Option<bool>,
 
     #[serde(default, skip_serializing_if = "is_default")]
-    /// `headers` are key-value pairs included in every server
+    /// `custom` are key-value pairs included in every server
     /// response. Useful for setting headers like `Access-Control-Allow-Origin`
     /// for cross-origin requests or additional headers for downstream services.
     pub custom: Vec<KeyValue>,
@@ -29,14 +28,14 @@ pub struct Headers {
     /// in the response. @default `[]`.
     pub experimental: Option<BTreeSet<String>>,
 
-    /// `setCookies` when enabled stores `set-cookie` headers
+    /// `set_cookies` when enabled stores `set-cookie` headers
     /// and all the response will be sent with the headers.
     #[serde(default, skip_serializing_if = "is_default")]
     pub set_cookies: Option<bool>,
 
     #[serde(default, skip_serializing_if = "is_default")]
     /// `cors` allows Cross-Origin Resource Sharing (CORS) for a server.
-    pub cors: Option<Cors>,
+    pub cors: Option<CorsStatic>,
 }
 
 impl Headers {
@@ -46,7 +45,7 @@ impl Headers {
     pub fn set_cookies(&self) -> bool {
         self.set_cookies.unwrap_or_default()
     }
-    pub fn get_cors(&self) -> Option<Cors> {
+    pub fn get_cors(&self) -> Option<CorsStatic> {
         self.cors.clone()
     }
 }
diff --git a/src/core/config/key_values.rs b/src/core/config/static_config/server_static/key_values.rs
similarity index 100%
rename from src/core/config/key_values.rs
rename to src/core/config/static_config/server_static/key_values.rs
diff --git a/src/core/config/static_config/server_static/routes_static.rs b/src/core/config/static_config/server_static/routes_static.rs
new file mode 100644
index 0000000000..f0ffae1ab4
--- /dev/null
+++ b/src/core/config/static_config/server_static/routes_static.rs
@@ -0,0 +1,29 @@
+use derive_getters::Getters;
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use tailcall_macros::MergeRight;
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, MergeRight, JsonSchema, Getters)]
+/// Used to configure the default routes of the server.
+pub struct Routes {
+    /// The path for the status endpoint. Defaults to `/status`.
+    status: String,
+    /// The path for the GraphQL endpoint. Defaults to `/graphql`.
+    graphql: String,
+}
+
+impl Default for Routes {
+    fn default() -> Self {
+        Self { status: "/status".into(), graphql: "/graphql".into() }
+    }
+}
+
+impl Routes {
+    pub fn with_status<T: Into<String>>(self, status: T) -> Self {
+        Self { graphql: self.graphql, status: status.into() }
+    }
+
+    pub fn with_graphql<T: Into<String>>(self, graphql: T) -> Self {
+        Self { status: self.status, graphql: graphql.into() }
+    }
+}
\ No newline at end of file
diff --git a/src/core/config/static_config/static_config.rs b/src/core/config/static_config/static_config.rs
new file mode 100644
index 0000000000..dba8552fac
--- /dev/null
+++ b/src/core/config/static_config/static_config.rs
@@ -0,0 +1,87 @@
+use derive_getters::Getters;
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use tailcall_macros::MergeRight;
+use tailcall_valid::{Valid, Validator};
+
+use super::{LinkStatic, ServerStatic, TelemetryStatic, UpstreamStatic};
+use crate::core::{config::{Config, Source}, is_default, merge_right::MergeRight, variance::Invariant};
+
+#[derive(
+    Serialize, Deserialize, Clone, Debug, Default, Getters, PartialEq, Eq, JsonSchema, MergeRight,
+)]
+pub struct StaticConfig {
+    ///
+    /// Dictates how the server behaves and helps tune tailcall for all ingress
+    /// requests. Features such as request batching, SSL, HTTP2 etc. can be
+    /// configured here.
+    pub server: ServerStatic,
+
+    ///
+    /// Dictates how tailcall should handle upstream requests/responses.
+    /// Tuning upstream can improve performance and reliability for connections.
+    pub upstream: UpstreamStatic,
+
+    ///
+    /// Linked files, that merge with config, schema or provide metadata.
+    pub links: Vec<LinkStatic>,
+
+    /// Enable [opentelemetry](https://opentelemetry.io) support.
+    #[serde(default, skip_serializing_if = "is_default")]
+    pub telemetry: TelemetryStatic,
+}
+
+impl StaticConfig {
+    pub fn port(&self) -> u16 {
+        self.server.port.unwrap_or(8000)
+    }
+
+    pub fn to_yaml(&self) -> anyhow::Result<String> {
+        Ok(serde_yaml::to_string(self)?)
+    }
+
+    pub fn to_json(&self, pretty: bool) -> anyhow::Result<String> {
+        if pretty {
+            Ok(serde_json::to_string_pretty(self)?)
+        } else {
+            Ok(serde_json::to_string(self)?)
+        }
+    }
+
+    pub fn from_json(json: &str) -> anyhow::Result<Self> {
+        Ok(serde_json::from_str(json)?)
+    }
+
+    pub fn from_yaml(yaml: &str) -> anyhow::Result<Self> {
+        Ok(serde_yaml::from_str(yaml)?)
+    }
+
+    pub fn from_graphql(graphql: &str) -> anyhow::Result<Self> {
+        let config = Config::from_sdl(graphql).to_result()?;
+        Ok(Self {
+            server: ServerStatic::from(config.server),
+            links: config.links.into_iter().map(LinkStatic::from).collect(),
+            upstream: UpstreamStatic::from(config.upstream),
+            telemetry: TelemetryStatic::from(config.telemetry),
+        })
+    }
+
+    pub fn from_source(source: Source, data: &str) -> anyhow::Result<Self> {
+        match source {
+            Source::Json => Ok(StaticConfig::from_json(data)?),
+            Source::Yml => Ok(StaticConfig::from_yaml(data)?),
+            Source::GraphQL => Ok(StaticConfig::from_graphql(data)?),
+        }
+    }
+}
+
+impl Invariant for StaticConfig {
+    fn unify(self, other: Self) -> Valid<Self, String> {
+        Valid::succeed(self.merge_right(other))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+   // TODO: FIXME
+}
diff --git a/src/core/config/static_config/telemetry_static.rs b/src/core/config/static_config/telemetry_static.rs
new file mode 100644
index 0000000000..c9cc85a91a
--- /dev/null
+++ b/src/core/config/static_config/telemetry_static.rs
@@ -0,0 +1,221 @@
+use anyhow::Result;
+use serde::{Deserialize, Serialize};
+use tailcall_valid::Validator;
+
+use crate::core::config::{KeyValue, Telemetry};
+use crate::core::helpers::headers::to_mustache_headers;
+use crate::core::is_default;
+use crate::core::macros::MergeRight;
+use crate::core::merge_right::MergeRight;
+use crate::core::mustache::Mustache;
+
+pub mod apollo_static;
+pub mod reader_context;
+pub use reader_context::ConfigReaderContext;
+pub use apollo_static::ApolloTelemetry;
+
+#[derive(
+    Debug,
+    Default,
+    Clone,
+    Serialize,
+    Deserialize,
+    PartialEq,
+    Eq,
+    schemars::JsonSchema
+)]
+#[serde(deny_unknown_fields)]
+/// The `telemetry` option facilitates seamless integration with OpenTelemetry,
+/// enhancing the observability of your GraphQL services powered by Tailcall.
+/// By configuring `telemetry`, developers gain access to valuable insights
+/// into the performance and behavior of their applications.
+pub struct TelemetryStatic {
+    // TODO: FIXME
+    pub export: Option<TelemetryExporterConfig>,
+    /// The list of headers that will be sent as additional attributes to
+    /// telemetry exporters Be careful about **leaking sensitive
+    /// information** from requests when enabling the headers that may
+    /// contain sensitive data
+    #[serde(default, skip_serializing_if = "is_default")]
+    pub request_headers: Vec<String>,
+}
+
+impl TelemetryStatic {
+    pub fn merge_right(mut self, other: Self) -> Self {
+        self.export = match (&self.export, other.export) {
+            (None, None) => None,
+            (None, Some(export)) => Some(export),
+            (Some(export), None) => Some(export.clone()),
+            (Some(left), Some(right)) => Some(left.clone().merge_right(right.clone())),
+        };
+        self.request_headers.extend(other.request_headers);
+
+        self
+    }
+
+    pub fn render_mustache(&mut self, reader_ctx: &ConfigReaderContext) -> Result<()> {
+        match &mut self.export {
+            Some(TelemetryExporterConfig::Otlp(otlp)) => {
+                let url_tmpl = Mustache::parse(&otlp.url);
+                otlp.url = url_tmpl.render(reader_ctx);
+
+                let headers = to_mustache_headers(&otlp.headers).to_result()?;
+                otlp.headers = headers
+                    .into_iter()
+                    .map(|(key, tmpl)| (key.as_str().to_owned(), tmpl.render(reader_ctx)))
+                    .map(|(key, value)| KeyValue { key, value })
+                    .collect();
+            }
+            Some(TelemetryExporterConfig::Apollo(apollo)) => apollo.render_mustache(reader_ctx)?,
+            _ => {}
+        }
+
+        Ok(())
+    }
+}
+
+impl From<Telemetry> for TelemetryStatic {
+    fn from(telemetry: Telemetry) -> Self {
+        Self {
+            export: telemetry.export,
+            request_headers: telemetry.request_headers,
+        }
+    }
+}
+
+mod defaults {
+    pub mod prometheus {
+        pub fn path() -> String {
+            "/metrics".to_owned()
+        }
+    }
+}
+
+/// Output the opentelemetry data to the stdout. Mostly used for debug purposes
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, schemars::JsonSchema, MergeRight)]
+pub struct StdoutExporter {
+    /// Output to stdout in pretty human-readable format
+    #[serde(default, skip_serializing_if = "is_default")]
+    pub pretty: bool,
+}
+
+/// Output the opentelemetry data to otlp collector
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, schemars::JsonSchema, MergeRight)]
+pub struct OtlpExporterConfig {
+    pub url: String,
+    #[serde(default, skip_serializing_if = "is_default")]
+    pub headers: Vec<KeyValue>,
+}
+
+/// Output format for prometheus data
+#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq, schemars::JsonSchema)]
+pub enum PrometheusFormat {
+    #[default]
+    Text,
+    Protobuf,
+}
+
+/// Output the telemetry metrics data to prometheus server
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, schemars::JsonSchema)]
+pub struct PrometheusExporter {
+    #[serde(
+        default = "defaults::prometheus::path",
+        skip_serializing_if = "is_default"
+    )]
+    pub path: String,
+    #[serde(default, skip_serializing_if = "is_default")]
+    pub format: PrometheusFormat,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, schemars::JsonSchema, MergeRight)]
+pub enum TelemetryExporterConfig {
+    Stdout(StdoutExporter),
+    Otlp(OtlpExporterConfig),
+    Prometheus(PrometheusExporter),
+    Apollo(ApolloTelemetry),
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn merge_right() {
+        let exporter_none = TelemetryStatic { export: None, ..Default::default() };
+        let exporter_stdout = TelemetryStatic {
+            export: Some(TelemetryExporterConfig::Stdout(StdoutExporter { pretty: true })),
+            ..Default::default()
+        };
+        let exporter_otlp_1 = TelemetryStatic {
+            export: Some(TelemetryExporterConfig::Otlp(OtlpExporterConfig {
+                url: "test-url".to_owned(),
+                headers: vec![KeyValue { key: "header_a".to_owned(), value: "a".to_owned() }],
+            })),
+            request_headers: vec!["Api-Key-A".to_owned()],
+        };
+        let exporter_otlp_2 = TelemetryStatic {
+            export: Some(TelemetryExporterConfig::Otlp(OtlpExporterConfig {
+                url: "test-url-2".to_owned(),
+                headers: vec![KeyValue { key: "header_b".to_owned(), value: "b".to_owned() }],
+            })),
+            request_headers: vec!["Api-Key-B".to_owned()],
+        };
+        let exporter_prometheus_1 = TelemetryStatic {
+            export: Some(TelemetryExporterConfig::Prometheus(PrometheusExporter {
+                path: "/metrics".to_owned(),
+                format: PrometheusFormat::Text,
+            })),
+            ..Default::default()
+        };
+        let exporter_prometheus_2 = TelemetryStatic {
+            export: Some(TelemetryExporterConfig::Prometheus(PrometheusExporter {
+                path: "/prom".to_owned(),
+                format: PrometheusFormat::Protobuf,
+            })),
+            ..Default::default()
+        };
+
+        assert_eq!(
+            exporter_none.clone().merge_right(exporter_none.clone()),
+            exporter_none
+        );
+
+        assert_eq!(
+            exporter_stdout.clone().merge_right(exporter_none.clone()),
+            exporter_stdout
+        );
+
+        assert_eq!(
+            exporter_none.clone().merge_right(exporter_otlp_1.clone()),
+            exporter_otlp_1
+        );
+
+        assert_eq!(
+            exporter_stdout.clone().merge_right(exporter_otlp_1.clone()),
+            exporter_otlp_1
+        );
+
+        assert_eq!(
+            exporter_stdout.clone().merge_right(exporter_stdout.clone()),
+            exporter_stdout
+        );
+
+        assert_eq!(
+            exporter_otlp_1.clone().merge_right(exporter_otlp_2.clone()),
+            TelemetryStatic {
+                export: Some(TelemetryExporterConfig::Otlp(OtlpExporterConfig {
+                    url: "test-url-2".to_owned(),
+                    headers: vec![KeyValue { key: "header_b".to_owned(), value: "b".to_owned() }]
+                })),
+                request_headers: vec!["Api-Key-A".to_string(), "Api-Key-B".to_string(),]
+            }
+        );
+
+        assert_eq!(
+            exporter_prometheus_1
+                .clone()
+                .merge_right(exporter_prometheus_2.clone()),
+            exporter_prometheus_2
+        );
+    }
+}
diff --git a/src/core/config/apollo.rs b/src/core/config/static_config/telemetry_static/apollo_static.rs
similarity index 83%
rename from src/core/config/apollo.rs
rename to src/core/config/static_config/telemetry_static/apollo_static.rs
index 2990d599b0..5bb2919833 100644
--- a/src/core/config/apollo.rs
+++ b/src/core/config/static_config/telemetry_static/apollo_static.rs
@@ -5,31 +5,34 @@ use crate::core::is_default;
 use crate::core::mustache::Mustache;
 
 #[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq, Eq, schemars::JsonSchema)]
-#[serde(rename_all = "camelCase")]
-pub struct Apollo {
+pub struct ApolloTelemetry {
     ///
-    /// Setting `apiKey` for Apollo.
+    /// Setting `api_key` for Apollo.
     pub api_key: String,
+
     ///
-    /// Setting `graphRef` for Apollo in the format <graphId>@<variant>.
+    /// Setting `graph_ref` for Apollo in the format <graphId>@<variant>.
     pub graph_ref: String,
+
     ///
-    /// Setting `userVersion` for Apollo.
+    /// Setting `user_version` for Apollo.
     #[serde(default, skip_serializing_if = "is_default")]
     pub user_version: Option<String>,
+
     ///
     /// Setting `platform` for Apollo.
     #[serde(default, skip_serializing_if = "is_default")]
     pub platform: Option<String>,
+
     ///
     /// Setting `version` for Apollo.
     #[serde(default, skip_serializing_if = "is_default")]
     pub version: Option<String>,
 }
 
-impl Apollo {
+impl ApolloTelemetry {
     pub fn render_mustache(&mut self, reader_ctx: &ConfigReaderContext) -> anyhow::Result<()> {
-        let Apollo { api_key, graph_ref, user_version, platform, version } = self;
+        let ApolloTelemetry { api_key, graph_ref, user_version, platform, version } = self;
 
         let api_key_tmpl = Mustache::parse(api_key);
         *api_key = api_key_tmpl.render(reader_ctx);
diff --git a/src/core/config/reader_context.rs b/src/core/config/static_config/telemetry_static/reader_context.rs
similarity index 100%
rename from src/core/config/reader_context.rs
rename to src/core/config/static_config/telemetry_static/reader_context.rs
diff --git a/src/core/config/static_config/upstream_static.rs b/src/core/config/static_config/upstream_static.rs
new file mode 100644
index 0000000000..15b8277ad6
--- /dev/null
+++ b/src/core/config/static_config/upstream_static.rs
@@ -0,0 +1,260 @@
+use std::collections::BTreeSet;
+
+use derive_setters::Setters;
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+
+use crate::core::config::Upstream;
+use crate::core::macros::MergeRight;
+use crate::core::{default_verify_ssl, is_default, verify_ssl_is_default};
+
+mod batch;
+pub use batch::*;
+
+#[derive(
+    Deserialize,
+    Serialize,
+    Clone,
+    Debug,
+    Default,
+    Setters,
+    PartialEq,
+    Eq,
+    JsonSchema,
+    MergeRight,
+)]
+#[serde(deny_unknown_fields)]
+/// The `upstream` configuration allows you to control various aspects of the
+/// upstream server connection. This includes settings like connection timeouts,
+/// keep-alive intervals, and more. If not specified, default values are used.
+pub struct UpstreamStatic {
+    #[serde(default, skip_serializing_if = "is_default")]
+    /// `on_request` field gives the ability to specify the global request
+    /// interception handler.
+    pub on_request: Option<String>,
+
+    #[serde(default, skip_serializing_if = "is_default")]
+    /// `allowed_headers` defines the HTTP headers allowed to be forwarded to
+    /// upstream services. If not set, no headers are forwarded, enhancing
+    /// security but possibly limiting data flow.
+    pub allowed_headers: Option<BTreeSet<String>>,
+
+    #[serde(default, skip_serializing_if = "is_default")]
+    /// An object that specifies the batch settings, including `max_size` (the
+    /// maximum size of the batch), `delay` (the delay in milliseconds between
+    /// each batch), and `headers` (an array of HTTP headers to be included in
+    /// the batch).
+    pub batch: Option<Batch>,
+
+    #[serde(default, skip_serializing_if = "is_default")]
+    /// The time in seconds that the connection will wait for a response before
+    /// timing out.
+    pub connect_timeout: Option<u64>,
+
+    #[serde(default, skip_serializing_if = "is_default")]
+    /// Providing `http_cache` size enables Tailcall's HTTP caching, adhering to the [HTTP Caching RFC](https://tools.ietf.org/html/rfc7234), to enhance performance by minimizing redundant data fetches. Defaults to `0` if unspecified.
+    pub http_cache: Option<u64>,
+
+    #[setters(strip_option)]
+    #[serde(default, skip_serializing_if = "is_default")]
+    /// The `http2_only` setting allows you to specify whether the client should
+    /// always issue HTTP2 requests, without checking if the server supports it
+    /// or not. By default it is set to `false` for all HTTP requests made by
+    /// the server, but is automatically set to true for GRPC.
+    pub http2_only: Option<bool>,
+
+    #[serde(default, skip_serializing_if = "is_default")]
+    /// The time in seconds between each keep-alive message sent to maintain the
+    /// connection.
+    pub keep_alive_interval: Option<u64>,
+
+    #[serde(default, skip_serializing_if = "is_default")]
+    /// The time in seconds that the connection will wait for a keep-alive
+    /// message before closing.
+    pub keep_alive_timeout: Option<u64>,
+
+    #[serde(default, skip_serializing_if = "is_default")]
+    /// A boolean value that determines whether keep-alive messages should be
+    /// sent while the connection is idle.
+    pub keep_alive_while_idle: Option<bool>,
+
+    #[serde(default, skip_serializing_if = "is_default")]
+    /// The maximum number of idle connections that will be maintained per host.
+    pub pool_max_idle_per_host: Option<usize>,
+
+    #[serde(default, skip_serializing_if = "is_default")]
+    /// The time in seconds that the connection pool will wait before closing
+    /// idle connections.
+    pub pool_idle_timeout: Option<u64>,
+
+    #[serde(default, skip_serializing_if = "is_default")]
+    /// The `proxy` setting defines an intermediary server through which the
+    /// upstream requests will be routed before reaching their intended
+    /// endpoint. By specifying a proxy URL, you introduce an additional layer,
+    /// enabling custom routing and security policies.
+    pub proxy: Option<Proxy>,
+
+    #[serde(default, skip_serializing_if = "is_default")]
+    /// The time in seconds between each TCP keep-alive message sent to maintain
+    /// the connection.
+    pub tcp_keep_alive: Option<u64>,
+
+    #[serde(default, skip_serializing_if = "is_default")]
+    /// The maximum time in seconds that the connection will wait for a
+    /// response.
+    pub timeout: Option<u64>,
+
+    #[serde(default, skip_serializing_if = "is_default")]
+    /// The User-Agent header value to be used in HTTP requests. @default
+    /// `Tailcall/1.0`
+    pub user_agent: Option<String>,
+
+    #[serde(
+        default = "default_verify_ssl",
+        skip_serializing_if = "verify_ssl_is_default"
+    )]
+    /// A boolean value that determines whether to verify certificates.
+    /// Setting this as `false` will make tailcall accept self-signed
+    /// certificates. NOTE: use this *only* during development or testing.
+    /// It is highly recommended to keep this enabled (`true`) in
+    /// production.
+    pub verify_ssl: Option<bool>,
+}
+
+impl UpstreamStatic {
+    pub fn get_pool_idle_timeout(&self) -> u64 {
+        self.pool_idle_timeout.unwrap_or(60)
+    }
+    pub fn get_pool_max_idle_per_host(&self) -> usize {
+        self.pool_max_idle_per_host.unwrap_or(60)
+    }
+    pub fn get_keep_alive_interval(&self) -> u64 {
+        self.keep_alive_interval.unwrap_or(60)
+    }
+    pub fn get_keep_alive_timeout(&self) -> u64 {
+        self.keep_alive_timeout.unwrap_or(60)
+    }
+    pub fn get_keep_alive_while_idle(&self) -> bool {
+        self.keep_alive_while_idle.unwrap_or(false)
+    }
+    pub fn get_connect_timeout(&self) -> u64 {
+        self.connect_timeout.unwrap_or(60)
+    }
+    pub fn get_timeout(&self) -> u64 {
+        self.timeout.unwrap_or(60)
+    }
+    pub fn get_tcp_keep_alive(&self) -> u64 {
+        self.tcp_keep_alive.unwrap_or(5)
+    }
+    pub fn get_user_agent(&self) -> String {
+        self.user_agent
+            .clone()
+            .unwrap_or("Tailcall/1.0".to_string())
+    }
+    pub fn get_http_cache_size(&self) -> u64 {
+        self.http_cache.unwrap_or(0)
+    }
+    pub fn get_allowed_headers(&self) -> BTreeSet<String> {
+        self.allowed_headers.clone().unwrap_or_default()
+    }
+    pub fn get_delay(&self) -> usize {
+        self.batch.clone().unwrap_or_default().delay
+    }
+
+    pub fn get_max_size(&self) -> usize {
+        self.batch
+            .as_ref()
+            .map_or(DEFAULT_MAX_SIZE, |b| b.max_size.unwrap_or(DEFAULT_MAX_SIZE))
+    }
+    pub fn get_http_2_only(&self) -> bool {
+        self.http2_only.unwrap_or(false)
+    }
+
+    pub fn get_on_request(&self) -> Option<String> {
+        self.on_request.clone()
+    }
+    pub fn get_verify_ssl(&self) -> bool {
+        self.verify_ssl.unwrap_or(true)
+    }
+}
+
+impl From<Upstream> for UpstreamStatic {
+    fn from(upstream: Upstream) -> Self {
+        Self {
+            on_request: upstream.on_request,
+            allowed_headers: upstream.allowed_headers,
+            batch: upstream.batch.map(Batch::from),
+            connect_timeout: upstream.connect_timeout,
+            http_cache: upstream.http_cache,
+            http2_only: upstream.http2_only,
+            keep_alive_interval: upstream.keep_alive_interval,
+            keep_alive_timeout: upstream.keep_alive_timeout,
+            keep_alive_while_idle: upstream.keep_alive_while_idle,
+            pool_max_idle_per_host: upstream.pool_max_idle_per_host,
+            pool_idle_timeout: upstream.pool_idle_timeout,
+            proxy: upstream.proxy.map(Proxy::from),
+            tcp_keep_alive: upstream.tcp_keep_alive,
+            timeout: upstream.timeout,
+            user_agent: upstream.user_agent,
+            verify_ssl: upstream.verify_ssl,
+        }
+    }
+}
+
+#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug, schemars::JsonSchema, MergeRight)]
+pub struct Proxy {
+    pub url: String,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::core::merge_right::MergeRight;
+
+    fn setup_upstream_with_headers(headers: &[&str]) -> UpstreamStatic {
+        UpstreamStatic {
+            allowed_headers: Some(headers.iter().map(|s| s.to_string()).collect()),
+            ..Default::default()
+        }
+    }
+
+    #[test]
+    fn allowed_headers_merge_both() {
+        let a = setup_upstream_with_headers(&["a", "b", "c"]);
+        let b = setup_upstream_with_headers(&["d", "e", "f"]);
+        let merged = a.merge_right(b);
+        assert_eq!(
+            merged.allowed_headers,
+            Some(
+                ["a", "b", "c", "d", "e", "f"]
+                    .iter()
+                    .map(|s| s.to_string())
+                    .collect()
+            )
+        );
+    }
+
+    #[test]
+    fn allowed_headers_merge_first() {
+        let a = setup_upstream_with_headers(&["a", "b", "c"]);
+        let b = UpstreamStatic::default();
+        let merged = a.merge_right(b);
+
+        assert_eq!(
+            merged.allowed_headers,
+            Some(["a", "b", "c"].iter().map(|s| s.to_string()).collect())
+        );
+    }
+
+    #[test]
+    fn allowed_headers_merge_second() {
+        let a = UpstreamStatic::default();
+        let b = setup_upstream_with_headers(&["a", "b", "c"]);
+        let merged = a.merge_right(b);
+
+        assert_eq!(
+            merged.allowed_headers,
+            Some(["a", "b", "c"].iter().map(|s| s.to_string()).collect())
+        );
+    }
+}
diff --git a/src/core/config/static_config/upstream_static/batch.rs b/src/core/config/static_config/upstream_static/batch.rs
new file mode 100644
index 0000000000..baff848f76
--- /dev/null
+++ b/src/core/config/static_config/upstream_static/batch.rs
@@ -0,0 +1,38 @@
+use std::collections::BTreeSet;
+
+use derive_setters::Setters;
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use tailcall_macros::MergeRight;
+
+use crate::core::is_default;
+
+pub const DEFAULT_MAX_SIZE: usize = 100;
+
+#[derive(
+    Serialize,
+    Deserialize,
+    Clone,
+    Debug,
+    Setters,
+    PartialEq,
+    Eq,
+    JsonSchema,
+    MergeRight,
+)]
+pub struct Batch {
+    pub delay: usize,
+    pub headers: BTreeSet<String>,
+    #[serde(default, skip_serializing_if = "is_default")]
+    pub max_size: Option<usize>,
+}
+
+impl Default for Batch {
+    fn default() -> Self {
+        Self {
+            max_size: Some(DEFAULT_MAX_SIZE),
+            delay: 0,
+            headers: BTreeSet::new(),
+        }
+    }
+}
diff --git a/src/core/config/utils/encoding.rs b/src/core/config/utils/encoding.rs
new file mode 100644
index 0000000000..e9e1349067
--- /dev/null
+++ b/src/core/config/utils/encoding.rs
@@ -0,0 +1,10 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(
+    Clone, Debug, Serialize, Deserialize, PartialEq, Eq, Hash, Default, schemars::JsonSchema,
+)]
+pub enum Encoding {
+    #[default]
+    ApplicationJson,
+    ApplicationXWwwFormUrlencoded,
+}
diff --git a/src/core/config/utils/mod.rs b/src/core/config/utils/mod.rs
new file mode 100644
index 0000000000..09d136ee5a
--- /dev/null
+++ b/src/core/config/utils/mod.rs
@@ -0,0 +1,6 @@
+pub mod source;
+pub use source::*;
+pub mod encoding;
+pub use encoding::*;
+pub mod private_key;
+pub use private_key::*;
\ No newline at end of file
diff --git a/src/core/config/utils/private_key.rs b/src/core/config/utils/private_key.rs
new file mode 100644
index 0000000000..11682c6100
--- /dev/null
+++ b/src/core/config/utils/private_key.rs
@@ -0,0 +1,24 @@
+use rustls_pki_types::PrivateKeyDer;
+
+
+
+#[derive(Debug)]
+pub struct PrivateKey(PrivateKeyDer<'static>);
+
+impl Clone for PrivateKey {
+    fn clone(&self) -> Self {
+        Self(self.0.clone_key())
+    }
+}
+
+impl From<PrivateKeyDer<'static>> for PrivateKey {
+    fn from(value: PrivateKeyDer<'static>) -> Self {
+        Self(value)
+    }
+}
+
+impl PrivateKey {
+    pub fn into_inner(self) -> PrivateKeyDer<'static> {
+        self.0
+    }
+}
\ No newline at end of file
diff --git a/src/core/config/utils/source.rs b/src/core/config/utils/source.rs
new file mode 100644
index 0000000000..ef407c7f91
--- /dev/null
+++ b/src/core/config/utils/source.rs
@@ -0,0 +1,89 @@
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use tailcall_valid::{ValidationError, Validator};
+use thiserror::Error;
+
+use crate::core::config::Config;
+
+#[derive(Clone, Default, Debug, Serialize, Deserialize, JsonSchema)]
+#[serde(rename_all = "camelCase")]
+pub enum Source {
+    Json,
+    Yml,
+    #[default]
+    GraphQL,
+}
+
+impl std::fmt::Display for Source {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Source::Json => write!(f, "JSON"),
+            Source::Yml => write!(f, "YML"),
+            Source::GraphQL => write!(f, "GraphQL"),
+        }
+    }
+}
+
+const JSON_EXT: &str = "json";
+const YML_EXT: &str = "yml";
+const GRAPHQL_EXT: &str = "graphql";
+const ALL: [Source; 3] = [Source::Json, Source::Yml, Source::GraphQL];
+
+#[derive(Debug, Error, PartialEq)]
+#[error("Unsupported config extension: {0}")]
+pub struct UnsupportedConfigFormat(pub String);
+
+impl std::str::FromStr for Source {
+    type Err = UnsupportedConfigFormat;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s.to_lowercase().as_str() {
+            "json" => Ok(Source::Json),
+            "yml" | "yaml" => Ok(Source::Yml),
+            "graphql" | "gql" => Ok(Source::GraphQL),
+            _ => Err(UnsupportedConfigFormat(s.to_string())),
+        }
+    }
+}
+
+impl Source {
+    /// Get the file extension for the given format
+    pub fn ext(&self) -> &'static str {
+        match self {
+            Source::Json => JSON_EXT,
+            Source::Yml => YML_EXT,
+            Source::GraphQL => GRAPHQL_EXT,
+        }
+    }
+
+    fn ends_with(&self, file: &str) -> bool {
+        file.ends_with(&format!(".{}", self.ext()))
+    }
+
+    /// Detect the config format from the file name
+    pub fn detect(name: &str) -> Result<Source, UnsupportedConfigFormat> {
+        ALL.into_iter()
+            .find(|format| format.ends_with(name))
+            .ok_or(UnsupportedConfigFormat(name.to_string()))
+    }
+
+    /// Encode the config to the given format
+    pub fn encode(&self, config: &Config) -> Result<String, anyhow::Error> {
+        match self {
+            Source::Yml => Ok(config.to_yaml()?),
+            Source::GraphQL => Ok(config.to_sdl()),
+            Source::Json => Ok(config.to_json(true)?),
+        }
+    }
+
+    /// Decode the config from the given data
+    pub fn decode(&self, data: &str) -> Result<Config, ValidationError<String>> {
+        match self {
+            Source::Yml => Config::from_yaml(data).map_err(|e| ValidationError::new(e.to_string())),
+            Source::GraphQL => Config::from_sdl(data).to_result(),
+            Source::Json => {
+                Config::from_json(data).map_err(|e| ValidationError::new(e.to_string()))
+            }
+        }
+    }
+}

From 0b4b1674af6acef63cd4e26ac63f396e8d501c99 Mon Sep 17 00:00:00 2001
From: Panagiotis <panagiotiskaratakis@gmail.com>
Date: Mon, 18 Nov 2024 14:56:08 +0200
Subject: [PATCH 2/4] refactor: limit the configuration exposure of `Blueprint`
 struct

---
 benches/handle_request_bench.rs               |   4 +-
 benches/http_execute_bench.rs                 |   4 +-
 ...impl_path_string_for_evaluation_context.rs |   3 +
 generated/.tailcallrc.graphql                 |  80 ++++++-----
 generated/.tailcallrc.schema.json             |  96 +++++++------
 src/cli/javascript/mod.rs                     |   5 +-
 src/cli/javascript/runtime.rs                 |  13 +-
 src/cli/runtime/http.rs                       |   7 +-
 src/cli/runtime/mod.rs                        |  21 ++-
 src/cli/server/http_1.rs                      |   4 +-
 src/cli/server/http_2.rs                      |   2 +-
 src/cli/server/http_server.rs                 |  15 +-
 src/cli/server/mod.rs                         |   2 +-
 src/cli/server/server_config.rs               |  18 ++-
 src/cli/telemetry.rs                          |  34 ++---
 src/core/app_context.rs                       |   4 +-
 src/core/auth/basic.rs                        |  22 +--
 src/core/auth/context.rs                      |  12 +-
 src/core/auth/jwt/jwt_verify.rs               |  45 +++---
 src/core/auth/verify.rs                       |  38 ++---
 src/core/blueprint/auth.rs                    | 133 ------------------
 src/core/blueprint/blueprint.rs               |   9 +-
 src/core/blueprint/from_config.rs             |  27 ++--
 src/core/blueprint/mod.rs                     |   3 -
 src/core/blueprint/server.rs                  |  41 ++----
 src/core/blueprint/telemetry.rs               | 128 -----------------
 src/core/blueprint/upstream.rs                |   7 +-
 src/core/config/config_module.rs              |   3 +-
 src/core/config/directives/server.rs          |   4 +-
 src/core/config/directives/telemetry.rs       |   9 +-
 src/core/config/mod.rs                        |   8 +-
 .../config/runtime_config/runtime_config.rs   |   3 +
 .../config/runtime_config/server_runtime.rs   |  37 ++++-
 .../server_runtime/auth_runtime.rs            |  55 +++-----
 .../config/runtime_config/upstream_runtime.rs |  24 ++++
 src/core/config/static_config/link.rs         |  11 +-
 src/core/config/static_config/mod.rs          |  10 +-
 .../config/static_config/server_static.rs     |  30 ++--
 .../server_static/headers_static.rs           |   3 +-
 .../server_static/routes_static.rs            |   2 +-
 .../config/static_config/static_config.rs     |   7 +-
 .../config/static_config/telemetry_static.rs  |  17 +--
 .../config/static_config/upstream_static.rs   |  11 +-
 .../static_config/upstream_static/batch.rs    |  12 +-
 src/core/config/utils/mod.rs                  |   2 +-
 src/core/config/utils/private_key.rs          |   4 +-
 src/core/http/request_context.rs              |  18 ++-
 src/core/http/request_handler.rs              |  41 +++---
 src/core/http/telemetry.rs                    |   4 +-
 src/core/jit/graphql_executor.rs              |   7 +-
 src/core/runtime.rs                           |   5 +-
 tests/core/parse.rs                           |   4 +-
 tests/core/runtime.rs                         |   5 +-
 tests/core/spec.rs                            |   2 +-
 tests/server_spec.rs                          |   5 +-
 55 files changed, 436 insertions(+), 684 deletions(-)
 delete mode 100644 src/core/blueprint/auth.rs
 delete mode 100644 src/core/blueprint/telemetry.rs

diff --git a/benches/handle_request_bench.rs b/benches/handle_request_bench.rs
index f33c52a895..efff2dee86 100644
--- a/benches/handle_request_bench.rs
+++ b/benches/handle_request_bench.rs
@@ -22,7 +22,7 @@ pub fn benchmark_handle_request(c: &mut Criterion) {
     let endpoints = config_module.extensions().endpoint_set.clone();
     let endpoints_clone = endpoints.clone();
 
-    blueprint.server.enable_jit = false;
+    blueprint.config.server.enable_jit = false;
     let server_config = tokio_runtime
         .block_on(ServerConfig::new(blueprint.clone(), endpoints.clone()))
         .unwrap();
@@ -47,7 +47,7 @@ pub fn benchmark_handle_request(c: &mut Criterion) {
         })
     });
 
-    blueprint_clone.server.enable_jit = true;
+    blueprint_clone.config.server.enable_jit = true;
     let server_config = tokio_runtime
         .block_on(ServerConfig::new(blueprint_clone, endpoints_clone))
         .unwrap();
diff --git a/benches/http_execute_bench.rs b/benches/http_execute_bench.rs
index c9a96edee6..71fbcd6da0 100644
--- a/benches/http_execute_bench.rs
+++ b/benches/http_execute_bench.rs
@@ -8,8 +8,8 @@ pub fn benchmark_http_execute_method(c: &mut Criterion) {
     let tokio_runtime = tokio::runtime::Runtime::new().unwrap();
 
     let mut blueprint = Blueprint::default();
-    blueprint.upstream.http_cache = 42; // allow http caching for bench test.
-    let native_http = NativeHttp::init(&blueprint.upstream, &blueprint.telemetry);
+    blueprint.config.upstream.http_cache = 42; // allow http caching for bench test.
+    let native_http = NativeHttp::init(&blueprint.config.upstream, &blueprint.config.telemetry);
     let request_url = String::from("http://jsonplaceholder.typicode.com/users");
 
     tokio_runtime.block_on(async {
diff --git a/benches/impl_path_string_for_evaluation_context.rs b/benches/impl_path_string_for_evaluation_context.rs
index e4eb603f67..406d341b9e 100644
--- a/benches/impl_path_string_for_evaluation_context.rs
+++ b/benches/impl_path_string_for_evaluation_context.rs
@@ -15,6 +15,7 @@ use reqwest::{Client, Request};
 use reqwest_middleware::{ClientBuilder, ClientWithMiddleware};
 use tailcall::core::blueprint::{Server, Upstream};
 use tailcall::core::cache::InMemoryCache;
+use tailcall::core::config::{ServerRuntime, UpstreamRuntime};
 use tailcall::core::http::{RequestContext, Response};
 use tailcall::core::ir::{EvalContext, ResolverContextLike, SelectionField};
 use tailcall::core::path::PathString;
@@ -242,6 +243,8 @@ fn request_context() -> RequestContext {
     let server = Server::try_from(config_module).unwrap();
     let http = Arc::new(Http::init(&upstream));
     let http2 = Arc::new(Http::init(&upstream.clone().http2_only(true)));
+    let server = ServerRuntime::from(server);
+    let upstream = UpstreamRuntime::from(upstream);
     let runtime = TargetRuntime {
         http2_only: http2,
         http,
diff --git a/generated/.tailcallrc.graphql b/generated/.tailcallrc.graphql
index 9dc5ed9dc1..b2e6a2be3d 100644
--- a/generated/.tailcallrc.graphql
+++ b/generated/.tailcallrc.graphql
@@ -373,7 +373,7 @@ directive, developers gain access to valuable insights into the performance and
 of their applications.
 """
 directive @telemetry(
-  export: TelemetryExporter
+  export: TelemetryExporterConfig
   """
   The list of headers that will be sent as additional attributes to telemetry exporters 
   Be careful about **leaking sensitive information** from requests when enabling the 
@@ -628,43 +628,43 @@ input Schema {
 """
 Type to configure Cross-Origin Resource Sharing (CORS) for a server.
 """
-input Cors {
+input CorsStatic {
   """
   Indicates whether the server allows credentials (e.g., cookies, authorization headers) 
   to be sent in cross-origin requests.
   """
-  allowCredentials: Boolean
+  allow_credentials: Boolean
   """
   A list of allowed headers in cross-origin requests. This can be used to specify custom 
   headers that are allowed to be included in cross-origin requests.
   """
-  allowHeaders: [String!]
+  allow_headers: [String!]
   """
   A list of allowed HTTP methods in cross-origin requests. These methods specify the 
   actions that are permitted in cross-origin requests.
   """
-  allowMethods: [Method]
+  allow_methods: [Method]
   """
   A list of origins that are allowed to access the server's resources in cross-origin 
   requests. An origin can be a domain, a subdomain, or even 'null' for local file schemes.
   """
-  allowOrigins: [String!]
+  allow_origins: [String!]
   """
   Indicates whether requests from private network addresses are allowed in cross-origin 
   requests. Private network addresses typically include IP addresses reserved for internal 
   networks.
   """
-  allowPrivateNetwork: Boolean
+  allow_private_network: Boolean
   """
   A list of headers that the server exposes to the browser in cross-origin responses. 
   Exposing certain headers allows the client-side code to access them in the response.
   """
-  exposeHeaders: [String!]
+  expose_headers: [String!]
   """
   The maximum time (in seconds) that the client should cache preflight OPTIONS requests 
   in order to avoid sending excessive requests to the server.
   """
-  maxAge: Int
+  max_age: Int
   """
   A list of header names that indicate the values of which might cause the server's 
   response to vary, potentially affecting caching.
@@ -674,16 +674,16 @@ input Cors {
 
 input Headers {
   """
-  `cacheControl` sends `Cache-Control` headers in responses when activated. The `max-age` 
+  `cache_control` sends `Cache-Control` headers in responses when activated. The `max-age` 
   value is the least of the values received from upstream services. @default `false`.
   """
-  cacheControl: Boolean
+  cache_control: Boolean
   """
   `cors` allows Cross-Origin Resource Sharing (CORS) for a server.
   """
-  cors: Cors
+  cors: CorsStatic
   """
-  `headers` are key-value pairs included in every server response. Useful for setting 
+  `custom` are key-value pairs included in every server response. Useful for setting 
   headers like `Access-Control-Allow-Origin` for cross-origin requests or additional 
   headers for downstream services.
   """
@@ -694,14 +694,23 @@ input Headers {
   """
   experimental: [String!]
   """
-  `setCookies` when enabled stores `set-cookie` headers and all the response will be 
-  sent with the headers.
+  `set_cookies` when enabled stores `set-cookie` headers and all the response will 
+  be sent with the headers.
   """
-  setCookies: Boolean
+  set_cookies: Boolean
 }
 
+"""
+Used to configure the default routes of the server.
+"""
 input Routes {
-  graphQL: String!
+  """
+  The path for the GraphQL endpoint. Defaults to `/graphql`.
+  """
+  graphql: String!
+  """
+  The path for the status endpoint. Defaults to `/status`.
+  """
   status: String!
 }
 
@@ -709,23 +718,23 @@ input ScriptOptions {
   timeout: Int
 }
 
-input Apollo {
+input ApolloTelemetry {
   """
-  Setting `apiKey` for Apollo.
+  Setting `api_key` for Apollo.
   """
-  apiKey: String!
+  api_key: String!
   """
-  Setting `graphRef` for Apollo in the format <graphId>@<variant>.
+  Setting `graph_ref` for Apollo in the format <graphId>@<variant>.
   """
-  graphRef: String!
+  graph_ref: String!
   """
   Setting `platform` for Apollo.
   """
   platform: String
   """
-  Setting `userVersion` for Apollo.
+  Setting `user_version` for Apollo.
   """
-  userVersion: String
+  user_version: String
   """
   Setting `version` for Apollo.
   """
@@ -735,7 +744,7 @@ input Apollo {
 """
 Output the opentelemetry data to otlp collector
 """
-input OtlpExporter {
+input OtlpExporterConfig {
   headers: [KeyValue]
   url: String!
 }
@@ -758,17 +767,17 @@ input StdoutExporter {
   pretty: Boolean!
 }
 
-input TelemetryExporter {
-  stdout: StdoutExporter
-  otlp: OtlpExporter
-  prometheus: PrometheusExporter
-  apollo: Apollo
+input TelemetryExporterConfig {
+  Stdout: StdoutExporter
+  Otlp: OtlpExporterConfig
+  Prometheus: PrometheusExporter
+  Apollo: ApolloTelemetry
 }
 
 input Batch {
   delay: Int!
   headers: [String!]
-  maxSize: Int
+  max_size: Int
 }
 
 input Proxy {
@@ -984,7 +993,7 @@ directive, developers gain access to valuable insights into the performance and
 of their applications.
 """
 input Telemetry {
-  export: TelemetryExporter
+  export: TelemetryExporterConfig
   """
   The list of headers that will be sent as additional attributes to telemetry exporters 
   Be careful about **leaking sensitive information** from requests when enabling the 
@@ -1010,6 +1019,9 @@ enum Method {
   TRACE
 }
 
+"""
+The acceptable types of linked files that can be loaded on bootstrap.
+"""
 enum LinkType {
   Config
   Protobuf
@@ -1031,6 +1043,6 @@ enum HttpVersion {
 Output format for prometheus data
 """
 enum PrometheusFormat {
-  text
-  protobuf
+  Text
+  Protobuf
 }
\ No newline at end of file
diff --git a/generated/.tailcallrc.schema.json b/generated/.tailcallrc.schema.json
index e32e9b91f8..2fbc9d3237 100644
--- a/generated/.tailcallrc.schema.json
+++ b/generated/.tailcallrc.schema.json
@@ -109,19 +109,19 @@
         }
       }
     },
-    "Apollo": {
+    "ApolloTelemetry": {
       "type": "object",
       "required": [
-        "apiKey",
-        "graphRef"
+        "api_key",
+        "graph_ref"
       ],
       "properties": {
-        "apiKey": {
-          "description": "Setting `apiKey` for Apollo.",
+        "api_key": {
+          "description": "Setting `api_key` for Apollo.",
           "type": "string"
         },
-        "graphRef": {
-          "description": "Setting `graphRef` for Apollo in the format <graphId>@<variant>.",
+        "graph_ref": {
+          "description": "Setting `graph_ref` for Apollo in the format <graphId>@<variant>.",
           "type": "string"
         },
         "platform": {
@@ -131,8 +131,8 @@
             "null"
           ]
         },
-        "userVersion": {
-          "description": "Setting `userVersion` for Apollo.",
+        "user_version": {
+          "description": "Setting `user_version` for Apollo.",
           "type": [
             "string",
             "null"
@@ -177,22 +177,24 @@
     },
     "Batch": {
       "type": "object",
+      "required": [
+        "delay",
+        "headers"
+      ],
       "properties": {
         "delay": {
-          "default": 0,
           "type": "integer",
           "format": "uint",
           "minimum": 0.0
         },
         "headers": {
-          "default": [],
           "type": "array",
           "items": {
             "type": "string"
           },
           "uniqueItems": true
         },
-        "maxSize": {
+        "max_size": {
           "type": [
             "integer",
             "null"
@@ -245,53 +247,53 @@
         }
       }
     },
-    "Cors": {
+    "CorsStatic": {
       "description": "Type to configure Cross-Origin Resource Sharing (CORS) for a server.",
       "type": "object",
       "properties": {
-        "allowCredentials": {
+        "allow_credentials": {
           "description": "Indicates whether the server allows credentials (e.g., cookies, authorization headers) to be sent in cross-origin requests.",
           "type": [
             "boolean",
             "null"
           ]
         },
-        "allowHeaders": {
+        "allow_headers": {
           "description": "A list of allowed headers in cross-origin requests. This can be used to specify custom headers that are allowed to be included in cross-origin requests.",
           "type": "array",
           "items": {
             "type": "string"
           }
         },
-        "allowMethods": {
+        "allow_methods": {
           "description": "A list of allowed HTTP methods in cross-origin requests. These methods specify the actions that are permitted in cross-origin requests.",
           "type": "array",
           "items": {
             "$ref": "#/definitions/Method"
           }
         },
-        "allowOrigins": {
+        "allow_origins": {
           "description": "A list of origins that are allowed to access the server's resources in cross-origin requests. An origin can be a domain, a subdomain, or even 'null' for local file schemes.",
           "type": "array",
           "items": {
             "type": "string"
           }
         },
-        "allowPrivateNetwork": {
+        "allow_private_network": {
           "description": "Indicates whether requests from private network addresses are allowed in cross-origin requests. Private network addresses typically include IP addresses reserved for internal networks.",
           "type": [
             "boolean",
             "null"
           ]
         },
-        "exposeHeaders": {
+        "expose_headers": {
           "description": "A list of headers that the server exposes to the browser in cross-origin responses. Exposing certain headers allows the client-side code to access them in the response.",
           "type": "array",
           "items": {
             "type": "string"
           }
         },
-        "maxAge": {
+        "max_age": {
           "description": "The maximum time (in seconds) that the client should cache preflight OPTIONS requests in order to avoid sending excessive requests to the server.",
           "type": [
             "integer",
@@ -662,8 +664,8 @@
     "Headers": {
       "type": "object",
       "properties": {
-        "cacheControl": {
-          "description": "`cacheControl` sends `Cache-Control` headers in responses when activated. The `max-age` value is the least of the values received from upstream services. @default `false`.",
+        "cache_control": {
+          "description": "`cache_control` sends `Cache-Control` headers in responses when activated. The `max-age` value is the least of the values received from upstream services. @default `false`.",
           "type": [
             "boolean",
             "null"
@@ -673,7 +675,7 @@
           "description": "`cors` allows Cross-Origin Resource Sharing (CORS) for a server.",
           "anyOf": [
             {
-              "$ref": "#/definitions/Cors"
+              "$ref": "#/definitions/CorsStatic"
             },
             {
               "type": "null"
@@ -681,7 +683,7 @@
           ]
         },
         "custom": {
-          "description": "`headers` are key-value pairs included in every server response. Useful for setting headers like `Access-Control-Allow-Origin` for cross-origin requests or additional headers for downstream services.",
+          "description": "`custom` are key-value pairs included in every server response. Useful for setting headers like `Access-Control-Allow-Origin` for cross-origin requests or additional headers for downstream services.",
           "type": "array",
           "items": {
             "$ref": "#/definitions/KeyValue"
@@ -698,8 +700,8 @@
           },
           "uniqueItems": true
         },
-        "setCookies": {
-          "description": "`setCookies` when enabled stores `set-cookie` headers and all the response will be sent with the headers.",
+        "set_cookies": {
+          "description": "`set_cookies` when enabled stores `set-cookie` headers and all the response will be sent with the headers.",
           "type": [
             "boolean",
             "null"
@@ -901,6 +903,7 @@
       "additionalProperties": false
     },
     "LinkType": {
+      "description": "The acceptable types of linked files that can be loaded on bootstrap.",
       "type": "string",
       "enum": [
         "Config",
@@ -951,7 +954,7 @@
       "type": "object",
       "additionalProperties": false
     },
-    "OtlpExporter": {
+    "OtlpExporterConfig": {
       "description": "Output the opentelemetry data to otlp collector",
       "type": "object",
       "required": [
@@ -990,8 +993,8 @@
       "description": "Output format for prometheus data",
       "type": "string",
       "enum": [
-        "text",
-        "protobuf"
+        "Text",
+        "Protobuf"
       ]
     },
     "Protected": {
@@ -1032,14 +1035,19 @@
       }
     },
     "Routes": {
+      "description": "Used to configure the default routes of the server.",
       "type": "object",
+      "required": [
+        "graphql",
+        "status"
+      ],
       "properties": {
-        "graphQL": {
-          "default": "/graphql",
+        "graphql": {
+          "description": "The path for the GraphQL endpoint. Defaults to `/graphql`.",
           "type": "string"
         },
         "status": {
-          "default": "/status",
+          "description": "The path for the status endpoint. Defaults to `/status`.",
           "type": "string"
         }
       }
@@ -1252,7 +1260,7 @@
         "export": {
           "anyOf": [
             {
-              "$ref": "#/definitions/TelemetryExporter"
+              "$ref": "#/definitions/TelemetryExporterConfig"
             },
             {
               "type": "null"
@@ -1269,15 +1277,15 @@
       },
       "additionalProperties": false
     },
-    "TelemetryExporter": {
+    "TelemetryExporterConfig": {
       "oneOf": [
         {
           "type": "object",
           "required": [
-            "stdout"
+            "Stdout"
           ],
           "properties": {
-            "stdout": {
+            "Stdout": {
               "$ref": "#/definitions/StdoutExporter"
             }
           },
@@ -1286,11 +1294,11 @@
         {
           "type": "object",
           "required": [
-            "otlp"
+            "Otlp"
           ],
           "properties": {
-            "otlp": {
-              "$ref": "#/definitions/OtlpExporter"
+            "Otlp": {
+              "$ref": "#/definitions/OtlpExporterConfig"
             }
           },
           "additionalProperties": false
@@ -1298,10 +1306,10 @@
         {
           "type": "object",
           "required": [
-            "prometheus"
+            "Prometheus"
           ],
           "properties": {
-            "prometheus": {
+            "Prometheus": {
               "$ref": "#/definitions/PrometheusExporter"
             }
           },
@@ -1310,11 +1318,11 @@
         {
           "type": "object",
           "required": [
-            "apollo"
+            "Apollo"
           ],
           "properties": {
-            "apollo": {
-              "$ref": "#/definitions/Apollo"
+            "Apollo": {
+              "$ref": "#/definitions/ApolloTelemetry"
             }
           },
           "additionalProperties": false
diff --git a/src/cli/javascript/mod.rs b/src/cli/javascript/mod.rs
index 173928a153..4e4a350110 100644
--- a/src/cli/javascript/mod.rs
+++ b/src/cli/javascript/mod.rs
@@ -9,9 +9,10 @@ mod runtime;
 
 pub use runtime::Runtime;
 
-use crate::core::{blueprint, WorkerIO};
+use crate::core::config::ScriptRuntime;
+use crate::core::WorkerIO;
 
-pub fn init_worker_io<T, V>(script: blueprint::Script) -> Arc<dyn WorkerIO<T, V> + Send + Sync>
+pub fn init_worker_io<T, V>(script: ScriptRuntime) -> Arc<dyn WorkerIO<T, V> + Send + Sync>
 where
     Runtime: WorkerIO<T, V>,
 {
diff --git a/src/cli/javascript/runtime.rs b/src/cli/javascript/runtime.rs
index a3c2fc6933..264856b0bc 100644
--- a/src/cli/javascript/runtime.rs
+++ b/src/cli/javascript/runtime.rs
@@ -5,8 +5,9 @@ use std::thread;
 use async_graphql_value::ConstValue;
 use rquickjs::{Context, Ctx, FromJs, Function, IntoJs, Value};
 
+use crate::core::config::ScriptRuntime;
 use crate::core::worker::{Command, Event, WorkerRequest};
-use crate::core::{blueprint, worker, WorkerIO};
+use crate::core::{worker, WorkerIO};
 
 struct LocalRuntime(Context);
 
@@ -33,10 +34,10 @@ fn setup_builtins(ctx: &Ctx<'_>) -> rquickjs::Result<()> {
     Ok(())
 }
 
-impl TryFrom<blueprint::Script> for LocalRuntime {
+impl TryFrom<ScriptRuntime> for LocalRuntime {
     type Error = anyhow::Error;
 
-    fn try_from(script: blueprint::Script) -> Result<Self, Self::Error> {
+    fn try_from(script: ScriptRuntime) -> Result<Self, Self::Error> {
         let source = script.source;
         let js_runtime = rquickjs::Runtime::new()?;
         let context = Context::full(&js_runtime)?;
@@ -51,7 +52,7 @@ impl TryFrom<blueprint::Script> for LocalRuntime {
 }
 
 pub struct Runtime {
-    script: blueprint::Script,
+    script: ScriptRuntime,
     // Single threaded JS runtime, that's shared across all tokio workers.
     tokio_runtime: Option<tokio::runtime::Runtime>,
 }
@@ -63,7 +64,7 @@ impl Debug for Runtime {
 }
 
 impl Runtime {
-    pub fn new(script: blueprint::Script) -> Self {
+    pub fn new(script: ScriptRuntime) -> Self {
         let tokio_runtime = tokio::runtime::Builder::new_multi_thread()
             .worker_threads(1)
             .build()
@@ -125,7 +126,7 @@ impl WorkerIO<ConstValue, ConstValue> for Runtime {
     }
 }
 
-fn init_rt(script: blueprint::Script) -> anyhow::Result<()> {
+fn init_rt(script: ScriptRuntime) -> anyhow::Result<()> {
     // initialize runtime if this is the first call
     // exit if failed to initialize
     LOCAL_RUNTIME.with(move |cell| {
diff --git a/src/cli/runtime/http.rs b/src/cli/runtime/http.rs
index 487febe544..50a045ff4b 100644
--- a/src/cli/runtime/http.rs
+++ b/src/cli/runtime/http.rs
@@ -17,8 +17,7 @@ use tailcall_http_cache::HttpCacheManager;
 use tracing_opentelemetry::OpenTelemetrySpanExt;
 
 use super::HttpIO;
-use crate::core::blueprint::telemetry::Telemetry;
-use crate::core::blueprint::Upstream;
+use crate::core::config::{TelemetryRuntime, UpstreamRuntime};
 use crate::core::http::Response;
 
 static HTTP_CLIENT_REQUEST_COUNT: Lazy<Counter<u64>> = Lazy::new(|| {
@@ -85,7 +84,7 @@ impl Default for NativeHttp {
 }
 
 impl NativeHttp {
-    pub fn init(upstream: &Upstream, telemetry: &Telemetry) -> Self {
+    pub fn init(upstream: &UpstreamRuntime, telemetry: &TelemetryRuntime) -> Self {
         let mut builder = Client::builder()
             .tcp_keepalive(Some(Duration::from_secs(upstream.tcp_keep_alive)))
             .timeout(Duration::from_secs(upstream.timeout))
@@ -253,7 +252,7 @@ mod tests {
             then.status(200).body("Hello");
         });
 
-        let upstream = Upstream { http_cache: 2, ..Default::default() };
+        let upstream = UpstreamRuntime { http_cache: 2, ..Default::default() };
         let native_http = NativeHttp::init(&upstream, &Default::default());
         let port = server.port();
 
diff --git a/src/cli/runtime/mod.rs b/src/cli/runtime/mod.rs
index d57bf1be31..307263f8a7 100644
--- a/src/cli/runtime/mod.rs
+++ b/src/cli/runtime/mod.rs
@@ -11,9 +11,10 @@ use inquire::{Confirm, Select};
 
 use crate::core::blueprint::Blueprint;
 use crate::core::cache::InMemoryCache;
+use crate::core::config::ScriptRuntime;
 use crate::core::runtime::TargetRuntime;
 use crate::core::worker::{Command, Event};
-use crate::core::{blueprint, EnvIO, FileIO, HttpIO, WorkerIO};
+use crate::core::{EnvIO, FileIO, HttpIO, WorkerIO};
 
 // Provides access to env in native rust environment
 fn init_env() -> Arc<dyn EnvIO> {
@@ -25,9 +26,7 @@ fn init_file() -> Arc<dyn FileIO> {
     Arc::new(file::NativeFileIO::init())
 }
 
-fn init_http_worker_io(
-    script: Option<blueprint::Script>,
-) -> Option<Arc<dyn WorkerIO<Event, Command>>> {
+fn init_http_worker_io(script: Option<ScriptRuntime>) -> Option<Arc<dyn WorkerIO<Event, Command>>> {
     #[cfg(feature = "js")]
     return Some(super::javascript::init_worker_io(script?));
     #[cfg(not(feature = "js"))]
@@ -38,7 +37,7 @@ fn init_http_worker_io(
 }
 
 fn init_resolver_worker_io(
-    script: Option<blueprint::Script>,
+    script: Option<ScriptRuntime>,
 ) -> Option<Arc<dyn WorkerIO<async_graphql::Value, async_graphql::Value>>> {
     #[cfg(feature = "js")]
     return Some(super::javascript::init_worker_io(script?));
@@ -52,16 +51,16 @@ fn init_resolver_worker_io(
 // Provides access to http in native rust environment
 fn init_http(blueprint: &Blueprint) -> Arc<dyn HttpIO> {
     Arc::new(http::NativeHttp::init(
-        &blueprint.upstream,
-        &blueprint.telemetry,
+        &blueprint.config.upstream,
+        &blueprint.config.telemetry,
     ))
 }
 
 // Provides access to http in native rust environment
 fn init_http2_only(blueprint: &Blueprint) -> Arc<dyn HttpIO> {
     Arc::new(http::NativeHttp::init(
-        &blueprint.upstream.clone().http2_only(true),
-        &blueprint.telemetry,
+        &blueprint.config.upstream.clone().http2_only(true),
+        &blueprint.config.telemetry,
     ))
 }
 
@@ -80,8 +79,8 @@ pub fn init(blueprint: &Blueprint) -> TargetRuntime {
         file: init_file(),
         cache: Arc::new(init_in_memory_cache()),
         extensions: Arc::new(vec![]),
-        cmd_worker: init_http_worker_io(blueprint.server.script.clone()),
-        worker: init_resolver_worker_io(blueprint.server.script.clone()),
+        cmd_worker: init_http_worker_io(blueprint.config.server.script.clone()),
+        worker: init_resolver_worker_io(blueprint.config.server.script.clone()),
     }
 }
 
diff --git a/src/cli/server/http_1.rs b/src/cli/server/http_1.rs
index 76360e860a..cde2e4403d 100644
--- a/src/cli/server/http_1.rs
+++ b/src/cli/server/http_1.rs
@@ -32,7 +32,7 @@ pub async fn start_http_1(
     });
     let builder = hyper::Server::try_bind(&addr)
         .map_err(Errata::from)?
-        .http1_pipeline_flush(sc.app_ctx.blueprint.server.pipeline_flush);
+        .http1_pipeline_flush(sc.app_ctx.blueprint.config.server.pipeline_flush);
     super::log_launch(sc.as_ref());
 
     if let Some(sender) = server_up_sender {
@@ -42,7 +42,7 @@ pub async fn start_http_1(
     }
 
     let server: std::prelude::v1::Result<(), hyper::Error> =
-        if sc.blueprint.server.enable_batch_requests {
+        if sc.blueprint.config.server.enable_batch_requests {
             builder.serve(make_svc_batch_req).await
         } else {
             builder.serve(make_svc_single_req).await
diff --git a/src/cli/server/http_2.rs b/src/cli/server/http_2.rs
index 7a38c74119..649001dadb 100644
--- a/src/cli/server/http_2.rs
+++ b/src/cli/server/http_2.rs
@@ -55,7 +55,7 @@ pub async fn start_http_2(
     }
 
     let server: std::prelude::v1::Result<(), hyper::Error> =
-        if sc.blueprint.server.enable_batch_requests {
+        if sc.blueprint.config.server.enable_batch_requests {
             builder.serve(make_svc_batch_req).await
         } else {
             builder.serve(make_svc_single_req).await
diff --git a/src/cli/server/http_server.rs b/src/cli/server/http_server.rs
index 3661c9f5f7..11f117187c 100644
--- a/src/cli/server/http_server.rs
+++ b/src/cli/server/http_server.rs
@@ -8,8 +8,8 @@ use super::http_1::start_http_1;
 use super::http_2::start_http_2;
 use super::server_config::ServerConfig;
 use crate::cli::telemetry::init_opentelemetry;
-use crate::core::blueprint::{Blueprint, Http};
-use crate::core::config::ConfigModule;
+use crate::core::blueprint::Blueprint;
+use crate::core::config::{ConfigModule, HttpVersionRuntime};
 use crate::core::Errata;
 
 pub struct Server {
@@ -36,13 +36,16 @@ impl Server {
         let endpoints = self.config_module.extensions().endpoint_set.clone();
         let server_config = Arc::new(ServerConfig::new(blueprint.clone(), endpoints).await?);
 
-        init_opentelemetry(blueprint.telemetry.clone(), &server_config.app_ctx.runtime)?;
+        init_opentelemetry(
+            blueprint.config.telemetry.clone(),
+            &server_config.app_ctx.runtime,
+        )?;
 
-        match blueprint.server.http.clone() {
-            Http::HTTP2 { cert, key } => {
+        match blueprint.config.server.http.clone() {
+            HttpVersionRuntime::HTTP2 { cert, key } => {
                 start_http_2(server_config, cert, key, self.server_up_sender).await
             }
-            Http::HTTP1 => start_http_1(server_config, self.server_up_sender).await,
+            HttpVersionRuntime::HTTP1 => start_http_1(server_config, self.server_up_sender).await,
         }
     }
 
diff --git a/src/cli/server/mod.rs b/src/cli/server/mod.rs
index 3cd410e27b..79515989cd 100644
--- a/src/cli/server/mod.rs
+++ b/src/cli/server/mod.rs
@@ -16,7 +16,7 @@ fn log_launch(sc: &ServerConfig) {
         sc.http_version()
     );
 
-    let gql_slug = sc.app_ctx.blueprint.server.routes.graphql();
+    let gql_slug = sc.app_ctx.blueprint.config.server.routes.graphql();
 
     let graphiql_url = sc.graphiql_url() + gql_slug;
     let url = playground::build_url(&graphiql_url);
diff --git a/src/cli/server/server_config.rs b/src/cli/server/server_config.rs
index b6fd3899c0..982e8b8682 100644
--- a/src/cli/server/server_config.rs
+++ b/src/cli/server/server_config.rs
@@ -5,8 +5,8 @@ use async_graphql_extension_apollo_tracing::ApolloTracing;
 
 use crate::cli::runtime::init;
 use crate::core::app_context::AppContext;
-use crate::core::blueprint::telemetry::TelemetryExporter;
-use crate::core::blueprint::{Blueprint, Http};
+use crate::core::blueprint::Blueprint;
+use crate::core::config::{HttpVersionRuntime, TelemetryExporterRuntime};
 use crate::core::rest::{EndpointSet, Unchecked};
 use crate::core::schema_extension::SchemaExtension;
 
@@ -24,7 +24,9 @@ impl ServerConfig {
 
         let mut extensions = vec![];
 
-        if let Some(TelemetryExporter::Apollo(apollo)) = blueprint.telemetry.export.as_ref() {
+        if let Some(TelemetryExporterRuntime::Apollo(apollo)) =
+            blueprint.config.telemetry.export.as_ref()
+        {
             let (graph_id, variant) = apollo.graph_ref.split_once('@').unwrap();
             extensions.push(SchemaExtension::new(ApolloTracing::new(
                 apollo.api_key.clone(),
@@ -43,12 +45,16 @@ impl ServerConfig {
     }
 
     pub fn addr(&self) -> SocketAddr {
-        (self.blueprint.server.hostname, self.blueprint.server.port).into()
+        (
+            self.blueprint.config.server.hostname,
+            self.blueprint.config.server.port,
+        )
+            .into()
     }
 
     pub fn http_version(&self) -> String {
-        match self.blueprint.server.http {
-            Http::HTTP2 { cert: _, key: _ } => "HTTP/2".to_string(),
+        match self.blueprint.config.server.http {
+            HttpVersionRuntime::HTTP2 { cert: _, key: _ } => "HTTP/2".to_string(),
             _ => "HTTP/1.1".to_string(),
         }
     }
diff --git a/src/cli/telemetry.rs b/src/cli/telemetry.rs
index 50ea364d41..bd282f0a82 100644
--- a/src/cli/telemetry.rs
+++ b/src/cli/telemetry.rs
@@ -24,7 +24,7 @@ use tracing_subscriber::layer::SubscriberExt;
 use tracing_subscriber::{Layer, Registry};
 
 use super::metrics::init_metrics;
-use crate::core::blueprint::telemetry::{OtlpExporter, Telemetry, TelemetryExporter};
+use crate::core::config::{OtlpExporterRuntime, TelemetryExporterRuntime, TelemetryRuntime};
 use crate::core::runtime::TargetRuntime;
 use crate::core::tracing::{
     default_tracing, default_tracing_tailcall, get_log_level, tailcall_filter_target,
@@ -53,7 +53,7 @@ fn pretty_encoder<T: Serialize>(writer: &mut dyn Write, data: T) -> Result<()> {
 }
 
 // TODO: add more options for otlp exporter if needed
-fn otlp_exporter(config: &OtlpExporter) -> TonicExporterBuilder {
+fn otlp_exporter(config: &OtlpExporterRuntime) -> TonicExporterBuilder {
     opentelemetry_otlp::new_exporter()
         .tonic()
         .with_endpoint(config.url.as_str())
@@ -61,10 +61,10 @@ fn otlp_exporter(config: &OtlpExporter) -> TonicExporterBuilder {
 }
 
 fn set_trace_provider(
-    exporter: &TelemetryExporter,
+    exporter: &TelemetryExporterRuntime,
 ) -> TraceResult<Option<OpenTelemetryLayer<Registry, Tracer>>> {
     let provider = match exporter {
-        TelemetryExporter::Stdout(config) => TracerProvider::builder()
+        TelemetryExporterRuntime::Stdout(config) => TracerProvider::builder()
             .with_batch_exporter(
                 {
                     let mut builder = opentelemetry_stdout::SpanExporterBuilder::default();
@@ -82,7 +82,7 @@ fn set_trace_provider(
             )
             .with_config(opentelemetry_sdk::trace::config().with_resource(RESOURCE.clone()))
             .build(),
-        TelemetryExporter::Otlp(config) => opentelemetry_otlp::new_pipeline()
+        TelemetryExporterRuntime::Otlp(config) => opentelemetry_otlp::new_pipeline()
             .tracing()
             .with_exporter(otlp_exporter(config))
             .with_trace_config(opentelemetry_sdk::trace::config().with_resource(RESOURCE.clone()))
@@ -92,8 +92,8 @@ fn set_trace_provider(
                 anyhow!("Failed to instantiate OTLP provider").into(),
             ))?,
         // Prometheus works only with metrics
-        TelemetryExporter::Prometheus(_) => return Ok(None),
-        TelemetryExporter::Apollo(_) => return Ok(None),
+        TelemetryExporterRuntime::Prometheus(_) => return Ok(None),
+        TelemetryExporterRuntime::Apollo(_) => return Ok(None),
     };
     let tracer = provider.tracer("tracing");
     let telemetry = tracing_opentelemetry::layer()
@@ -107,10 +107,10 @@ fn set_trace_provider(
 }
 
 fn set_logger_provider(
-    exporter: &TelemetryExporter,
+    exporter: &TelemetryExporterRuntime,
 ) -> LogResult<Option<OpenTelemetryTracingBridge<LoggerProvider, Logger>>> {
     let provider = match exporter {
-        TelemetryExporter::Stdout(config) => LoggerProvider::builder()
+        TelemetryExporterRuntime::Stdout(config) => LoggerProvider::builder()
             .with_batch_exporter(
                 {
                     let mut builder = opentelemetry_stdout::LogExporterBuilder::default();
@@ -127,15 +127,15 @@ fn set_logger_provider(
             )
             .with_config(opentelemetry_sdk::logs::config().with_resource(RESOURCE.clone()))
             .build(),
-        TelemetryExporter::Otlp(config) => opentelemetry_otlp::new_pipeline()
+        TelemetryExporterRuntime::Otlp(config) => opentelemetry_otlp::new_pipeline()
             .logging()
             .with_exporter(otlp_exporter(config))
             .with_log_config(opentelemetry_sdk::logs::config().with_resource(RESOURCE.clone()))
             .install_batch(runtime::Tokio)?
         ,
         // Prometheus works only with metrics
-        TelemetryExporter::Prometheus(_) => return Ok(None),
-        TelemetryExporter::Apollo(_) => return Ok(None),
+        TelemetryExporterRuntime::Prometheus(_) => return Ok(None),
+        TelemetryExporterRuntime::Apollo(_) => return Ok(None),
     };
 
     let otel_tracing_appender = OpenTelemetryTracingBridge::new(&provider);
@@ -143,9 +143,9 @@ fn set_logger_provider(
     Ok(Some(otel_tracing_appender))
 }
 
-fn set_meter_provider(exporter: &TelemetryExporter) -> MetricsResult<()> {
+fn set_meter_provider(exporter: &TelemetryExporterRuntime) -> MetricsResult<()> {
     let provider = match exporter {
-        TelemetryExporter::Stdout(config) => {
+        TelemetryExporterRuntime::Stdout(config) => {
             let mut builder = opentelemetry_stdout::MetricsExporterBuilder::default();
 
             if config.pretty {
@@ -162,12 +162,12 @@ fn set_meter_provider(exporter: &TelemetryExporter) -> MetricsResult<()> {
                 .with_resource(RESOURCE.clone())
                 .build()
         }
-        TelemetryExporter::Otlp(config) => opentelemetry_otlp::new_pipeline()
+        TelemetryExporterRuntime::Otlp(config) => opentelemetry_otlp::new_pipeline()
             .metrics(Tokio)
             .with_resource(RESOURCE.clone())
             .with_exporter(otlp_exporter(config))
             .build()?,
-        TelemetryExporter::Prometheus(_) => {
+        TelemetryExporterRuntime::Prometheus(_) => {
             let exporter = opentelemetry_prometheus::exporter()
                 .with_registry(prometheus::default_registry().clone())
                 .build()?;
@@ -192,7 +192,7 @@ fn set_tracing_subscriber(subscriber: impl Subscriber + Send + Sync) {
     let _ = tracing::subscriber::set_global_default(subscriber);
 }
 
-pub fn init_opentelemetry(config: Telemetry, runtime: &TargetRuntime) -> anyhow::Result<()> {
+pub fn init_opentelemetry(config: TelemetryRuntime, runtime: &TargetRuntime) -> anyhow::Result<()> {
     if let Some(export) = &config.export {
         global::set_error_handler(|error| {
             if !matches!(
diff --git a/src/core/app_context.rs b/src/core/app_context.rs
index af1963868e..8a3e764ca7 100644
--- a/src/core/app_context.rs
+++ b/src/core/app_context.rs
@@ -47,7 +47,7 @@ impl AppContext {
         for def in blueprint.definitions.iter_mut() {
             if let Definition::Object(def) = def {
                 for field in &mut def.fields {
-                    let upstream_batch = &blueprint.upstream.batch;
+                    let upstream_batch = &blueprint.config.upstream.batch;
                     field.map_expr(|expr| {
                         expr.modify(&mut |expr| match expr {
                             IR::IO(io) => match io {
@@ -138,7 +138,7 @@ impl AppContext {
 
         let schema = blueprint
             .to_schema_with(SchemaModifiers::default().extensions(runtime.extensions.clone()));
-        let auth = blueprint.server.auth.clone();
+        let auth = blueprint.config.server.auth.clone();
         let auth_ctx = GlobalAuthContext::new(auth);
 
         AppContext {
diff --git a/src/core/auth/basic.rs b/src/core/auth/basic.rs
index 1806d63205..ca3d596099 100644
--- a/src/core/auth/basic.rs
+++ b/src/core/auth/basic.rs
@@ -5,7 +5,7 @@ use htpasswd_verify::Htpasswd;
 use super::error::Error;
 use super::verification::Verification;
 use super::verify::Verify;
-use crate::core::blueprint;
+use crate::core::config::BasicRuntime;
 use crate::core::http::RequestContext;
 
 pub struct BasicVerifier {
@@ -36,7 +36,7 @@ impl Verify for BasicVerifier {
 }
 
 impl BasicVerifier {
-    pub fn new(options: blueprint::Basic) -> Self {
+    pub fn new(options: BasicRuntime) -> Self {
         Self { verifier: Htpasswd::new_owned(&options.htpasswd) }
     }
 }
@@ -46,21 +46,7 @@ pub mod tests {
     use http::header::HeaderValue;
 
     use super::*;
-
-    // testuser1:password123
-    // testuser2:mypassword
-    // testuser3:abc123
-    pub static HTPASSWD_TEST: &str = "
-testuser1:$apr1$e3dp9qh2$fFIfHU9bilvVZBl8TxKzL/
-testuser2:$2y$10$wJ/mZDURcAOBIrswCAKFsO0Nk7BpHmWl/XuhF7lNm3gBAFH3ofsuu
-testuser3:{SHA}Y2fEjdGT1W6nsLqtJbGUVeUp9e4=
-";
-
-    impl blueprint::Basic {
-        pub fn test_value() -> Self {
-            Self { htpasswd: HTPASSWD_TEST.to_owned() }
-        }
-    }
+    use crate::core::config::HTPASSWD_TEST;
 
     pub fn create_basic_auth_request(username: &str, password: &str) -> RequestContext {
         let mut req_context = RequestContext::default();
@@ -129,6 +115,6 @@ testuser3:{SHA}Y2fEjdGT1W6nsLqtJbGUVeUp9e4=
 
     // Helper function for setting up the provider
     fn setup_provider() -> BasicVerifier {
-        BasicVerifier::new(blueprint::Basic { htpasswd: HTPASSWD_TEST.to_owned() })
+        BasicVerifier::new(BasicRuntime { htpasswd: HTPASSWD_TEST.to_owned() })
     }
 }
diff --git a/src/core/auth/context.rs b/src/core/auth/context.rs
index 40ab641853..a25201d487 100644
--- a/src/core/auth/context.rs
+++ b/src/core/auth/context.rs
@@ -2,7 +2,7 @@ use std::sync::{Arc, RwLock};
 
 use super::verification::Verification;
 use super::verify::{AuthVerifier, Verify};
-use crate::core::blueprint::Auth;
+use crate::core::config::AuthRuntime;
 use crate::core::http::RequestContext;
 
 #[derive(Default)]
@@ -31,7 +31,7 @@ impl GlobalAuthContext {
 }
 
 impl GlobalAuthContext {
-    pub fn new(auth: Option<Auth>) -> Self {
+    pub fn new(auth: Option<AuthRuntime>) -> Self {
         Self { verifier: auth.map(AuthVerifier::from) }
     }
 }
@@ -62,7 +62,7 @@ impl From<&Arc<GlobalAuthContext>> for AuthContext {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::core::auth::basic::tests::{create_basic_auth_request, HTPASSWD_TEST};
+    use crate::core::auth::basic::tests::create_basic_auth_request;
     use crate::core::auth::basic::BasicVerifier;
     use crate::core::auth::error::Error;
     use crate::core::auth::jwt::jwt_verify::tests::{
@@ -70,7 +70,7 @@ mod tests {
     };
     use crate::core::auth::jwt::jwt_verify::JwtVerifier;
     use crate::core::auth::verify::Verifier;
-    use crate::core::blueprint;
+    use crate::core::config::{BasicRuntime, JwtRuntime, HTPASSWD_TEST};
 
     #[tokio::test]
     async fn validate_request_missing_credentials() {
@@ -109,8 +109,8 @@ mod tests {
     // Helper function for setting up the auth context
     async fn setup_auth_context() -> GlobalAuthContext {
         let basic_provider =
-            BasicVerifier::new(blueprint::Basic { htpasswd: HTPASSWD_TEST.to_owned() });
-        let jwt_options = blueprint::Jwt::test_value();
+            BasicVerifier::new(BasicRuntime { htpasswd: HTPASSWD_TEST.to_owned() });
+        let jwt_options = JwtRuntime::test_value();
         let jwt_provider = JwtVerifier::new(jwt_options);
 
         GlobalAuthContext {
diff --git a/src/core/auth/jwt/jwt_verify.rs b/src/core/auth/jwt/jwt_verify.rs
index 5238b4364e..b6ff94830f 100644
--- a/src/core/auth/jwt/jwt_verify.rs
+++ b/src/core/auth/jwt/jwt_verify.rs
@@ -6,7 +6,7 @@ use super::jwks::Jwks;
 use crate::core::auth::error::Error;
 use crate::core::auth::verification::Verification;
 use crate::core::auth::verify::Verify;
-use crate::core::blueprint;
+use crate::core::config::JwtRuntime;
 use crate::core::http::RequestContext;
 
 #[derive(Debug, Deserialize)]
@@ -23,12 +23,12 @@ pub struct JwtClaim {
 }
 
 pub struct JwtVerifier {
-    options: blueprint::Jwt,
+    options: JwtRuntime,
     decoder: Jwks,
 }
 
 impl JwtVerifier {
-    pub fn new(options: blueprint::Jwt) -> Self {
+    pub fn new(options: JwtRuntime) -> Self {
         Self {
             decoder: Jwks {
                 set: options.jwks.clone(),
@@ -78,7 +78,7 @@ impl Verify for JwtVerifier {
     }
 }
 
-pub fn validate_iss(options: &blueprint::Jwt, claims: &JwtClaim) -> bool {
+pub fn validate_iss(options: &JwtRuntime, claims: &JwtClaim) -> bool {
     options
         .issuer
         .as_ref()
@@ -92,7 +92,7 @@ pub fn validate_iss(options: &blueprint::Jwt, claims: &JwtClaim) -> bool {
         .unwrap_or(true)
 }
 
-pub fn validate_aud(options: &blueprint::Jwt, claims: &JwtClaim) -> bool {
+pub fn validate_aud(options: &JwtRuntime, claims: &JwtClaim) -> bool {
     let audiences = &options.audiences;
 
     if audiences.is_empty() {
@@ -152,7 +152,7 @@ pub mod tests {
         serde_json::from_value(value).unwrap()
     });
 
-    impl blueprint::Jwt {
+    impl JwtRuntime {
         pub fn test_value() -> Self {
             Self {
                 issuer: Default::default(),
@@ -175,7 +175,7 @@ pub mod tests {
 
     #[tokio::test]
     async fn validate_token_iss() {
-        let jwt_options = blueprint::Jwt::test_value();
+        let jwt_options = JwtRuntime::test_value();
         let jwt_provider = JwtVerifier::new(jwt_options);
 
         let valid = jwt_provider
@@ -184,10 +184,7 @@ pub mod tests {
 
         assert_eq!(valid, Verification::succeed());
 
-        let jwt_options = blueprint::Jwt {
-            issuer: Some("me".to_owned()),
-            ..blueprint::Jwt::test_value()
-        };
+        let jwt_options = JwtRuntime { issuer: Some("me".to_owned()), ..JwtRuntime::test_value() };
         let jwt_provider = JwtVerifier::new(jwt_options);
 
         let valid = jwt_provider
@@ -196,9 +193,9 @@ pub mod tests {
 
         assert_eq!(valid, Verification::succeed());
 
-        let jwt_options = blueprint::Jwt {
+        let jwt_options = JwtRuntime {
             issuer: Some("another".to_owned()),
-            ..blueprint::Jwt::test_value()
+            ..JwtRuntime::test_value()
         };
         let jwt_provider = JwtVerifier::new(jwt_options);
 
@@ -211,7 +208,7 @@ pub mod tests {
 
     #[tokio::test]
     async fn validate_token_aud() {
-        let jwt_options = blueprint::Jwt::test_value();
+        let jwt_options = JwtRuntime::test_value();
         let jwt_provider = JwtVerifier::new(jwt_options);
 
         let valid = jwt_provider
@@ -220,9 +217,9 @@ pub mod tests {
 
         assert_eq!(valid, Verification::succeed());
 
-        let jwt_options = blueprint::Jwt {
+        let jwt_options = JwtRuntime {
             audiences: HashSet::from_iter(["them".to_string()]),
-            ..blueprint::Jwt::test_value()
+            ..JwtRuntime::test_value()
         };
         let jwt_provider = JwtVerifier::new(jwt_options);
 
@@ -232,9 +229,9 @@ pub mod tests {
 
         assert_eq!(valid, Verification::succeed());
 
-        let jwt_options = blueprint::Jwt {
+        let jwt_options = JwtRuntime {
             audiences: HashSet::from_iter(["anothem".to_string()]),
-            ..blueprint::Jwt::test_value()
+            ..JwtRuntime::test_value()
         };
         let jwt_provider = JwtVerifier::new(jwt_options);
 
@@ -247,11 +244,10 @@ pub mod tests {
 
     mod iss {
         use super::*;
-        use crate::core::blueprint::Jwt;
 
         #[test]
         fn validate_iss_not_defined() {
-            let options = Jwt::test_value();
+            let options = JwtRuntime::test_value();
             let mut claims = JwtClaim::default();
 
             assert!(validate_iss(&options, &claims));
@@ -263,7 +259,7 @@ pub mod tests {
 
         #[test]
         fn validate_iss_defined() {
-            let options = Jwt { issuer: Some("iss".to_owned()), ..Jwt::test_value() };
+            let options = JwtRuntime { issuer: Some("iss".to_owned()), ..JwtRuntime::test_value() };
             let mut claims = JwtClaim::default();
 
             assert!(!validate_iss(&options, &claims));
@@ -282,11 +278,10 @@ pub mod tests {
         use std::collections::HashSet;
 
         use super::*;
-        use crate::core::blueprint::Jwt;
 
         #[test]
         fn validate_aud_not_defined() {
-            let options = Jwt::test_value();
+            let options = JwtRuntime::test_value();
             let mut claims = JwtClaim::default();
             assert!(validate_aud(&options, &claims));
 
@@ -299,9 +294,9 @@ pub mod tests {
 
         #[test]
         fn validate_aud_defined() {
-            let options = Jwt {
+            let options = JwtRuntime {
                 audiences: HashSet::from_iter(["aud1".to_owned(), "aud2".to_owned()]),
-                ..Jwt::test_value()
+                ..JwtRuntime::test_value()
             };
             let mut claims = JwtClaim::default();
             assert!(!validate_aud(&options, &claims));
diff --git a/src/core/auth/verify.rs b/src/core/auth/verify.rs
index 4c6934f939..da503b46e0 100644
--- a/src/core/auth/verify.rs
+++ b/src/core/auth/verify.rs
@@ -3,7 +3,7 @@ use futures_util::join;
 use super::basic::BasicVerifier;
 use super::jwt::jwt_verify::JwtVerifier;
 use super::verification::Verification;
-use crate::core::blueprint;
+use crate::core::config::{AuthProviderRuntime, AuthRuntime};
 use crate::core::http::RequestContext;
 
 #[async_trait::async_trait]
@@ -22,23 +22,23 @@ pub enum AuthVerifier {
     Or(Box<AuthVerifier>, Box<AuthVerifier>),
 }
 
-impl From<blueprint::Provider> for Verifier {
-    fn from(provider: blueprint::Provider) -> Self {
+impl From<AuthProviderRuntime> for Verifier {
+    fn from(provider: AuthProviderRuntime) -> Self {
         match provider {
-            blueprint::Provider::Basic(options) => Verifier::Basic(BasicVerifier::new(options)),
-            blueprint::Provider::Jwt(options) => Verifier::Jwt(JwtVerifier::new(options)),
+            AuthProviderRuntime::Basic(options) => Verifier::Basic(BasicVerifier::new(options)),
+            AuthProviderRuntime::Jwt(options) => Verifier::Jwt(JwtVerifier::new(options)),
         }
     }
 }
 
-impl From<blueprint::Auth> for AuthVerifier {
-    fn from(provider: blueprint::Auth) -> Self {
+impl From<AuthRuntime> for AuthVerifier {
+    fn from(provider: AuthRuntime) -> Self {
         match provider {
-            blueprint::Auth::Provider(provider) => AuthVerifier::Single(provider.into()),
-            blueprint::Auth::And(left, right) => {
+            AuthRuntime::Provider(provider) => AuthVerifier::Single(provider.into()),
+            AuthRuntime::And(left, right) => {
                 AuthVerifier::And(Box::new((*left).into()), Box::new((*right).into()))
             }
-            blueprint::Auth::Or(left, right) => {
+            AuthRuntime::Or(left, right) => {
                 AuthVerifier::Or(Box::new((*left).into()), Box::new((*right).into()))
             }
         }
@@ -81,7 +81,7 @@ mod tests {
     };
     use crate::core::auth::verification::Verification;
     use crate::core::auth::verify::Verify;
-    use crate::core::blueprint::{Auth, Basic, Jwt, Provider};
+    use crate::core::config::{AuthProviderRuntime, AuthRuntime, BasicRuntime, JwtRuntime};
     use crate::core::http::RequestContext;
 
     #[tokio::test]
@@ -143,20 +143,22 @@ mod tests {
     }
 
     fn setup_basic_verifier() -> AuthVerifier {
-        AuthVerifier::from(Auth::Provider(Provider::Basic(Basic::test_value())))
+        AuthVerifier::from(AuthRuntime::Provider(AuthProviderRuntime::Basic(
+            BasicRuntime::test_value(),
+        )))
     }
 
     fn setup_and_verifier() -> AuthVerifier {
-        AuthVerifier::from(Auth::And(
-            Auth::Provider(Provider::Basic(Basic::test_value())).into(),
-            Auth::Provider(Provider::Basic(Basic::test_value())).into(),
+        AuthVerifier::from(AuthRuntime::And(
+            AuthRuntime::Provider(AuthProviderRuntime::Basic(BasicRuntime::test_value())).into(),
+            AuthRuntime::Provider(AuthProviderRuntime::Basic(BasicRuntime::test_value())).into(),
         ))
     }
 
     fn setup_or_verifier() -> AuthVerifier {
-        AuthVerifier::from(Auth::Or(
-            Auth::Provider(Provider::Basic(Basic::test_value())).into(),
-            Auth::Provider(Provider::Jwt(Jwt::test_value())).into(),
+        AuthVerifier::from(AuthRuntime::Or(
+            AuthRuntime::Provider(AuthProviderRuntime::Basic(BasicRuntime::test_value())).into(),
+            AuthRuntime::Provider(AuthProviderRuntime::Jwt(JwtRuntime::test_value())).into(),
         ))
     }
 }
diff --git a/src/core/blueprint/auth.rs b/src/core/blueprint/auth.rs
deleted file mode 100644
index 55ab644626..0000000000
--- a/src/core/blueprint/auth.rs
+++ /dev/null
@@ -1,133 +0,0 @@
-use std::collections::HashSet;
-use std::fmt::Debug;
-
-use jsonwebtoken::jwk::JwkSet;
-use tailcall_valid::Valid;
-
-use crate::core::config::ConfigModule;
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Basic {
-    pub htpasswd: String,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Jwt {
-    pub issuer: Option<String>,
-    pub audiences: HashSet<String>,
-    pub optional_kid: bool,
-    pub jwks: JwkSet,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub enum Provider {
-    Basic(Basic),
-    Jwt(Jwt),
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub enum Auth {
-    Provider(Provider),
-    And(Box<Auth>, Box<Auth>),
-    Or(Box<Auth>, Box<Auth>),
-}
-
-impl Auth {
-    pub fn make(config_module: &ConfigModule) -> Valid<Option<Auth>, String> {
-        let htpasswd = config_module.extensions().htpasswd.iter().map(|htpasswd| {
-            Auth::Provider(Provider::Basic(Basic {
-                htpasswd: htpasswd.content.clone(),
-            }))
-        });
-
-        let jwks = config_module.extensions().jwks.iter().map(|jwks| {
-            Auth::Provider(Provider::Jwt(Jwt {
-                jwks: jwks.content.clone(),
-                // TODO: read those options from link instead of using defaults
-                issuer: Default::default(),
-                audiences: Default::default(),
-                optional_kid: Default::default(),
-            }))
-        });
-
-        let auth = htpasswd.chain(jwks).reduce(|left, right| left.or(right));
-
-        Valid::succeed(auth)
-    }
-
-    pub fn and(self, other: Self) -> Self {
-        Auth::And(Box::new(self), Box::new(other))
-    }
-
-    pub fn or(self, other: Self) -> Self {
-        Auth::Or(Box::new(self), Box::new(other))
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{Auth, Basic, Jwt, Provider};
-
-    fn test_basic_provider_1() -> Provider {
-        Provider::Basic(Basic { htpasswd: "1".into() })
-    }
-
-    fn test_basic_provider_2() -> Provider {
-        Provider::Basic(Basic { htpasswd: "2".into() })
-    }
-
-    fn test_jwt_provider() -> Provider {
-        Provider::Jwt(Jwt::test_value())
-    }
-
-    #[test]
-    fn and_basic_with_basic() {
-        let basic_provider_1 = test_basic_provider_1();
-        let basic_provider_2 = test_basic_provider_2();
-
-        assert_eq!(
-            Auth::Provider(basic_provider_1.clone()).and(Auth::Provider(basic_provider_2.clone())),
-            Auth::And(
-                Auth::Provider(basic_provider_1).into(),
-                Auth::Provider(basic_provider_2).into()
-            )
-        );
-    }
-
-    #[test]
-    fn and_basic_with_jwt() {
-        let basic_provider = test_basic_provider_1();
-        let jwt_provider = test_jwt_provider();
-
-        assert_eq!(
-            Auth::Provider(basic_provider.clone()).and(Auth::Provider(jwt_provider.clone())),
-            Auth::And(
-                Auth::Provider(basic_provider).into(),
-                Auth::Provider(jwt_provider).into()
-            )
-        );
-    }
-
-    #[test]
-    fn and_nested_and_with_jwt() {
-        let basic_provider_1 = test_basic_provider_1();
-        let basic_provider_2 = test_basic_provider_2();
-        let jwt_provider = test_jwt_provider();
-
-        assert_eq!(
-            Auth::And(
-                Auth::Provider(basic_provider_1.clone()).into(),
-                Auth::Provider(basic_provider_2.clone()).into()
-            )
-            .and(Auth::Provider(jwt_provider.clone())),
-            Auth::And(
-                Auth::And(
-                    Auth::Provider(basic_provider_1).into(),
-                    Auth::Provider(basic_provider_2).into()
-                )
-                .into(),
-                Auth::Provider(jwt_provider).into()
-            )
-        );
-    }
-}
diff --git a/src/core/blueprint/blueprint.rs b/src/core/blueprint/blueprint.rs
index decd19d822..aeac0315d4 100644
--- a/src/core/blueprint/blueprint.rs
+++ b/src/core/blueprint/blueprint.rs
@@ -7,9 +7,8 @@ use async_graphql::ValidationMode;
 use derive_setters::Setters;
 
 use super::directive::Directive;
-use super::telemetry::Telemetry;
 use super::{GlobalTimeout, Index};
-use crate::core::blueprint::{Server, Upstream};
+use crate::core::config::RuntimeConfig;
 use crate::core::ir::model::IR;
 use crate::core::schema_extension::SchemaExtension;
 use crate::core::{scalar, Type};
@@ -22,9 +21,7 @@ use crate::core::{scalar, Type};
 pub struct Blueprint {
     pub definitions: Vec<Definition>,
     pub schema: SchemaDefinition,
-    pub server: Server,
-    pub upstream: Upstream,
-    pub telemetry: Telemetry,
+    pub config: RuntimeConfig,
 }
 
 #[derive(Clone, Debug)]
@@ -210,7 +207,7 @@ impl Blueprint {
             self.clone()
         };
 
-        let server = &blueprint.server;
+        let server = &blueprint.config.server;
         let mut schema = SchemaBuilder::from(&blueprint);
 
         if server.enable_apollo_tracing {
diff --git a/src/core/blueprint/from_config.rs b/src/core/blueprint/from_config.rs
index e9a8d094b3..a9428879a3 100644
--- a/src/core/blueprint/from_config.rs
+++ b/src/core/blueprint/from_config.rs
@@ -4,20 +4,22 @@ use async_graphql::dynamic::SchemaBuilder;
 use indexmap::IndexMap;
 use tailcall_valid::{Valid, ValidationError, Validator};
 
-use self::telemetry::to_opentelemetry;
 use super::Server;
 use crate::core::blueprint::compress::compress;
 use crate::core::blueprint::*;
 use crate::core::config::transformer::Required;
-use crate::core::config::{Arg, Batch, Config, ConfigModule};
+use crate::core::config::{to_opentelemetry, Arg, Batch, Config, ConfigModule};
 use crate::core::ir::model::{IO, IR};
 use crate::core::json::JsonSchema;
 use crate::core::try_fold::TryFold;
 use crate::core::Type;
 
 pub fn config_blueprint<'a>() -> TryFold<'a, ConfigModule, Blueprint, String> {
-    let server = TryFoldConfig::<Blueprint>::new(|config_module, blueprint| {
-        Valid::from(Server::try_from(config_module.clone())).map(|server| blueprint.server(server))
+    let server = TryFoldConfig::<Blueprint>::new(|config_module, mut blueprint| {
+        Valid::from(Server::try_from(config_module.clone())).map(|server| {
+            blueprint.config = blueprint.config.server(server.into());
+            blueprint
+        })
     });
 
     let schema = to_schema().transform::<Blueprint>(
@@ -30,8 +32,11 @@ pub fn config_blueprint<'a>() -> TryFold<'a, ConfigModule, Blueprint, String> {
         |blueprint| blueprint.definitions,
     );
 
-    let upstream = TryFoldConfig::<Blueprint>::new(|config_module, blueprint| {
-        Valid::from(Upstream::try_from(config_module)).map(|upstream| blueprint.upstream(upstream))
+    let upstream = TryFoldConfig::<Blueprint>::new(|config_module, mut blueprint| {
+        Valid::from(Upstream::try_from(config_module)).map(|upstream| {
+            blueprint.config = blueprint.config.upstream(upstream.into());
+            blueprint
+        })
     });
 
     let links = TryFoldConfig::<Blueprint>::new(|config_module, blueprint| {
@@ -39,8 +44,11 @@ pub fn config_blueprint<'a>() -> TryFold<'a, ConfigModule, Blueprint, String> {
     });
 
     let opentelemetry = to_opentelemetry().transform::<Blueprint>(
-        |opentelemetry, blueprint| blueprint.telemetry(opentelemetry),
-        |blueprint| blueprint.telemetry,
+        |opentelemetry, mut blueprint| {
+            blueprint.config = blueprint.config.telemetry(opentelemetry);
+            blueprint
+        },
+        |blueprint| blueprint.config.telemetry,
     );
 
     server
@@ -63,7 +71,8 @@ pub fn apply_batching(mut blueprint: Blueprint) -> Blueprint {
         if let Definition::Object(object_type_definition) = def {
             for field in object_type_definition.fields.iter() {
                 if let Some(IR::IO(IO::Http { group_by: Some(_), .. })) = field.resolver.clone() {
-                    blueprint.upstream.batch = blueprint.upstream.batch.or(Some(Batch::default()));
+                    blueprint.config.upstream.batch =
+                        blueprint.config.upstream.batch.or(Some(Batch::default()));
                     return blueprint;
                 }
             }
diff --git a/src/core/blueprint/mod.rs b/src/core/blueprint/mod.rs
index 93c97302d0..1065ccaf24 100644
--- a/src/core/blueprint/mod.rs
+++ b/src/core/blueprint/mod.rs
@@ -1,4 +1,3 @@
-mod auth;
 mod blueprint;
 mod compress;
 mod cors;
@@ -15,12 +14,10 @@ mod mustache;
 mod operators;
 mod schema;
 mod server;
-pub mod telemetry;
 mod timeout;
 mod union_resolver;
 mod upstream;
 
-pub use auth::*;
 pub use blueprint::*;
 pub use cors::*;
 pub use definitions::*;
diff --git a/src/core/blueprint/server.rs b/src/core/blueprint/server.rs
index 0d2a34a151..481dc16797 100644
--- a/src/core/blueprint/server.rs
+++ b/src/core/blueprint/server.rs
@@ -5,12 +5,13 @@ use std::time::Duration;
 
 use derive_setters::Setters;
 use http::header::{HeaderMap, HeaderName, HeaderValue};
-use rustls_pki_types::CertificateDer;
 use tailcall_valid::{Valid, ValidationError, Validator};
 
-use super::Auth;
 use crate::core::config::cors_static::CorsStatic;
-use crate::core::config::{self, ConfigModule, CorsRuntime, HttpVersion, PrivateKey, Routes};
+use crate::core::config::{
+    self, AuthRuntime, ConfigModule, CorsRuntime, HttpVersion, HttpVersionRuntime, Routes,
+    ScriptRuntime,
+};
 
 #[derive(Clone, Debug, Setters)]
 pub struct Server {
@@ -29,31 +30,15 @@ pub struct Server {
     pub hostname: IpAddr,
     pub vars: BTreeMap<String, String>,
     pub response_headers: HeaderMap,
-    pub http: Http,
+    pub http: HttpVersionRuntime,
     pub pipeline_flush: bool,
-    pub script: Option<Script>,
+    pub script: Option<ScriptRuntime>,
     pub cors: Option<CorsRuntime>,
     pub experimental_headers: HashSet<HeaderName>,
-    pub auth: Option<Auth>,
+    pub auth: Option<AuthRuntime>,
     pub routes: Routes,
 }
 
-/// Mimic of mini_v8::Script that's wasm compatible
-#[derive(Clone, Debug)]
-pub struct Script {
-    pub source: String,
-    pub timeout: Option<Duration>,
-}
-
-#[derive(Clone, Debug)]
-pub enum Http {
-    HTTP1,
-    HTTP2 {
-        cert: Vec<CertificateDer<'static>>,
-        key: PrivateKey,
-    },
-}
-
 impl Default for Server {
     fn default() -> Self {
         // NOTE: Using unwrap because try_from default will never fail
@@ -104,9 +89,9 @@ impl TryFrom<crate::core::config::ConfigModule> for Server {
                     .ok_or_else(|| ValidationError::new("Key is required for HTTP2".to_string()))?
                     .clone();
 
-                Valid::succeed(Http::HTTP2 { cert, key })
+                Valid::succeed(HttpVersionRuntime::HTTP2 { cert, key })
             }
-            _ => Valid::succeed(Http::HTTP1),
+            _ => Valid::succeed(HttpVersionRuntime::HTTP1),
         };
 
         validate_hostname((config_server).get_hostname().to_lowercase())
@@ -124,7 +109,7 @@ impl TryFrom<crate::core::config::ConfigModule> for Server {
                     .as_ref()
                     .and_then(|headers| headers.get_cors()),
             ))
-            .fuse(Auth::make(&config_module))
+            .fuse(AuthRuntime::make(&config_module))
             .map(
                 |(hostname, http, response_headers, script, experimental_headers, cors, auth)| {
                     Server {
@@ -157,11 +142,13 @@ impl TryFrom<crate::core::config::ConfigModule> for Server {
     }
 }
 
-fn to_script(config_module: &crate::core::config::ConfigModule) -> Valid<Option<Script>, String> {
+fn to_script(
+    config_module: &crate::core::config::ConfigModule,
+) -> Valid<Option<ScriptRuntime>, String> {
     config_module.extensions().script.as_ref().map_or_else(
         || Valid::succeed(None),
         |script| {
-            Valid::succeed(Some(Script {
+            Valid::succeed(Some(ScriptRuntime {
                 source: script.clone(),
                 timeout: config_module
                     .server
diff --git a/src/core/blueprint/telemetry.rs b/src/core/blueprint/telemetry.rs
deleted file mode 100644
index ac628c3082..0000000000
--- a/src/core/blueprint/telemetry.rs
+++ /dev/null
@@ -1,128 +0,0 @@
-use std::str::FromStr;
-
-use http::header::{HeaderMap, HeaderName, HeaderValue};
-use tailcall_valid::{Valid, ValidationError, Validator};
-use url::Url;
-
-use super::TryFoldConfig;
-use crate::core::config::{
-    self, ApolloTelemetry, ConfigModule, KeyValue, PrometheusExporter, StdoutExporter
-};
-use crate::core::directive::DirectiveCodec;
-use crate::core::try_fold::TryFold;
-
-#[derive(Debug, Clone)]
-pub struct OtlpExporter {
-    pub url: Url,
-    pub headers: HeaderMap,
-}
-
-#[derive(Debug, Clone)]
-pub enum TelemetryExporter {
-    Stdout(StdoutExporter),
-    Otlp(OtlpExporter),
-    Prometheus(PrometheusExporter),
-    Apollo(ApolloTelemetry),
-}
-
-#[derive(Debug, Default, Clone)]
-pub struct Telemetry {
-    pub export: Option<TelemetryExporter>,
-    pub request_headers: Vec<String>,
-}
-
-fn to_url(url: &str) -> Valid<Url, String> {
-    Valid::from(Url::parse(url).map_err(|e| ValidationError::new(e.to_string()))).trace("url")
-}
-
-fn to_headers(headers: Vec<KeyValue>) -> Valid<HeaderMap, String> {
-    Valid::from_iter(headers.iter(), |key_value| {
-        Valid::from(
-            HeaderName::from_str(&key_value.key)
-                .map_err(|err| ValidationError::new(err.to_string())),
-        )
-        .zip(Valid::from(
-            HeaderValue::from_str(&key_value.value)
-                .map_err(|err| ValidationError::new(err.to_string())),
-        ))
-    })
-    .map(HeaderMap::from_iter)
-    .trace("headers")
-}
-
-pub fn to_opentelemetry<'a>() -> TryFold<'a, ConfigModule, Telemetry, String> {
-    TryFoldConfig::<Telemetry>::new(|config, up| {
-        if let Some(export) = config.telemetry.export.as_ref() {
-            let export = match export {
-                config::TelemetryExporterConfig::Stdout(config) => {
-                    Valid::succeed(TelemetryExporter::Stdout(config.clone()))
-                }
-                config::TelemetryExporterConfig::Otlp(config) => to_url(&config.url)
-                    .zip(to_headers(config.headers.clone()))
-                    .map(|(url, headers)| TelemetryExporter::Otlp(OtlpExporter { url, headers }))
-                    .trace("otlp"),
-                config::TelemetryExporterConfig::Prometheus(config) => {
-                    Valid::succeed(TelemetryExporter::Prometheus(config.clone()))
-                }
-                config::TelemetryExporterConfig::Apollo(apollo) => validate_apollo(apollo.clone())
-                    .and_then(|apollo| Valid::succeed(TelemetryExporter::Apollo(apollo))),
-            };
-
-            export
-                .map(|export| Telemetry {
-                    export: Some(export),
-                    request_headers: config.telemetry.request_headers.clone(),
-                })
-                .trace(config::Telemetry::trace_name().as_str())
-        } else {
-            Valid::succeed(up)
-        }
-    })
-}
-
-fn validate_apollo(apollo: ApolloTelemetry) -> Valid<ApolloTelemetry, String> {
-    validate_graph_ref(&apollo.graph_ref)
-        .map(|_| apollo)
-        .trace("apollo.graph_ref")
-}
-
-fn validate_graph_ref(graph_ref: &str) -> Valid<(), String> {
-    let is_valid = regex::Regex::new(r"^[A-Za-z0-9-_]+@[A-Za-z0-9-_]+$")
-        .unwrap()
-        .is_match(graph_ref);
-    if is_valid {
-        Valid::succeed(())
-    } else {
-        Valid::fail(format!("`graph_ref` should be in the format <graph_id>@<variant> where `graph_id` and `variant` can only contain letters, numbers, '-' and '_'. Found {graph_ref}").to_string())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use tailcall_valid::Valid;
-
-    use super::validate_graph_ref;
-
-    #[test]
-    fn test_validate_graph_ref() {
-        let success = || Valid::succeed(());
-        let failure = |graph_ref| {
-            Valid::fail(format!("`graph_ref` should be in the format <graph_id>@<variant> where `graph_id` and `variant` can only contain letters, numbers, '-' and '_'. Found {graph_ref}").to_string())
-        };
-
-        assert_eq!(validate_graph_ref("graph_id@variant"), success());
-        assert_eq!(
-            validate_graph_ref("gr@ph_id@variant"),
-            failure("gr@ph_id@variant")
-        );
-        assert_eq!(validate_graph_ref("graph-Id@variant"), success());
-        assert_eq!(
-            validate_graph_ref("graph$id@variant1"),
-            failure("graph$id@variant1")
-        );
-        assert_eq!(
-            validate_graph_ref("gr@ph_id@variant"),
-            failure("gr@ph_id@variant")
-        );
-    }
-}
diff --git a/src/core/blueprint/upstream.rs b/src/core/blueprint/upstream.rs
index e8304ac224..2ef11b7c7a 100644
--- a/src/core/blueprint/upstream.rs
+++ b/src/core/blueprint/upstream.rs
@@ -3,12 +3,7 @@ use std::collections::BTreeSet;
 use derive_setters::Setters;
 use tailcall_valid::{Valid, ValidationError, Validator};
 
-use crate::core::config::{self, Batch, ConfigModule};
-
-#[derive(PartialEq, Eq, Clone, Debug, schemars::JsonSchema)]
-pub struct Proxy {
-    pub url: String,
-}
+use crate::core::config::{self, Batch, ConfigModule, Proxy};
 
 #[derive(PartialEq, Eq, Clone, Debug, Setters, schemars::JsonSchema)]
 pub struct Upstream {
diff --git a/src/core/config/config_module.rs b/src/core/config/config_module.rs
index c5d01076f5..d0dcd0bf78 100644
--- a/src/core/config/config_module.rs
+++ b/src/core/config/config_module.rs
@@ -6,6 +6,7 @@ use prost_reflect::prost_types::{FileDescriptorProto, FileDescriptorSet};
 use rustls_pki_types::CertificateDer;
 use tailcall_valid::{Valid, Validator};
 
+use super::PrivateKey;
 use crate::core::config::Config;
 use crate::core::macros::MergeRight;
 use crate::core::merge_right::MergeRight;
@@ -13,8 +14,6 @@ use crate::core::proto_reader::ProtoMetadata;
 use crate::core::rest::{EndpointSet, Unchecked};
 use crate::core::Transform;
 
-use super::PrivateKey;
-
 mod merge;
 
 /// A wrapper on top of Config that contains all the resolved extensions and
diff --git a/src/core/config/directives/server.rs b/src/core/config/directives/server.rs
index 768f6c6cf4..97da76c551 100644
--- a/src/core/config/directives/server.rs
+++ b/src/core/config/directives/server.rs
@@ -3,7 +3,9 @@ use std::collections::{BTreeMap, BTreeSet};
 use serde::{Deserialize, Serialize};
 use tailcall_macros::DirectiveDefinition;
 
-use crate::core::config::{merge_key_value_vecs, Headers, HttpVersion, KeyValue, Routes, ScriptOptions};
+use crate::core::config::{
+    merge_key_value_vecs, Headers, HttpVersion, KeyValue, Routes, ScriptOptions,
+};
 use crate::core::is_default;
 use crate::core::macros::MergeRight;
 
diff --git a/src/core/config/directives/telemetry.rs b/src/core/config/directives/telemetry.rs
index dd0983dd0d..d2be665813 100644
--- a/src/core/config/directives/telemetry.rs
+++ b/src/core/config/directives/telemetry.rs
@@ -74,15 +74,18 @@ impl Telemetry {
 
 #[cfg(test)]
 mod tests {
-    use crate::core::config::{OtlpExporterConfig, PrometheusExporter, PrometheusFormat, StdoutExporter};
-
     use super::*;
+    use crate::core::config::{
+        OtlpExporterConfig, PrometheusExporter, PrometheusFormat, StdoutExporter,
+    };
 
     #[test]
     fn merge_right() {
         let exporter_none = Telemetry { export: None, ..Default::default() };
         let exporter_stdout = Telemetry {
-            export: Some(TelemetryExporterConfig::Stdout(StdoutExporter { pretty: true })),
+            export: Some(TelemetryExporterConfig::Stdout(StdoutExporter {
+                pretty: true,
+            })),
             ..Default::default()
         };
         let exporter_otlp_1 = Telemetry {
diff --git a/src/core/config/mod.rs b/src/core/config/mod.rs
index 8001369473..72b1384cfd 100644
--- a/src/core/config/mod.rs
+++ b/src/core/config/mod.rs
@@ -15,11 +15,11 @@ mod into_document;
 mod npo;
 pub mod reader;
 mod resolver;
+pub mod runtime_config;
+pub mod static_config;
 pub mod transformer;
 mod url_query;
 pub mod utils;
-pub mod static_config;
-pub mod runtime_config;
-pub use utils::*;
-pub use static_config::*;
 pub use runtime_config::*;
+pub use static_config::*;
+pub use utils::*;
diff --git a/src/core/config/runtime_config/runtime_config.rs b/src/core/config/runtime_config/runtime_config.rs
index 90ce3ab96b..32af28f704 100644
--- a/src/core/config/runtime_config/runtime_config.rs
+++ b/src/core/config/runtime_config/runtime_config.rs
@@ -1,5 +1,8 @@
+use derive_setters::Setters;
+
 use super::{ServerRuntime, TelemetryRuntime, UpstreamRuntime};
 
+#[derive(Clone, Debug, Default, Setters)]
 pub struct RuntimeConfig {
     pub server: ServerRuntime,
     pub upstream: UpstreamRuntime,
diff --git a/src/core/config/runtime_config/server_runtime.rs b/src/core/config/runtime_config/server_runtime.rs
index c6fe945a60..e1a601eee7 100644
--- a/src/core/config/runtime_config/server_runtime.rs
+++ b/src/core/config/runtime_config/server_runtime.rs
@@ -8,9 +8,9 @@ use http::header::{HeaderMap, HeaderName, HeaderValue};
 use rustls_pki_types::CertificateDer;
 use tailcall_valid::{Valid, ValidationError, Validator};
 
+use crate::core::blueprint;
 use crate::core::config::cors_static::CorsStatic;
-use crate::core::config::Routes;
-use crate::core::config::{self, ConfigModule, HttpVersion, PrivateKey};
+use crate::core::config::{self, ConfigModule, HttpVersion, PrivateKey, Routes};
 
 pub mod auth_runtime;
 pub use auth_runtime::*;
@@ -162,7 +162,38 @@ impl TryFrom<crate::core::config::ConfigModule> for ServerRuntime {
     }
 }
 
-fn to_script(config_module: &crate::core::config::ConfigModule) -> Valid<Option<ScriptRuntime>, String> {
+impl From<blueprint::Server> for ServerRuntime {
+    fn from(server: blueprint::Server) -> Self {
+        Self {
+            enable_jit: server.enable_jit,
+            enable_apollo_tracing: server.enable_apollo_tracing,
+            enable_cache_control_header: server.enable_cache_control_header,
+            enable_set_cookie_header: server.enable_set_cookie_header,
+            enable_introspection: server.enable_introspection,
+            enable_query_validation: server.enable_query_validation,
+            enable_response_validation: server.enable_response_validation,
+            enable_batch_requests: server.enable_batch_requests,
+            enable_showcase: server.enable_showcase,
+            global_response_timeout: server.global_response_timeout,
+            worker: server.worker,
+            port: server.port,
+            hostname: server.hostname,
+            vars: server.vars,
+            response_headers: server.response_headers,
+            http: server.http,
+            pipeline_flush: server.pipeline_flush,
+            script: server.script,
+            cors: server.cors,
+            experimental_headers: server.experimental_headers,
+            auth: server.auth,
+            routes: server.routes,
+        }
+    }
+}
+
+fn to_script(
+    config_module: &crate::core::config::ConfigModule,
+) -> Valid<Option<ScriptRuntime>, String> {
     config_module.extensions().script.as_ref().map_or_else(
         || Valid::succeed(None),
         |script| {
diff --git a/src/core/config/runtime_config/server_runtime/auth_runtime.rs b/src/core/config/runtime_config/server_runtime/auth_runtime.rs
index 988f47c2f3..64140eb466 100644
--- a/src/core/config/runtime_config/server_runtime/auth_runtime.rs
+++ b/src/core/config/runtime_config/server_runtime/auth_runtime.rs
@@ -50,6 +50,21 @@ pub struct BasicRuntime {
     pub htpasswd: String,
 }
 
+// testuser1:password123
+// testuser2:mypassword
+// testuser3:abc123
+pub static HTPASSWD_TEST: &str = "
+testuser1:$apr1$e3dp9qh2$fFIfHU9bilvVZBl8TxKzL/
+testuser2:$2y$10$wJ/mZDURcAOBIrswCAKFsO0Nk7BpHmWl/XuhF7lNm3gBAFH3ofsuu
+testuser3:{SHA}Y2fEjdGT1W6nsLqtJbGUVeUp9e4=
+";
+
+impl BasicRuntime {
+    pub fn test_value() -> Self {
+        Self { htpasswd: HTPASSWD_TEST.to_owned() }
+    }
+}
+
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct JwtRuntime {
     pub issuer: Option<String>,
@@ -70,40 +85,6 @@ mod tests {
 
     use super::*;
 
-    pub static JWK_SET: Lazy<JwkSet> = Lazy::new(|| {
-        let value = serde_json::json!({
-          "keys": [
-            {
-              "kty": "RSA",
-              "use": "sig",
-              "alg": "RS256",
-              "kid": "I48qMJp566SSKQogYXYtHBo9q6ZcEKHixNPeNoxV1c8",
-              "n": "ksMb5oMlhJ_HzAebCuBG6-v5Qc4J111ur7Aux6-8SbxzqFONsf2Bw6ATG8pAfNeZ-USA3_T1mGkYTDvfoggXnxsduWV_lePZKKOq_Qp_EDdzic1bVTJQDad3CXldR3wV6UFDtMx6cCLXxPZM5n76e7ybPt0iNgwoGpJE28emMZJXrnEUFzxwFMq61UlzWEumYqW3uOUVp7r5XAF5jQ_1nQAnpHBnRFzdNPVb3E6odMGu3jgp8mkPbPMP16Fund4LVplLz8yrsE9TdVrSdYJThylRWn_BwvJ0DjUcp8ibJya86iClUlixAmBwR9NdStHwQqHwmMXMKkTXo-ytRmSUobzxX9T8ESkij6iBhQpmDMD3FbkK30Y7pUVEBBOyDfNcWOhholjOj9CRrxu9to5rc2wvufe24VlbKb9wngS_uGfK4AYvVyrcjdYMFkdqw-Mft14HwzdO2BTS0TeMDZuLmYhj_bu5_g2Zu6PH5OpIXF6Fi8_679pCG8wWAcFQrFrM0eA70wD_SqD_BXn6pWRpFXlcRy_7PWTZ3QmC7ycQFR6Wc6Px44y1xDUoq3rH0RlZkeicfvP6FRlpjFU7xF6LjAfd9ciYBZfJll6PE7zf-i_ZXEslv-tJ5-30-I4Slwj0tDrZ2Z54OgAg07AIwAiI5o4y-0vmuhUscNpfZsGAGhE",
-              "e": "AQAB"
-            },
-            {
-              "kty": "RSA",
-              "n": "u1SU1LfVLPHCozMxH2Mo4lgOEePzNm0tRgeLezV6ffAt0gunVTLw7onLRnrq0_IzW7yWR7QkrmBL7jTKEn5u-qKhbwKfBstIs-bMY2Zkp18gnTxKLxoS2tFczGkPLPgizskuemMghRniWaoLcyehkd3qqGElvW_VDL5AaWTg0nLVkjRo9z-40RQzuVaE8AkAFmxZzow3x-VJYKdjykkJ0iT9wCS0DRTXu269V264Vf_3jvredZiKRkgwlL9xNAwxXFg0x_XFw005UWVRIkdgcKWTjpBP2dPwVZ4WWC-9aGVd-Gyn1o0CLelf4rEjGoXbAAEgAqeGUxrcIlbjXfbcmw",
-              "e": "AQAB",
-              "alg": "RS256"
-            }
-          ]
-        });
-
-        serde_json::from_value(value).unwrap()
-    });
-
-    impl JwtRuntime {
-        fn test_value() -> Self {
-            Self {
-                issuer: Default::default(),
-                audiences: Default::default(),
-                optional_kid: false,
-                jwks: JWK_SET.clone(),
-            }
-        }
-    }
-
     fn test_basic_provider_1() -> AuthProviderRuntime {
         AuthProviderRuntime::Basic(BasicRuntime { htpasswd: "1".into() })
     }
@@ -122,7 +103,8 @@ mod tests {
         let basic_provider_2 = test_basic_provider_2();
 
         assert_eq!(
-            AuthRuntime::Provider(basic_provider_1.clone()).and(AuthRuntime::Provider(basic_provider_2.clone())),
+            AuthRuntime::Provider(basic_provider_1.clone())
+                .and(AuthRuntime::Provider(basic_provider_2.clone())),
             AuthRuntime::And(
                 AuthRuntime::Provider(basic_provider_1).into(),
                 AuthRuntime::Provider(basic_provider_2).into()
@@ -136,7 +118,8 @@ mod tests {
         let jwt_provider = test_jwt_provider();
 
         assert_eq!(
-            AuthRuntime::Provider(basic_provider.clone()).and(AuthRuntime::Provider(jwt_provider.clone())),
+            AuthRuntime::Provider(basic_provider.clone())
+                .and(AuthRuntime::Provider(jwt_provider.clone())),
             AuthRuntime::And(
                 AuthRuntime::Provider(basic_provider).into(),
                 AuthRuntime::Provider(jwt_provider).into()
diff --git a/src/core/config/runtime_config/upstream_runtime.rs b/src/core/config/runtime_config/upstream_runtime.rs
index c89f95c7e1..6caeacb422 100644
--- a/src/core/config/runtime_config/upstream_runtime.rs
+++ b/src/core/config/runtime_config/upstream_runtime.rs
@@ -3,6 +3,7 @@ use std::collections::BTreeSet;
 use derive_setters::Setters;
 use tailcall_valid::{Valid, ValidationError, Validator};
 
+use crate::core::blueprint::{self};
 use crate::core::config::{Batch, ConfigModule, Proxy, UpstreamStatic};
 
 #[derive(PartialEq, Eq, Clone, Debug, Setters, schemars::JsonSchema)]
@@ -82,6 +83,29 @@ impl TryFrom<&ConfigModule> for UpstreamRuntime {
     }
 }
 
+impl From<blueprint::Upstream> for UpstreamRuntime {
+    fn from(upstream: blueprint::Upstream) -> Self {
+        Self {
+            pool_idle_timeout: upstream.pool_idle_timeout,
+            pool_max_idle_per_host: upstream.pool_max_idle_per_host,
+            keep_alive_interval: upstream.keep_alive_interval,
+            keep_alive_timeout: upstream.keep_alive_timeout,
+            keep_alive_while_idle: upstream.keep_alive_while_idle,
+            proxy: upstream.proxy,
+            connect_timeout: upstream.connect_timeout,
+            timeout: upstream.timeout,
+            tcp_keep_alive: upstream.tcp_keep_alive,
+            user_agent: upstream.user_agent,
+            allowed_headers: upstream.allowed_headers,
+            http_cache: upstream.http_cache,
+            batch: upstream.batch,
+            http2_only: upstream.http2_only,
+            on_request: upstream.on_request,
+            verify_ssl: upstream.verify_ssl,
+        }
+    }
+}
+
 fn get_batch(upstream: &UpstreamStatic) -> Valid<Option<Batch>, String> {
     upstream.batch.as_ref().map_or_else(
         || Valid::succeed(None),
diff --git a/src/core/config/static_config/link.rs b/src/core/config/static_config/link.rs
index bc9134eb67..af5c9290d0 100644
--- a/src/core/config/static_config/link.rs
+++ b/src/core/config/static_config/link.rs
@@ -31,16 +31,7 @@ pub enum LinkType {
 /// Used to represent external resources, such as
 /// configuration – which will be merged into the config importing it –,
 /// or a .proto file – which will be later used by `@grpc` directive –.
-#[derive(
-    Default,
-    Serialize,
-    Deserialize,
-    PartialEq,
-    Eq,
-    Debug,
-    Clone,
-    schemars::JsonSchema,
-)]
+#[derive(Default, Serialize, Deserialize, PartialEq, Eq, Debug, Clone, schemars::JsonSchema)]
 #[serde(deny_unknown_fields)]
 pub struct LinkStatic {
     ///
diff --git a/src/core/config/static_config/mod.rs b/src/core/config/static_config/mod.rs
index 702974a434..4ff4abe2ed 100644
--- a/src/core/config/static_config/mod.rs
+++ b/src/core/config/static_config/mod.rs
@@ -1,10 +1,10 @@
-pub mod server_static;
-pub mod upstream_static;
 pub mod link;
+pub mod server_static;
 pub mod telemetry_static;
-pub use telemetry_static::*;
+pub mod upstream_static;
 pub use link::*;
-pub use upstream_static::*;
 pub use server_static::*;
+pub use telemetry_static::*;
+pub use upstream_static::*;
 pub mod static_config;
-pub use static_config::*;
\ No newline at end of file
+pub use static_config::*;
diff --git a/src/core/config/static_config/server_static.rs b/src/core/config/static_config/server_static.rs
index a512778fb5..cc55f95faa 100644
--- a/src/core/config/static_config/server_static.rs
+++ b/src/core/config/static_config/server_static.rs
@@ -1,40 +1,32 @@
-pub mod headers_static;
-pub mod routes_static;
 pub mod cors_static;
+pub mod headers_static;
 pub mod key_values;
-pub use headers_static::*;
-pub use routes_static::*;
-pub use key_values::*;
-
+pub mod routes_static;
 use std::collections::{BTreeMap, BTreeSet};
 
 use derive_getters::Getters;
+pub use headers_static::*;
+pub use key_values::*;
+pub use routes_static::*;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
+
 use crate::core::config::Server;
 use crate::core::is_default;
 use crate::core::macros::MergeRight;
 
 #[derive(
-    Serialize,
-    Deserialize,
-    Clone,
-    Default,
-    Debug,
-    Getters,
-    PartialEq,
-    Eq,
-    JsonSchema,
-    MergeRight,
+    Serialize, Deserialize, Clone, Default, Debug, Getters, PartialEq, Eq, JsonSchema, MergeRight,
 )]
 /// This structure offers a comprehensive set of server configurations.
 /// It dictates how the server behaves and helps tune tailcall for various
 /// use-cases.
 #[serde(deny_unknown_fields)]
 pub struct ServerStatic {
-    /// The `enable_jit` option activates Just-In-Time (JIT) compilation. When set to true, it
-    /// optimizes execution of each incoming request independently, resulting in significantly
-    /// better performance in most cases, it's enabled by default.
+    /// The `enable_jit` option activates Just-In-Time (JIT) compilation. When
+    /// set to true, it optimizes execution of each incoming request
+    /// independently, resulting in significantly better performance in most
+    /// cases, it's enabled by default.
     #[serde(default, skip_serializing_if = "is_default")]
     pub enable_jit: Option<bool>,
 
diff --git a/src/core/config/static_config/server_static/headers_static.rs b/src/core/config/static_config/server_static/headers_static.rs
index 00e8458728..c0cc46643e 100644
--- a/src/core/config/static_config/server_static/headers_static.rs
+++ b/src/core/config/static_config/server_static/headers_static.rs
@@ -3,12 +3,11 @@ use std::collections::BTreeSet;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
+use super::cors_static::CorsStatic;
 use crate::core::config::KeyValue;
 use crate::core::is_default;
 use crate::core::macros::MergeRight;
 
-use super::cors_static::CorsStatic;
-
 #[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq, Eq, JsonSchema, MergeRight)]
 pub struct Headers {
     #[serde(default, skip_serializing_if = "is_default")]
diff --git a/src/core/config/static_config/server_static/routes_static.rs b/src/core/config/static_config/server_static/routes_static.rs
index f0ffae1ab4..9ab1fbbd88 100644
--- a/src/core/config/static_config/server_static/routes_static.rs
+++ b/src/core/config/static_config/server_static/routes_static.rs
@@ -26,4 +26,4 @@ impl Routes {
     pub fn with_graphql<T: Into<String>>(self, graphql: T) -> Self {
         Self { status: self.status, graphql: graphql.into() }
     }
-}
\ No newline at end of file
+}
diff --git a/src/core/config/static_config/static_config.rs b/src/core/config/static_config/static_config.rs
index dba8552fac..ac3a57ee9a 100644
--- a/src/core/config/static_config/static_config.rs
+++ b/src/core/config/static_config/static_config.rs
@@ -5,7 +5,10 @@ use tailcall_macros::MergeRight;
 use tailcall_valid::{Valid, Validator};
 
 use super::{LinkStatic, ServerStatic, TelemetryStatic, UpstreamStatic};
-use crate::core::{config::{Config, Source}, is_default, merge_right::MergeRight, variance::Invariant};
+use crate::core::config::{Config, Source};
+use crate::core::is_default;
+use crate::core::merge_right::MergeRight;
+use crate::core::variance::Invariant;
 
 #[derive(
     Serialize, Deserialize, Clone, Debug, Default, Getters, PartialEq, Eq, JsonSchema, MergeRight,
@@ -83,5 +86,5 @@ impl Invariant for StaticConfig {
 
 #[cfg(test)]
 mod tests {
-   // TODO: FIXME
+    // TODO: FIXME
 }
diff --git a/src/core/config/static_config/telemetry_static.rs b/src/core/config/static_config/telemetry_static.rs
index c9cc85a91a..a22f382ad4 100644
--- a/src/core/config/static_config/telemetry_static.rs
+++ b/src/core/config/static_config/telemetry_static.rs
@@ -11,19 +11,10 @@ use crate::core::mustache::Mustache;
 
 pub mod apollo_static;
 pub mod reader_context;
-pub use reader_context::ConfigReaderContext;
 pub use apollo_static::ApolloTelemetry;
+pub use reader_context::ConfigReaderContext;
 
-#[derive(
-    Debug,
-    Default,
-    Clone,
-    Serialize,
-    Deserialize,
-    PartialEq,
-    Eq,
-    schemars::JsonSchema
-)]
+#[derive(Debug, Default, Clone, Serialize, Deserialize, PartialEq, Eq, schemars::JsonSchema)]
 #[serde(deny_unknown_fields)]
 /// The `telemetry` option facilitates seamless integration with OpenTelemetry,
 /// enhancing the observability of your GraphQL services powered by Tailcall.
@@ -143,7 +134,9 @@ mod tests {
     fn merge_right() {
         let exporter_none = TelemetryStatic { export: None, ..Default::default() };
         let exporter_stdout = TelemetryStatic {
-            export: Some(TelemetryExporterConfig::Stdout(StdoutExporter { pretty: true })),
+            export: Some(TelemetryExporterConfig::Stdout(StdoutExporter {
+                pretty: true,
+            })),
             ..Default::default()
         };
         let exporter_otlp_1 = TelemetryStatic {
diff --git a/src/core/config/static_config/upstream_static.rs b/src/core/config/static_config/upstream_static.rs
index 15b8277ad6..d1b3830120 100644
--- a/src/core/config/static_config/upstream_static.rs
+++ b/src/core/config/static_config/upstream_static.rs
@@ -12,16 +12,7 @@ mod batch;
 pub use batch::*;
 
 #[derive(
-    Deserialize,
-    Serialize,
-    Clone,
-    Debug,
-    Default,
-    Setters,
-    PartialEq,
-    Eq,
-    JsonSchema,
-    MergeRight,
+    Deserialize, Serialize, Clone, Debug, Default, Setters, PartialEq, Eq, JsonSchema, MergeRight,
 )]
 #[serde(deny_unknown_fields)]
 /// The `upstream` configuration allows you to control various aspects of the
diff --git a/src/core/config/static_config/upstream_static/batch.rs b/src/core/config/static_config/upstream_static/batch.rs
index baff848f76..2836706882 100644
--- a/src/core/config/static_config/upstream_static/batch.rs
+++ b/src/core/config/static_config/upstream_static/batch.rs
@@ -9,17 +9,7 @@ use crate::core::is_default;
 
 pub const DEFAULT_MAX_SIZE: usize = 100;
 
-#[derive(
-    Serialize,
-    Deserialize,
-    Clone,
-    Debug,
-    Setters,
-    PartialEq,
-    Eq,
-    JsonSchema,
-    MergeRight,
-)]
+#[derive(Serialize, Deserialize, Clone, Debug, Setters, PartialEq, Eq, JsonSchema, MergeRight)]
 pub struct Batch {
     pub delay: usize,
     pub headers: BTreeSet<String>,
diff --git a/src/core/config/utils/mod.rs b/src/core/config/utils/mod.rs
index 09d136ee5a..7e614f8da9 100644
--- a/src/core/config/utils/mod.rs
+++ b/src/core/config/utils/mod.rs
@@ -3,4 +3,4 @@ pub use source::*;
 pub mod encoding;
 pub use encoding::*;
 pub mod private_key;
-pub use private_key::*;
\ No newline at end of file
+pub use private_key::*;
diff --git a/src/core/config/utils/private_key.rs b/src/core/config/utils/private_key.rs
index 11682c6100..8c88be7119 100644
--- a/src/core/config/utils/private_key.rs
+++ b/src/core/config/utils/private_key.rs
@@ -1,7 +1,5 @@
 use rustls_pki_types::PrivateKeyDer;
 
-
-
 #[derive(Debug)]
 pub struct PrivateKey(PrivateKeyDer<'static>);
 
@@ -21,4 +19,4 @@ impl PrivateKey {
     pub fn into_inner(self) -> PrivateKeyDer<'static> {
         self.0
     }
-}
\ No newline at end of file
+}
diff --git a/src/core/http/request_context.rs b/src/core/http/request_context.rs
index cd77ffc979..29cde7addc 100644
--- a/src/core/http/request_context.rs
+++ b/src/core/http/request_context.rs
@@ -9,7 +9,7 @@ use http::header::{HeaderMap, HeaderName, HeaderValue};
 
 use crate::core::app_context::AppContext;
 use crate::core::auth::context::AuthContext;
-use crate::core::blueprint::{Server, Upstream};
+use crate::core::config::{ServerRuntime, UpstreamRuntime};
 use crate::core::data_loader::{DataLoader, DedupeResult};
 use crate::core::graphql::GraphqlDataLoader;
 use crate::core::grpc::data_loader::GrpcDataLoader;
@@ -21,8 +21,8 @@ use crate::core::{cache, grpc};
 
 #[derive(Setters)]
 pub struct RequestContext {
-    pub server: Server,
-    pub upstream: Upstream,
+    pub server: ServerRuntime,
+    pub upstream: UpstreamRuntime,
     pub x_response_headers: Arc<Mutex<HeaderMap>>,
     pub cookie_headers: Option<Arc<Mutex<HeaderMap>>>,
     // A subset of all the headers received in the GraphQL Request that will be sent to the
@@ -185,14 +185,14 @@ impl RequestContext {
 
 impl From<&AppContext> for RequestContext {
     fn from(app_ctx: &AppContext) -> Self {
-        let cookie_headers = if app_ctx.blueprint.server.enable_set_cookie_header {
+        let cookie_headers = if app_ctx.blueprint.config.server.enable_set_cookie_header {
             Some(Arc::new(Mutex::new(HeaderMap::new())))
         } else {
             None
         };
         Self {
-            server: app_ctx.blueprint.server.clone(),
-            upstream: app_ctx.blueprint.upstream.clone(),
+            server: app_ctx.blueprint.config.server.clone(),
+            upstream: app_ctx.blueprint.config.upstream.clone(),
             x_response_headers: Arc::new(Mutex::new(HeaderMap::new())),
             cookie_headers,
             allowed_headers: HeaderMap::new(),
@@ -214,7 +214,7 @@ mod test {
     use cache_control::Cachability;
 
     use crate::core::blueprint::{Server, Upstream};
-    use crate::core::config::{self, Batch};
+    use crate::core::config::{self, Batch, ServerRuntime, UpstreamRuntime};
     use crate::core::http::RequestContext;
 
     impl Default for RequestContext {
@@ -223,6 +223,8 @@ mod test {
 
             let upstream = Upstream::try_from(&config_module).unwrap();
             let server = Server::try_from(config_module).unwrap();
+            let upstream = UpstreamRuntime::from(upstream);
+            let server = ServerRuntime::from(server);
             RequestContext::new(crate::core::runtime::test::init(None))
                 .upstream(upstream)
                 .server(server)
@@ -271,6 +273,8 @@ mod test {
         let mut upstream = Upstream::try_from(&config_module).unwrap();
         let server = Server::try_from(config_module).unwrap();
         upstream.batch = Some(batch);
+        let upstream = UpstreamRuntime::from(upstream);
+        let server = ServerRuntime::from(server);
         RequestContext::default().upstream(upstream).server(server)
     }
 
diff --git a/src/core/http/request_handler.rs b/src/core/http/request_handler.rs
index 712929ee0d..40d1295176 100644
--- a/src/core/http/request_handler.rs
+++ b/src/core/http/request_handler.rs
@@ -20,8 +20,7 @@ use super::telemetry::{get_response_status_code, RequestCounter};
 use super::{showcase, telemetry, TAILCALL_HTTPS_ORIGIN, TAILCALL_HTTP_ORIGIN};
 use crate::core::app_context::AppContext;
 use crate::core::async_graphql_hyper::{GraphQLRequestLike, GraphQLResponse};
-use crate::core::blueprint::telemetry::TelemetryExporter;
-use crate::core::config::{PrometheusExporter, PrometheusFormat};
+use crate::core::config::{PrometheusExporter, PrometheusFormat, TelemetryExporterRuntime};
 use crate::core::jit::JITExecutor;
 
 pub const API_URL_PREFIX: &str = "/api";
@@ -55,8 +54,10 @@ fn not_found() -> Result<Response<Body>> {
 }
 
 fn create_request_context(req: &Request<Body>, app_ctx: &AppContext) -> RequestContext {
-    let allowed_headers =
-        create_allowed_headers(req.headers(), &app_ctx.blueprint.upstream.allowed_headers);
+    let allowed_headers = create_allowed_headers(
+        req.headers(),
+        &app_ctx.blueprint.config.upstream.allowed_headers,
+    );
     RequestContext::from(app_ctx).allowed_headers(allowed_headers)
 }
 
@@ -65,10 +66,10 @@ pub fn update_response_headers(
     req_ctx: &RequestContext,
     app_ctx: &AppContext,
 ) {
-    if !app_ctx.blueprint.server.response_headers.is_empty() {
+    if !app_ctx.blueprint.config.server.response_headers.is_empty() {
         // Add static response headers
         resp.headers_mut()
-            .extend(app_ctx.blueprint.server.response_headers.clone());
+            .extend(app_ctx.blueprint.config.server.response_headers.clone());
     }
 
     // Insert Cookie Headers
@@ -119,14 +120,14 @@ async fn execute_query<T: DeserializeOwned + GraphQLRequestLike>(
     request: T,
     req: Parts,
 ) -> anyhow::Result<Response<Body>> {
-    let mut response = if app_ctx.blueprint.server.enable_jit {
+    let mut response = if app_ctx.blueprint.config.server.enable_jit {
         let operation_id = request.operation_id(&req.headers);
         let exec = JITExecutor::new(app_ctx.clone(), req_ctx.clone(), operation_id);
         request
             .execute_with_jit(exec)
             .await
             .set_cache_control(
-                app_ctx.blueprint.server.enable_cache_control_header,
+                app_ctx.blueprint.config.server.enable_cache_control_header,
                 req_ctx.get_min_max_age().unwrap_or(0),
                 req_ctx.is_cache_public().unwrap_or(true),
             )
@@ -137,7 +138,7 @@ async fn execute_query<T: DeserializeOwned + GraphQLRequestLike>(
             .execute(&app_ctx.schema)
             .await
             .set_cache_control(
-                app_ctx.blueprint.server.enable_cache_control_header,
+                app_ctx.blueprint.config.server.enable_cache_control_header,
                 req_ctx.get_min_max_age().unwrap_or(0),
                 req_ctx.is_cache_public().unwrap_or(true),
             )
@@ -200,7 +201,7 @@ async fn handle_request_with_cors<T: DeserializeOwned + GraphQLRequestLike>(
 ) -> Result<Response<Body>> {
     // Safe to call `.unwrap()` because this method will only be called when
     // `cors` is `Some`
-    let cors = app_ctx.blueprint.server.cors.as_ref().unwrap();
+    let cors = app_ctx.blueprint.config.server.cors.as_ref().unwrap();
     let (parts, body) = req.into_parts();
     let origin = parts.headers.get(&header::ORIGIN);
 
@@ -270,7 +271,7 @@ async fn handle_rest_apis(
                 .execute(&app_ctx.schema)
                 .await
                 .set_cache_control(
-                    app_ctx.blueprint.server.enable_cache_control_header,
+                    app_ctx.blueprint.config.server.enable_cache_control_header,
                     req_ctx.get_min_max_age().unwrap_or(0),
                     req_ctx.is_cache_public().unwrap_or(true),
                 )
@@ -294,8 +295,8 @@ async fn handle_request_inner<T: DeserializeOwned + GraphQLRequestLike>(
         return handle_rest_apis(req, app_ctx, req_counter).await;
     }
 
-    let health_check_endpoint = app_ctx.blueprint.server.routes.status();
-    let graphql_endpoint = app_ctx.blueprint.server.routes.graphql();
+    let health_check_endpoint = app_ctx.blueprint.config.server.routes.status();
+    let graphql_endpoint = app_ctx.blueprint.config.server.routes.graphql();
 
     match *req.method() {
         // NOTE:
@@ -305,7 +306,7 @@ async fn handle_request_inner<T: DeserializeOwned + GraphQLRequestLike>(
             graphql_request::<T>(req, &app_ctx, req_counter).await
         }
         Method::POST
-            if app_ctx.blueprint.server.enable_showcase
+            if app_ctx.blueprint.config.server.enable_showcase
                 && req.uri().path() == "/showcase/graphql" =>
         {
             let app_ctx =
@@ -324,8 +325,8 @@ async fn handle_request_inner<T: DeserializeOwned + GraphQLRequestLike>(
             Ok(status_response)
         }
         Method::GET => {
-            if let Some(TelemetryExporter::Prometheus(prometheus)) =
-                app_ctx.blueprint.telemetry.export.as_ref()
+            if let Some(TelemetryExporterRuntime::Prometheus(prometheus)) =
+                app_ctx.blueprint.config.telemetry.export.as_ref()
             {
                 if req.uri().path() == prometheus.path {
                     return prometheus_metrics(prometheus);
@@ -352,9 +353,9 @@ pub async fn handle_request<T: DeserializeOwned + GraphQLRequestLike>(
     app_ctx: Arc<AppContext>,
 ) -> Result<Response<Body>> {
     telemetry::propagate_context(&req);
-    let mut req_counter = RequestCounter::new(&app_ctx.blueprint.telemetry, &req);
+    let mut req_counter = RequestCounter::new(&app_ctx.blueprint.config.telemetry, &req);
 
-    let response = if app_ctx.blueprint.server.cors.is_some() {
+    let response = if app_ctx.blueprint.config.server.cors.is_some() {
         handle_request_with_cors::<T>(req, app_ctx, &mut req_counter).await
     } else if let Some(origin) = req.headers().get(&header::ORIGIN) {
         if origin == TAILCALL_HTTPS_ORIGIN || origin == TAILCALL_HTTP_ORIGIN {
@@ -391,7 +392,7 @@ mod test {
         let sdl = tokio::fs::read_to_string(tailcall_fixtures::configs::JSONPLACEHOLDER).await?;
         let config = Config::from_sdl(&sdl).to_result()?;
         let mut blueprint = Blueprint::try_from(&ConfigModule::from(config))?;
-        blueprint.server.routes = Routes::default().with_status("/health");
+        blueprint.config.server.routes = Routes::default().with_status("/health");
         let app_ctx = Arc::new(AppContext::new(
             blueprint,
             init(None),
@@ -417,7 +418,7 @@ mod test {
         let sdl = tokio::fs::read_to_string(tailcall_fixtures::configs::JSONPLACEHOLDER).await?;
         let config = Config::from_sdl(&sdl).to_result()?;
         let mut blueprint = Blueprint::try_from(&ConfigModule::from(config))?;
-        blueprint.server.routes = Routes::default().with_graphql("/gql");
+        blueprint.config.server.routes = Routes::default().with_graphql("/gql");
         let app_ctx = Arc::new(AppContext::new(
             blueprint,
             init(None),
diff --git a/src/core/http/telemetry.rs b/src/core/http/telemetry.rs
index 14fa9d7961..0e8ccedc38 100644
--- a/src/core/http/telemetry.rs
+++ b/src/core/http/telemetry.rs
@@ -10,7 +10,7 @@ use opentelemetry_semantic_conventions::trace::{
 };
 use tracing_opentelemetry::OpenTelemetrySpanExt;
 
-use crate::core::blueprint::telemetry::Telemetry;
+use crate::core::config::TelemetryRuntime;
 
 static HTTP_SERVER_REQUEST_COUNT: Lazy<Counter<u64>> = Lazy::new(|| {
     let meter = opentelemetry::global::meter("http_request");
@@ -27,7 +27,7 @@ pub struct RequestCounter {
 }
 
 impl RequestCounter {
-    pub fn new(telemetry: &Telemetry, req: &Request<Body>) -> Self {
+    pub fn new(telemetry: &TelemetryRuntime, req: &Request<Body>) -> Self {
         if telemetry.export.is_none() {
             return Self::default();
         }
diff --git a/src/core/jit/graphql_executor.rs b/src/core/jit/graphql_executor.rs
index 0ed7e1dc37..29a67da8d5 100644
--- a/src/core/jit/graphql_executor.rs
+++ b/src/core/jit/graphql_executor.rs
@@ -37,7 +37,12 @@ impl JITExecutor {
         exec: ConstValueExecutor,
         jit_request: jit::Request<ConstValue>,
     ) -> AnyResponse<Vec<u8>> {
-        let is_introspection_query = self.app_ctx.blueprint.server.get_enable_introspection()
+        let is_introspection_query = self
+            .app_ctx
+            .blueprint
+            .config
+            .server
+            .get_enable_introspection()
             && exec.plan.is_introspection_query;
         let response = exec.execute(&self.req_ctx, &jit_request).await;
         let response = if is_introspection_query {
diff --git a/src/core/runtime.rs b/src/core/runtime.rs
index 1caf1d5e3b..72c44fee88 100644
--- a/src/core/runtime.rs
+++ b/src/core/runtime.rs
@@ -59,10 +59,11 @@ pub mod test {
     use crate::cli::javascript::init_worker_io;
     use crate::core::blueprint::Upstream;
     use crate::core::cache::InMemoryCache;
+    use crate::core::config::ScriptRuntime;
     use crate::core::http::Response;
     use crate::core::runtime::TargetRuntime;
     use crate::core::worker::{Command, Event};
-    use crate::core::{blueprint, EnvIO, FileIO, HttpIO};
+    use crate::core::{EnvIO, FileIO, HttpIO};
 
     #[derive(Clone)]
     struct TestHttp {
@@ -174,7 +175,7 @@ pub mod test {
         }
     }
 
-    pub fn init(script: Option<blueprint::Script>) -> TargetRuntime {
+    pub fn init(script: Option<ScriptRuntime>) -> TargetRuntime {
         let http = TestHttp::init(&Default::default());
         let http2 = TestHttp::init(&Upstream::default().http2_only(true));
 
diff --git a/tests/core/parse.rs b/tests/core/parse.rs
index 00744100cc..563618d7ff 100644
--- a/tests/core/parse.rs
+++ b/tests/core/parse.rs
@@ -276,10 +276,10 @@ impl ExecutionSpec {
         let mut blueprint = Blueprint::try_from(config).unwrap();
 
         if cfg!(feature = "force_jit") {
-            blueprint.server.enable_jit = true;
+            blueprint.config.server.enable_jit = true;
         }
 
-        let script = blueprint.server.script.clone();
+        let script = blueprint.config.server.script.clone();
 
         let http2_only = http.clone();
 
diff --git a/tests/core/runtime.rs b/tests/core/runtime.rs
index 0961593cc3..4d8da9dc24 100644
--- a/tests/core/runtime.rs
+++ b/tests/core/runtime.rs
@@ -8,9 +8,8 @@ use std::sync::Arc;
 use async_graphql::Value;
 use derive_setters::Setters;
 use tailcall::cli::javascript::init_worker_io;
-use tailcall::core::blueprint::Script;
 use tailcall::core::cache::InMemoryCache;
-use tailcall::core::config::Source;
+use tailcall::core::config::{ScriptRuntime, Source};
 use tailcall::core::runtime::TargetRuntime;
 use tailcall::core::worker::{Command, Event};
 
@@ -65,7 +64,7 @@ impl ExecutionMock {
 pub fn create_runtime(
     http_client: Arc<Http>,
     env: Option<HashMap<String, String>>,
-    script: Option<Script>,
+    script: Option<ScriptRuntime>,
 ) -> TargetRuntime {
     let http = http_client.clone();
 
diff --git a/tests/core/spec.rs b/tests/core/spec.rs
index 1a0099eb0b..6065aeb878 100644
--- a/tests/core/spec.rs
+++ b/tests/core/spec.rs
@@ -299,7 +299,7 @@ async fn run_test(
         .body(body)?;
 
     // TODO: reuse logic from server.rs to select the correct handler
-    if app_ctx.blueprint.server.enable_batch_requests {
+    if app_ctx.blueprint.config.server.enable_batch_requests {
         handle_request::<GraphQLBatchRequest>(req, app_ctx).await
     } else {
         handle_request::<GraphQLRequest>(req, app_ctx).await
diff --git a/tests/server_spec.rs b/tests/server_spec.rs
index a024dad739..9223a21f5e 100644
--- a/tests/server_spec.rs
+++ b/tests/server_spec.rs
@@ -12,8 +12,9 @@ pub mod test {
     use reqwest::Client;
     use reqwest_middleware::{ClientBuilder, ClientWithMiddleware};
     use tailcall::cli::javascript::init_worker_io;
-    use tailcall::core::blueprint::{Script, Upstream};
+    use tailcall::core::blueprint::Upstream;
     use tailcall::core::cache::InMemoryCache;
+    use tailcall::core::config::ScriptRuntime;
     use tailcall::core::http::Response;
     use tailcall::core::runtime::TargetRuntime;
     use tailcall::core::worker::{Command, Event};
@@ -131,7 +132,7 @@ pub mod test {
         }
     }
 
-    pub fn init(script: Option<Script>) -> TargetRuntime {
+    pub fn init(script: Option<ScriptRuntime>) -> TargetRuntime {
         let http = TestHttp::init(&Default::default());
         let http2 = TestHttp::init(&Upstream::default().http2_only(true));
 

From 372b7cadfec011b7bfdad0ed2f7d286eae620407 Mon Sep 17 00:00:00 2001
From: Panagiotis <panagiotiskaratakis@gmail.com>
Date: Mon, 18 Nov 2024 16:10:07 +0200
Subject: [PATCH 3/4] refactor: move schema types to blueprint and start
 working on `BlueprintBuilder`

---
 ...impl_path_string_for_evaluation_context.rs |  11 +-
 .../blueprint_builder/blueprint_builder.rs    |  43 +++
 .../blueprint_builder_types.rs                | 280 ++++++++++++++++++
 src/core/blueprint/blueprint_builder/mod.rs   |   4 +
 src/core/blueprint/blueprint_runtime/mod.rs   |   1 +
 src/core/blueprint/cors.rs                    | 245 ---------------
 src/core/blueprint/from_config.rs             |  13 +-
 src/core/blueprint/mod.rs                     |  10 +-
 src/core/blueprint/server.rs                  | 234 ---------------
 src/core/blueprint/upstream.rs                | 103 -------
 src/core/config/config.rs                     | 279 +----------------
 .../config/runtime_config/server_runtime.rs   |  30 --
 .../server_runtime/auth_runtime.rs            |   2 -
 .../config/runtime_config/upstream_runtime.rs |  24 --
 src/core/http/request_context.rs              |  13 +-
 src/core/runtime.rs                           |   7 +-
 tests/server_spec.rs                          |   7 +-
 17 files changed, 360 insertions(+), 946 deletions(-)
 create mode 100644 src/core/blueprint/blueprint_builder/blueprint_builder.rs
 create mode 100644 src/core/blueprint/blueprint_builder/blueprint_builder_types.rs
 create mode 100644 src/core/blueprint/blueprint_builder/mod.rs
 create mode 100644 src/core/blueprint/blueprint_runtime/mod.rs
 delete mode 100644 src/core/blueprint/cors.rs
 delete mode 100644 src/core/blueprint/server.rs
 delete mode 100644 src/core/blueprint/upstream.rs

diff --git a/benches/impl_path_string_for_evaluation_context.rs b/benches/impl_path_string_for_evaluation_context.rs
index 406d341b9e..2824d57d57 100644
--- a/benches/impl_path_string_for_evaluation_context.rs
+++ b/benches/impl_path_string_for_evaluation_context.rs
@@ -13,7 +13,6 @@ use indexmap::IndexMap;
 use once_cell::sync::Lazy;
 use reqwest::{Client, Request};
 use reqwest_middleware::{ClientBuilder, ClientWithMiddleware};
-use tailcall::core::blueprint::{Server, Upstream};
 use tailcall::core::cache::InMemoryCache;
 use tailcall::core::config::{ServerRuntime, UpstreamRuntime};
 use tailcall::core::http::{RequestContext, Response};
@@ -29,7 +28,7 @@ struct Http {
 }
 
 impl Http {
-    fn init(upstream: &Upstream) -> Self {
+    fn init(upstream: &UpstreamRuntime) -> Self {
         let mut builder = Client::builder()
             .tcp_keepalive(Some(Duration::from_secs(upstream.tcp_keep_alive)))
             .timeout(Duration::from_secs(upstream.timeout))
@@ -239,12 +238,12 @@ fn request_context() -> RequestContext {
     let config_module = tailcall::core::config::ConfigModule::default();
 
     //TODO: default is used only in tests. Drop default and move it to test.
-    let upstream = Upstream::try_from(&config_module).unwrap();
-    let server = Server::try_from(config_module).unwrap();
+    let upstream = UpstreamRuntime::try_from(&config_module).unwrap();
+    let server = ServerRuntime::try_from(config_module).unwrap();
     let http = Arc::new(Http::init(&upstream));
     let http2 = Arc::new(Http::init(&upstream.clone().http2_only(true)));
-    let server = ServerRuntime::from(server);
-    let upstream = UpstreamRuntime::from(upstream);
+    let server = server;
+    let upstream = upstream;
     let runtime = TargetRuntime {
         http2_only: http2,
         http,
diff --git a/src/core/blueprint/blueprint_builder/blueprint_builder.rs b/src/core/blueprint/blueprint_builder/blueprint_builder.rs
new file mode 100644
index 0000000000..77d836adfa
--- /dev/null
+++ b/src/core/blueprint/blueprint_builder/blueprint_builder.rs
@@ -0,0 +1,43 @@
+use std::collections::BTreeMap;
+
+use derive_setters::Setters;
+use serde::{Deserialize, Serialize};
+use tailcall_macros::MergeRight;
+
+use super::{Enum, RootSchema, Type, Union};
+use crate::core::is_default;
+
+#[derive(
+    Serialize,
+    Deserialize,
+    Clone,
+    Debug,
+    Default,
+    Setters,
+    PartialEq,
+    Eq,
+    schemars::JsonSchema,
+    MergeRight,
+)]
+pub struct BlueprintBuilder {
+    ///
+    /// Specifies the entry points for query and mutation in the generated
+    /// GraphQL schema.
+    pub schema: RootSchema,
+
+    ///
+    /// A map of all the types in the schema.
+    #[serde(default)]
+    #[setters(skip)]
+    pub types: BTreeMap<String, Type>,
+
+    ///
+    /// A map of all the union types in the schema.
+    #[serde(default, skip_serializing_if = "is_default")]
+    pub unions: BTreeMap<String, Union>,
+
+    ///
+    /// A map of all the enum types in the schema
+    #[serde(default, skip_serializing_if = "is_default")]
+    pub enums: BTreeMap<String, Enum>,
+}
diff --git a/src/core/blueprint/blueprint_builder/blueprint_builder_types.rs b/src/core/blueprint/blueprint_builder/blueprint_builder_types.rs
new file mode 100644
index 0000000000..b768b0cd39
--- /dev/null
+++ b/src/core/blueprint/blueprint_builder/blueprint_builder_types.rs
@@ -0,0 +1,280 @@
+use std::collections::{BTreeMap, BTreeSet, HashMap};
+use std::fmt::{self, Display};
+
+use derive_setters::Setters;
+use indexmap::IndexMap;
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+use tailcall_macros::MergeRight;
+
+use crate::core::config::{
+    AddField, Alias, Cache, Directive, Discriminate, Modify, Omit, Protected, Resolver,
+};
+use crate::core::is_default;
+use crate::core::merge_right::MergeRight;
+
+///
+/// Represents a GraphQL type.
+/// A type can be an object, interface, enum or scalar.
+#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq, Eq, JsonSchema, MergeRight)]
+pub struct Type {
+    ///
+    /// A map of field name and its definition.
+    pub fields: BTreeMap<String, Field>,
+    #[serde(default, skip_serializing_if = "is_default")]
+    ///
+    /// Additional fields to be added to the type
+    pub added_fields: Vec<AddField>,
+    #[serde(default, skip_serializing_if = "is_default")]
+    ///
+    /// Documentation for the type that is publicly visible.
+    pub doc: Option<String>,
+    #[serde(default, skip_serializing_if = "is_default")]
+    ///
+    /// Interfaces that the type implements.
+    pub implements: BTreeSet<String>,
+    #[serde(default, skip_serializing_if = "is_default")]
+    ///
+    /// Setting to indicate if the type can be cached.
+    pub cache: Option<Cache>,
+    ///
+    /// Marks field as protected by auth providers
+    #[serde(default)]
+    pub protected: Option<Protected>,
+    ///
+    /// Apollo federation entity resolver.
+    #[serde(flatten, default, skip_serializing_if = "is_default")]
+    pub resolver: Option<Resolver>,
+    ///
+    /// Any additional directives
+    #[serde(default, skip_serializing_if = "is_default")]
+    pub directives: Vec<Directive>,
+}
+
+impl Display for Type {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        writeln!(f, "{{")?;
+
+        for (field_name, field) in &self.fields {
+            writeln!(f, "  {}: {:?},", field_name, field.type_of)?;
+        }
+        writeln!(f, "}}")
+    }
+}
+
+impl Type {
+    pub fn fields(mut self, fields: Vec<(&str, Field)>) -> Self {
+        let mut graphql_fields = BTreeMap::new();
+        for (name, field) in fields {
+            graphql_fields.insert(name.to_string(), field);
+        }
+        self.fields = graphql_fields;
+        self
+    }
+
+    pub fn scalar(&self) -> bool {
+        self.fields.is_empty()
+    }
+}
+
+#[derive(
+    Serialize,
+    Deserialize,
+    Clone,
+    Debug,
+    Default,
+    Setters,
+    PartialEq,
+    Eq,
+    schemars::JsonSchema,
+    MergeRight,
+)]
+#[setters(strip_option)]
+pub struct RootSchema {
+    pub query: Option<String>,
+    #[serde(default, skip_serializing_if = "is_default")]
+    pub mutation: Option<String>,
+    #[serde(default, skip_serializing_if = "is_default")]
+    pub subscription: Option<String>,
+}
+
+///
+/// A field definition containing all the metadata information about resolving a
+/// field.
+#[derive(
+    Serialize, Deserialize, Clone, Debug, Default, Setters, PartialEq, Eq, schemars::JsonSchema,
+)]
+#[setters(strip_option)]
+pub struct Field {
+    ///
+    /// Refers to the type of the value the field can be resolved to.
+    #[serde(rename = "type", default, skip_serializing_if = "is_default")]
+    pub type_of: crate::core::Type,
+
+    ///
+    /// Map of argument name and its definition.
+    #[serde(default, skip_serializing_if = "is_default")]
+    #[schemars(with = "HashMap::<String, Arg>")]
+    pub args: IndexMap<String, Arg>,
+
+    ///
+    /// Publicly visible documentation for the field.
+    #[serde(default, skip_serializing_if = "is_default")]
+    pub doc: Option<String>,
+
+    ///
+    /// Allows modifying existing fields.
+    #[serde(default, skip_serializing_if = "is_default")]
+    pub modify: Option<Modify>,
+
+    ///
+    /// Omits a field from public consumption.
+    #[serde(default, skip_serializing_if = "is_default")]
+    pub omit: Option<Omit>,
+
+    ///
+    /// Sets the cache configuration for a field
+    pub cache: Option<Cache>,
+
+    ///
+    /// Stores the default value for the field
+    #[serde(default, skip_serializing_if = "is_default")]
+    pub default_value: Option<Value>,
+
+    ///
+    /// Marks field as protected by auth provider
+    #[serde(default)]
+    pub protected: Option<Protected>,
+
+    ///
+    /// Used to overwrite the default discrimination strategy
+    pub discriminate: Option<Discriminate>,
+
+    ///
+    /// Resolver for the field
+    #[serde(flatten, default, skip_serializing_if = "is_default")]
+    pub resolver: Option<Resolver>,
+
+    ///
+    /// Any additional directives
+    #[serde(default, skip_serializing_if = "is_default")]
+    pub directives: Vec<Directive>,
+}
+
+// It's a terminal implementation of MergeRight
+impl MergeRight for Field {
+    fn merge_right(self, other: Self) -> Self {
+        other
+    }
+}
+
+impl Field {
+    pub fn has_resolver(&self) -> bool {
+        self.resolver.is_some()
+    }
+
+    pub fn has_batched_resolver(&self) -> bool {
+        self.resolver
+            .as_ref()
+            .map(Resolver::is_batched)
+            .unwrap_or(false)
+    }
+
+    pub fn int() -> Self {
+        Self { type_of: "Int".to_string().into(), ..Default::default() }
+    }
+
+    pub fn string() -> Self {
+        Self { type_of: "String".to_string().into(), ..Default::default() }
+    }
+
+    pub fn float() -> Self {
+        Self { type_of: "Float".to_string().into(), ..Default::default() }
+    }
+
+    pub fn boolean() -> Self {
+        Self { type_of: "Boolean".to_string().into(), ..Default::default() }
+    }
+
+    pub fn id() -> Self {
+        Self { type_of: "ID".to_string().into(), ..Default::default() }
+    }
+
+    pub fn is_omitted(&self) -> bool {
+        self.omit.is_some()
+            || self
+                .modify
+                .as_ref()
+                .and_then(|m| m.omit)
+                .unwrap_or_default()
+    }
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
+pub struct Inline {
+    pub path: Vec<String>,
+}
+
+#[derive(Default, Serialize, Deserialize, Clone, Debug, PartialEq, Eq, schemars::JsonSchema)]
+pub struct Arg {
+    #[serde(rename = "type")]
+    pub type_of: crate::core::Type,
+    #[serde(default, skip_serializing_if = "is_default")]
+    pub doc: Option<String>,
+    #[serde(default, skip_serializing_if = "is_default")]
+    pub modify: Option<Modify>,
+    #[serde(default, skip_serializing_if = "is_default")]
+    pub default_value: Option<Value>,
+}
+
+#[derive(
+    Serialize, Deserialize, Clone, Debug, Default, PartialEq, Eq, schemars::JsonSchema, MergeRight,
+)]
+pub struct Union {
+    pub types: BTreeSet<String>,
+    pub doc: Option<String>,
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, schemars::JsonSchema, MergeRight)]
+/// Definition of GraphQL enum type
+pub struct Enum {
+    pub variants: BTreeSet<Variant>,
+    pub doc: Option<String>,
+}
+
+/// Definition of GraphQL value
+#[derive(
+    Serialize,
+    Deserialize,
+    Clone,
+    Debug,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    schemars::JsonSchema,
+    MergeRight,
+)]
+pub struct Variant {
+    pub name: String,
+    // directive: alias
+    pub alias: Option<Alias>,
+}
+
+#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "lowercase")]
+pub enum GraphQLOperationType {
+    #[default]
+    Query,
+    Mutation,
+}
+
+impl Display for GraphQLOperationType {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.write_str(match self {
+            Self::Query => "query",
+            Self::Mutation => "mutation",
+        })
+    }
+}
diff --git a/src/core/blueprint/blueprint_builder/mod.rs b/src/core/blueprint/blueprint_builder/mod.rs
new file mode 100644
index 0000000000..66c4c94f51
--- /dev/null
+++ b/src/core/blueprint/blueprint_builder/mod.rs
@@ -0,0 +1,4 @@
+pub mod blueprint_builder;
+pub use blueprint_builder::*;
+pub mod blueprint_builder_types;
+pub use blueprint_builder_types::*;
diff --git a/src/core/blueprint/blueprint_runtime/mod.rs b/src/core/blueprint/blueprint_runtime/mod.rs
new file mode 100644
index 0000000000..03b96367b1
--- /dev/null
+++ b/src/core/blueprint/blueprint_runtime/mod.rs
@@ -0,0 +1 @@
+pub struct BlueprintRuntime {}
diff --git a/src/core/blueprint/cors.rs b/src/core/blueprint/cors.rs
deleted file mode 100644
index c73aa11ff4..0000000000
--- a/src/core/blueprint/cors.rs
+++ /dev/null
@@ -1,245 +0,0 @@
-use std::fmt::Display;
-
-use derive_setters::Setters;
-use http::header;
-use http::header::{HeaderName, HeaderValue};
-use http::request::Parts;
-use tailcall_valid::ValidationError;
-
-use crate::core::config::cors_static::CorsStatic;
-
-#[derive(Clone, Debug, Setters, Default)]
-pub struct Cors {
-    pub allow_credentials: bool,
-    pub allow_headers: Option<HeaderValue>,
-    pub allow_methods: Option<HeaderValue>,
-    pub allow_origins: Vec<HeaderValue>,
-    pub allow_private_network: bool,
-    pub expose_headers: Option<HeaderValue>,
-    pub max_age: Option<HeaderValue>,
-    pub vary: Vec<HeaderValue>,
-}
-
-impl Cors {
-    pub fn allow_origin_to_header(
-        &self,
-        origin: Option<&HeaderValue>,
-    ) -> Option<(HeaderName, HeaderValue)> {
-        if self.allow_origins.iter().any(is_wildcard) {
-            Some((header::ACCESS_CONTROL_ALLOW_ORIGIN, origin.cloned()?))
-        } else {
-            let allow_origin = origin.filter(|o| self.allow_origins.contains(o))?.clone();
-            Some((header::ACCESS_CONTROL_ALLOW_ORIGIN, allow_origin))
-        }
-    }
-
-    pub fn allow_credentials_to_header(&self) -> Option<(HeaderName, HeaderValue)> {
-        self.allow_credentials.then(|| {
-            (
-                header::ACCESS_CONTROL_ALLOW_CREDENTIALS,
-                HeaderValue::from_static("true"),
-            )
-        })
-    }
-
-    pub fn allow_private_network_to_header(
-        &self,
-        parts: &Parts,
-    ) -> Option<(HeaderName, HeaderValue)> {
-        #[allow(clippy::declare_interior_mutable_const)]
-        const REQUEST_PRIVATE_NETWORK: HeaderName =
-            HeaderName::from_static("access-control-request-private-network");
-
-        #[allow(clippy::declare_interior_mutable_const)]
-        const ALLOW_PRIVATE_NETWORK: HeaderName =
-            HeaderName::from_static("access-control-allow-private-network");
-
-        #[allow(clippy::declare_interior_mutable_const)]
-        const TRUE: HeaderValue = HeaderValue::from_static("true");
-
-        if !self.allow_private_network {
-            return None;
-        }
-
-        // Access-Control-Allow-Private-Network is only relevant if the request
-        // has the Access-Control-Request-Private-Network header set, else skip
-        #[allow(clippy::borrow_interior_mutable_const)]
-        if parts.headers.get(REQUEST_PRIVATE_NETWORK) != Some(&TRUE) {
-            return None;
-        }
-
-        self.allow_private_network
-            .then_some((ALLOW_PRIVATE_NETWORK, TRUE))
-    }
-
-    pub fn allow_methods_to_header(&self) -> Option<(HeaderName, HeaderValue)> {
-        Some((
-            header::ACCESS_CONTROL_ALLOW_METHODS,
-            self.allow_methods.clone()?,
-        ))
-    }
-
-    pub fn allow_headers_to_header(&self) -> Option<(HeaderName, HeaderValue)> {
-        Some((
-            header::ACCESS_CONTROL_ALLOW_HEADERS,
-            self.allow_headers.clone()?,
-        ))
-    }
-
-    pub fn max_age_to_header(&self) -> Option<(HeaderName, HeaderValue)> {
-        Some((
-            header::ACCESS_CONTROL_MAX_AGE,
-            self.max_age.as_ref()?.clone(),
-        ))
-    }
-
-    pub fn expose_headers_to_header(&self) -> Option<(HeaderName, HeaderValue)> {
-        Some((
-            header::ACCESS_CONTROL_EXPOSE_HEADERS,
-            self.expose_headers.as_ref()?.clone(),
-        ))
-    }
-
-    pub fn vary_to_header(&self) -> Option<(HeaderName, HeaderValue)> {
-        let values = &self.vary;
-        let mut res = values.first()?.as_bytes().to_owned();
-        for val in &values[1..] {
-            res.extend_from_slice(b", ");
-            res.extend_from_slice(val.as_bytes());
-        }
-
-        let header_val = HeaderValue::from_bytes(&res).ok()?;
-        Some((header::VARY, header_val))
-    }
-
-    #[allow(clippy::borrow_interior_mutable_const)]
-    pub fn expose_headers_is_wildcard(&self) -> bool {
-        matches!(&self.expose_headers, Some(v) if v == WILDCARD)
-    }
-}
-
-fn ensure_usable_cors_rules(layer: &Cors) -> Result<(), ValidationError<String>> {
-    if layer.allow_credentials {
-        let allowing_all_headers = layer
-            .allow_headers
-            .as_ref()
-            .filter(|val| is_wildcard(val))
-            .is_some();
-
-        if allowing_all_headers {
-            Err(ValidationError::new("Invalid CORS configuration: Cannot combine `Access-Control-Allow-Credentials: true` \
-                with `Access-Control-Allow-Headers: *`".into()))?
-        }
-
-        let allowing_all_methods = layer
-            .allow_methods
-            .as_ref()
-            .filter(|val| is_wildcard(val))
-            .is_some();
-
-        if allowing_all_methods {
-            Err(ValidationError::new("Invalid CORS configuration: Cannot combine `Access-Control-Allow-Credentials: true` \
-                with `Access-Control-Allow-Methods: *`".into()))?
-        }
-
-        let allowing_all_origins = layer.allow_origins.iter().any(is_wildcard);
-
-        if allowing_all_origins {
-            Err(ValidationError::new("Invalid CORS configuration: Cannot combine `Access-Control-Allow-Credentials: true` \
-             with `Access-Control-Allow-Origin: *`".into()))?
-        }
-
-        if layer.expose_headers_is_wildcard() {
-            Err(ValidationError::new("Invalid CORS configuration: Cannot combine `Access-Control-Allow-Credentials: true` \
-             with `Access-Control-Expose-Headers: *`".into()))?
-        }
-    }
-    Ok(())
-}
-
-fn to_validation_err<T: Display>(err: T) -> ValidationError<String> {
-    ValidationError::new(err.to_string())
-}
-
-impl TryFrom<CorsStatic> for Cors {
-    type Error = ValidationError<String>;
-
-    fn try_from(value: CorsStatic) -> Result<Self, ValidationError<String>> {
-        let cors = Cors {
-            allow_credentials: value.allow_credentials.unwrap_or_default(),
-            allow_headers: (!value.allow_headers.is_empty()).then_some(
-                value
-                    .allow_headers
-                    .join(", ")
-                    .parse()
-                    .map_err(to_validation_err)?,
-            ),
-            allow_methods: {
-                Some(if value.allow_methods.is_empty() {
-                    "*".parse().map_err(to_validation_err)?
-                } else {
-                    value
-                        .allow_methods
-                        .into_iter()
-                        .map(|val| val.to_string())
-                        .collect::<Vec<String>>()
-                        .join(", ")
-                        .parse()
-                        .map_err(to_validation_err)?
-                })
-            },
-            allow_origins: value
-                .allow_origins
-                .into_iter()
-                .map(|val| val.parse().map_err(to_validation_err))
-                .collect::<Result<_, ValidationError<String>>>()?,
-            allow_private_network: value.allow_private_network.unwrap_or_default(),
-            expose_headers: Some(
-                value
-                    .expose_headers
-                    .join(", ")
-                    .parse()
-                    .map_err(to_validation_err)?,
-            ),
-            max_age: value.max_age.map(|val| val.into()),
-            vary: value
-                .vary
-                .iter()
-                .map(|val| val.parse().map_err(to_validation_err))
-                .collect::<Result<_, ValidationError<String>>>()?,
-        };
-        ensure_usable_cors_rules(&cors)?;
-        Ok(cors)
-    }
-}
-
-#[allow(clippy::declare_interior_mutable_const)]
-const WILDCARD: HeaderValue = HeaderValue::from_static("*");
-
-#[allow(clippy::borrow_interior_mutable_const)]
-pub fn is_wildcard(header_value: &HeaderValue) -> bool {
-    header_value == WILDCARD
-}
-
-#[cfg(test)]
-mod tests {
-    use http::header::HeaderValue;
-
-    use super::*;
-
-    #[test]
-    fn test_allow_origin_to_header() {
-        let cors = Cors {
-            allow_origins: vec![HeaderValue::from_static("https://example.com")],
-            ..std::default::Default::default()
-        };
-        let origin = Some(HeaderValue::from_static("https://example.com"));
-        assert_eq!(
-            cors.allow_origin_to_header(origin.as_ref()),
-            Some((
-                header::ACCESS_CONTROL_ALLOW_ORIGIN,
-                HeaderValue::from_static("https://example.com")
-            ))
-        );
-    }
-}
diff --git a/src/core/blueprint/from_config.rs b/src/core/blueprint/from_config.rs
index a9428879a3..f89f5c4049 100644
--- a/src/core/blueprint/from_config.rs
+++ b/src/core/blueprint/from_config.rs
@@ -4,11 +4,12 @@ use async_graphql::dynamic::SchemaBuilder;
 use indexmap::IndexMap;
 use tailcall_valid::{Valid, ValidationError, Validator};
 
-use super::Server;
 use crate::core::blueprint::compress::compress;
 use crate::core::blueprint::*;
 use crate::core::config::transformer::Required;
-use crate::core::config::{to_opentelemetry, Arg, Batch, Config, ConfigModule};
+use crate::core::config::{
+    to_opentelemetry, Batch, Config, ConfigModule, ServerRuntime, UpstreamRuntime,
+};
 use crate::core::ir::model::{IO, IR};
 use crate::core::json::JsonSchema;
 use crate::core::try_fold::TryFold;
@@ -16,8 +17,8 @@ use crate::core::Type;
 
 pub fn config_blueprint<'a>() -> TryFold<'a, ConfigModule, Blueprint, String> {
     let server = TryFoldConfig::<Blueprint>::new(|config_module, mut blueprint| {
-        Valid::from(Server::try_from(config_module.clone())).map(|server| {
-            blueprint.config = blueprint.config.server(server.into());
+        Valid::from(ServerRuntime::try_from(config_module.clone())).map(|server| {
+            blueprint.config = blueprint.config.server(server);
             blueprint
         })
     });
@@ -33,8 +34,8 @@ pub fn config_blueprint<'a>() -> TryFold<'a, ConfigModule, Blueprint, String> {
     );
 
     let upstream = TryFoldConfig::<Blueprint>::new(|config_module, mut blueprint| {
-        Valid::from(Upstream::try_from(config_module)).map(|upstream| {
-            blueprint.config = blueprint.config.upstream(upstream.into());
+        Valid::from(UpstreamRuntime::try_from(config_module)).map(|upstream| {
+            blueprint.config = blueprint.config.upstream(upstream);
             blueprint
         })
     });
diff --git a/src/core/blueprint/mod.rs b/src/core/blueprint/mod.rs
index 1065ccaf24..1bd2c8d547 100644
--- a/src/core/blueprint/mod.rs
+++ b/src/core/blueprint/mod.rs
@@ -1,6 +1,7 @@
 mod blueprint;
+pub mod blueprint_builder;
+mod blueprint_runtime;
 mod compress;
-mod cors;
 mod definitions;
 mod directive;
 mod dynamic_value;
@@ -13,13 +14,12 @@ mod links;
 mod mustache;
 mod operators;
 mod schema;
-mod server;
 mod timeout;
 mod union_resolver;
-mod upstream;
 
 pub use blueprint::*;
-pub use cors::*;
+pub use blueprint_builder::*;
+pub use blueprint_runtime::*;
 pub use definitions::*;
 pub use dynamic_value::*;
 pub use from_config::*;
@@ -27,9 +27,7 @@ pub use index::*;
 pub use links::*;
 pub use operators::*;
 pub use schema::*;
-pub use server::*;
 pub use timeout::GlobalTimeout;
-pub use upstream::*;
 
 use crate::core::config::ConfigModule;
 use crate::core::try_fold::TryFold;
diff --git a/src/core/blueprint/server.rs b/src/core/blueprint/server.rs
deleted file mode 100644
index 481dc16797..0000000000
--- a/src/core/blueprint/server.rs
+++ /dev/null
@@ -1,234 +0,0 @@
-use std::collections::{BTreeMap, BTreeSet, HashSet};
-use std::net::{AddrParseError, IpAddr};
-use std::str::FromStr;
-use std::time::Duration;
-
-use derive_setters::Setters;
-use http::header::{HeaderMap, HeaderName, HeaderValue};
-use tailcall_valid::{Valid, ValidationError, Validator};
-
-use crate::core::config::cors_static::CorsStatic;
-use crate::core::config::{
-    self, AuthRuntime, ConfigModule, CorsRuntime, HttpVersion, HttpVersionRuntime, Routes,
-    ScriptRuntime,
-};
-
-#[derive(Clone, Debug, Setters)]
-pub struct Server {
-    pub enable_jit: bool,
-    pub enable_apollo_tracing: bool,
-    pub enable_cache_control_header: bool,
-    pub enable_set_cookie_header: bool,
-    pub enable_introspection: bool,
-    pub enable_query_validation: bool,
-    pub enable_response_validation: bool,
-    pub enable_batch_requests: bool,
-    pub enable_showcase: bool,
-    pub global_response_timeout: i64,
-    pub worker: usize,
-    pub port: u16,
-    pub hostname: IpAddr,
-    pub vars: BTreeMap<String, String>,
-    pub response_headers: HeaderMap,
-    pub http: HttpVersionRuntime,
-    pub pipeline_flush: bool,
-    pub script: Option<ScriptRuntime>,
-    pub cors: Option<CorsRuntime>,
-    pub experimental_headers: HashSet<HeaderName>,
-    pub auth: Option<AuthRuntime>,
-    pub routes: Routes,
-}
-
-impl Default for Server {
-    fn default() -> Self {
-        // NOTE: Using unwrap because try_from default will never fail
-        Server::try_from(ConfigModule::default()).unwrap()
-    }
-}
-
-impl Server {
-    pub fn get_enable_http_validation(&self) -> bool {
-        self.enable_response_validation
-    }
-    pub fn get_enable_cache_control(&self) -> bool {
-        self.enable_cache_control_header
-    }
-
-    pub fn get_enable_introspection(&self) -> bool {
-        self.enable_introspection
-    }
-
-    pub fn get_enable_query_validation(&self) -> bool {
-        self.enable_query_validation
-    }
-
-    pub fn get_experimental_headers(&self) -> HashSet<HeaderName> {
-        self.experimental_headers.clone()
-    }
-}
-
-impl TryFrom<crate::core::config::ConfigModule> for Server {
-    type Error = ValidationError<String>;
-
-    fn try_from(config_module: config::ConfigModule) -> Result<Self, Self::Error> {
-        let config_server = config_module.server.clone();
-
-        let http_server = match config_server.clone().get_version() {
-            HttpVersion::HTTP2 => {
-                if config_module.extensions().cert.is_empty() {
-                    return Valid::fail("Certificate is required for HTTP2".to_string())
-                        .to_result();
-                }
-
-                let cert = config_module.extensions().cert.clone();
-
-                let key = config_module
-                    .extensions()
-                    .keys
-                    .first()
-                    .ok_or_else(|| ValidationError::new("Key is required for HTTP2".to_string()))?
-                    .clone();
-
-                Valid::succeed(HttpVersionRuntime::HTTP2 { cert, key })
-            }
-            _ => Valid::succeed(HttpVersionRuntime::HTTP1),
-        };
-
-        validate_hostname((config_server).get_hostname().to_lowercase())
-            .fuse(http_server)
-            .fuse(handle_response_headers(
-                (config_server).get_response_headers(),
-            ))
-            .fuse(to_script(&config_module))
-            .fuse(handle_experimental_headers(
-                (config_server).get_experimental_headers(),
-            ))
-            .fuse(validate_cors(
-                config_server
-                    .headers
-                    .as_ref()
-                    .and_then(|headers| headers.get_cors()),
-            ))
-            .fuse(AuthRuntime::make(&config_module))
-            .map(
-                |(hostname, http, response_headers, script, experimental_headers, cors, auth)| {
-                    Server {
-                        enable_jit: (config_server).enable_jit(),
-                        enable_apollo_tracing: (config_server).enable_apollo_tracing(),
-                        enable_cache_control_header: (config_server).enable_cache_control(),
-                        enable_set_cookie_header: (config_server).enable_set_cookies(),
-                        enable_introspection: (config_server).enable_introspection(),
-                        enable_query_validation: (config_server).enable_query_validation(),
-                        enable_response_validation: (config_server).enable_http_validation(),
-                        enable_batch_requests: (config_server).enable_batch_requests(),
-                        enable_showcase: (config_server).enable_showcase(),
-                        experimental_headers,
-                        global_response_timeout: (config_server).get_global_response_timeout(),
-                        http,
-                        worker: (config_server).get_workers(),
-                        port: (config_server).get_port(),
-                        hostname,
-                        vars: (config_server).get_vars(),
-                        pipeline_flush: (config_server).get_pipeline_flush(),
-                        response_headers,
-                        script,
-                        cors,
-                        auth,
-                        routes: config_server.get_routes(),
-                    }
-                },
-            )
-            .to_result()
-    }
-}
-
-fn to_script(
-    config_module: &crate::core::config::ConfigModule,
-) -> Valid<Option<ScriptRuntime>, String> {
-    config_module.extensions().script.as_ref().map_or_else(
-        || Valid::succeed(None),
-        |script| {
-            Valid::succeed(Some(ScriptRuntime {
-                source: script.clone(),
-                timeout: config_module
-                    .server
-                    .script
-                    .clone()
-                    .map_or_else(|| None, |script| script.timeout)
-                    .map(Duration::from_millis),
-            }))
-        },
-    )
-}
-
-fn validate_cors(cors: Option<CorsStatic>) -> Valid<Option<CorsRuntime>, String> {
-    Valid::from(cors.map(|cors| cors.try_into()).transpose())
-        .trace("cors")
-        .trace("headers")
-        .trace("@server")
-        .trace("schema")
-}
-
-fn validate_hostname(hostname: String) -> Valid<IpAddr, String> {
-    if hostname == "localhost" {
-        Valid::succeed(IpAddr::from([127, 0, 0, 1]))
-    } else {
-        Valid::from(hostname.parse().map_err(|e: AddrParseError| {
-            ValidationError::new(format!("Parsing failed because of {}", e))
-        }))
-        .trace("hostname")
-        .trace("@server")
-        .trace("schema")
-    }
-}
-
-fn handle_response_headers(resp_headers: Vec<(String, String)>) -> Valid<HeaderMap, String> {
-    Valid::from_iter(resp_headers.iter(), |(k, v)| {
-        let name = Valid::from(
-            HeaderName::from_bytes(k.as_bytes())
-                .map_err(|e| ValidationError::new(format!("Parsing failed because of {}", e))),
-        );
-        let value = Valid::from(
-            HeaderValue::from_str(v.as_str())
-                .map_err(|e| ValidationError::new(format!("Parsing failed because of {}", e))),
-        );
-        name.zip(value)
-    })
-    .map(|headers| headers.into_iter().collect::<HeaderMap>())
-    .trace("custom")
-    .trace("headers")
-    .trace("@server")
-    .trace("schema")
-}
-
-fn handle_experimental_headers(headers: BTreeSet<String>) -> Valid<HashSet<HeaderName>, String> {
-    Valid::from_iter(headers.iter(), |h| {
-        if !h.to_lowercase().starts_with("x-") {
-            Valid::fail(
-                format!(
-                    "Experimental headers must start with 'x-' or 'X-'. Got: '{}'",
-                    h
-                )
-                .to_string(),
-            )
-        } else {
-            Valid::from(HeaderName::from_str(h).map_err(|e| ValidationError::new(e.to_string())))
-        }
-    })
-    .map(HashSet::from_iter)
-    .trace("experimental")
-    .trace("headers")
-    .trace("@server")
-    .trace("schema")
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::core::config::ConfigModule;
-
-    #[test]
-    fn test_try_from_default() {
-        let actual = super::Server::try_from(ConfigModule::default());
-        assert!(actual.is_ok())
-    }
-}
diff --git a/src/core/blueprint/upstream.rs b/src/core/blueprint/upstream.rs
deleted file mode 100644
index 2ef11b7c7a..0000000000
--- a/src/core/blueprint/upstream.rs
+++ /dev/null
@@ -1,103 +0,0 @@
-use std::collections::BTreeSet;
-
-use derive_setters::Setters;
-use tailcall_valid::{Valid, ValidationError, Validator};
-
-use crate::core::config::{self, Batch, ConfigModule, Proxy};
-
-#[derive(PartialEq, Eq, Clone, Debug, Setters, schemars::JsonSchema)]
-pub struct Upstream {
-    pub pool_idle_timeout: u64,
-    pub pool_max_idle_per_host: usize,
-    pub keep_alive_interval: u64,
-    pub keep_alive_timeout: u64,
-    pub keep_alive_while_idle: bool,
-    pub proxy: Option<Proxy>,
-    pub connect_timeout: u64,
-    pub timeout: u64,
-    pub tcp_keep_alive: u64,
-    pub user_agent: String,
-    pub allowed_headers: BTreeSet<String>,
-    pub http_cache: u64,
-    pub batch: Option<Batch>,
-    pub http2_only: bool,
-    pub on_request: Option<String>,
-    pub verify_ssl: bool,
-}
-
-impl Upstream {
-    /// If the delay is set to 0, then batching is disabled. By default delay is
-    /// set to 0.
-    pub fn is_batching_enabled(&self) -> bool {
-        if let Some(batch) = self.batch.as_ref() {
-            batch.delay >= 1
-        } else {
-            false
-        }
-    }
-}
-
-impl Default for Upstream {
-    fn default() -> Self {
-        // NOTE: Using unwrap because try_from default will never fail
-        Upstream::try_from(&ConfigModule::default()).unwrap()
-    }
-}
-
-impl TryFrom<&ConfigModule> for Upstream {
-    type Error = ValidationError<String>;
-
-    fn try_from(config_module: &ConfigModule) -> Result<Self, Self::Error> {
-        let config_upstream = config_module.upstream.clone();
-
-        let mut allowed_headers = config_upstream.get_allowed_headers();
-
-        if config_module.extensions().has_auth() {
-            // force add auth specific headers to use it to make actual validation
-            allowed_headers.insert(http::header::AUTHORIZATION.to_string());
-        }
-
-        get_batch(&config_upstream)
-            .fuse(get_proxy(&config_upstream))
-            .map(|(batch, proxy)| Upstream {
-                pool_idle_timeout: (config_upstream).get_pool_idle_timeout(),
-                pool_max_idle_per_host: (config_upstream).get_pool_max_idle_per_host(),
-                keep_alive_interval: (config_upstream).get_keep_alive_interval(),
-                keep_alive_timeout: (config_upstream).get_keep_alive_timeout(),
-                keep_alive_while_idle: (config_upstream).get_keep_alive_while_idle(),
-                proxy,
-                connect_timeout: (config_upstream).get_connect_timeout(),
-                timeout: (config_upstream).get_timeout(),
-                tcp_keep_alive: (config_upstream).get_tcp_keep_alive(),
-                user_agent: (config_upstream).get_user_agent(),
-                allowed_headers,
-                http_cache: (config_upstream).get_http_cache_size(),
-                batch,
-                http2_only: (config_upstream).get_http_2_only(),
-                on_request: (config_upstream).get_on_request(),
-                verify_ssl: (config_upstream).get_verify_ssl(),
-            })
-            .to_result()
-    }
-}
-
-fn get_batch(upstream: &config::Upstream) -> Valid<Option<Batch>, String> {
-    upstream.batch.as_ref().map_or_else(
-        || Valid::succeed(None),
-        |batch| {
-            Valid::succeed(Some(Batch {
-                max_size: Some((upstream).get_max_size()),
-                delay: (upstream).get_delay(),
-                headers: batch.headers.clone(),
-            }))
-        },
-    )
-}
-
-fn get_proxy(upstream: &config::Upstream) -> Valid<Option<Proxy>, String> {
-    if let Some(ref proxy) = upstream.proxy {
-        Valid::succeed(Some(Proxy { url: proxy.url.clone() }))
-    } else {
-        Valid::succeed(None)
-    }
-}
diff --git a/src/core/config/config.rs b/src/core/config/config.rs
index 9692420573..286afd28e4 100644
--- a/src/core/config/config.rs
+++ b/src/core/config/config.rs
@@ -1,23 +1,22 @@
-use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
-use std::fmt::{self, Display};
+use std::collections::{BTreeMap, BTreeSet, HashSet};
 
 use anyhow::Result;
 use async_graphql::parser::types::ServiceDocument;
 use derive_setters::Setters;
-use indexmap::IndexMap;
 use serde::{Deserialize, Serialize};
-use serde_json::Value;
 use strum::IntoEnumIterator;
 use tailcall_typedefs_common::directive_definition::DirectiveDefinition;
 use tailcall_typedefs_common::input_definition::InputDefinition;
 use tailcall_typedefs_common::ServiceDocumentBuilder;
 use tailcall_valid::{Valid, Validator};
 
-use super::directive::Directive;
 use super::from_document::from_document;
 use super::{
     AddField, Alias, Cache, Call, Discriminate, Expr, GraphQL, Grpc, Http, Link, Modify, Omit,
-    Protected, Resolver, Server, Telemetry, Upstream, JS,
+    Protected, Server, Telemetry, Upstream, JS,
+};
+pub use crate::core::blueprint::{
+    Arg, Enum, Field, GraphQLOperationType, RootSchema, Type, Union, Variant,
 };
 use crate::core::config::npo::QueryPath;
 use crate::core::config::source::Source;
@@ -84,273 +83,6 @@ pub struct Config {
     pub telemetry: Telemetry,
 }
 
-///
-/// Represents a GraphQL type.
-/// A type can be an object, interface, enum or scalar.
-#[derive(
-    Serialize, Deserialize, Clone, Debug, Default, PartialEq, Eq, schemars::JsonSchema, MergeRight,
-)]
-pub struct Type {
-    ///
-    /// A map of field name and its definition.
-    pub fields: BTreeMap<String, Field>,
-    #[serde(default, skip_serializing_if = "is_default")]
-    ///
-    /// Additional fields to be added to the type
-    pub added_fields: Vec<AddField>,
-    #[serde(default, skip_serializing_if = "is_default")]
-    ///
-    /// Documentation for the type that is publicly visible.
-    pub doc: Option<String>,
-    #[serde(default, skip_serializing_if = "is_default")]
-    ///
-    /// Interfaces that the type implements.
-    pub implements: BTreeSet<String>,
-    #[serde(default, skip_serializing_if = "is_default")]
-    ///
-    /// Setting to indicate if the type can be cached.
-    pub cache: Option<Cache>,
-    ///
-    /// Marks field as protected by auth providers
-    #[serde(default)]
-    pub protected: Option<Protected>,
-    ///
-    /// Apollo federation entity resolver.
-    #[serde(flatten, default, skip_serializing_if = "is_default")]
-    pub resolver: Option<Resolver>,
-    ///
-    /// Any additional directives
-    #[serde(default, skip_serializing_if = "is_default")]
-    pub directives: Vec<Directive>,
-}
-
-impl Display for Type {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        writeln!(f, "{{")?;
-
-        for (field_name, field) in &self.fields {
-            writeln!(f, "  {}: {:?},", field_name, field.type_of)?;
-        }
-        writeln!(f, "}}")
-    }
-}
-
-impl Type {
-    pub fn fields(mut self, fields: Vec<(&str, Field)>) -> Self {
-        let mut graphql_fields = BTreeMap::new();
-        for (name, field) in fields {
-            graphql_fields.insert(name.to_string(), field);
-        }
-        self.fields = graphql_fields;
-        self
-    }
-
-    pub fn scalar(&self) -> bool {
-        self.fields.is_empty()
-    }
-}
-
-#[derive(
-    Serialize,
-    Deserialize,
-    Clone,
-    Debug,
-    Default,
-    Setters,
-    PartialEq,
-    Eq,
-    schemars::JsonSchema,
-    MergeRight,
-)]
-#[setters(strip_option)]
-pub struct RootSchema {
-    pub query: Option<String>,
-    #[serde(default, skip_serializing_if = "is_default")]
-    pub mutation: Option<String>,
-    #[serde(default, skip_serializing_if = "is_default")]
-    pub subscription: Option<String>,
-}
-
-///
-/// A field definition containing all the metadata information about resolving a
-/// field.
-#[derive(
-    Serialize, Deserialize, Clone, Debug, Default, Setters, PartialEq, Eq, schemars::JsonSchema,
-)]
-#[setters(strip_option)]
-pub struct Field {
-    ///
-    /// Refers to the type of the value the field can be resolved to.
-    #[serde(rename = "type", default, skip_serializing_if = "is_default")]
-    pub type_of: crate::core::Type,
-
-    ///
-    /// Map of argument name and its definition.
-    #[serde(default, skip_serializing_if = "is_default")]
-    #[schemars(with = "HashMap::<String, Arg>")]
-    pub args: IndexMap<String, Arg>,
-
-    ///
-    /// Publicly visible documentation for the field.
-    #[serde(default, skip_serializing_if = "is_default")]
-    pub doc: Option<String>,
-
-    ///
-    /// Allows modifying existing fields.
-    #[serde(default, skip_serializing_if = "is_default")]
-    pub modify: Option<Modify>,
-
-    ///
-    /// Omits a field from public consumption.
-    #[serde(default, skip_serializing_if = "is_default")]
-    pub omit: Option<Omit>,
-
-    ///
-    /// Sets the cache configuration for a field
-    pub cache: Option<Cache>,
-
-    ///
-    /// Stores the default value for the field
-    #[serde(default, skip_serializing_if = "is_default")]
-    pub default_value: Option<Value>,
-
-    ///
-    /// Marks field as protected by auth provider
-    #[serde(default)]
-    pub protected: Option<Protected>,
-
-    ///
-    /// Used to overwrite the default discrimination strategy
-    pub discriminate: Option<Discriminate>,
-
-    ///
-    /// Resolver for the field
-    #[serde(flatten, default, skip_serializing_if = "is_default")]
-    pub resolver: Option<Resolver>,
-
-    ///
-    /// Any additional directives
-    #[serde(default, skip_serializing_if = "is_default")]
-    pub directives: Vec<Directive>,
-}
-
-// It's a terminal implementation of MergeRight
-impl MergeRight for Field {
-    fn merge_right(self, other: Self) -> Self {
-        other
-    }
-}
-
-impl Field {
-    pub fn has_resolver(&self) -> bool {
-        self.resolver.is_some()
-    }
-
-    pub fn has_batched_resolver(&self) -> bool {
-        self.resolver
-            .as_ref()
-            .map(Resolver::is_batched)
-            .unwrap_or(false)
-    }
-
-    pub fn int() -> Self {
-        Self { type_of: "Int".to_string().into(), ..Default::default() }
-    }
-
-    pub fn string() -> Self {
-        Self { type_of: "String".to_string().into(), ..Default::default() }
-    }
-
-    pub fn float() -> Self {
-        Self { type_of: "Float".to_string().into(), ..Default::default() }
-    }
-
-    pub fn boolean() -> Self {
-        Self { type_of: "Boolean".to_string().into(), ..Default::default() }
-    }
-
-    pub fn id() -> Self {
-        Self { type_of: "ID".to_string().into(), ..Default::default() }
-    }
-
-    pub fn is_omitted(&self) -> bool {
-        self.omit.is_some()
-            || self
-                .modify
-                .as_ref()
-                .and_then(|m| m.omit)
-                .unwrap_or_default()
-    }
-}
-
-#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
-pub struct Inline {
-    pub path: Vec<String>,
-}
-
-#[derive(Default, Serialize, Deserialize, Clone, Debug, PartialEq, Eq, schemars::JsonSchema)]
-pub struct Arg {
-    #[serde(rename = "type")]
-    pub type_of: crate::core::Type,
-    #[serde(default, skip_serializing_if = "is_default")]
-    pub doc: Option<String>,
-    #[serde(default, skip_serializing_if = "is_default")]
-    pub modify: Option<Modify>,
-    #[serde(default, skip_serializing_if = "is_default")]
-    pub default_value: Option<Value>,
-}
-
-#[derive(
-    Serialize, Deserialize, Clone, Debug, Default, PartialEq, Eq, schemars::JsonSchema, MergeRight,
-)]
-pub struct Union {
-    pub types: BTreeSet<String>,
-    pub doc: Option<String>,
-}
-
-#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, schemars::JsonSchema, MergeRight)]
-/// Definition of GraphQL enum type
-pub struct Enum {
-    pub variants: BTreeSet<Variant>,
-    pub doc: Option<String>,
-}
-
-/// Definition of GraphQL value
-#[derive(
-    Serialize,
-    Deserialize,
-    Clone,
-    Debug,
-    PartialEq,
-    Eq,
-    PartialOrd,
-    Ord,
-    schemars::JsonSchema,
-    MergeRight,
-)]
-pub struct Variant {
-    pub name: String,
-    // directive: alias
-    pub alias: Option<Alias>,
-}
-
-#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
-#[serde(rename_all = "lowercase")]
-pub enum GraphQLOperationType {
-    #[default]
-    Query,
-    Mutation,
-}
-
-impl Display for GraphQLOperationType {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.write_str(match self {
-            Self::Query => "query",
-            Self::Mutation => "mutation",
-        })
-    }
-}
-
 impl Config {
     pub fn is_root_operation_type(&self, type_name: &str) -> bool {
         let type_name = type_name.to_lowercase();
@@ -684,6 +416,7 @@ mod tests {
     use pretty_assertions::assert_eq;
 
     use super::*;
+    use crate::core::config::Resolver;
     use crate::core::directive::DirectiveCodec;
 
     #[test]
diff --git a/src/core/config/runtime_config/server_runtime.rs b/src/core/config/runtime_config/server_runtime.rs
index e1a601eee7..03b744e1b7 100644
--- a/src/core/config/runtime_config/server_runtime.rs
+++ b/src/core/config/runtime_config/server_runtime.rs
@@ -8,7 +8,6 @@ use http::header::{HeaderMap, HeaderName, HeaderValue};
 use rustls_pki_types::CertificateDer;
 use tailcall_valid::{Valid, ValidationError, Validator};
 
-use crate::core::blueprint;
 use crate::core::config::cors_static::CorsStatic;
 use crate::core::config::{self, ConfigModule, HttpVersion, PrivateKey, Routes};
 
@@ -162,35 +161,6 @@ impl TryFrom<crate::core::config::ConfigModule> for ServerRuntime {
     }
 }
 
-impl From<blueprint::Server> for ServerRuntime {
-    fn from(server: blueprint::Server) -> Self {
-        Self {
-            enable_jit: server.enable_jit,
-            enable_apollo_tracing: server.enable_apollo_tracing,
-            enable_cache_control_header: server.enable_cache_control_header,
-            enable_set_cookie_header: server.enable_set_cookie_header,
-            enable_introspection: server.enable_introspection,
-            enable_query_validation: server.enable_query_validation,
-            enable_response_validation: server.enable_response_validation,
-            enable_batch_requests: server.enable_batch_requests,
-            enable_showcase: server.enable_showcase,
-            global_response_timeout: server.global_response_timeout,
-            worker: server.worker,
-            port: server.port,
-            hostname: server.hostname,
-            vars: server.vars,
-            response_headers: server.response_headers,
-            http: server.http,
-            pipeline_flush: server.pipeline_flush,
-            script: server.script,
-            cors: server.cors,
-            experimental_headers: server.experimental_headers,
-            auth: server.auth,
-            routes: server.routes,
-        }
-    }
-}
-
 fn to_script(
     config_module: &crate::core::config::ConfigModule,
 ) -> Valid<Option<ScriptRuntime>, String> {
diff --git a/src/core/config/runtime_config/server_runtime/auth_runtime.rs b/src/core/config/runtime_config/server_runtime/auth_runtime.rs
index 64140eb466..67ba521b42 100644
--- a/src/core/config/runtime_config/server_runtime/auth_runtime.rs
+++ b/src/core/config/runtime_config/server_runtime/auth_runtime.rs
@@ -81,8 +81,6 @@ pub enum AuthProviderRuntime {
 
 #[cfg(test)]
 mod tests {
-    use once_cell::sync::Lazy;
-
     use super::*;
 
     fn test_basic_provider_1() -> AuthProviderRuntime {
diff --git a/src/core/config/runtime_config/upstream_runtime.rs b/src/core/config/runtime_config/upstream_runtime.rs
index 6caeacb422..c89f95c7e1 100644
--- a/src/core/config/runtime_config/upstream_runtime.rs
+++ b/src/core/config/runtime_config/upstream_runtime.rs
@@ -3,7 +3,6 @@ use std::collections::BTreeSet;
 use derive_setters::Setters;
 use tailcall_valid::{Valid, ValidationError, Validator};
 
-use crate::core::blueprint::{self};
 use crate::core::config::{Batch, ConfigModule, Proxy, UpstreamStatic};
 
 #[derive(PartialEq, Eq, Clone, Debug, Setters, schemars::JsonSchema)]
@@ -83,29 +82,6 @@ impl TryFrom<&ConfigModule> for UpstreamRuntime {
     }
 }
 
-impl From<blueprint::Upstream> for UpstreamRuntime {
-    fn from(upstream: blueprint::Upstream) -> Self {
-        Self {
-            pool_idle_timeout: upstream.pool_idle_timeout,
-            pool_max_idle_per_host: upstream.pool_max_idle_per_host,
-            keep_alive_interval: upstream.keep_alive_interval,
-            keep_alive_timeout: upstream.keep_alive_timeout,
-            keep_alive_while_idle: upstream.keep_alive_while_idle,
-            proxy: upstream.proxy,
-            connect_timeout: upstream.connect_timeout,
-            timeout: upstream.timeout,
-            tcp_keep_alive: upstream.tcp_keep_alive,
-            user_agent: upstream.user_agent,
-            allowed_headers: upstream.allowed_headers,
-            http_cache: upstream.http_cache,
-            batch: upstream.batch,
-            http2_only: upstream.http2_only,
-            on_request: upstream.on_request,
-            verify_ssl: upstream.verify_ssl,
-        }
-    }
-}
-
 fn get_batch(upstream: &UpstreamStatic) -> Valid<Option<Batch>, String> {
     upstream.batch.as_ref().map_or_else(
         || Valid::succeed(None),
diff --git a/src/core/http/request_context.rs b/src/core/http/request_context.rs
index 29cde7addc..19380883c9 100644
--- a/src/core/http/request_context.rs
+++ b/src/core/http/request_context.rs
@@ -213,7 +213,6 @@ impl From<&AppContext> for RequestContext {
 mod test {
     use cache_control::Cachability;
 
-    use crate::core::blueprint::{Server, Upstream};
     use crate::core::config::{self, Batch, ServerRuntime, UpstreamRuntime};
     use crate::core::http::RequestContext;
 
@@ -221,10 +220,8 @@ mod test {
         fn default() -> Self {
             let config_module = crate::core::config::ConfigModule::default();
 
-            let upstream = Upstream::try_from(&config_module).unwrap();
-            let server = Server::try_from(config_module).unwrap();
-            let upstream = UpstreamRuntime::from(upstream);
-            let server = ServerRuntime::from(server);
+            let upstream = UpstreamRuntime::try_from(&config_module).unwrap();
+            let server = ServerRuntime::try_from(config_module).unwrap();
             RequestContext::new(crate::core::runtime::test::init(None))
                 .upstream(upstream)
                 .server(server)
@@ -270,11 +267,9 @@ mod test {
 
     fn create_req_ctx_with_batch(batch: Batch) -> RequestContext {
         let config_module = config::ConfigModule::default();
-        let mut upstream = Upstream::try_from(&config_module).unwrap();
-        let server = Server::try_from(config_module).unwrap();
+        let mut upstream = UpstreamRuntime::try_from(&config_module).unwrap();
+        let server = ServerRuntime::try_from(config_module).unwrap();
         upstream.batch = Some(batch);
-        let upstream = UpstreamRuntime::from(upstream);
-        let server = ServerRuntime::from(server);
         RequestContext::default().upstream(upstream).server(server)
     }
 
diff --git a/src/core/runtime.rs b/src/core/runtime.rs
index 72c44fee88..7c64b25263 100644
--- a/src/core/runtime.rs
+++ b/src/core/runtime.rs
@@ -57,9 +57,8 @@ pub mod test {
     use tokio::io::{AsyncReadExt, AsyncWriteExt};
 
     use crate::cli::javascript::init_worker_io;
-    use crate::core::blueprint::Upstream;
     use crate::core::cache::InMemoryCache;
-    use crate::core::config::ScriptRuntime;
+    use crate::core::config::{ScriptRuntime, UpstreamRuntime};
     use crate::core::http::Response;
     use crate::core::runtime::TargetRuntime;
     use crate::core::worker::{Command, Event};
@@ -77,7 +76,7 @@ pub mod test {
     }
 
     impl TestHttp {
-        fn init(upstream: &Upstream) -> Arc<Self> {
+        fn init(upstream: &UpstreamRuntime) -> Arc<Self> {
             let mut builder = Client::builder()
                 .tcp_keepalive(Some(Duration::from_secs(upstream.tcp_keep_alive)))
                 .timeout(Duration::from_secs(upstream.timeout))
@@ -177,7 +176,7 @@ pub mod test {
 
     pub fn init(script: Option<ScriptRuntime>) -> TargetRuntime {
         let http = TestHttp::init(&Default::default());
-        let http2 = TestHttp::init(&Upstream::default().http2_only(true));
+        let http2 = TestHttp::init(&UpstreamRuntime::default().http2_only(true));
 
         let file = TestFileIO::init();
         let env = TestEnvIO::init();
diff --git a/tests/server_spec.rs b/tests/server_spec.rs
index 9223a21f5e..d53c69e1b8 100644
--- a/tests/server_spec.rs
+++ b/tests/server_spec.rs
@@ -12,9 +12,8 @@ pub mod test {
     use reqwest::Client;
     use reqwest_middleware::{ClientBuilder, ClientWithMiddleware};
     use tailcall::cli::javascript::init_worker_io;
-    use tailcall::core::blueprint::Upstream;
     use tailcall::core::cache::InMemoryCache;
-    use tailcall::core::config::ScriptRuntime;
+    use tailcall::core::config::{ScriptRuntime, UpstreamRuntime};
     use tailcall::core::http::Response;
     use tailcall::core::runtime::TargetRuntime;
     use tailcall::core::worker::{Command, Event};
@@ -34,7 +33,7 @@ pub mod test {
     }
 
     impl TestHttp {
-        fn init(upstream: &Upstream) -> Arc<Self> {
+        fn init(upstream: &UpstreamRuntime) -> Arc<Self> {
             let mut builder = Client::builder()
                 .tcp_keepalive(Some(Duration::from_secs(upstream.tcp_keep_alive)))
                 .timeout(Duration::from_secs(upstream.timeout))
@@ -134,7 +133,7 @@ pub mod test {
 
     pub fn init(script: Option<ScriptRuntime>) -> TargetRuntime {
         let http = TestHttp::init(&Default::default());
-        let http2 = TestHttp::init(&Upstream::default().http2_only(true));
+        let http2 = TestHttp::init(&UpstreamRuntime::default().http2_only(true));
 
         let file = TestFileIO::init();
         let env = TestEnvIO::init();

From b96466a08524709df4214b63672421de26966667 Mon Sep 17 00:00:00 2001
From: Panagiotis <panagiotiskaratakis@gmail.com>
Date: Mon, 18 Nov 2024 16:43:11 +0200
Subject: [PATCH 4/4] refactor: limit exposure to blueprint properties on
 `Config` struct

---
 ...impl_path_string_for_evaluation_context.rs |   2 -
 generated/.tailcallrc.schema.json             |  77 +++++++-----
 src/cli/llm/infer_type_name.rs                |   6 +-
 src/cli/tc/init.rs                            |  11 +-
 src/core/blueprint/definitions.rs             |  61 +++++----
 src/core/blueprint/mustache.rs                |  19 ++-
 .../blueprint/operators/apollo_federation.rs  |   2 +-
 src/core/blueprint/operators/enum_alias.rs    |   2 +-
 src/core/blueprint/schema.rs                  |  22 +++-
 src/core/config/config.rs                     |  85 ++++++-------
 src/core/config/config_module/merge.rs        |  21 +++-
 src/core/config/from_document.rs              |   6 +-
 src/core/config/into_document.rs              |  15 ++-
 src/core/config/npo/tracker.rs                |   2 +-
 src/core/config/reader.rs                     |   8 +-
 src/core/config/transformer/ambiguous_type.rs |  45 +++++--
 .../transformer/flatten_single_field.rs       |   6 +-
 .../config/transformer/improve_type_names.rs  |   8 +-
 .../transformer/merge_types/similarity.rs     | 119 +++++++++++++-----
 .../transformer/merge_types/type_merger.rs    |  65 ++++++----
 src/core/config/transformer/nested_unions.rs  |   4 +-
 src/core/config/transformer/rename_types.rs   |  43 ++++---
 src/core/config/transformer/subgraph.rs       |  64 ++++++----
 .../config/transformer/union_input_type.rs    |  10 +-
 src/core/generator/from_proto.rs              |  21 +++-
 .../generator/json/operation_generator.rs     |   9 +-
 src/core/generator/json/schema_generator.rs   |  31 +++--
 src/core/generator/json/types_generator.rs    |  12 +-
 src/core/grpc/data_loader_request.rs          |   2 +-
 src/core/grpc/protobuf.rs                     |   2 +-
 src/core/grpc/request_template.rs             |   2 +-
 31 files changed, 502 insertions(+), 280 deletions(-)

diff --git a/benches/impl_path_string_for_evaluation_context.rs b/benches/impl_path_string_for_evaluation_context.rs
index 2824d57d57..711d1fd5eb 100644
--- a/benches/impl_path_string_for_evaluation_context.rs
+++ b/benches/impl_path_string_for_evaluation_context.rs
@@ -242,8 +242,6 @@ fn request_context() -> RequestContext {
     let server = ServerRuntime::try_from(config_module).unwrap();
     let http = Arc::new(Http::init(&upstream));
     let http2 = Arc::new(Http::init(&upstream.clone().http2_only(true)));
-    let server = server;
-    let upstream = upstream;
     let runtime = TargetRuntime {
         http2_only: http2,
         http,
diff --git a/generated/.tailcallrc.schema.json b/generated/.tailcallrc.schema.json
index 2fbc9d3237..641494ac61 100644
--- a/generated/.tailcallrc.schema.json
+++ b/generated/.tailcallrc.schema.json
@@ -2,16 +2,14 @@
   "$schema": "http://json-schema.org/draft-07/schema#",
   "title": "Config",
   "type": "object",
-  "required": [
-    "schema"
-  ],
   "properties": {
-    "enums": {
-      "description": "A map of all the enum types in the schema",
-      "type": "object",
-      "additionalProperties": {
-        "$ref": "#/definitions/Enum"
-      }
+    "blueprintBuilder": {
+      "description": "A builder for generating the blueprint.",
+      "allOf": [
+        {
+          "$ref": "#/definitions/BlueprintBuilder"
+        }
+      ]
     },
     "links": {
       "description": "A list of all links in the schema.",
@@ -20,14 +18,6 @@
         "$ref": "#/definitions/Link"
       }
     },
-    "schema": {
-      "description": "Specifies the entry points for query and mutation in the generated GraphQL schema.",
-      "allOf": [
-        {
-          "$ref": "#/definitions/RootSchema"
-        }
-      ]
-    },
     "server": {
       "description": "Dictates how the server behaves and helps tune tailcall for all ingress requests. Features such as request batching, SSL, HTTP2 etc. can be configured here.",
       "default": {},
@@ -45,21 +35,6 @@
         }
       ]
     },
-    "types": {
-      "description": "A map of all the types in the schema.",
-      "default": {},
-      "type": "object",
-      "additionalProperties": {
-        "$ref": "#/definitions/Type"
-      }
-    },
-    "unions": {
-      "description": "A map of all the union types in the schema.",
-      "type": "object",
-      "additionalProperties": {
-        "$ref": "#/definitions/Union"
-      }
-    },
     "upstream": {
       "description": "Dictates how tailcall should handle upstream requests/responses. Tuning upstream can improve performance and reliability for connections.",
       "default": {},
@@ -204,6 +179,44 @@
         }
       }
     },
+    "BlueprintBuilder": {
+      "type": "object",
+      "required": [
+        "schema"
+      ],
+      "properties": {
+        "enums": {
+          "description": "A map of all the enum types in the schema",
+          "type": "object",
+          "additionalProperties": {
+            "$ref": "#/definitions/Enum"
+          }
+        },
+        "schema": {
+          "description": "Specifies the entry points for query and mutation in the generated GraphQL schema.",
+          "allOf": [
+            {
+              "$ref": "#/definitions/RootSchema"
+            }
+          ]
+        },
+        "types": {
+          "description": "A map of all the types in the schema.",
+          "default": {},
+          "type": "object",
+          "additionalProperties": {
+            "$ref": "#/definitions/Type"
+          }
+        },
+        "unions": {
+          "description": "A map of all the union types in the schema.",
+          "type": "object",
+          "additionalProperties": {
+            "$ref": "#/definitions/Union"
+          }
+        }
+      }
+    },
     "Bytes": {
       "title": "Bytes",
       "description": "Field whose value is a sequence of bytes."
diff --git a/src/cli/llm/infer_type_name.rs b/src/cli/llm/infer_type_name.rs
index 7183eacbde..5f4ce84d0d 100644
--- a/src/cli/llm/infer_type_name.rs
+++ b/src/cli/llm/infer_type_name.rs
@@ -97,6 +97,7 @@ impl InferTypeName {
         let mut new_name_mappings: HashMap<String, String> = HashMap::new();
         // Filter out root operation types and types with non-auto-generated names
         let types_to_be_processed = config
+            .blueprint_builder
             .types
             .iter()
             .filter(|(type_name, _)| {
@@ -105,6 +106,7 @@ impl InferTypeName {
             .collect::<Vec<_>>();
 
         let mut used_type_names = config
+            .blueprint_builder
             .types
             .iter()
             .filter(|(ty_name, _)| !Self::is_auto_generated(ty_name))
@@ -130,7 +132,9 @@ impl InferTypeName {
                     Ok(answer) => {
                         let name = &answer.suggestions.join(", ");
                         for name in answer.suggestions {
-                            if config.types.contains_key(&name) || used_type_names.contains(&name) {
+                            if config.blueprint_builder.types.contains_key(&name)
+                                || used_type_names.contains(&name)
+                            {
                                 continue;
                             }
                             used_type_names.insert(name.clone());
diff --git a/src/cli/tc/init.rs b/src/cli/tc/init.rs
index 99be5b3296..eaceb589a8 100644
--- a/src/cli/tc/init.rs
+++ b/src/cli/tc/init.rs
@@ -5,6 +5,7 @@ use anyhow::Result;
 
 use super::helpers::{GRAPHQL_RC, TAILCALL_RC, TAILCALL_RC_SCHEMA};
 use crate::cli::runtime::{confirm_and_write, create_directory, select_prompt};
+use crate::core::blueprint::BlueprintBuilder;
 use crate::core::config::{Config, Expr, Field, Resolver, RootSchema, Source};
 use crate::core::merge_right::MergeRight;
 use crate::core::runtime::TargetRuntime;
@@ -102,9 +103,13 @@ fn main_config() -> Config {
     Config {
         server: Default::default(),
         upstream: Default::default(),
-        schema: RootSchema { query: Some("Query".to_string()), ..Default::default() },
-        types: BTreeMap::from([("Query".into(), query_type)]),
-        ..Default::default()
+        blueprint_builder: BlueprintBuilder {
+            schema: RootSchema { query: Some("Query".to_string()), ..Default::default() },
+            types: BTreeMap::from([("Query".into(), query_type)]),
+            ..Default::default()
+        },
+        links: Default::default(),
+        telemetry: Default::default(),
     }
 }
 
diff --git a/src/core/blueprint/definitions.rs b/src/core/blueprint/definitions.rs
index 15dc40bb41..f331e46e01 100644
--- a/src/core/blueprint/definitions.rs
+++ b/src/core/blueprint/definitions.rs
@@ -335,7 +335,13 @@ pub fn fix_dangling_resolvers<'a>(
         move |(config, field, _, name), mut b_field| {
             let mut set = HashSet::new();
             if !field.has_resolver()
-                && validate_field_has_resolver(name, field, &config.types, &mut set).is_succeed()
+                && validate_field_has_resolver(
+                    name,
+                    field,
+                    &config.blueprint_builder.types,
+                    &mut set,
+                )
+                .is_succeed()
             {
                 b_field = b_field.resolver(Some(IR::Dynamic(DynamicValue::Value(
                     ConstValue::Object(Default::default()),
@@ -378,6 +384,7 @@ fn to_fields(
     config_module: &ConfigModule,
 ) -> Valid<Vec<FieldDefinition>, String> {
     let operation_type = if config_module
+        .blueprint_builder
         .schema
         .mutation
         .as_deref()
@@ -520,32 +527,42 @@ pub fn to_field_definition(
 
 pub fn to_definitions<'a>() -> TryFold<'a, ConfigModule, Vec<Definition>, String> {
     TryFold::<ConfigModule, Vec<Definition>, String>::new(|config_module, _| {
-        Valid::from_iter(config_module.types.iter(), |(name, type_)| {
-            if type_.scalar() {
-                to_scalar_type_definition(name).trace(name)
-            } else {
-                to_object_type_definition(name, type_, config_module)
-                    .trace(name)
-                    .and_then(|definition| match definition.clone() {
-                        Definition::Object(object_type_definition) => {
-                            if config_module.input_types().contains(name) {
-                                to_input_object_type_definition(object_type_definition).trace(name)
-                            } else if config_module.interfaces_types_map().contains_key(name) {
-                                to_interface_type_definition(object_type_definition).trace(name)
-                            } else {
-                                Valid::succeed(definition)
+        Valid::from_iter(
+            config_module.blueprint_builder.types.iter(),
+            |(name, type_)| {
+                if type_.scalar() {
+                    to_scalar_type_definition(name).trace(name)
+                } else {
+                    to_object_type_definition(name, type_, config_module)
+                        .trace(name)
+                        .and_then(|definition| match definition.clone() {
+                            Definition::Object(object_type_definition) => {
+                                if config_module.input_types().contains(name) {
+                                    to_input_object_type_definition(object_type_definition)
+                                        .trace(name)
+                                } else if config_module.interfaces_types_map().contains_key(name) {
+                                    to_interface_type_definition(object_type_definition).trace(name)
+                                } else {
+                                    Valid::succeed(definition)
+                                }
                             }
-                        }
-                        _ => Valid::succeed(definition),
-                    })
-            }
-        })
+                            _ => Valid::succeed(definition),
+                        })
+                }
+            },
+        )
         .map(|mut types| {
-            types.extend(config_module.unions.iter().map(to_union_type_definition));
+            types.extend(
+                config_module
+                    .blueprint_builder
+                    .unions
+                    .iter()
+                    .map(to_union_type_definition),
+            );
             types
         })
         .fuse(Valid::from_iter(
-            config_module.enums.iter(),
+            config_module.blueprint_builder.enums.iter(),
             |(name, type_)| {
                 if type_.variants.is_empty() {
                     Valid::fail("No variants found for enum".to_string())
diff --git a/src/core/blueprint/mustache.rs b/src/core/blueprint/mustache.rs
index 8845aaa5ac..3067a17ff0 100644
--- a/src/core/blueprint/mustache.rs
+++ b/src/core/blueprint/mustache.rs
@@ -198,7 +198,10 @@ mod test {
                 ..Default::default()
             },
         );
-        config.types.insert("T1".to_string(), t1_type);
+        config
+            .blueprint_builder
+            .types
+            .insert("T1".to_string(), t1_type);
 
         let type_ = Type::List {
             of_type: Box::new(Type::Named { name: "Int".to_string(), non_null: false }),
@@ -227,8 +230,11 @@ mod test {
     fn test_allow_list_arguments_for_query_type() {
         let (config, field_def) = initialize_test_config_and_field();
 
-        let parts_validator =
-            MustachePartsValidator::new(config.types.get("T1").unwrap(), &config, &field_def);
+        let parts_validator = MustachePartsValidator::new(
+            config.blueprint_builder.types.get("T1").unwrap(),
+            &config,
+            &field_def,
+        );
         let validation_result =
             parts_validator.validate(&["args".to_string(), "q".to_string()], true);
 
@@ -239,8 +245,11 @@ mod test {
     fn test_should_not_allow_list_arguments_for_path_variable() {
         let (config, field_def) = initialize_test_config_and_field();
 
-        let parts_validator =
-            MustachePartsValidator::new(config.types.get("T1").unwrap(), &config, &field_def);
+        let parts_validator = MustachePartsValidator::new(
+            config.blueprint_builder.types.get("T1").unwrap(),
+            &config,
+            &field_def,
+        );
         let validation_result =
             parts_validator.validate(&["args".to_string(), "q".to_string()], false);
 
diff --git a/src/core/blueprint/operators/apollo_federation.rs b/src/core/blueprint/operators/apollo_federation.rs
index 46c4a8e770..b238e35f01 100644
--- a/src/core/blueprint/operators/apollo_federation.rs
+++ b/src/core/blueprint/operators/apollo_federation.rs
@@ -114,7 +114,7 @@ pub fn update_federation<'a>() -> TryFoldConfig<'a, Blueprint> {
                 return Valid::fail("Query type is not an object inside the blueprint".to_string());
             };
 
-            let Some(config_type) = config_module.types.get(&query_name) else {
+            let Some(config_type) = config_module.blueprint_builder.types.get(&query_name) else {
                 return Valid::fail(format!("Cannot find type {query_name} in the config"));
             };
 
diff --git a/src/core/blueprint/operators/enum_alias.rs b/src/core/blueprint/operators/enum_alias.rs
index 22eebd4965..c3532973ad 100644
--- a/src/core/blueprint/operators/enum_alias.rs
+++ b/src/core/blueprint/operators/enum_alias.rs
@@ -13,7 +13,7 @@ pub fn update_enum_alias<'a>(
 {
     TryFold::<(&ConfigModule, &Field, &config::Type, &'a str), FieldDefinition, String>::new(
         |(config, field, _, _), mut b_field| {
-            let enum_type = config.enums.get(field.type_of.name());
+            let enum_type = config.blueprint_builder.enums.get(field.type_of.name());
             if let Some(enum_type) = enum_type {
                 let has_alias = enum_type.variants.iter().any(|v| v.alias.is_some());
                 if !has_alias {
diff --git a/src/core/blueprint/schema.rs b/src/core/blueprint/schema.rs
index 8ecaf24651..a2c3d83b8f 100644
--- a/src/core/blueprint/schema.rs
+++ b/src/core/blueprint/schema.rs
@@ -9,7 +9,7 @@ use crate::core::directive::DirectiveCodec;
 
 fn validate_query(config: &Config) -> Valid<(), String> {
     Valid::from_option(
-        config.schema.query.clone(),
+        config.blueprint_builder.schema.query.clone(),
         "Query root is missing".to_owned(),
     )
     .and_then(|ref query_type_name| {
@@ -17,7 +17,12 @@ fn validate_query(config: &Config) -> Valid<(), String> {
             return Valid::fail("Query type is not defined".to_owned()).trace(query_type_name);
         };
         let mut set = HashSet::new();
-        validate_type_has_resolvers(query_type_name, query, &config.types, &mut set)
+        validate_type_has_resolvers(
+            query_type_name,
+            query,
+            &config.blueprint_builder.types,
+            &mut set,
+        )
     })
     .unit()
 }
@@ -66,7 +71,7 @@ pub fn validate_field_has_resolver(
 }
 
 fn validate_mutation(config: &Config) -> Valid<(), String> {
-    let mutation_type_name = config.schema.mutation.as_ref();
+    let mutation_type_name = config.blueprint_builder.schema.mutation.as_ref();
 
     if let Some(mutation_type_name) = mutation_type_name {
         let Some(mutation) = config.find_type(mutation_type_name) else {
@@ -74,7 +79,12 @@ fn validate_mutation(config: &Config) -> Valid<(), String> {
                 .trace(mutation_type_name);
         };
         let mut set = HashSet::new();
-        validate_type_has_resolvers(mutation_type_name, mutation, &config.types, &mut set)
+        validate_type_has_resolvers(
+            mutation_type_name,
+            mutation,
+            &config.blueprint_builder.types,
+            &mut set,
+        )
     } else {
         Valid::succeed(())
     }
@@ -85,13 +95,13 @@ pub fn to_schema<'a>() -> TryFoldConfig<'a, SchemaDefinition> {
         validate_query(config)
             .and(validate_mutation(config))
             .and(Valid::from_option(
-                config.schema.query.as_ref(),
+                config.blueprint_builder.schema.query.as_ref(),
                 "Query root is missing".to_owned(),
             ))
             .zip(to_directive(config.server.to_directive()))
             .map(|(query_type_name, directive)| SchemaDefinition {
                 query: query_type_name.to_owned(),
-                mutation: config.schema.mutation.clone(),
+                mutation: config.blueprint_builder.schema.mutation.clone(),
                 directives: vec![directive],
             })
     })
diff --git a/src/core/config/config.rs b/src/core/config/config.rs
index 286afd28e4..15969f6320 100644
--- a/src/core/config/config.rs
+++ b/src/core/config/config.rs
@@ -15,6 +15,7 @@ use super::{
     AddField, Alias, Cache, Call, Discriminate, Expr, GraphQL, Grpc, Http, Link, Modify, Omit,
     Protected, Server, Telemetry, Upstream, JS,
 };
+use crate::core::blueprint::BlueprintBuilder;
 pub use crate::core::blueprint::{
     Arg, Enum, Field, GraphQLOperationType, RootSchema, Type, Union, Variant,
 };
@@ -52,27 +53,6 @@ pub struct Config {
     #[serde(default)]
     pub upstream: Upstream,
 
-    ///
-    /// Specifies the entry points for query and mutation in the generated
-    /// GraphQL schema.
-    pub schema: RootSchema,
-
-    ///
-    /// A map of all the types in the schema.
-    #[serde(default)]
-    #[setters(skip)]
-    pub types: BTreeMap<String, Type>,
-
-    ///
-    /// A map of all the union types in the schema.
-    #[serde(default, skip_serializing_if = "is_default")]
-    pub unions: BTreeMap<String, Union>,
-
-    ///
-    /// A map of all the enum types in the schema
-    #[serde(default, skip_serializing_if = "is_default")]
-    pub enums: BTreeMap<String, Enum>,
-
     ///
     /// A list of all links in the schema.
     #[serde(default, skip_serializing_if = "is_default")]
@@ -81,6 +61,11 @@ pub struct Config {
     /// Enable [opentelemetry](https://opentelemetry.io) support
     #[serde(default, skip_serializing_if = "is_default")]
     pub telemetry: Telemetry,
+
+    ///
+    /// A builder for generating the blueprint.
+    #[serde(default, skip_serializing_if = "is_default")]
+    pub blueprint_builder: BlueprintBuilder,
 }
 
 impl Config {
@@ -88,9 +73,9 @@ impl Config {
         let type_name = type_name.to_lowercase();
 
         [
-            &self.schema.query,
-            &self.schema.mutation,
-            &self.schema.subscription,
+            &self.blueprint_builder.schema.query,
+            &self.blueprint_builder.schema.mutation,
+            &self.blueprint_builder.schema.subscription,
         ]
         .iter()
         .filter_map(|&root_name| root_name.as_ref())
@@ -102,15 +87,15 @@ impl Config {
     }
 
     pub fn find_type(&self, name: &str) -> Option<&Type> {
-        self.types.get(name)
+        self.blueprint_builder.types.get(name)
     }
 
     pub fn find_union(&self, name: &str) -> Option<&Union> {
-        self.unions.get(name)
+        self.blueprint_builder.unions.get(name)
     }
 
     pub fn find_enum(&self, name: &str) -> Option<&Enum> {
-        self.enums.get(name)
+        self.blueprint_builder.enums.get(name)
     }
 
     pub fn to_yaml(&self) -> Result<String> {
@@ -131,7 +116,7 @@ impl Config {
     }
 
     pub fn query(mut self, query: &str) -> Self {
-        self.schema.query = Some(query.to_string());
+        self.blueprint_builder.schema.query = Some(query.to_string());
         self
     }
 
@@ -140,14 +125,14 @@ impl Config {
         for (name, type_) in types {
             graphql_types.insert(name.to_string(), type_);
         }
-        self.types = graphql_types;
+        self.blueprint_builder.types = graphql_types;
         self
     }
 
     pub fn contains(&self, name: &str) -> bool {
-        self.types.contains_key(name)
-            || self.unions.contains_key(name)
-            || self.enums.contains_key(name)
+        self.blueprint_builder.types.contains_key(name)
+            || self.blueprint_builder.unions.contains_key(name)
+            || self.blueprint_builder.enums.contains_key(name)
     }
 
     pub fn from_json(json: &str) -> Result<Self> {
@@ -204,7 +189,8 @@ impl Config {
     ///
     /// Checks if a type is a scalar or not.
     pub fn is_scalar(&self, type_name: &str) -> bool {
-        self.types
+        self.blueprint_builder
+            .types
             .get(type_name)
             .map_or(Scalar::is_predefined(type_name), |ty| ty.scalar())
     }
@@ -224,7 +210,8 @@ impl Config {
 
     /// finds the all types which are present in union.
     pub fn union_types(&self) -> HashSet<String> {
-        self.unions
+        self.blueprint_builder
+            .unions
             .values()
             .flat_map(|union| union.types.iter().cloned())
             .collect()
@@ -234,11 +221,11 @@ impl Config {
     pub fn output_types(&self) -> HashSet<String> {
         let mut types = HashSet::new();
 
-        if let Some(ref query) = &self.schema.query {
+        if let Some(ref query) = &self.blueprint_builder.schema.query {
             types = self.find_connections(query, types);
         }
 
-        if let Some(ref mutation) = &self.schema.mutation {
+        if let Some(ref mutation) = &self.blueprint_builder.schema.mutation {
             types = self.find_connections(mutation, types);
         }
 
@@ -248,7 +235,7 @@ impl Config {
     pub fn interfaces_types_map(&self) -> BTreeMap<String, BTreeSet<String>> {
         let mut interfaces_types: BTreeMap<String, BTreeSet<String>> = BTreeMap::new();
 
-        for (type_name, type_definition) in self.types.iter() {
+        for (type_name, type_definition) in self.blueprint_builder.types.iter() {
             for implement_name in type_definition.implements.clone() {
                 interfaces_types
                     .entry(implement_name)
@@ -306,7 +293,8 @@ impl Config {
 
     /// Returns a list of all the arguments in the configuration
     fn arguments(&self) -> Vec<(&String, &Arg)> {
-        self.types
+        self.blueprint_builder
+            .types
             .iter()
             .flat_map(|(_, type_of)| type_of.fields.iter())
             .flat_map(|(_, field)| field.args.iter())
@@ -315,8 +303,8 @@ impl Config {
     /// Removes all types that are passed in the set
     pub fn remove_types(mut self, types: HashSet<String>) -> Self {
         for unused_type in types {
-            self.types.remove(&unused_type);
-            self.unions.remove(&unused_type);
+            self.blueprint_builder.types.remove(&unused_type);
+            self.blueprint_builder.unions.remove(&unused_type);
         }
 
         self
@@ -325,9 +313,10 @@ impl Config {
     pub fn unused_types(&self) -> HashSet<String> {
         let used_types = self.get_all_used_type_names();
         let all_types: HashSet<String> = self
+            .blueprint_builder
             .types
             .keys()
-            .chain(self.unions.keys())
+            .chain(self.blueprint_builder.unions.keys())
             .cloned()
             .collect();
         all_types.difference(&used_types).cloned().collect()
@@ -337,22 +326,22 @@ impl Config {
     pub fn get_all_used_type_names(&self) -> HashSet<String> {
         let mut set = HashSet::new();
         let mut stack = Vec::new();
-        if let Some(query) = &self.schema.query {
+        if let Some(query) = &self.blueprint_builder.schema.query {
             stack.push(query.clone());
         }
-        if let Some(mutation) = &self.schema.mutation {
+        if let Some(mutation) = &self.blueprint_builder.schema.mutation {
             stack.push(mutation.clone());
         }
         while let Some(type_name) = stack.pop() {
             if set.contains(&type_name) {
                 continue;
             }
-            if let Some(union_) = self.unions.get(&type_name) {
+            if let Some(union_) = self.blueprint_builder.unions.get(&type_name) {
                 set.insert(type_name);
                 for type_ in &union_.types {
                     stack.push(type_.clone());
                 }
-            } else if let Some(typ) = self.types.get(&type_name) {
+            } else if let Some(typ) = self.blueprint_builder.types.get(&type_name) {
                 set.insert(type_name);
                 for field in typ.fields.values() {
                     stack.extend(field.args.values().map(|arg| arg.type_of.name().to_owned()));
@@ -489,7 +478,7 @@ mod tests {
     #[test]
     fn test_is_root_operation_type_with_query() {
         let mut config = Config::default();
-        config.schema.query = Some("Query".to_string());
+        config.blueprint_builder.schema.query = Some("Query".to_string());
 
         assert!(config.is_root_operation_type("Query"));
         assert!(!config.is_root_operation_type("Mutation"));
@@ -499,7 +488,7 @@ mod tests {
     #[test]
     fn test_is_root_operation_type_with_mutation() {
         let mut config = Config::default();
-        config.schema.mutation = Some("Mutation".to_string());
+        config.blueprint_builder.schema.mutation = Some("Mutation".to_string());
 
         assert!(!config.is_root_operation_type("Query"));
         assert!(config.is_root_operation_type("Mutation"));
@@ -509,7 +498,7 @@ mod tests {
     #[test]
     fn test_is_root_operation_type_with_subscription() {
         let mut config = Config::default();
-        config.schema.subscription = Some("Subscription".to_string());
+        config.blueprint_builder.schema.subscription = Some("Subscription".to_string());
 
         assert!(!config.is_root_operation_type("Query"));
         assert!(!config.is_root_operation_type("Mutation"));
diff --git a/src/core/config/config_module/merge.rs b/src/core/config/config_module/merge.rs
index 0c145234d2..cee14ae5af 100644
--- a/src/core/config/config_module/merge.rs
+++ b/src/core/config/config_module/merge.rs
@@ -5,6 +5,7 @@ use tailcall_valid::{Valid, Validator};
 
 use super::{Cache, ConfigModule};
 use crate::core;
+use crate::core::blueprint::BlueprintBuilder;
 use crate::core::config::{Arg, Config, Enum, Field, Type};
 use crate::core::merge_right::MergeRight;
 use crate::core::variance::{Contravariant, Covariant, Invariant};
@@ -185,10 +186,10 @@ impl Covariant for Enum {
 
 impl Invariant for Cache {
     fn unify(self, other: Self) -> Valid<Self, String> {
-        let mut types = self.config.types;
-        let mut enums = self.config.enums;
+        let mut types = self.config.blueprint_builder.types;
+        let mut enums = self.config.blueprint_builder.enums;
 
-        Valid::from_iter(other.config.types, |(type_name, other_type)| {
+        Valid::from_iter(other.config.blueprint_builder.types, |(type_name, other_type)| {
             let trace_name = type_name.clone();
             match types.remove(&type_name) {
                 Some(ty) => {
@@ -229,7 +230,7 @@ impl Invariant for Cache {
             .map(|ty| (type_name, ty))
             .trace(&trace_name)
         })
-        .fuse(Valid::from_iter(other.config.enums, |(name, other_enum)| {
+        .fuse(Valid::from_iter(other.config.blueprint_builder.enums, |(name, other_enum)| {
             let trace_name = name.clone();
 
             match enums.remove(&name) {
@@ -275,7 +276,17 @@ impl Invariant for Cache {
             enums.extend(merged_enums);
 
             let config = Config {
-                types, enums, unions: self.config.unions.merge_right(other.config.unions), server: self.config.server.merge_right(other.config.server), upstream: self.config.upstream.merge_right(other.config.upstream), schema: self.config.schema.merge_right(other.config.schema), links: self.config.links.merge_right(other.config.links), telemetry: self.config.telemetry.merge_right(other.config.telemetry)  };
+                blueprint_builder: BlueprintBuilder {
+                    types,
+                    enums,
+                    unions: self.config.blueprint_builder.unions.merge_right(other.config.blueprint_builder.unions),
+                    schema: self.config.blueprint_builder.schema.merge_right(other.config.blueprint_builder.schema),
+                },
+                server: self.config.server.merge_right(other.config.server),
+                upstream: self.config.upstream.merge_right(other.config.upstream),
+                links: self.config.links.merge_right(other.config.links),
+                telemetry: self.config.telemetry.merge_right(other.config.telemetry)
+            };
 
             Cache {
                 config,
diff --git a/src/core/config/from_document.rs b/src/core/config/from_document.rs
index 3ccd7b72b6..379b6961cb 100644
--- a/src/core/config/from_document.rs
+++ b/src/core/config/from_document.rs
@@ -13,6 +13,7 @@ use tailcall_valid::{Valid, ValidationError, Validator};
 
 use super::directive::{to_directive, Directive};
 use super::{Alias, Discriminate, Resolver, Telemetry, FEDERATION_DIRECTIVES};
+use crate::core::blueprint::BlueprintBuilder;
 use crate::core::config::{
     self, Cache, Config, Enum, Link, Modify, Omit, Protected, RootSchema, Server, Union, Upstream,
     Variant,
@@ -54,12 +55,9 @@ pub fn from_document(doc: ServiceDocument) -> Valid<Config, String> {
                 |(server, upstream, types, unions, enums, schema, links, telemetry)| Config {
                     server,
                     upstream,
-                    types,
-                    unions,
-                    enums,
-                    schema,
                     links,
                     telemetry,
+                    blueprint_builder: BlueprintBuilder { types, unions, enums, schema },
                 },
             )
     })
diff --git a/src/core/config/into_document.rs b/src/core/config/into_document.rs
index b06ff84311..561b39d613 100644
--- a/src/core/config/into_document.rs
+++ b/src/core/config/into_document.rs
@@ -43,13 +43,20 @@ fn config_document(config: &Config) -> ServiceDocument {
     let schema_definition = SchemaDefinition {
         extend: false,
         directives,
-        query: config.schema.query.clone().map(|name| pos(Name::new(name))),
+        query: config
+            .blueprint_builder
+            .schema
+            .query
+            .clone()
+            .map(|name| pos(Name::new(name))),
         mutation: config
+            .blueprint_builder
             .schema
             .mutation
             .clone()
             .map(|name| pos(Name::new(name))),
         subscription: config
+            .blueprint_builder
             .schema
             .subscription
             .clone()
@@ -58,7 +65,7 @@ fn config_document(config: &Config) -> ServiceDocument {
     definitions.push(TypeSystemDefinition::Schema(pos(schema_definition)));
     let interface_types = config.interfaces_types_map();
     let input_types = config.input_types();
-    for (type_name, type_def) in config.types.iter() {
+    for (type_name, type_def) in config.blueprint_builder.types.iter() {
         let kind = if interface_types.contains_key(type_name) {
             TypeKind::Interface(InterfaceType {
                 implements: type_def
@@ -159,7 +166,7 @@ fn config_document(config: &Config) -> ServiceDocument {
             kind,
         })));
     }
-    for (name, union) in config.unions.iter() {
+    for (name, union) in config.blueprint_builder.unions.iter() {
         definitions.push(TypeSystemDefinition::Type(pos(TypeDefinition {
             extend: false,
             description: None,
@@ -175,7 +182,7 @@ fn config_document(config: &Config) -> ServiceDocument {
         })));
     }
 
-    for (name, values) in config.enums.iter() {
+    for (name, values) in config.blueprint_builder.enums.iter() {
         definitions.push(TypeSystemDefinition::Type(pos(TypeDefinition {
             extend: false,
             description: values.doc.clone().map(pos),
diff --git a/src/core/config/npo/tracker.rs b/src/core/config/npo/tracker.rs
index 80d5c0f800..412e556c55 100644
--- a/src/core/config/npo/tracker.rs
+++ b/src/core/config/npo/tracker.rs
@@ -153,7 +153,7 @@ impl<'a> PathTracker<'a> {
     }
 
     fn find_chunks(&mut self) -> Chunk<Chunk<FieldName<'a>>> {
-        match &self.config.schema.query {
+        match &self.config.blueprint_builder.schema.query {
             None => Chunk::new(),
             Some(query) => self.iter(
                 Chunk::new(),
diff --git a/src/core/config/reader.rs b/src/core/config/reader.rs
index fc6c6c9ebc..1556848df5 100644
--- a/src/core/config/reader.rs
+++ b/src/core/config/reader.rs
@@ -265,7 +265,7 @@ mod reader_tests {
         let runtime = crate::core::runtime::test::init(None);
 
         let mut cfg = Config::default();
-        cfg.schema.query = Some("Test".to_string());
+        cfg.blueprint_builder.schema.query = Some("Test".to_string());
         cfg = cfg.types([("Test", Type::default())].to_vec());
 
         let server = start_mock_server();
@@ -301,7 +301,8 @@ mod reader_tests {
                 .iter()
                 .map(|i| i.to_string())
                 .collect::<Vec<String>>(),
-            c.types
+            c.blueprint_builder
+                .types
                 .keys()
                 .map(|i| i.to_string())
                 .collect::<Vec<String>>()
@@ -329,7 +330,8 @@ mod reader_tests {
                 .iter()
                 .map(|i| i.to_string())
                 .collect::<Vec<String>>(),
-            c.types
+            c.blueprint_builder
+                .types
                 .keys()
                 .map(|i| i.to_string())
                 .collect::<Vec<String>>()
diff --git a/src/core/config/transformer/ambiguous_type.rs b/src/core/config/transformer/ambiguous_type.rs
index 994de6557b..47fa379dc8 100644
--- a/src/core/config/transformer/ambiguous_type.rs
+++ b/src/core/config/transformer/ambiguous_type.rs
@@ -74,7 +74,7 @@ impl Transform for AmbiguousType {
                 .trace(current_name)
             } else {
                 let mut resolution_map = HashMap::new();
-                if let Some(ty) = config.types.get(current_name) {
+                if let Some(ty) = config.blueprint_builder.types.get(current_name) {
                     resolution_map = insert_resolution(resolution_map, current_name, resolution);
                     for field in ty.fields.values() {
                         for args in field.args.values() {
@@ -103,26 +103,37 @@ impl Transform for AmbiguousType {
                 let input_name = &resolution.input;
                 let output_name = &resolution.output;
 
-                let og_ty = config.types.get(current_name).cloned();
+                let og_ty = config.blueprint_builder.types.get(current_name).cloned();
 
                 // remove old types
-                config.types.remove(current_name);
+                config.blueprint_builder.types.remove(current_name);
                 input_types.remove(current_name);
                 output_types.remove(current_name);
 
                 // add new types
                 if let Some(og_ty) = og_ty {
-                    config.types.insert(input_name.clone(), og_ty.clone());
+                    config
+                        .blueprint_builder
+                        .types
+                        .insert(input_name.clone(), og_ty.clone());
                     input_types.insert(input_name.clone());
 
-                    config.types.insert(output_name.clone(), og_ty);
+                    config
+                        .blueprint_builder
+                        .types
+                        .insert(output_name.clone(), og_ty);
                     output_types.insert(output_name.clone());
                 }
             }
-            let keys = config.types.keys().cloned().collect::<Vec<_>>();
+            let keys = config
+                .blueprint_builder
+                .types
+                .keys()
+                .cloned()
+                .collect::<Vec<_>>();
 
             for k in keys {
-                if let Some(ty) = config.types.get_mut(&k) {
+                if let Some(ty) = config.blueprint_builder.types.get_mut(&k) {
                     for field in ty.fields.values_mut() {
                         if let Some(resolution) = resolution_map.get(field.type_of.name()) {
                             if output_types.contains(&k) {
@@ -190,7 +201,10 @@ mod tests {
         query.fields.insert("field1".to_string(), field1);
         query.fields.insert("field2".to_string(), field2);
 
-        config.types.insert("Query".to_string(), query);
+        config
+            .blueprint_builder
+            .types
+            .insert("Query".to_string(), query);
         config = config.query("Query");
 
         config
@@ -224,9 +238,18 @@ mod tests {
             crate::core::config::Field::default().type_of("Type2".to_string().into()),
         );
 
-        config.types.insert("Type1".to_string(), type1);
-        config.types.insert("Type2".to_string(), type2);
-        config.types.insert("Type3".to_string(), type3);
+        config
+            .blueprint_builder
+            .types
+            .insert("Type1".to_string(), type1);
+        config
+            .blueprint_builder
+            .types
+            .insert("Type2".to_string(), type2);
+        config
+            .blueprint_builder
+            .types
+            .insert("Type3".to_string(), type3);
 
         config = build_qry(config);
 
diff --git a/src/core/config/transformer/flatten_single_field.rs b/src/core/config/transformer/flatten_single_field.rs
index b153ce87f9..1d7453cf23 100644
--- a/src/core/config/transformer/flatten_single_field.rs
+++ b/src/core/config/transformer/flatten_single_field.rs
@@ -22,10 +22,10 @@ fn get_single_field_path(
     visited_types.insert(type_name.to_owned());
     let mut path = Vec::new();
     path.push(field_name.to_owned());
-    if config.is_scalar(type_name) || config.enums.contains_key(type_name) {
+    if config.is_scalar(type_name) || config.blueprint_builder.enums.contains_key(type_name) {
         return Some(path);
     }
-    let ty = config.types.get(type_name);
+    let ty = config.blueprint_builder.types.get(type_name);
     if let Some(ty) = ty {
         if ty.fields.len() == 1 {
             if let Some((sub_field_name, sub_field)) = ty.fields.first_key_value() {
@@ -58,7 +58,7 @@ impl Transform for FlattenSingleField {
     fn transform(&self, mut config: Self::Value) -> Valid<Self::Value, Self::Error> {
         let origin_config = config.clone();
 
-        for ty in config.types.values_mut() {
+        for ty in config.blueprint_builder.types.values_mut() {
             for (field_name, field) in ty.fields.iter_mut() {
                 let mut visited_types = HashSet::<String>::new();
                 if let Some(path) = get_single_field_path(
diff --git a/src/core/config/transformer/improve_type_names.rs b/src/core/config/transformer/improve_type_names.rs
index a2cdfaa69b..a84b5b27fc 100644
--- a/src/core/config/transformer/improve_type_names.rs
+++ b/src/core/config/transformer/improve_type_names.rs
@@ -42,7 +42,11 @@ impl<'a> CandidateConvergence<'a> {
             let candidates_to_consider = candidate_list.iter().filter(|(candidate_name, _)| {
                 let candidate_type_name = candidate_name.to_case(Case::Pascal);
                 !converged_candidate_set.contains(&candidate_type_name)
-                    && !self.config.types.contains_key(&candidate_type_name)
+                    && !self
+                        .config
+                        .blueprint_builder
+                        .types
+                        .contains_key(&candidate_type_name)
             });
 
             // Find the candidate with the highest frequency and priority
@@ -76,7 +80,7 @@ impl<'a> CandidateGeneration<'a> {
     /// This method iterates over the configuration and collects candidate type
     /// names for each type.
     fn generate(mut self) -> CandidateConvergence<'a> {
-        for (type_name, type_info) in self.config.types.iter() {
+        for (type_name, type_info) in self.config.blueprint_builder.types.iter() {
             for (field_name, field_info) in type_info.fields.iter() {
                 if self.config.is_scalar(field_info.type_of.name())
                     || field_name.starts_with(PREFIX)
diff --git a/src/core/config/transformer/merge_types/similarity.rs b/src/core/config/transformer/merge_types/similarity.rs
index f0ca65d3fa..d54d7822a6 100644
--- a/src/core/config/transformer/merge_types/similarity.rs
+++ b/src/core/config/transformer/merge_types/similarity.rs
@@ -91,8 +91,9 @@ impl<'a> Similarity<'a> {
                             // If the list properties don't match, we cannot merge these types.
                             return Valid::fail("Type merge failed: The fields have different list types and cannot be merged.".to_string());
                         }
-                    } else if let Some(type_1) = config.types.get(field_1_type_of) {
-                        if let Some(type_2) = config.types.get(field_2_type_of) {
+                    } else if let Some(type_1) = config.blueprint_builder.types.get(field_1_type_of)
+                    {
+                        if let Some(type_2) = config.blueprint_builder.types.get(field_2_type_of) {
                             if visited_type.contains(field_1_type_of, field_2_type_of) {
                                 // it's cyclic type, return true as they're the same.
                                 return Valid::succeed(true);
@@ -195,10 +196,14 @@ mod test {
         );
 
         let mut cfg: Config = Config::default();
-        cfg.types.insert("Foo1".to_owned(), foo1.to_owned());
-        cfg.types.insert("Foo2".to_owned(), foo2.to_owned());
-        cfg.types.insert("Bar1".to_owned(), bar1);
-        cfg.types.insert("Bar2".to_owned(), bar2);
+        cfg.blueprint_builder
+            .types
+            .insert("Foo1".to_owned(), foo1.to_owned());
+        cfg.blueprint_builder
+            .types
+            .insert("Foo2".to_owned(), foo2.to_owned());
+        cfg.blueprint_builder.types.insert("Bar1".to_owned(), bar1);
+        cfg.blueprint_builder.types.insert("Bar2".to_owned(), bar2);
 
         let mut gen = Similarity::new(&cfg);
         let is_similar = gen
@@ -235,10 +240,14 @@ mod test {
         );
 
         let mut cfg: Config = Config::default();
-        cfg.types.insert("Foo1".to_owned(), foo1.to_owned());
-        cfg.types.insert("Foo2".to_owned(), foo2.to_owned());
-        cfg.types.insert("Bar1".to_owned(), bar1);
-        cfg.types.insert("Bar2".to_owned(), bar2);
+        cfg.blueprint_builder
+            .types
+            .insert("Foo1".to_owned(), foo1.to_owned());
+        cfg.blueprint_builder
+            .types
+            .insert("Foo2".to_owned(), foo2.to_owned());
+        cfg.blueprint_builder.types.insert("Bar1".to_owned(), bar1);
+        cfg.blueprint_builder.types.insert("Bar2".to_owned(), bar2);
 
         let mut gen = Similarity::new(&cfg);
         let is_similar = gen
@@ -287,12 +296,16 @@ mod test {
         );
 
         let mut cfg: Config = Config::default();
-        cfg.types.insert("Foo1".to_owned(), foo1.to_owned());
-        cfg.types.insert("Foo2".to_owned(), foo2.to_owned());
-        cfg.types.insert("Bar1".to_owned(), bar1);
-        cfg.types.insert("Bar2".to_owned(), bar2);
-        cfg.types.insert("Far1".to_owned(), far1);
-        cfg.types.insert("Far2".to_owned(), far2);
+        cfg.blueprint_builder
+            .types
+            .insert("Foo1".to_owned(), foo1.to_owned());
+        cfg.blueprint_builder
+            .types
+            .insert("Foo2".to_owned(), foo2.to_owned());
+        cfg.blueprint_builder.types.insert("Bar1".to_owned(), bar1);
+        cfg.blueprint_builder.types.insert("Bar2".to_owned(), bar2);
+        cfg.blueprint_builder.types.insert("Far1".to_owned(), far1);
+        cfg.blueprint_builder.types.insert("Far2".to_owned(), far2);
 
         let mut gen = Similarity::new(&cfg);
         let is_similar = gen
@@ -329,8 +342,14 @@ mod test {
             .insert("c".to_string(), optional_int_field.clone());
 
         let mut config = Config::default();
-        config.types.insert("Foo".to_string(), ty1.clone());
-        config.types.insert("Bar".to_string(), ty2.clone());
+        config
+            .blueprint_builder
+            .types
+            .insert("Foo".to_string(), ty1.clone());
+        config
+            .blueprint_builder
+            .types
+            .insert("Bar".to_string(), ty2.clone());
 
         let types_equal = Similarity::new(&config)
             .similarity(("Foo", &ty1), ("Bar", &ty2), 1.0)
@@ -360,8 +379,14 @@ mod test {
             .insert("a".to_string(), optional_int_field.clone());
 
         let mut config = Config::default();
-        config.types.insert("Foo".to_string(), ty1.clone());
-        config.types.insert("Bar".to_string(), ty2.clone());
+        config
+            .blueprint_builder
+            .types
+            .insert("Foo".to_string(), ty1.clone());
+        config
+            .blueprint_builder
+            .types
+            .insert("Bar".to_string(), ty2.clone());
 
         let types_equal = Similarity::new(&config)
             .similarity(("Foo", &ty1), ("Bar", &ty2), 1.0)
@@ -391,8 +416,14 @@ mod test {
             .insert("a".to_string(), optional_int_field.clone());
 
         let mut config = Config::default();
-        config.types.insert("Foo".to_string(), ty1.clone());
-        config.types.insert("Bar".to_string(), ty2.clone());
+        config
+            .blueprint_builder
+            .types
+            .insert("Foo".to_string(), ty1.clone());
+        config
+            .blueprint_builder
+            .types
+            .insert("Bar".to_string(), ty2.clone());
 
         let types_equal = Similarity::new(&config)
             .similarity(("Foo", &ty1), ("Bar", &ty2), 1.0)
@@ -417,8 +448,14 @@ mod test {
             .insert("a".to_string(), required_int_field.clone());
 
         let mut config = Config::default();
-        config.types.insert("Foo".to_string(), ty1.clone());
-        config.types.insert("Bar".to_string(), ty2.clone());
+        config
+            .blueprint_builder
+            .types
+            .insert("Foo".to_string(), ty1.clone());
+        config
+            .blueprint_builder
+            .types
+            .insert("Bar".to_string(), ty2.clone());
 
         let types_equal = Similarity::new(&config)
             .similarity(("Foo", &ty1), ("Bar", &ty2), 1.0)
@@ -443,8 +480,14 @@ mod test {
             .insert("a".to_string(), required_int_field.clone());
 
         let mut config = Config::default();
-        config.types.insert("Foo".to_string(), ty1.clone());
-        config.types.insert("Bar".to_string(), ty2.clone());
+        config
+            .blueprint_builder
+            .types
+            .insert("Foo".to_string(), ty1.clone());
+        config
+            .blueprint_builder
+            .types
+            .insert("Bar".to_string(), ty2.clone());
 
         let types_equal = Similarity::new(&config)
             .similarity(("Foo", &ty1), ("Bar", &ty2), 1.0)
@@ -472,8 +515,14 @@ mod test {
             .insert("a".to_string(), required_int_field.clone());
 
         let mut config = Config::default();
-        config.types.insert("Foo".to_string(), ty1.clone());
-        config.types.insert("Bar".to_string(), ty2.clone());
+        config
+            .blueprint_builder
+            .types
+            .insert("Foo".to_string(), ty1.clone());
+        config
+            .blueprint_builder
+            .types
+            .insert("Bar".to_string(), ty2.clone());
 
         let types_equal = Similarity::new(&config)
             .similarity(("Foo", &ty1), ("Bar", &ty2), 1.0)
@@ -504,8 +553,14 @@ mod test {
 
         // Create configuration with Foo and Bar types
         let mut config = Config::default();
-        config.types.insert("Foo".to_owned(), foo.clone());
-        config.types.insert("Bar".to_owned(), bar.clone());
+        config
+            .blueprint_builder
+            .types
+            .insert("Foo".to_owned(), foo.clone());
+        config
+            .blueprint_builder
+            .types
+            .insert("Bar".to_owned(), bar.clone());
 
         // Calculate similarity between Foo and Bar
         let result = Similarity::new(&config)
@@ -532,8 +587,8 @@ mod test {
 
         let result = similarity
             .similarity(
-                ("B", config.types.get("B").unwrap()),
-                ("A", config.types.get("A").unwrap()),
+                ("B", config.blueprint_builder.types.get("B").unwrap()),
+                ("A", config.blueprint_builder.types.get("A").unwrap()),
                 0.9,
             )
             .to_result()
diff --git a/src/core/config/transformer/merge_types/type_merger.rs b/src/core/config/transformer/merge_types/type_merger.rs
index 4cf82f8e45..0afa2ad145 100644
--- a/src/core/config/transformer/merge_types/type_merger.rs
+++ b/src/core/config/transformer/merge_types/type_merger.rs
@@ -49,7 +49,7 @@ impl TypeMerger {
         // them.
         for type_name_1 in types.iter() {
             let type_name_1 = type_name_1.as_str();
-            if let Some(type_info_1) = config.types.get(type_name_1) {
+            if let Some(type_info_1) = config.blueprint_builder.types.get(type_name_1) {
                 if visited_types.contains(type_name_1) {
                     continue;
                 }
@@ -65,7 +65,7 @@ impl TypeMerger {
                         continue;
                     }
 
-                    if let Some(type_info_2) = config.types.get(type_name_2) {
+                    if let Some(type_info_2) = config.blueprint_builder.types.get(type_name_2) {
                         let threshold = mergeable_types.get_threshold(type_name_1, type_name_2);
                         visited_types.insert(type_name_1.to_owned());
                         let is_similar = stat_gen
@@ -101,7 +101,7 @@ impl TypeMerger {
             let merged_type_name = format!("{}M{}", PREFIX, merge_counter);
             let mut did_we_merge = false;
             for type_name in same_types {
-                if let Some(type_) = config.types.get(type_name.as_str()) {
+                if let Some(type_) = config.blueprint_builder.types.get(type_name.as_str()) {
                     type_to_merge_type_mapping.insert(type_name.clone(), merged_type_name.clone());
                     merged_into = merge_type(type_, merged_into);
                     did_we_merge = true;
@@ -109,7 +109,10 @@ impl TypeMerger {
             }
 
             if did_we_merge {
-                config.types.insert(merged_type_name, merged_into);
+                config
+                    .blueprint_builder
+                    .types
+                    .insert(merged_type_name, merged_into);
                 merge_counter += 1;
             }
         }
@@ -119,7 +122,7 @@ impl TypeMerger {
         }
 
         // step 3: replace typeof of fields with newly merged types.
-        for type_info in config.types.values_mut() {
+        for type_info in config.blueprint_builder.types.values_mut() {
             for actual_field in type_info.fields.values_mut() {
                 if let Some(merged_into_type_name) =
                     type_to_merge_type_mapping.get(actual_field.type_of.name())
@@ -156,7 +159,7 @@ impl TypeMerger {
         }
 
         // replace the merged types in union as well.
-        for union_type_ in config.unions.values_mut() {
+        for union_type_ in config.blueprint_builder.unions.values_mut() {
             // Collect changes to be made
             let mut types_to_remove = HashSet::new();
             let mut types_to_add = HashSet::new();
@@ -178,7 +181,7 @@ impl TypeMerger {
         }
 
         // replace the merged types in union as well.
-        for union_type_ in config.unions.values_mut() {
+        for union_type_ in config.blueprint_builder.unions.values_mut() {
             union_type_.types = union_type_
                 .types
                 .iter()
@@ -276,8 +279,8 @@ mod test {
 
         let mut config = Config::default();
 
-        config.types.insert("T1".to_string(), ty1);
-        config.types.insert("T2".to_string(), ty2);
+        config.blueprint_builder.types.insert("T1".to_string(), ty1);
+        config.blueprint_builder.types.insert("T2".to_string(), ty2);
 
         let mut q_type = Type::default();
         q_type.fields.insert(
@@ -289,7 +292,10 @@ mod test {
             Field { type_of: "T2".to_string().into(), ..Default::default() },
         );
 
-        config.types.insert("Query".to_owned(), q_type);
+        config
+            .blueprint_builder
+            .types
+            .insert("Query".to_owned(), q_type);
         config = config.query("Query");
 
         config = TypeMerger::new(0.5).transform(config).to_result()?;
@@ -315,10 +321,22 @@ mod test {
         ty.fields.insert("f5".to_string(), id_field.clone());
 
         let mut config = Config::default();
-        config.types.insert("T1".to_string(), ty.clone());
-        config.types.insert("T2".to_string(), ty.clone());
-        config.types.insert("T3".to_string(), ty.clone());
-        config.types.insert("T4".to_string(), ty.clone());
+        config
+            .blueprint_builder
+            .types
+            .insert("T1".to_string(), ty.clone());
+        config
+            .blueprint_builder
+            .types
+            .insert("T2".to_string(), ty.clone());
+        config
+            .blueprint_builder
+            .types
+            .insert("T3".to_string(), ty.clone());
+        config
+            .blueprint_builder
+            .types
+            .insert("T4".to_string(), ty.clone());
 
         let mut q_type = Type::default();
         q_type.fields.insert(
@@ -338,14 +356,17 @@ mod test {
             Field { type_of: "T4".to_string().into(), ..Default::default() },
         );
 
-        config.types.insert("Query".to_owned(), q_type);
+        config
+            .blueprint_builder
+            .types
+            .insert("Query".to_owned(), q_type);
         config = config.query("Query");
 
-        assert_eq!(config.types.len(), 5);
+        assert_eq!(config.blueprint_builder.types.len(), 5);
 
         config = TypeMerger::new(1.0).transform(config).to_result()?;
 
-        assert_eq!(config.types.len(), 2);
+        assert_eq!(config.blueprint_builder.types.len(), 2);
         insta::assert_snapshot!(config.to_sdl());
         Ok(())
     }
@@ -390,8 +411,8 @@ mod test {
         ty2.fields.insert("c".to_string(), str_field.clone());
 
         let mut config = Config::default();
-        config.types.insert("T1".to_string(), ty1);
-        config.types.insert("T2".to_string(), ty2);
+        config.blueprint_builder.types.insert("T1".to_string(), ty1);
+        config.blueprint_builder.types.insert("T2".to_string(), ty2);
 
         let config = TypeMerger::new(0.5).transform(config).to_result().unwrap();
         insta::assert_snapshot!(config.to_sdl());
@@ -414,9 +435,9 @@ mod test {
         ty3.implements.insert("B".to_string());
 
         let mut config = Config::default();
-        config.types.insert("A".to_string(), ty1);
-        config.types.insert("B".to_string(), ty2);
-        config.types.insert("C".to_string(), ty3);
+        config.blueprint_builder.types.insert("A".to_string(), ty1);
+        config.blueprint_builder.types.insert("B".to_string(), ty2);
+        config.blueprint_builder.types.insert("C".to_string(), ty3);
 
         let config = TypeMerger::default().transform(config).to_result().unwrap();
         insta::assert_snapshot!(config.to_sdl());
diff --git a/src/core/config/transformer/nested_unions.rs b/src/core/config/transformer/nested_unions.rs
index faab9d98ed..de796e03c7 100644
--- a/src/core/config/transformer/nested_unions.rs
+++ b/src/core/config/transformer/nested_unions.rs
@@ -15,10 +15,10 @@ impl Transform for NestedUnions {
     type Error = String;
 
     fn transform(&self, mut config: Config) -> Valid<Config, String> {
-        let visitor = Visitor { unions: &config.unions };
+        let visitor = Visitor { unions: &config.blueprint_builder.unions };
 
         visitor.visit().map(|unions| {
-            config.unions = unions;
+            config.blueprint_builder.unions = unions;
             config
         })
     }
diff --git a/src/core/config/transformer/rename_types.rs b/src/core/config/transformer/rename_types.rs
index 26d9b599c9..35e4b9d224 100644
--- a/src/core/config/transformer/rename_types.rs
+++ b/src/core/config/transformer/rename_types.rs
@@ -30,32 +30,43 @@ impl Transform for RenameTypes {
 
         // Ensure all types exist in the configuration
         Valid::from_iter(self.0.iter(), |(existing_name, suggested_name)| {
-            if config.types.contains_key(existing_name)
-                || config.enums.contains_key(existing_name)
-                || config.unions.contains_key(existing_name)
+            if config.blueprint_builder.types.contains_key(existing_name)
+                || config.blueprint_builder.enums.contains_key(existing_name)
+                || config.blueprint_builder.unions.contains_key(existing_name)
             {
                 // handle for the types.
-                if let Some(type_info) = config.types.remove(existing_name) {
-                    config.types.insert(suggested_name.to_string(), type_info);
+                if let Some(type_info) = config.blueprint_builder.types.remove(existing_name) {
+                    config
+                        .blueprint_builder
+                        .types
+                        .insert(suggested_name.to_string(), type_info);
                     lookup.insert(existing_name.clone(), suggested_name.clone());
 
                     // edge case where type is of operation type.
-                    if config.schema.query == Some(existing_name.clone()) {
-                        config.schema.query = Some(suggested_name.clone());
-                    } else if config.schema.mutation == Some(existing_name.clone()) {
-                        config.schema.mutation = Some(suggested_name.clone());
+                    if config.blueprint_builder.schema.query == Some(existing_name.clone()) {
+                        config.blueprint_builder.schema.query = Some(suggested_name.clone());
+                    } else if config.blueprint_builder.schema.mutation
+                        == Some(existing_name.clone())
+                    {
+                        config.blueprint_builder.schema.mutation = Some(suggested_name.clone());
                     }
                 }
 
                 // handle for the enums.
-                if let Some(type_info) = config.enums.remove(existing_name) {
-                    config.enums.insert(suggested_name.to_string(), type_info);
+                if let Some(type_info) = config.blueprint_builder.enums.remove(existing_name) {
+                    config
+                        .blueprint_builder
+                        .enums
+                        .insert(suggested_name.to_string(), type_info);
                     lookup.insert(existing_name.clone(), suggested_name.clone());
                 }
 
                 // handle for the union.
-                if let Some(type_info) = config.unions.remove(existing_name) {
-                    config.unions.insert(suggested_name.to_string(), type_info);
+                if let Some(type_info) = config.blueprint_builder.unions.remove(existing_name) {
+                    config
+                        .blueprint_builder
+                        .unions
+                        .insert(suggested_name.to_string(), type_info);
                     lookup.insert(existing_name.clone(), suggested_name.clone());
                 }
 
@@ -68,7 +79,7 @@ impl Transform for RenameTypes {
             }
         })
         .map(|_| {
-            for type_ in config.types.values_mut() {
+            for type_ in config.blueprint_builder.types.values_mut() {
                 for field_ in type_.fields.values_mut() {
                     // replace type of field.
                     if let Some(suggested_name) = lookup.get(field_.type_of.name()) {
@@ -98,7 +109,7 @@ impl Transform for RenameTypes {
             }
 
             // replace in the union as well.
-            for union_type_ in config.unions.values_mut() {
+            for union_type_ in config.blueprint_builder.unions.values_mut() {
                 // Collect changes to be made
                 let mut types_to_remove = HashSet::new();
                 let mut types_to_add = HashSet::new();
@@ -120,7 +131,7 @@ impl Transform for RenameTypes {
             }
 
             // replace in union as well.
-            for union_type_ in config.unions.values_mut() {
+            for union_type_ in config.blueprint_builder.unions.values_mut() {
                 union_type_.types = union_type_
                     .types
                     .iter()
diff --git a/src/core/config/transformer/subgraph.rs b/src/core/config/transformer/subgraph.rs
index b95dc2d5a3..32c20f5118 100644
--- a/src/core/config/transformer/subgraph.rs
+++ b/src/core/config/transformer/subgraph.rs
@@ -39,30 +39,33 @@ impl Transform for Subgraph {
             // if federation is disabled don't process the config
             return Valid::succeed(config);
         }
-        let config_types = config.types.clone();
+        let config_types = config.blueprint_builder.types.clone();
         let mut resolver_by_type = BTreeMap::new();
 
-        let valid = Valid::from_iter(config.types.iter_mut(), |(type_name, ty)| {
-            if let Some(resolver) = &ty.resolver {
-                resolver_by_type.insert(type_name.clone(), resolver.clone());
-
-                KeysExtractor::validate(&config_types, resolver, type_name).and_then(|_| {
-                    KeysExtractor::extract_keys(resolver).and_then(|fields| match fields {
-                        Some(fields) => {
-                            let key = Key { fields };
-
-                            to_directive(key.to_directive()).map(|directive| {
-                                ty.directives.push(directive);
-                            })
-                        }
-                        None => Valid::succeed(()),
+        let valid = Valid::from_iter(
+            config.blueprint_builder.types.iter_mut(),
+            |(type_name, ty)| {
+                if let Some(resolver) = &ty.resolver {
+                    resolver_by_type.insert(type_name.clone(), resolver.clone());
+
+                    KeysExtractor::validate(&config_types, resolver, type_name).and_then(|_| {
+                        KeysExtractor::extract_keys(resolver).and_then(|fields| match fields {
+                            Some(fields) => {
+                                let key = Key { fields };
+
+                                to_directive(key.to_directive()).map(|directive| {
+                                    ty.directives.push(directive);
+                                })
+                            }
+                            None => Valid::succeed(()),
+                        })
                     })
-                })
-            } else {
-                Valid::succeed(())
-            }
-            .trace(type_name)
-        });
+                } else {
+                    Valid::succeed(())
+                }
+                .trace(type_name)
+            },
+        );
 
         if valid.is_fail() {
             return valid.map_to(config);
@@ -77,18 +80,23 @@ impl Transform for Subgraph {
 
         // type that represents the response for service
         config
+            .blueprint_builder
             .types
             .insert(SERVICE_TYPE_NAME.to_owned(), service_type);
 
-        let query_type_name = match config.schema.query.as_ref() {
+        let query_type_name = match config.blueprint_builder.schema.query.as_ref() {
             Some(name) => name,
             None => {
-                config.schema.query = Some("Query".to_string());
+                config.blueprint_builder.schema.query = Some("Query".to_string());
                 "Query"
             }
         };
 
-        let query_type = config.types.entry(query_type_name.to_owned()).or_default();
+        let query_type = config
+            .blueprint_builder
+            .types
+            .entry(query_type_name.to_owned())
+            .or_default();
 
         query_type.fields.insert(
             SERVICE_FIELD_NAME.to_string(),
@@ -110,14 +118,20 @@ impl Transform for Subgraph {
 
             // union that wraps any possible types for entities
             config
+                .blueprint_builder
                 .unions
                 .insert(UNION_ENTITIES_NAME.to_owned(), entity_union);
             // any scalar for argument `representations`
             config
+                .blueprint_builder
                 .types
                 .insert(ENTITIES_TYPE_NAME.to_owned(), config::Type::default());
 
-            let query_type = config.types.entry(query_type_name.to_owned()).or_default();
+            let query_type = config
+                .blueprint_builder
+                .types
+                .entry(query_type_name.to_owned())
+                .or_default();
 
             let arg = Arg {
                 type_of: Type::from(ENTITIES_TYPE_NAME.to_string())
diff --git a/src/core/config/transformer/union_input_type.rs b/src/core/config/transformer/union_input_type.rs
index 906650dd6d..5e456effca 100644
--- a/src/core/config/transformer/union_input_type.rs
+++ b/src/core/config/transformer/union_input_type.rs
@@ -34,7 +34,7 @@ impl Transform for UnionInputType {
 
         let new_types = visitor.visit();
 
-        config.types = new_types;
+        config.blueprint_builder.types = new_types;
 
         Valid::succeed(config)
     }
@@ -51,7 +51,7 @@ enum UnionPresence {
 struct Visitor<'cfg> {
     /// Original config
     config: &'cfg Config,
-    /// Result types that will replace original config.types
+    /// Result types that will replace original config.blueprint_builder.types
     new_types: BTreeMap<String, Type>,
     // maps type name to UnionPresence
     union_presence: HashMap<&'cfg String, UnionPresence>,
@@ -73,7 +73,7 @@ impl<'cfg> Visitor<'cfg> {
     /// or replace the field set for the type if any of the arguments use
     /// a union somewhere down the fields tree.
     fn visit(mut self) -> BTreeMap<String, Type> {
-        for (type_name, type_) in &self.config.types {
+        for (type_name, type_) in &self.config.blueprint_builder.types {
             let fields = type_
                 .fields
                 .iter()
@@ -112,7 +112,7 @@ impl<'cfg> Visitor<'cfg> {
         // avoid endless recursion
         self.visited_types.insert(type_name);
 
-        if let Some(union_) = self.config.unions.get(type_name) {
+        if let Some(union_) = self.config.blueprint_builder.unions.get(type_name) {
             // if the type is union process the nested types recursively
             for type_name in &union_.types {
                 self.collect_nested_unions_for_type(type_name);
@@ -133,7 +133,7 @@ impl<'cfg> Visitor<'cfg> {
 
             self.union_presence
                 .insert(type_name, UnionPresence::Union(types.into_iter().collect()));
-        } else if let Some(type_) = self.config.types.get(type_name) {
+        } else if let Some(type_) = self.config.blueprint_builder.types.get(type_name) {
             // first, recursively walk over nested fields to see if there any nested unions
             for field in type_.fields.values() {
                 self.collect_nested_unions_for_type(field.type_of.name());
diff --git a/src/core/generator/from_proto.rs b/src/core/generator/from_proto.rs
index b85aca8efa..c98cc8fc8e 100644
--- a/src/core/generator/from_proto.rs
+++ b/src/core/generator/from_proto.rs
@@ -58,7 +58,10 @@ impl Context {
 
     /// Resolves the actual name and inserts the type.
     fn insert_type(mut self, name: String, ty: config::Type) -> Self {
-        self.config.types.insert(name.to_string(), ty);
+        self.config
+            .blueprint_builder
+            .types
+            .insert(name.to_string(), ty);
         self
     }
 
@@ -137,7 +140,7 @@ impl Context {
         // to actually create union and use just this type
         if union_types.len() == 1 {
             let (_, ty) = union_types.pop().unwrap();
-            self.config.types.insert(type_name, ty);
+            self.config.blueprint_builder.types.insert(type_name, ty);
             return self;
         }
 
@@ -152,8 +155,14 @@ impl Context {
         }
 
         // base interface type
-        self.config.types.insert(interface_name, base_type);
-        self.config.unions.insert(type_name, union_);
+        self.config
+            .blueprint_builder
+            .types
+            .insert(interface_name, base_type);
+        self.config
+            .blueprint_builder
+            .unions
+            .insert(type_name, union_);
 
         self
     }
@@ -211,6 +220,7 @@ impl Context {
                 .collect();
 
             self.config
+                .blueprint_builder
                 .enums
                 .insert(type_name, Enum { variants: variants_with_comments, doc });
         }
@@ -383,10 +393,11 @@ impl Context {
 
                 let ty = self
                     .config
+                    .blueprint_builder
                     .types
                     .entry(self.query.clone())
                     .or_insert_with(|| {
-                        self.config.schema.query = Some(self.query.clone());
+                        self.config.blueprint_builder.schema.query = Some(self.query.clone());
                         config::Type::default()
                     });
 
diff --git a/src/core/generator/json/operation_generator.rs b/src/core/generator/json/operation_generator.rs
index f30b489a6d..fd4dcdfefb 100644
--- a/src/core/generator/json/operation_generator.rs
+++ b/src/core/generator/json/operation_generator.rs
@@ -57,7 +57,7 @@ impl OperationTypeGenerator {
             .operation_type
             .to_string()
             .to_case(Case::Pascal);
-        if let Some(type_) = config.types.get_mut(req_op.as_str()) {
+        if let Some(type_) = config.blueprint_builder.types.get_mut(req_op.as_str()) {
             type_
                 .fields
                 .insert(request_sample.field_name.to_owned(), field);
@@ -65,7 +65,7 @@ impl OperationTypeGenerator {
             let mut ty = config::Type::default();
             ty.fields
                 .insert(request_sample.field_name.to_owned(), field);
-            config.types.insert(req_op.to_owned(), ty);
+            config.blueprint_builder.types.insert(req_op.to_owned(), ty);
         }
 
         Valid::succeed(config)
@@ -114,7 +114,10 @@ mod test {
         );
 
         let type_ = Type { fields, ..Default::default() };
-        config.types.insert("Query".to_owned(), type_);
+        config
+            .blueprint_builder
+            .types
+            .insert("Query".to_owned(), type_);
 
         let config = OperationTypeGenerator
             .generate(&sample, "T44", &NameGenerator::new("Input"), config)
diff --git a/src/core/generator/json/schema_generator.rs b/src/core/generator/json/schema_generator.rs
index a466924b92..af07393925 100644
--- a/src/core/generator/json/schema_generator.rs
+++ b/src/core/generator/json/schema_generator.rs
@@ -26,14 +26,14 @@ impl Transform for SchemaGenerator<'_> {
     fn transform(&self, mut config: Self::Value) -> Valid<Self::Value, Self::Error> {
         match self.operation_type {
             GraphQLOperationType::Query => {
-                config.schema.query = Some(
+                config.blueprint_builder.schema.query = Some(
                     GraphQLOperationType::Query
                         .to_string()
                         .to_case(Case::Pascal),
                 );
             }
             GraphQLOperationType::Mutation => {
-                config.schema.mutation = Some(
+                config.blueprint_builder.schema.mutation = Some(
                     GraphQLOperationType::Mutation
                         .to_string()
                         .to_case(Case::Pascal),
@@ -65,10 +65,13 @@ mod test {
             .transform(Default::default())
             .to_result()
             .unwrap();
-        assert!(config.schema.mutation.is_some());
-        assert_eq!(config.schema.mutation, Some("Mutation".to_owned()));
+        assert!(config.blueprint_builder.schema.mutation.is_some());
+        assert_eq!(
+            config.blueprint_builder.schema.mutation,
+            Some("Mutation".to_owned())
+        );
 
-        assert!(config.schema.query.is_none());
+        assert!(config.blueprint_builder.schema.query.is_none());
     }
 
     #[test]
@@ -78,10 +81,13 @@ mod test {
             .transform(Default::default())
             .to_result()
             .unwrap();
-        assert!(config.schema.query.is_some());
-        assert_eq!(config.schema.query, Some("Query".to_owned()));
+        assert!(config.blueprint_builder.schema.query.is_some());
+        assert_eq!(
+            config.blueprint_builder.schema.query,
+            Some("Query".to_owned())
+        );
 
-        assert!(config.schema.mutation.is_none());
+        assert!(config.blueprint_builder.schema.mutation.is_none());
     }
 
     #[test]
@@ -92,10 +98,13 @@ mod test {
             .transform(Default::default())
             .to_result()
             .unwrap();
-        assert!(config.schema.query.is_some());
-        assert_eq!(config.schema.query, Some("Query".to_owned()));
+        assert!(config.blueprint_builder.schema.query.is_some());
+        assert_eq!(
+            config.blueprint_builder.schema.query,
+            Some("Query".to_owned())
+        );
         assert_eq!(config.upstream.allowed_headers, expected_header_keys);
 
-        assert!(config.schema.mutation.is_none());
+        assert!(config.blueprint_builder.schema.mutation.is_none());
     }
 }
diff --git a/src/core/generator/json/types_generator.rs b/src/core/generator/json/types_generator.rs
index 923afb1393..3d27bab57e 100644
--- a/src/core/generator/json/types_generator.rs
+++ b/src/core/generator/json/types_generator.rs
@@ -63,7 +63,11 @@ impl<'a> TypeGenerator<'a> {
 
     fn generate_scalar(&self, config: &mut Config) -> Scalar {
         let any_scalar = Scalar::JSON;
-        if config.types.contains_key(&any_scalar.name()) {
+        if config
+            .blueprint_builder
+            .types
+            .contains_key(&any_scalar.name())
+        {
             return any_scalar;
         }
         any_scalar
@@ -131,6 +135,7 @@ impl<'a> TypeGenerator<'a> {
                     let merged_type = TypeMerger::merge_fields(object_types);
                     let generate_type_name = self.type_name_generator.next();
                     config
+                        .blueprint_builder
                         .types
                         .insert(generate_type_name.to_owned(), merged_type);
                     return generate_type_name;
@@ -145,7 +150,10 @@ impl<'a> TypeGenerator<'a> {
                 }
                 let ty = self.create_type_from_object(json_obj, config);
                 let generate_type_name = self.type_name_generator.next();
-                config.types.insert(generate_type_name.to_owned(), ty);
+                config
+                    .blueprint_builder
+                    .types
+                    .insert(generate_type_name.to_owned(), ty);
                 generate_type_name
             }
             other => to_gql_type(other),
diff --git a/src/core/grpc/data_loader_request.rs b/src/core/grpc/data_loader_request.rs
index a8af211bde..1a4853a164 100644
--- a/src/core/grpc/data_loader_request.rs
+++ b/src/core/grpc/data_loader_request.rs
@@ -81,7 +81,7 @@ mod tests {
             name: "SayHello".to_string(),
         };
         let grpc = Grpc { method: method.to_string(), ..Default::default() };
-        config.types.insert(
+        config.blueprint_builder.types.insert(
             "foo".to_string(),
             Type::default().fields(vec![(
                 "bar",
diff --git a/src/core/grpc/protobuf.rs b/src/core/grpc/protobuf.rs
index ca0012b46b..f770a4f92a 100644
--- a/src/core/grpc/protobuf.rs
+++ b/src/core/grpc/protobuf.rs
@@ -272,7 +272,7 @@ pub mod tests {
 
         let method = GrpcMethod { package: id, service: "a".to_owned(), name: "b".to_owned() };
         let grpc = Grpc { method: method.to_string(), ..Default::default() };
-        config.types.insert(
+        config.blueprint_builder.types.insert(
             "foo".to_string(),
             Type::default().fields(vec![(
                 "bar",
diff --git a/src/core/grpc/request_template.rs b/src/core/grpc/request_template.rs
index f4901f5cc5..8afb671664 100644
--- a/src/core/grpc/request_template.rs
+++ b/src/core/grpc/request_template.rs
@@ -167,7 +167,7 @@ mod tests {
             name: "b".to_string(),
         };
         let grpc = Grpc { method: method.to_string(), ..Default::default() };
-        config.types.insert(
+        config.blueprint_builder.types.insert(
             "foo".to_string(),
             Type::default().fields(vec![(
                 "bar",