foobara 0.0.78 → 0.0.80

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3c5ce6bf1f2bf6f67db74bbc811f5fe37218215b00876564b97e315ec3016c6d
-  data.tar.gz: a17df1d60eb6b77e162a799250df7d13c44bde9c4a387ed96d3c7c05f3819d26
+  metadata.gz: 1b2fdc64452fe8ed0285ac3b9d9ad26108cd7157f798a3fac36b814a0855d802
+  data.tar.gz: 4e37ca0d5af8ffd919b068a2fb67573ecddf056e2b13d6d39604f09188cc11c6
 SHA512:
-  metadata.gz: 4e1d33d80f67cfc49407079dfafe3c8fe7e0da904f4ece41021ce6a8df412c754ce2dfe09cc3a60fbee74c2d2784b65b05e5839370deb06afd632f23c9e479f1
-  data.tar.gz: 408920762e79e50dd77c568f75345f6a3b952f4b10a5d2c412e3efb1fa6244874921e98c0b942d0c599f560f4769684e3261dd487e07f5a3494352c8b8525f6b
+  metadata.gz: cefd96fe33a1c2fdf1fd2f53aa128e8c6f636507d921f0f30dd9730983b8fa10c5aa10b43bd2b8c0008f50452106f90cf7b8bacae9b0142df4898d3c1ba62b2f
+  data.tar.gz: b8fb560d295f3fe8c6a1f0e194f8528a02771e5504b9c482235e16cd9cba7cb0d51858e7b12952027e14d78909a4fd07c68be54553ff3b6356f029ff4cc3259c

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+# [0.0.80] - 2025-03-19
+
+- Fix bug preventing combining array type sugar with sensitive flag in type declarations
+
+# [0.0.79] - 2025-03-19
+
+- Make foobara manifest output more deterministic (alphabetize required fields array)
+- Add sensitive/sensitive_exposed type declaration flags
+- Add sensitive-type removing feature and default to removing all sensitive (but not sensitive_exposed types)
+  from the command connector manifest
+
 # [0.0.78] - 2025-03-17
 
 - Include types that possible errors depend on in TransformedCommand#types_depdended_on

data/projects/builtin_types/src/attributes/supported_validators/required/type_declaration_extension/extend_attributes_type_declaration/desugarizers/alphabetize_required.rb

@@ -0,0 +1,38 @@
+module Foobara
+  module BuiltinTypes
+    module Attributes
+      module SupportedValidators
+        class Required < TypeDeclarations::Validator
+          module TypeDeclarationExtension
+            module ExtendAttributesTypeDeclaration
+              module Desugarizers
+                class AlphabetizeRequired < TypeDeclarations::Desugarizer
+                  def applicable?(value)
+                    value.is_a?(::Hash) && value[:type] == :attributes &&
+                      value.key?(:required) && value[:required].size > 1
+                  end
+
+                  def desugarize(rawish_type_declaration)
+                    required = rawish_type_declaration[:required]
+
+                    sorted_required = required.sort
+
+                    if sorted_required == required
+                      rawish_type_declaration
+                    else
+                      rawish_type_declaration.merge(required: sorted_required)
+                    end
+                  end
+
+                  def priority
+                    Priority::LOW
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/projects/command/src/command_pattern_implementation/concerns/reflection.rb

@@ -19,7 +19,7 @@ module Foobara
             remove_instance_variable("@all") if instance_variable_defined?("@all")
           end
 
-          def foobara_manifest(to_include: Set.new)
+          def foobara_manifest(to_include: Set.new, remove_sensitive: false)
             depends_on = self.depends_on.map do |command_name|
               other_command = Foobara::Namespace.global.foobara_lookup!(command_name,
                                                                         mode: Foobara::Namespace::LookupMode::ABSOLUTE)
@@ -27,7 +27,7 @@ module Foobara
               other_command.foobara_manifest_reference
             end.sort
 
-            types = types_depended_on.map do |t|
+            types = types_depended_on(remove_sensitive:).map do |t|
               to_include << t
               t.foobara_manifest_reference
             end.sort
@@ -78,54 +78,82 @@ module Foobara
             Util.non_full_name(self)
           end
 
-          def types_depended_on
-            # TODO: is there a simpler way to wrap these methods in this namespace?
-            # something aspect-oriented-ish?
-            @types_depended_on ||= begin
-              types = inputs_types_depended_on | result_types_depended_on | errors_types_depended_on
+          def types_depended_on(remove_sensitive: false)
+            if defined?(@types_depended_on) && @types_depended_on.key?(remove_sensitive)
+              return @types_depended_on[remove_sensitive]
+            end
+
+            @types_depended_on ||= {}
+            @types_depended_on[remove_sensitive] = begin
+              types = inputs_types_depended_on(remove_sensitive:) | result_types_depended_on(remove_sensitive:) |
+                      errors_types_depended_on(remove_sensitive:)
 
               unless depends_on_entities.empty?
                 entity_types = depends_on_entities.map(&:entity_type)
+
+                if remove_sensitive
+                  entity_types = entity_types.reject(&:sensitive?)
+                end
+
                 types |= entity_types
-                types |= entity_types.map(&:types_depended_on).inject(:|)
+                types |= entity_types.map { |t| t.types_depended_on(remove_sensitive:) }.inject(:|)
               end
 
               types
             end
           end
 
-          def inputs_types_depended_on
-            @inputs_types_depended_on ||= if inputs_type
-                                            if inputs_type.registered?
-                                              # TODO: if we ever change from attributes-only inputs type
-                                              # then this will be handy
-                                              # :nocov:
-                                              Set[inputs_type]
-                                              # :nocov:
-                                            else
-                                              inputs_type.types_depended_on
-                                            end
-                                          else
-                                            Set.new
-                                          end
+          def inputs_types_depended_on(remove_sensitive: false)
+            if defined?(@inputs_types_depended_on) && @inputs_types_depended_on.key?(remove_sensitive)
+              return @inputs_types_depended_on[remove_sensitive]
+            end
+
+            @inputs_types_depended_on ||= {}
+            @inputs_types_depended_on[remove_sensitive] = if inputs_type
+                                                            if inputs_type.registered?
+                                                              # TODO: if we ever change from attributes-only inputs type
+                                                              # then this will be handy
+                                                              # :nocov:
+                                                              if !remove_sensitive || !inputs_type.sensitive?
+                                                                Set[inputs_type]
+                                                              else
+                                                                Set.new
+                                                              end
+                                                              # :nocov:
+                                                            else
+                                                              inputs_type.types_depended_on(remove_sensitive:)
+                                                            end
+                                                          else
+                                                            Set.new
+                                                          end
           end
 
-          def result_types_depended_on
-            @result_types_depended_on ||= if result_type
-                                            if result_type.registered?
-                                              Set[result_type]
-                                            else
-                                              result_type.types_depended_on
-                                            end
-                                          else
-                                            Set.new
-                                          end
+          def result_types_depended_on(remove_sensitive: false)
+            if defined?(@result_types_depended_on) && @result_types_depended_on.key?(remove_sensitive)
+              return @result_types_depended_on[remove_sensitive]
+            end
+
+            @result_types_depended_on ||= {}
+            @result_types_depended_on[remove_sensitive] = if result_type
+                                                            if result_type.registered?
+                                                              Set[result_type]
+                                                            else
+                                                              result_type.types_depended_on(remove_sensitive:)
+                                                            end
+                                                          else
+                                                            Set.new
+                                                          end
           end
 
-          def errors_types_depended_on
-            @errors_types_depended_on ||= begin
+          def errors_types_depended_on(remove_sensitive: false)
+            if defined?(@errors_types_depended_on) && @errors_types_depended_on.key?(remove_sensitive)
+              return @errors_types_depended_on[remove_sensitive]
+            end
+
+            @errors_types_depended_on ||= {}
+            @errors_types_depended_on[remove_sensitive] = begin
               error_classes = possible_errors.map(&:error_class)
-              error_classes.map(&:types_depended_on).inject(:|) || Set.new
+              error_classes.map { |e| e.types_depended_on(remove_sensitive:) }.inject(:|) || Set.new
             end
           end
         end

data/projects/command/src/transformed_command.rb

@@ -114,16 +114,16 @@ module Foobara
         @possible_errors ||= error_context_type_map.values
       end
 
-      def possible_errors_manifest(to_include:)
+      def possible_errors_manifest(to_include:, remove_sensitive: true)
         possible_errors.map do |possible_error|
-          [possible_error.key.to_s, possible_error.foobara_manifest(to_include:)]
+          [possible_error.key.to_s, possible_error.foobara_manifest(to_include:, remove_sensitive:)]
         end.sort.to_h
       end
 
-      def types_depended_on
+      def types_depended_on(remove_sensitive: true)
         # TODO: memoize this
         # TODO: this should not delegate to command since transformers are in play
-        types = command_class.types_depended_on
+        types = command_class.types_depended_on(remove_sensitive:)
 
         type = inputs_type
 
@@ -135,7 +135,7 @@ module Foobara
                      [type]
                      # :nocov:
                    else
-                     type.types_depended_on
+                     type.types_depended_on(remove_sensitive:)
                    end
         end
 
@@ -149,19 +149,19 @@ module Foobara
                      [type]
                      # :nocov:
                    else
-                     type.types_depended_on
+                     type.types_depended_on(remove_sensitive:)
                    end
         end
 
         possible_errors.each do |possible_error|
           error_class = possible_error.error_class
-          types |= error_class.types_depended_on
+          types |= error_class.types_depended_on(remove_sensitive:)
         end
 
         types
       end
 
-      def foobara_manifest(to_include: Set.new)
+      def foobara_manifest(to_include: Set.new, remove_sensitive: true)
         types = types_depended_on.select(&:registered?).map do |t|
           to_include << t
           t.foobara_manifest_reference
@@ -180,12 +180,13 @@ module Foobara
           end
         end
 
-        command_class.foobara_manifest(to_include:).merge(
+        command_class.foobara_manifest(to_include:, remove_sensitive:).merge(
           Util.remove_blank(
             types_depended_on: types,
             inputs_type: inputs_type&.reference_or_declaration_data,
-            result_type: result_type&.reference_or_declaration_data,
-            possible_errors: possible_errors_manifest(to_include:),
+            # TODO: we need a way to unmask values in the result type that we want to expose
+            result_type: result_type&.reference_or_declaration_data(remove_sensitive:),
+            possible_errors: possible_errors_manifest(to_include:, remove_sensitive:),
             capture_unknown_error:,
             inputs_transformers:,
             result_transformers:,

data/projects/command_connectors/src/command_connector.rb

@@ -1,5 +1,7 @@
 module Foobara
   class CommandConnector
+    class UnexpectedSensitiveTypeInManifestError < StandardError; end
+
     class CommandConnectorError < Foobara::RuntimeError
       class << self
         def context_type_declaration
@@ -349,7 +351,7 @@ module Foobara
       Foobara.foobara_lookup_type(name, mode: Namespace::LookupMode::RELAXED)
     end
 
-    def foobara_manifest
+    def foobara_manifest(remove_sensitive: true)
       process_delayed_connections
 
       # Drive all of this off of the list of exposed commands...
@@ -384,6 +386,11 @@ module Foobara
               if o.foobara_domain? || o.foobara_organization? || (o.is_a?(::Class) && o < Foobara::Command)
                 next
               end
+            elsif o.is_a?(Types::Type) && remove_sensitive && o.sensitive?
+              # :nocov:
+              raise UnexpectedSensitiveTypeInManifestError,
+                    "Unexpected sensitive type in manifest: #{o.scoped_full_path}. Make sure these are not included."
+              # :nocov:
             end
 
             object = o
@@ -412,7 +419,7 @@ module Foobara
         cat = h[category_symbol] ||= {}
         # TODO: do we really need to enter the namespace here for this?
         cat[manifest_reference] = Foobara::Namespace.use namespace do
-          object.foobara_manifest(to_include: additional_to_include)
+          object.foobara_manifest(to_include: additional_to_include, remove_sensitive:)
         end
 
         included << object

data/projects/command_connectors/src/command_registry/exposed_command.rb

@@ -100,11 +100,11 @@ module Foobara
         parent
       end
 
-      def foobara_manifest(to_include: Set.new)
+      def foobara_manifest(to_include: Set.new, remove_sensitive: true)
         # A bit of a hack here. We don't have an exposed type class to encapsulate including exposed domains/orgs
         # which leads to a bug when a global command is exposed that depends on a type in a non-global domain
         # but there being no other reason to include that non-global domain.
-        transformed_command_class.types_depended_on.select(&:registered?).each do |type|
+        transformed_command_class.types_depended_on(remove_sensitive:).select(&:registered?).each do |type|
           full_domain_name = type.foobara_domain.scoped_full_name
 
           unless root_registry.foobara_lookup_domain(full_domain_name)
@@ -114,7 +114,7 @@ module Foobara
           end
         end
 
-        transformed_command_class.foobara_manifest(to_include:).merge(super).merge(
+        transformed_command_class.foobara_manifest(to_include:, remove_sensitive:).merge(super).merge(
           Util.remove_blank(
             scoped_category: :command,
             domain: command_class.domain.foobara_manifest_reference,

data/projects/command_connectors/src/command_registry/exposed_domain.rb

@@ -14,10 +14,10 @@ module Foobara
       end
 
       # TODO: unable to address types here so it is handled as a hack higher up...
-      def foobara_manifest(to_include: Set.new)
+      def foobara_manifest(to_include: Set.new, remove_sensitive: true)
         to_include << foobara_organization
 
-        domain_manifest = domain_module.foobara_manifest(to_include: Set.new)
+        domain_manifest = domain_module.foobara_manifest(to_include: Set.new, remove_sensitive:)
         mode = Foobara::Namespace::LookupMode::DIRECT
         commands = foobara_all_command(mode:).map(&:foobara_manifest_reference).sort
 

data/projects/command_connectors/src/command_registry/exposed_organization.rb

@@ -14,8 +14,8 @@ module Foobara
       end
 
       # TODO: unable to address types here so it is handled as a hack higher up...
-      def foobara_manifest(to_include: Set.new)
-        organization_manifest = organization_module.foobara_manifest(to_include: Set.new)
+      def foobara_manifest(to_include: Set.new, remove_sensitive: true)
+        organization_manifest = organization_module.foobara_manifest(to_include: Set.new, remove_sensitive:)
         mode = Foobara::Namespace::LookupMode::DIRECT
         domains = foobara_all_domain(mode:).map(&:foobara_manifest_reference).sort
 

data/projects/common/src/error.rb

@@ -102,8 +102,8 @@ module Foobara
         }
       end
 
-      def foobara_manifest(to_include: Set.new)
-        types = types_depended_on.map do |t|
+      def foobara_manifest(to_include: Set.new, remove_sensitive: false)
+        types = types_depended_on(remove_sensitive:).map do |t|
           to_include << t
           t.foobara_manifest_reference
         end

data/projects/common/src/possible_error.rb

@@ -46,7 +46,7 @@ module Foobara
     end
 
     # TODO: technically does not belong in this project but maybe it should
-    def foobara_manifest(to_include: Set.new)
+    def foobara_manifest(to_include: Set.new, remove_sensitive: false)
       to_include << error_class
 
       if processor

data/projects/detached_entity/lib/foobara/detached_entity.rb

@@ -5,7 +5,10 @@ module Foobara
     class << self
       # Need to override this otherwise we install Model twice
       def install!
-        TypeDeclarations.register_type_declaration(TypeDeclarations::Handlers::ExtendDetachedEntityTypeDeclaration.new)
+        handler = TypeDeclarations::Handlers::ExtendDetachedEntityTypeDeclaration.new
+        TypeDeclarations.register_type_declaration(handler)
+
+        TypeDeclarations.register_sensitive_type_remover(SensitiveTypeRemovers::DetachedEntity.new(handler))
 
         model = Namespace.global.foobara_lookup_type!(:model)
         BuiltinTypes.build_and_register!(:detached_entity, model, nil)

data/projects/detached_entity/src/concerns/associations.rb

@@ -5,14 +5,24 @@ module Foobara
         include Concern
 
         module ClassMethods
-          def foobara_associations
-            @foobara_associations ||= construct_associations
+          def foobara_associations(remove_sensitive: false)
+            if defined?(@foobara_associations) && @foobara_associations.key?(remove_sensitive)
+              return @foobara_associations[remove_sensitive]
+            end
+
+            @foobara_associations ||= {}
+            @foobara_associations[remove_sensitive] = construct_associations(remove_sensitive:)
           end
 
           alias associations foobara_associations
 
-          def foobara_deep_associations
-            @foobara_deep_associations ||= begin
+          def foobara_deep_associations(remove_sensitive: false)
+            if defined?(@foobara_deep_associations) && @foobara_deep_associations.key?(remove_sensitive)
+              return @foobara_deep_associations[remove_sensitive]
+            end
+
+            @foobara_deep_associations ||= {}
+            @foobara_deep_associations[remove_sensitive] = begin
               deep = {}
 
               associations.each_pair do |data_path, type|
@@ -20,7 +30,7 @@ module Foobara
 
                 entity_class = type.target_class
 
-                entity_class.deep_associations.each_pair do |sub_data_path, sub_type|
+                entity_class.deep_associations(remove_sensitive:).each_pair do |sub_data_path, sub_type|
                   deep["#{data_path}.#{sub_data_path}"] = sub_type
                 end
               end
@@ -118,27 +128,39 @@ module Foobara
           def construct_associations(
             type = attributes_type,
             path = DataPath.new,
-            result = {}
+            result = {},
+            remove_sensitive: false
           )
             if type.extends?(BuiltinTypes[:entity])
               result[path.to_s] = type
             elsif type.extends?(BuiltinTypes[:tuple])
               element_types = type.element_types
 
+              if remove_sensitive
+                # TODO: test this code path
+                # :nocov:
+                element_types = element_types&.reject(&:sensitive?)
+                # :nocov:
+              end
+
               element_types&.each&.with_index do |element_type, index|
-                construct_associations(element_type, path.append(index), result)
+                construct_associations(element_type, path.append(index), result, remove_sensitive:)
               end
             elsif type.extends?(BuiltinTypes[:array])
               # TODO: what to do about an associative array type?? Unclear how to make a key from that...
               # TODO: raise if associative array contains a non-persisted record to handle this edge case for now.
               element_type = type.element_type
 
-              if element_type
-                construct_associations(element_type, path.append(:"#"), result)
+              if element_type && (!remove_sensitive || !element_type.sensitive?)
+                construct_associations(element_type, path.append(:"#"), result, remove_sensitive:)
               end
             elsif type.extends?(BuiltinTypes[:attributes]) # TODO: matches attributes itself instead of only subtypes
               type.element_types.each_pair do |attribute_name, element_type|
-                construct_associations(element_type, path.append(attribute_name), result)
+                if remove_sensitive && element_type.sensitive?
+                  next
+                end
+
+                construct_associations(element_type, path.append(attribute_name), result, remove_sensitive:)
               end
             elsif type.extends?(BuiltinTypes[:model])
               target_class = type.target_class
@@ -146,11 +168,13 @@ module Foobara
               method = target_class.respond_to?(:foobara_attributes_type) ? :foobara_attributes_type : :attributes_type
               attributes_type = target_class.send(method)
 
-              construct_associations(attributes_type, path, result)
+              if !remove_sensitive || !attributes_type.sensitive?
+                construct_associations(attributes_type, path, result, remove_sensitive:)
+              end
             elsif type.extends?(BuiltinTypes[:associative_array])
               # not going to bother testing this for now
               # :nocov:
-              if contains_associations?(type)
+              if contains_associations?(type, remove_sensitive:)
                 raise "Associative array types with associations in them are not currently supported. " \
                       "Use attributes type if you can or set the key_type and/or value_type to duck type"
               end
@@ -160,10 +184,19 @@ module Foobara
             result
           end
 
-          def contains_associations?(type = entity_type, initial = true)
+          def contains_associations?(type = entity_type, initial = true, remove_sensitive: false)
             if type.extends?(BuiltinTypes[:detached_entity])
               if initial
-                contains_associations?(type.element_types, false)
+                element_types = type.element_types
+
+                if remove_sensitive
+                  # TODO: test this code path
+                  # :nocov:
+                  element_types = element_types&.reject(&:sensitive?)
+                  # :nocov:
+                end
+
+                contains_associations?(element_types, false, remove_sensitive:)
               else
                 true
               end
@@ -172,21 +205,28 @@ module Foobara
               # TODO: raise if associative array contains a non-persisted record to handle this edge case for now.
               element_type = type.element_type
 
-              if element_type
-                contains_associations?(element_type, false)
+              if element_type && (!remove_sensitive || !element_type.sensitive?)
+                contains_associations?(element_type, false, remove_sensitive:)
               end
             elsif type.extends?(BuiltinTypes[:attributes])
               type.element_types.values.any? do |element_type|
-                contains_associations?(element_type, false)
+                if !remove_sensitive || !element_type.sensitive?
+                  contains_associations?(element_type, false, remove_sensitive:)
+                end
               end
             elsif type.extends?(BuiltinTypes[:associative_array])
               element_types = type.element_types
 
               if element_types
-                key_type, value_type = element_types
+                types = element_types
+
+                if remove_sensitive
+                  types = types&.reject(&:sensitive?)
+                end
 
-                contains_associations?(key_type, false) ||
-                  contains_associations?(value_type, false)
+                types.any? do |type|
+                  contains_associations?(type, false, remove_sensitive:)
+                end
               end
             end
           end

data/projects/detached_entity/src/concerns/reflection.rb

@@ -17,15 +17,15 @@ module Foobara
             types.map(&:target_class).uniq
           end
 
-          def foobara_manifest(to_include: Set.new)
-            associations = foobara_associations.map do |(path, type)|
+          def foobara_manifest(to_include: Set.new, remove_sensitive: false)
+            associations = foobara_associations(remove_sensitive:).map do |(path, type)|
               entity_class = type.target_class
               entity_name = entity_class.foobara_type.scoped_full_name
 
               [path, entity_name]
             end.sort.to_h
 
-            deep_associations = foobara_deep_associations.map do |(path, type)|
+            deep_associations = foobara_deep_associations(remove_sensitive:).map do |(path, type)|
               entity_class = type.target_class
               entity_name = entity_class.foobara_type.scoped_full_name
 

data/projects/detached_entity/src/concerns/types.rb

@@ -8,7 +8,13 @@ module Foobara
 
         module ClassMethods
           def entity_type
-            model_type
+            return @model_type if defined?(@model_type)
+
+            if attributes_type
+              set_model_type
+            end
+
+            @model_type
           end
 
           def type_declaration(...)

data/projects/detached_entity/src/detached_entity_type.rb

@@ -18,7 +18,7 @@ module Foobara
       end
     end
 
-    def foobara_manifest(to_include: Set.new)
+    def foobara_manifest(to_include: Set.new, remove_sensitive: false)
       manifest = super
 
       if detached_context?
@@ -37,7 +37,7 @@ module Foobara
       manifest
     end
 
-    def types_to_add_to_manifest
+    def types_to_add_to_manifest(remove_sensitive: false)
       types = super
 
       if detached_context?

data/projects/detached_entity/src/sensitive_type_removers/detached_entity.rb

@@ -0,0 +1,8 @@
+module Foobara
+  class DetachedEntity < Model
+    module SensitiveTypeRemovers
+      class DetachedEntity < Model::SensitiveTypeRemovers::Model
+      end
+    end
+  end
+end

data/projects/domain/src/domain_module_extension.rb

@@ -109,10 +109,14 @@ module Foobara
 
                   # TODO: unclear why we need this check, hmmm, figure it out and document it (or delete if not needed)
                   break if child.constants(false).any? do |constant|
+                    # TODO: a clue: this stopped being entered by the test suite after deleting GlobalDomain::Types
+                    # in .reset_alls hmmmmmm...
+                    # :nocov:
                     value = child.const_get(constant)
 
                     # TODO: can we make this not coupled to model project??
                     value.is_a?(Types::Type) || (value.is_a?(::Class) && value < Foobara::Model)
+                    # :nocov:
                   end
 
                   lower_case_constants = child.instance_variable_get(:@foobara_lowercase_constants)
@@ -393,7 +397,7 @@ module Foobara
         end
 
         # TODO: can we kill this skip concept?
-        def foobara_manifest(to_include: Set.new)
+        def foobara_manifest(to_include: Set.new, remove_sensitive: false)
           depends_on = foobara_depends_on.map do |name|
             domain = Domain.to_domain(name)
             to_include << domain

data/projects/domain/src/is_manifestable.rb

@@ -37,7 +37,7 @@ module Foobara
       end
     end
 
-    def foobara_manifest(to_include: Set.new)
+    def foobara_manifest(to_include: Set.new, remove_sensitive: false)
       h = {
         scoped_path:,
         scoped_name:,