fix: use restricted Jinja context for macro property resolution

Match dbt Core by preventing project/package macro execution while rendering
macro properties YAML descriptions, while preserving doc() and parse metadata context.

Author: Yashwanth Reddy Mali

.changes/unreleased/Fixes-20260413-054800.yaml

@@ -0,0 +1,7 @@
+kind: Fixes
+body: "[dbt-fusion] Use restricted Jinja context for macro property resolution to match dbt Core behavior (#1576)"
+time: 2026-04-13T05:48:00.000000+00:00
+custom:
+    author: yxshwanth
+    issue: "1576"
+    project: dbt-fusion

crates/dbt-jinja-utils/src/phases/parse/mod.rs

@@ -7,5 +7,5 @@ pub mod init;
 pub mod sql_resource;
 
 pub use crate::utils::render_extract_ref_or_source_expr;
-pub use resolve_context::build_resolve_context;
+pub use resolve_context::{build_macro_properties_resolve_context, build_resolve_context};
 pub use resolve_model_context::build_resolve_model_context;

crates/dbt-jinja-utils/src/phases/parse/resolve_context.rs

@@ -9,6 +9,27 @@ use minijinja::{
 use crate::functions::DocMacro;
 use crate::phases::compile_and_run_context::DbtNamespace;
 
+/// Builds a context for resolving `macros:` entries in YAML property files and for patching
+/// macro catalog fields such as `description` in `schema.yml`.
+///
+/// dbt-core only exposes a narrow Jinja scope there (e.g. `doc()`), not callable project
+/// macros. Omitting macro namespace keys matches that behavior so `{{ my_macro(...) }}` in a
+/// macro description fails instead of being rendered into SQL at parse time.
+pub fn build_macro_properties_resolve_context(
+    root_project_name: &str,
+    local_project_name: &str,
+    docs_macros: &BTreeMap<String, DbtDocsMacro>,
+    macro_dispatch_order: BTreeMap<String, Vec<String>>,
+) -> BTreeMap<String, MinijinjaValue> {
+    build_resolve_context(
+        root_project_name,
+        local_project_name,
+        docs_macros,
+        macro_dispatch_order,
+        vec![],
+    )
+}
+
 /// Builds a context for resolving models
 pub fn build_resolve_context(
     root_project_name: &str,
@@ -63,3 +84,207 @@ pub fn build_resolve_context(
 
     ctx
 }
+
+#[cfg(test)]
+mod tests {
+    use std::collections::BTreeSet;
+    use std::path::PathBuf;
+    use std::sync::Mutex;
+
+    use super::*;
+    use crate::environment_builder::{JinjaEnvBuilder, MacroUnitsWrapper};
+    use crate::serde::into_typed_with_jinja;
+    use dbt_adapter::sql_types::SATypeOpsImpl;
+    use dbt_adapter::Adapter;
+    use dbt_adapter_core::AdapterType;
+    use dbt_common::io_args::IoArgs;
+    use dbt_schemas::schemas::macros::DbtDocsMacro;
+    use dbt_schemas::schemas::properties::MacrosProperties;
+    use dbt_schemas::schemas::relations::DEFAULT_DBT_QUOTING;
+    use minijinja::dispatch_object::THREAD_LOCAL_DEPENDENCIES;
+    use minijinja::macro_unit::{MacroInfo, MacroUnit};
+    use minijinja::machinery::Span;
+    use minijinja::UndefinedBehavior;
+
+    static DEPS_TEST_LOCK: Mutex<()> = Mutex::new(());
+
+    fn set_thread_local_dependencies(pkgs: impl IntoIterator<Item = String>) {
+        let _guard = DEPS_TEST_LOCK.lock().unwrap();
+        let deps = THREAD_LOCAL_DEPENDENCIES.get_or_init(|| Mutex::new(BTreeSet::new()));
+        let mut deps = deps.lock().unwrap();
+        deps.clear();
+        deps.extend(pkgs);
+    }
+
+    fn create_macro_unit(name: &str, sql: &str) -> MacroUnit {
+        MacroUnit {
+            info: MacroInfo {
+                name: name.to_string(),
+                path: PathBuf::from("macros/test.sql"),
+                span: Span {
+                    start_line: 0,
+                    start_col: 0,
+                    start_offset: 0,
+                    end_line: 0,
+                    end_col: 0,
+                    end_offset: 0,
+                },
+                funcsign: None,
+                args: vec![],
+                unique_id: "test".to_string(),
+                name_span: Span::default(),
+            },
+            sql: sql.to_string(),
+        }
+    }
+
+    fn parse_jinja_env_with_my_pkg_macro() -> crate::jinja_environment::JinjaEnv {
+        set_thread_local_dependencies(std::iter::once("my_pkg".to_string()));
+        let mut macro_units = MacroUnitsWrapper::new(BTreeMap::new());
+        macro_units.macros.insert(
+            "my_pkg".to_string(),
+            vec![create_macro_unit(
+                "cents_to_dollars",
+                "{% macro cents_to_dollars(column_name) %}{{ column_name }} / 100.0{% endmacro %}",
+            )],
+        );
+        let adapter = Adapter::new_parse_phase_adapter(
+            AdapterType::Postgres,
+            dbt_yaml::Mapping::default(),
+            DEFAULT_DBT_QUOTING,
+            Box::new(SATypeOpsImpl::new(AdapterType::Postgres)),
+            None,
+        );
+        JinjaEnvBuilder::new()
+            .with_undefined_behavior(UndefinedBehavior::Strict)
+            .with_adapter(std::sync::Arc::new(adapter))
+            .with_root_package("my_pkg".to_string())
+            .try_with_macros(macro_units)
+            .expect("Failed to register macros")
+            .build()
+    }
+
+    /// One macro-properties YAML blob; description uses the package namespace (matches Fusion
+    /// before the fix when namespaces were injected).
+    fn macro_yaml_value_with_desc(description: &str) -> dbt_yaml::Value {
+        let mut mapping = dbt_yaml::Mapping::new();
+        mapping.insert(
+            dbt_yaml::Value::String("name".to_string(), dbt_yaml::Span::default()),
+            dbt_yaml::Value::String("cents_to_dollars".to_string(), dbt_yaml::Span::default()),
+        );
+        mapping.insert(
+            dbt_yaml::Value::String("description".to_string(), dbt_yaml::Span::default()),
+            dbt_yaml::Value::String(description.to_string(), dbt_yaml::Span::default()),
+        );
+        dbt_yaml::Value::Mapping(mapping, dbt_yaml::Span::default())
+    }
+
+    #[test]
+    fn macro_properties_context_omits_macro_namespace_keys() {
+        let docs = BTreeMap::new();
+        let dispatch = BTreeMap::new();
+        let full = build_resolve_context(
+            "root_pkg",
+            "local_pkg",
+            &docs,
+            dispatch.clone(),
+            vec!["dbt".to_string(), "local_pkg".to_string()],
+        );
+        let narrow = build_macro_properties_resolve_context(
+            "root_pkg",
+            "local_pkg",
+            &docs,
+            dispatch,
+        );
+        assert!(full.contains_key("dbt"));
+        assert!(full.contains_key("local_pkg"));
+        assert!(!narrow.contains_key("dbt"));
+        assert!(!narrow.contains_key("local_pkg"));
+        assert!(narrow.get("doc").is_some());
+        assert_eq!(
+            narrow.get(TARGET_PACKAGE_NAME).and_then(|v| v.as_str()),
+            Some("local_pkg")
+        );
+    }
+
+    #[test]
+    fn narrow_context_errors_on_macro_call_in_description() {
+        let env = parse_jinja_env_with_my_pkg_macro();
+        let dispatch = BTreeMap::new();
+        let full_ctx = build_resolve_context(
+            "my_pkg",
+            "my_pkg",
+            &BTreeMap::new(),
+            dispatch.clone(),
+            vec!["my_pkg".to_string()],
+        );
+        let narrow_ctx = build_macro_properties_resolve_context("my_pkg", "my_pkg", &BTreeMap::new(), dispatch);
+
+        let yml = macro_yaml_value_with_desc("{{ my_pkg.cents_to_dollars('price_cents') }}");
+        let io = IoArgs::default();
+        let parsed: MacrosProperties = into_typed_with_jinja(
+            &io,
+            yml.clone(),
+            false,
+            &env,
+            &full_ctx,
+            &[],
+            None,
+            false,
+        )
+        .expect("full resolve context should render macro in description");
+        assert!(
+            parsed.description.unwrap().contains("price_cents / 100.0"),
+            "expected macro body in description"
+        );
+
+        let err = into_typed_with_jinja::<MacrosProperties, _>(
+            &io,
+            yml,
+            false,
+            &env,
+            &narrow_ctx,
+            &[],
+            None,
+            false,
+        )
+        .expect_err("narrow context should not resolve package macros in description");
+        let msg = err.to_string();
+        assert!(
+            msg.contains("undefined") || msg.contains("Undefined"),
+            "expected undefined error, got: {msg}"
+        );
+    }
+
+    #[test]
+    fn narrow_context_allows_doc_in_macro_description() {
+        let env = parse_jinja_env_with_my_pkg_macro();
+        let mut docs = BTreeMap::new();
+        docs.insert(
+            "doc.my_pkg.my_doc".to_string(),
+            DbtDocsMacro {
+                name: "my_doc".to_string(),
+                package_name: "my_pkg".to_string(),
+                path: PathBuf::from("models/docs.md"),
+                original_file_path: PathBuf::from("models/docs.md"),
+                unique_id: "doc.my_pkg.my_doc".to_string(),
+                block_contents: "hello from doc".to_string(),
+            },
+        );
+        let narrow_ctx = build_macro_properties_resolve_context("my_pkg", "my_pkg", &docs, BTreeMap::new());
+        let yml = macro_yaml_value_with_desc("{{ doc('my_doc') }}");
+        let io = IoArgs::default();
+        let parsed: MacrosProperties = into_typed_with_jinja(
+            &io,
+            yml,
+            false,
+            &env,
+            &narrow_ctx,
+            &[],
+            None,
+            false,
+        )
+        .expect("doc() should work in macro description with narrow context");
+        assert_eq!(parsed.description.as_deref(), Some("hello from doc"));
+    }
+}

crates/dbt-parser/src/resolve/resolve_properties.rs

@@ -60,6 +60,7 @@ impl MinimalProperties {
         jinja_env: &JinjaEnv,
         properties_path: &Path,
         base_ctx: &BTreeMap<String, MinijinjaValue>,
+        macro_properties_ctx: &BTreeMap<String, MinijinjaValue>,
     ) -> FsResult<()> {
         // TODO: This is a bit repetetive. Can be shortened!
         if let Some(models) = other.models {
@@ -545,9 +546,9 @@ impl MinimalProperties {
                     macro_value.clone(),
                     false,
                     jinja_env,
-                    base_ctx,
+                    macro_properties_ctx,
                     &[],
-                    dependency_package_name_from_ctx(jinja_env, base_ctx),
+                    dependency_package_name_from_ctx(jinja_env, macro_properties_ctx),
                     true,
                 )?;
                 if let Some(existing_macro) = self.macros.get_mut(&macro_props.name) {
@@ -597,6 +598,7 @@ pub fn resolve_minimal_properties(
     root_package_name: &str,
     jinja_env: &JinjaEnv,
     base_ctx: &BTreeMap<String, MinijinjaValue>,
+    macro_properties_ctx: &BTreeMap<String, MinijinjaValue>,
     token: &CancellationToken,
 ) -> FsResult<MinimalProperties> {
     let mut minimal_resolved_properties = MinimalProperties {
@@ -646,6 +648,7 @@ pub fn resolve_minimal_properties(
                         jinja_env,
                         properties_path,
                         base_ctx,
+                        macro_properties_ctx,
                     )?;
 
                     if !minimal_resolved_properties.semantic_layer_spec_is_legacy

crates/dbt-parser/src/resolver.rs

@@ -15,7 +15,7 @@ use dbt_jinja_utils::listener::JinjaTypeCheckingEventListenerFactory;
 use dbt_jinja_utils::node_resolver::{
     NodeResolver, check_for_model_deprecations, resolve_dependencies,
 };
-use dbt_jinja_utils::phases::parse::build_resolve_context;
+use dbt_jinja_utils::phases::parse::{build_macro_properties_resolve_context, build_resolve_context};
 use dbt_jinja_utils::phases::parse::init::initialize_parse_jinja_environment;
 use dbt_jinja_utils::serde::{into_typed_with_error, into_typed_with_jinja};
 use dbt_jinja_utils::utils::dependency_package_name_from_ctx;
@@ -275,25 +275,19 @@ pub async fn resolve(
             .iter()
             .find(|p| p.dbt_project.name == package_name);
         if let Some(package) = package {
-            let namespace_keys: Vec<String> = jinja_env
-                .env
-                .get_macro_namespace_registry()
-                .map(|r| r.keys().map(|k| k.to_string()).collect())
-                .unwrap_or_default();
-            let base_ctx = build_resolve_context(
+            let macro_properties_ctx = build_macro_properties_resolve_context(
                 root_project_name,
                 package.dbt_project.name.as_str(),
                 &macros.docs_macros,
                 DISPATCH_CONFIG.get().unwrap().read().unwrap().clone(),
-                namespace_keys,
             );
             apply_macro_patches(
                 &arg.io,
                 &mut macros.macros,
                 &macro_properties,
                 &package_name,
                 &jinja_env,
-                &base_ctx,
+                &macro_properties_ctx,
                 validate_macro_args,
             )?;
         }
@@ -568,13 +562,20 @@ pub async fn resolve_inner(
         DISPATCH_CONFIG.get().unwrap().read().unwrap().clone(),
         namespace_keys,
     );
+    let macro_properties_ctx = build_macro_properties_resolve_context(
+        root_package_name,
+        package.dbt_project.name.as_str(),
+        &macros.docs_macros,
+        DISPATCH_CONFIG.get().unwrap().read().unwrap().clone(),
+    );
     // Resolve the dbt properties (schema.yml) files
     let mut min_properties = resolve_minimal_properties(
         arg,
         package,
         root_package_name,
         &jinja_env,
         &base_ctx,
+        &macro_properties_ctx,
         token,
     )?;