patch

Author: LukasAud

lib/puppet/provider/base_dsc_lite/powershell.rb

@@ -67,9 +67,11 @@ def ps_manager
     Pwsh::Manager.instance(command(:powershell), Pwsh::Manager.powershell_args, debug: debug_output)
   end
 
-  # ===== Deferred helpers (instance methods) =====
+  # ============================================================================
+  # Deferred helpers (instance methods)
+  # ============================================================================
 
-  # Detects if a value (or nested) contains a DeferredValue
+  # Returns true if obj (or any nested member) is a DeferredValue
   def deep_contains_deferred?(obj)
     case obj
     when Puppet::Pops::Evaluator::DeferredValue
@@ -89,25 +91,18 @@ def deep_contains_deferred?(obj)
     end
   end
 
-  # Force resolution of Deferreds across the catalog before script generation.
-  # This mirrors Puppet's own preprocessing when preprocess_deferred=true.
-  def ensure_deferreds_resolved!
-    # (A) Prefer compiler-based resolution for properties when available
-    props_param = resource.parameters[:properties]
-    compiler    = Puppet.lookup(:compiler) { nil }
-
-    if props_param
-      pv = props_param.value
-      if deep_contains_deferred?(pv)
-        Puppet.debug('DSC_lite: Deferred detected in properties; resolving via compiler') if compiler
-        if compiler
-          resolved = Puppet::Pops::Evaluator::DeferredResolver.resolve(pv, compiler)
-          resource[:properties] = resolved
-        end
-      end
-    end
+  # Resolves a value with the current compiler if available; otherwise returns it unchanged
+  def resolve_value_with_compiler(value)
+    compiler = Puppet.lookup(:compiler) { nil }
+    return value unless compiler
+    Puppet::Pops::Evaluator::DeferredResolver.resolve(value, compiler)
+  end
 
-    # (B) Always run a full catalog resolution pass as a safety net.
+  # Resolve any lingering Deferreds before script generation:
+  #  A) catalog-wide pass (resolve_and_replace), then
+  #  B) per-parameter pass using compiler resolution for any stragglers
+  def ensure_deferreds_resolved!
+    # (A) Catalog-wide resolution (mirrors preprocess_deferred=true behavior)
     facts = Puppet::Node::Facts.new(
       (resource.catalog.respond_to?(:host) && resource.catalog.host) ||
         Facter.value(:fqdn) || Facter.value(:hostname) || 'localhost',
@@ -118,19 +113,32 @@ def ensure_deferreds_resolved!
     Puppet.debug('DSC_lite: invoking DeferredResolver.resolve_and_replace on catalog')
     Puppet::Pops::Evaluator::DeferredResolver.resolve_and_replace(facts, resource.catalog, env, true)
 
-    # Post-check for diagnostics
-    pp = resource.parameters[:properties]
-    if pp && deep_contains_deferred?(pp.value)
-      Puppet.debug('DSC_lite: WARNING — Deferred still present in properties after resolution pass')
+    # (B) Per-parameter scan & fix-up
+    resource.parameters_with_value.each do |param|
+      val = param.value
+      next unless deep_contains_deferred?(val)
+
+      Puppet.debug("DSC_lite: Deferred detected in parameter `#{param.name}`; attempting compiler-based resolution")
+      begin
+        resolved = resolve_value_with_compiler(val)
+        resource[param.name] = resolved unless resolved.equal?(val)
+      rescue => e
+        raise Puppet::Error, "DSC_lite: failed to resolve Deferred in parameter `#{param.name}`: #{e.class}: #{e.message}"
+      end
+    end
+
+    # Post-check diagnostics for the critical :properties blob
+    props_param = resource.parameters[:properties]
+    if props_param && deep_contains_deferred?(props_param.value)
+      Puppet.debug('DSC_lite: WARNING — Deferred still present in `properties` after resolution passes')
     else
-      Puppet.debug('DSC_lite: no Deferred values remain in properties after resolution')
+      Puppet.debug('DSC_lite: no Deferred values remain in `properties` after resolution')
     end
-  rescue => e
-    # Raise a targeted error; this is better than failing later with "unsupported type DeferredValue"
-    raise Puppet::Error, "DSC_lite: failed while resolving Deferred values: #{e.class}: #{e.message}"
   end
 
-  # ===== END Deferred helpers =====
+  # ============================================================================
+  # Provider lifecycle
+  # ============================================================================
 
   def exists?
     timeout = set_timeout
@@ -213,20 +221,10 @@ def notify_reboot_pending
     end
   end
 
-  # ---- CHANGED: resolve Deferreds right before formatting the hash ----
+  # Keep formatter behavior identical to main; resolution happens in provider
   def self.format_dsc_lite(dsc_value)
-    # Resolve any direct/nested Deferred values using the current compiler scope if available.
-    compiler = Puppet.lookup(:compiler) { nil }
-    value_for_format =
-      if compiler
-        Puppet::Pops::Evaluator::DeferredResolver.resolve(dsc_value, compiler)
-      else
-        dsc_value
-      end
-
-    PuppetX::PuppetLabs::DscLite::PowerShellHashFormatter.format(value_for_format)
+    PuppetX::PuppetLabs::DscLite::PowerShellHashFormatter.format(dsc_value)
   end
-  # --------------------------------------------------------------------
 
   def self.escape_quotes(text)
     text.gsub("'", "''")

lib/puppet_x/puppetlabs/dsc_lite/powershell_hash_formatter.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 require 'ruby-pwsh'
-require 'puppet'
-require 'puppet/pops/evaluator/deferred_resolver'
 
 # rubocop:disable Style/ClassAndModuleChildren
 module PuppetX
@@ -14,39 +12,14 @@ class PowerShellHashFormatter
         #
         # @return [Object] Formatted value.
         def self.format(dsc_value)
-          resolved = resolve_deferred_deep(dsc_value)
-
-          if resolved.instance_of?(::Hash)
-            format_hash(resolved)
-          elsif resolved.instance_of?(::Puppet::Pops::Types::PSensitiveType::Sensitive)
-            "'#{escape_quotes(resolved.unwrap)}' # PuppetSensitive"
-          else
-            Pwsh::Util.format_powershell_value(resolved)
-          end
-        end
-
-        # --- Resolve any DeferredValue recursively before formatting ---
-        def self.resolve_deferred_deep(obj)
-          case obj
-          when Puppet::Pops::Evaluator::DeferredValue
-            compiler = Puppet.lookup(:compiler) { nil }
-            raise Puppet::Error, 'DSC_lite: DeferredValue encountered but no compiler is available to resolve it' unless compiler
-
-            Puppet::Pops::Evaluator::DeferredResolver.resolve(obj, compiler)
-          when Puppet::Pops::Types::PSensitiveType::Sensitive
-            inner = resolve_deferred_deep(obj.unwrap)
-            Puppet::Pops::Types::PSensitiveType::Sensitive.new(inner)
-          when Hash
-            obj.each_with_object({}) do |(k, v), h|
-              h[resolve_deferred_deep(k)] = resolve_deferred_deep(v)
-            end
-          when Array
-            obj.map { |v| resolve_deferred_deep(v) }
+          if dsc_value.instance_of?(::Hash)
+            format_hash(dsc_value)
+          elsif dsc_value.instance_of?(::Puppet::Pops::Types::PSensitiveType::Sensitive)
+            "'#{escape_quotes(dsc_value.unwrap)}' # PuppetSensitive"
           else
-            obj
+            Pwsh::Util.format_powershell_value(dsc_value)
           end
         end
-        # ----------------------------------------------------------------
 
         private_class_method def self.format_hash(value)
           if value.key?('dsc_type')