Serialize configs from Jinja via resource_types (#4081)

* Serialize configs from Jinja via resource_types

* Add docs

* Clean up todos

GitOrigin-RevId: ce978753cb3a7b4d554cd6c3f1ec9bf5c3e3e014

Author: jasonlin45

.changes/unreleased/Under the Hood-20250623-223706.yaml

@@ -0,0 +1,3 @@
+kind: Under the Hood
+body: Serialize configs via resource_types
+time: 2025-06-23T22:37:06.040844497-07:00

crates/dbt-fusion-adapter/src/bridge_adapter.rs

@@ -30,7 +30,7 @@ use dbt_schemas::schemas::manifest::{
 use dbt_schemas::schemas::project::ModelConfig;
 use dbt_schemas::schemas::properties::ModelConstraint;
 use dbt_schemas::schemas::relations::base::{BaseRelation, ComponentName};
-use dbt_schemas::schemas::{CommonAttributes, CommonAttributesWrapper, DbtModel};
+use dbt_schemas::schemas::InternalDbtNodeWrapper;
 use dbt_xdbc::Connection;
 use minijinja::arg_utils::{check_num_args, ArgParser};
 use minijinja::dispatch_object::DispatchObject;
@@ -927,18 +927,17 @@ impl BaseAdapter for BridgeAdapter {
             )
         })?;
 
-        let common_attr = CommonAttributes::deserialize(node).map_err(|e| {
+        let node_wrapper = InternalDbtNodeWrapper::deserialize(node).map_err(|e| {
             MinijinjaError::new(
                 MinijinjaErrorKind::SerdeDeserializeError,
-                format!("get_table_options: Failed to deserialize common attributes: {e}"),
+                format!("get_table_options: Failed to deserialize InternalDbtNodeWrapper: {e}"),
             )
         })?;
+        let node = node_wrapper.as_internal_node();
 
-        let options = self.typed_adapter.get_table_options(
-            config,
-            CommonAttributesWrapper(common_attr),
-            temporary,
-        )?;
+        let options = self
+            .typed_adapter
+            .get_table_options(config, node.common(), temporary)?;
         Ok(Value::from_serialize(options))
     }
 
@@ -957,16 +956,15 @@ impl BaseAdapter for BridgeAdapter {
             )
         })?;
 
-        let common_attr = CommonAttributes::deserialize(node).map_err(|e| {
+        let node_wrapper = InternalDbtNodeWrapper::deserialize(node).map_err(|e| {
             MinijinjaError::new(
                 MinijinjaErrorKind::SerdeDeserializeError,
-                format!("get_view_options: Failed to deserialize common attributes: {e}"),
+                format!("get_table_options: Failed to deserialize InternalDbtNodeWrapper: {e}"),
             )
         })?;
+        let node = node_wrapper.as_internal_node();
 
-        let options = self
-            .typed_adapter
-            .get_view_options(config, CommonAttributesWrapper(common_attr))?;
+        let options = self.typed_adapter.get_view_options(config, node.common())?;
         Ok(Value::from_serialize(options))
     }
 
@@ -1181,13 +1179,22 @@ impl BaseAdapter for BridgeAdapter {
         let config = ModelConfig::deserialize(config).map_err(|e| {
             MinijinjaError::new(MinijinjaErrorKind::SerdeDeserializeError, e.to_string())
         })?;
-        let model = DbtModel::deserialize(model).map_err(|e| {
-            MinijinjaError::new(MinijinjaErrorKind::SerdeDeserializeError, e.to_string())
+
+        let node = InternalDbtNodeWrapper::deserialize(model).map_err(|e| {
+            MinijinjaError::new(
+                MinijinjaErrorKind::SerdeDeserializeError,
+                format!(
+                    "adapter.compute_external_path expected an InternalDbtNodeWrapper: {}",
+                    e
+                ),
+            )
         })?;
 
-        let result = self
-            .typed_adapter
-            .compute_external_path(config, model, is_incremental)?;
+        let result = self.typed_adapter.compute_external_path(
+            config,
+            node.as_internal_node(),
+            is_incremental,
+        )?;
         Ok(Value::from(result))
     }
 
@@ -1348,12 +1355,27 @@ impl BaseAdapter for BridgeAdapter {
         check_num_args(current_function_name!(), &parser, 1, 1)?;
 
         let model = parser.get::<Value>("model")?;
-        let model = DbtModel::deserialize(model).map_err(|e| {
+
+        let deserialized_node = InternalDbtNodeWrapper::deserialize(model).map_err(|e| {
             MinijinjaError::new(
                 MinijinjaErrorKind::SerdeDeserializeError,
-                format!("adapter.get_config_from_model expected a DbtModel: {}", e),
+                format!(
+                    "adapter.get_config_from_model expected an InternalDbtNodeWrapper: {}",
+                    e
+                ),
             )
         })?;
+
+        let model = match deserialized_node {
+            InternalDbtNodeWrapper::Model(model) => model,
+            _ => {
+                return Err(MinijinjaError::new(
+                    MinijinjaErrorKind::InvalidOperation,
+                    "adapter.get_config_from_model expected a DbtModel node".to_string(),
+                ))
+            }
+        };
+
         Ok(self.typed_adapter.get_config_from_model(&model)?)
     }
 

crates/dbt-fusion-adapter/src/typed_adapter.rs

@@ -25,7 +25,7 @@ use dbt_schemas::schemas::dbt_column::DbtColumn;
 use dbt_schemas::schemas::manifest::{BigqueryClusterConfig, BigqueryPartitionConfig};
 use dbt_schemas::schemas::project::ModelConfig;
 use dbt_schemas::schemas::relations::base::{BaseRelation, ComponentName};
-use dbt_schemas::schemas::{CommonAttributesWrapper, DbtModel};
+use dbt_schemas::schemas::{CommonAttributes, DbtModel, InternalDbtNodeAttributes};
 use dbt_xdbc::{Connection, QueryCtx};
 use minijinja::{args, State, Value};
 
@@ -623,7 +623,7 @@ pub trait TypedBaseAdapter: fmt::Debug + Send + Sync + AdapterTyping {
     fn get_table_options(
         &self,
         _config: ModelConfig,
-        _node: CommonAttributesWrapper,
+        _node: &CommonAttributes,
         _temporary: bool,
     ) -> AdapterResult<BTreeMap<String, Value>> {
         unimplemented!("only available with BigQuery adapter")
@@ -633,7 +633,7 @@ pub trait TypedBaseAdapter: fmt::Debug + Send + Sync + AdapterTyping {
     fn get_view_options(
         &self,
         _config: ModelConfig,
-        _node: CommonAttributesWrapper,
+        _node: &CommonAttributes,
     ) -> AdapterResult<BTreeMap<String, Value>> {
         unimplemented!("only available with BigQuery adapter")
     }
@@ -680,7 +680,7 @@ pub trait TypedBaseAdapter: fmt::Debug + Send + Sync + AdapterTyping {
     fn compute_external_path(
         &self,
         _config: ModelConfig,
-        _model: DbtModel,
+        _node: &dyn InternalDbtNodeAttributes,
         _is_incremental: bool,
     ) -> AdapterResult<String> {
         unimplemented!("only available with Databricks adapter")

crates/dbt-schemas/src/lib.rs

@@ -26,8 +26,8 @@ pub mod schemas {
 
     mod nodes;
     pub use nodes::{
-        CommonAttributes, CommonAttributesWrapper, DbtModel, DbtSeed, DbtSnapshot, DbtSource,
-        DbtTest, DbtUnitTest, InternalDbtNode, InternalDbtNodeAttributes, IntrospectionKind,
+        CommonAttributes, DbtModel, DbtSeed, DbtSnapshot, DbtSource, DbtTest, DbtUnitTest,
+        InternalDbtNode, InternalDbtNodeAttributes, InternalDbtNodeWrapper, IntrospectionKind,
         NodeBaseAttributes, Nodes,
     };
 

crates/dbt-schemas/src/schemas/nodes.rs

@@ -44,6 +44,63 @@ impl Display for IntrospectionKind {
     }
 }
 
+/// A wrapper enum that represents different types of dbt nodes.
+///
+/// This enum uses serde's tag-based deserialization to automatically determine
+/// the correct variant based on the "resource_type" field in the JSON.
+/// The resource_type values are converted to snake_case for matching.
+///
+/// # Example
+///
+/// ```rust
+///
+/// // Deserialize a node from Jinja
+/// let node = InternalDbtNodeWrapper::deserialize(value).unwrap();
+///
+/// // Access the underlying node attributes
+/// let attributes = node.as_internal_node();
+/// ```
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(tag = "resource_type")]
+#[serde(rename_all = "snake_case")]
+pub enum InternalDbtNodeWrapper {
+    Model(DbtModel),
+    Seed(DbtSeed),
+    Test(DbtTest),
+    UnitTest(DbtUnitTest),
+    Source(DbtSource),
+    Snapshot(DbtSnapshot),
+}
+
+impl InternalDbtNodeWrapper {
+    /// Returns a reference to the underlying node as a trait object.
+    ///
+    /// This method allows accessing common functionality across all node types
+    /// through the `InternalDbtNodeAttributes` trait.
+    ///
+    /// # Returns
+    ///
+    /// A reference to the node implementing `InternalDbtNodeAttributes`
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// let node = InternalDbtNodeWrapper::Model(some_model);
+    /// let attributes = node.as_internal_node();
+    /// println!("Node name: {}", attributes.name());
+    /// ```
+    pub fn as_internal_node(&self) -> &dyn InternalDbtNodeAttributes {
+        match self {
+            InternalDbtNodeWrapper::Model(model) => model,
+            InternalDbtNodeWrapper::Seed(seed) => seed,
+            InternalDbtNodeWrapper::Test(test) => test,
+            InternalDbtNodeWrapper::UnitTest(unit_test) => unit_test,
+            InternalDbtNodeWrapper::Source(source) => source,
+            InternalDbtNodeWrapper::Snapshot(snapshot) => snapshot,
+        }
+    }
+}
+
 pub trait InternalDbtNode: Any + Send + Sync + fmt::Debug {
     fn common(&self) -> &CommonAttributes;
     fn base(&self) -> NodeBaseAttributes;
@@ -1199,12 +1256,6 @@ pub struct CommonAttributes {
     pub description: Option<String>,
 }
 
-// Workaround to larger issue: https://github.com/dbt-labs/fs/issues/4068
-// We need to serialize configs from Jinja flexibly to access type attributes
-// without a wrapper type or enum.
-#[derive(Debug, Clone)]
-pub struct CommonAttributesWrapper(pub CommonAttributes);
-
 #[skip_serializing_none]
 #[derive(Debug, Clone, Serialize, Deserialize, Default)]
 #[serde(rename_all = "snake_case")]