foobara 0.2.5 → 0.2.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e05617e8bea9b7a9ce861246a1a5c664ad3b525630dd1cd7362b80b4d6d809ea
-  data.tar.gz: 10bd954f202f83aef9a20f0dec859212766a81e9682f6526ece70e3cd457b6a7
+  metadata.gz: 4f5b2b0f1316a7d5530778566c64df6cffafb44dfdb99e5fd4797de2fbe3b0a2
+  data.tar.gz: 9819421a3b7dafcb39ac4d3dadb3b7a8ee2967648abf9adad4cc2fd094769bf3
 SHA512:
-  metadata.gz: 26fa0c9be295542f963963ac892405a315d5b6f004fadcdf23336bab09ad973cdae843186134c20c1e173be816506c37f2ad34e825c6d84f2c2ef42845262011
-  data.tar.gz: efefbce7b11751d240a09ca34bc5e20a182c60daa00cc79399aceee55c74e33b8b1135aca706abd2a8d3e80c39414477a19d3fee05cc28bdd0e13b063d6fda77
+  metadata.gz: 388210bea30291de942b1b42b80c5105c31a8f74a039e33ac42700c85f8052e7f229390eb57214a15d7cda3ba76767fa4934cf8c8bb2dae187dbce22ee72a631
+  data.tar.gz: bfb8114f0b127c60389fa83d0d6145178a6b3e6e28418ec2a7faaf645c16ff31d5075688edcd6005ea33fb67e02a76155286dc0cc4a93b5ad710787b2d93ad4d

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+# [0.2.7] - 2025-11-10
+
+- Fix CommandConnector authorization bug that can fail to close transactions
+
+# [0.2.6] - 2025-10-30
+
+- Add a set inputs transformer
+
 # [0.2.5] - 2025-10-27
 
 - Do not allow commands to be connected multiple times via symbol/string

data/projects/command_connectors/lib/foobara/command_connectors.rb

@@ -17,6 +17,7 @@ module Foobara
         CommandConnector.add_desugarizer Desugarizers.rename :response, :response_mutators
         CommandConnector.add_desugarizer Desugarizers::Attributes::OnlyInputs
         CommandConnector.add_desugarizer Desugarizers::Attributes::RejectInputs
+        CommandConnector.add_desugarizer Desugarizers::SetInputs
         CommandConnector.add_desugarizer Desugarizers::Attributes::OnlyResult
         CommandConnector.add_desugarizer Desugarizers::Attributes::RejectResult
         CommandConnector.add_desugarizer Desugarizers::Attributes::InputsFromYaml

data/projects/command_connectors/src/command_connector.rb

@@ -443,12 +443,10 @@ module Foobara
           end
         end
       ensure
-        request.use_transaction do
-          if (request.response || request).outcome&.success?
-            request.commit_transaction_if_open
-          else
-            request.rollback_transaction
-          end
+        if (request.response || request).outcome&.success?
+          request.commit_transaction_if_open
+        else
+          request.rollback_transaction
         end
       end
 

data/projects/command_connectors/src/desugarizers/set_inputs.rb

@@ -0,0 +1,48 @@
+require_relative "../desugarizer"
+
+module Foobara
+  module CommandConnectors
+    module Desugarizers
+      class SetInputs < Desugarizer
+        def applicable?(args_and_opts)
+          _args, opts = args_and_opts
+
+          return false unless opts.key?(:inputs_transformers)
+
+          transformers = opts[:inputs_transformers]
+          transformers = Util.array(transformers)
+
+          transformers.any? do |transformer|
+            transformer.is_a?(::Hash) && transformer.key?(:set)
+          end
+        end
+
+        def desugarize(args_and_opts)
+          args, opts = args_and_opts
+
+          transformers = opts[:inputs_transformers]
+          is_array = transformers.is_a?(::Array)
+
+          transformers = Util.array(transformers)
+
+          transformers = transformers.map do |transformer|
+            if transformer.is_a?(::Hash) && transformer.key?(:set)
+              AttributesTransformers.set(transformer[:set])
+            else
+              # TODO: add a test for this
+              # :nocov:
+              transformer
+              # :nocov:
+            end
+          end
+
+          transformers = transformers.first unless is_array
+
+          opts = opts.merge(inputs_transformers: transformers)
+
+          [args, opts]
+        end
+      end
+    end
+  end
+end

data/projects/command_connectors/src/serializers/atomic_serializer.rb

@@ -1,6 +1,14 @@
 module Foobara
   module CommandConnectors
     module Serializers
+      # This seems to interpret "Atomic" as load the first entity you hit but not deeper entities.
+      # Other interpretations it could have been:
+      # 1) If top-level is an entity, load it and convert all nested entities to primary keys,
+      #    otherwise, convert all entities to primary keys
+      # 2) Once past the first model, all entities are cast to primary keys
+      #
+      # However, in the typescript-remote-command-generator, the logic is a little different...
+      # There, AtomModelGenerator always uses primary keys for all entities.
       class AtomicSerializer < SuccessSerializer
         def serialize(object)
           case object

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

@@ -13,6 +13,8 @@ module Foobara
 
         model = Namespace.global.foobara_lookup_type!(:model)
         BuiltinTypes.build_and_register!(:detached_entity, model, nil)
+
+        TypeDeclarations::RemoveSensitiveValuesTransformer.include(RemoveSensitiveValuesTransformerExtensions)
       end
 
       def reset_all

data/projects/detached_entity/src/remove_sensitive_values_transformer_extensions.rb

@@ -0,0 +1,64 @@
+module Foobara
+  class DetachedEntity < Model
+    module RemoveSensitiveValuesTransformerExtensions
+      def from(...)
+        super.tap do
+          create_all_association_types_in_current_namespace(from_type)
+        end
+      end
+
+      def to(...)
+        super.tap do
+          create_all_association_types_in_current_namespace(to_type)
+        end
+      end
+
+      def create_all_association_types_in_current_namespace(type)
+        already_sanitized = Set.new
+
+        associations = Foobara::DetachedEntity.construct_deep_associations(type)
+
+        associations&.values&.reverse&.each do |entity_type|
+          next if already_sanitized.include?(entity_type)
+
+          next if entity_type.sensitive?
+
+          unless entity_type.has_sensitive_types?
+            already_sanitized << entity_type
+            next
+          end
+
+          ns = Namespace.current
+
+          declaration = entity_type.declaration_data
+          sanitized_type_declaration = TypeDeclarations.remove_sensitive_types(declaration)
+
+          existing_type = ns.foobara_lookup(
+            entity_type.full_type_symbol,
+            mode: Namespace::LookupMode::ABSOLUTE_SINGLE_NAMESPACE
+          )
+
+          if existing_type
+            if existing_type.declaration_data == sanitized_type_declaration
+              already_sanitized << entity_type
+              already_sanitized << existing_type
+              next
+            else
+              # :nocov:
+              raise "Did not expect to be re-sanitizing #{entity_type.full_type_symbol}"
+              # :nocov:
+            end
+
+          end
+
+          # We want to make sure that any types that change due to having sensitive types
+          # has a corresponding registered type in the command registry domain if needed
+          # TODO: this all feels so messy and brittle.
+          Domain.current.foobara_type_from_declaration(sanitized_type_declaration)
+
+          already_sanitized << entity_type
+        end
+      end
+    end
+  end
+end

data/projects/domain/src/domain_module_extension.rb

@@ -310,27 +310,6 @@ module Foobara
           type
         end
 
-        def foobara_register_model(model_class)
-          type = model_class.model_type
-
-          full_name = type.scoped_full_name
-
-          if model_class.full_model_name.size > full_name.size
-            # TODO: why does this happen exactly??
-            full_name = model_class.full_model_name
-          end
-
-          if type.scoped_path_set? && foobara_registered?(full_name, mode: Namespace::LookupMode::DIRECT)
-            # :nocov:
-            raise AlreadyRegisteredError, "Already registered: #{type.inspect}"
-            # :nocov:
-          end
-
-          foobara_register(type)
-
-          type.target_class
-        end
-
         def foobara_register_and_deanonymize_entity(name, *, &)
           entity_class = foobara_register_entity(name, *, &)
           Foobara::Model.deanonymize_class(entity_class)

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

@@ -208,6 +208,7 @@ module Foobara
             delegates[attribute_name] = delegate_manifest
 
             delegated_type_declaration = model_type.type_at_path(data_path).reference_or_declaration_data
+            # TODO: add defaults and required for the delegated declaration!
             attributes(type: :attributes, element_type_declarations: { attribute_name => delegated_type_declaration })
 
             define_method attribute_name do

data/projects/model/src/extensions/type_declarations/handlers/extend_model_type_declaration/to_type_transformer.rb

@@ -118,7 +118,7 @@ module Foobara
 
                   model_class.description type.declaration_data[:description]
 
-                  domain.foobara_register_model(model_class)
+                  domain.foobara_register(type)
 
                   if type.declaration_data[:delegates]
                     model_class.delegate_attributes type.declaration_data[:delegates]

data/projects/namespace/src/ambiguous_registry.rb

@@ -8,6 +8,12 @@ module Foobara
       def register(scoped)
         short_name = scoped.scoped_short_name
         registry[short_name] ||= []
+        # This kind of error should only happen in test suites that need to unregister/reregister things
+        # with different object_ids but the same scoped full name. So will check it in commented out.
+        # if registry[short_name].map(&:scoped_full_name).include?(scoped.scoped_full_name)
+        #   raise "Already registered: #{scoped.scoped_full_name}"
+        # end
+
         registry[short_name] |= [scoped]
       end
 

data/projects/persistence/src/entity_base/transaction/concerns/state_transitions.rb

@@ -7,8 +7,6 @@ module Foobara
 
         module Concerns
           module StateTransitions
-            foobara_delegate :close, to: :state_machine
-
             def currently_open?
               state_machine.currently_open?
             end

data/projects/persistence/src/entity_base.rb

@@ -188,6 +188,7 @@ module Foobara
           if tx.currently_open? && !existing_transaction
             tx.commit!
           end
+
           result
         rescue Foobara::Persistence::EntityBase::Transaction::RolledBack # rubocop:disable Lint/SuppressedException
         rescue => e

data/projects/type_declarations/lib/foobara/type_declarations.rb

@@ -46,8 +46,10 @@ module Foobara
           Namespace.global.foobara_register(scoped)
         end
 
+        children = Namespace.global.foobara_children
+
         @original_children.each do |child|
-          Namespace.global.foobara_children << child
+          children.foobara_children << child unless children.include?(child)
         end
 
         GlobalOrganization.foobara_register(GlobalDomain)

data/projects/type_declarations/src/attributes_transformers/set.rb

@@ -0,0 +1,77 @@
+module Foobara
+  class AttributesTransformers < TypeDeclarations::TypedTransformer
+    class << self
+      def next_index
+        @index ||= 0
+        @index += 1
+      end
+
+      def set(attribute_names_to_values)
+        if attribute_names_to_values.empty?
+          # :nocov:
+          raise ArgumentError, "You must specify at least one attribute name/value pair"
+          # :nocov:
+        end
+
+        symbol = symbol_for_attribute_names([*attribute_names_to_values.keys, next_index.to_s.to_sym])
+        existing = Set.foobara_lookup(symbol, mode: Namespace::LookupMode::DIRECT)
+
+        return existing if existing
+
+        transformer_class = Class.new(Set)
+        transformer_class.attribute_names_to_values = attribute_names_to_values
+
+        Namespace::NamespaceHelpers.foobara_autoset_scoped_path(transformer_class, set_namespace: true)
+        transformer_class.scoped_namespace.foobara_register(transformer_class)
+
+        transformer_class
+      end
+    end
+
+    class Set < AttributesTransformers
+      class << self
+        attr_accessor :attribute_names_to_values
+
+        def symbol
+          if attribute_names_to_values
+            symbol_for_attribute_names(attribute_names_to_values.keys)
+          end
+        end
+
+        def will_set_scoped_path?
+          true
+        end
+      end
+
+      def to_type_declaration
+        # TODO: test this
+        # :nocov:
+        if from_type
+          from_declaration = from_type.declaration_data
+          TypeDeclarations::Attributes.reject(from_declaration, *self.class.attribute_names_to_values.keys)
+        end
+        # :nocov:
+      end
+
+      def from_type_declaration
+        if to_type
+          to_declaration = to_type.declaration_data
+          TypeDeclarations::Attributes.reject(to_declaration, *self.class.attribute_names_to_values.keys)
+        end
+      end
+
+      def transform(inputs)
+        to_merge = {}
+
+        self.class.attribute_names_to_values.each_pair do |input_name, value|
+          if value.is_a?(::Proc)
+            value = value.call
+          end
+          to_merge[input_name] = value
+        end
+
+        inputs.merge(to_merge)
+      end
+    end
+  end
+end

data/projects/type_declarations/src/remove_sensitive_values_transformer.rb

@@ -3,65 +3,6 @@ require_relative "typed_transformer"
 module Foobara
   module TypeDeclarations
     class RemoveSensitiveValuesTransformer < TypedTransformer
-      def from(...)
-        super.tap do
-          create_all_association_types_in_current_namespace(from_type)
-        end
-      end
-
-      def to(...)
-        super.tap do
-          create_all_association_types_in_current_namespace(to_type)
-        end
-      end
-
-      def create_all_association_types_in_current_namespace(type)
-        already_sanitized = Set.new
-
-        associations = Foobara::DetachedEntity.construct_deep_associations(type)
-
-        associations&.values&.reverse&.each do |entity_type|
-          next if already_sanitized.include?(entity_type)
-
-          next if entity_type.sensitive?
-
-          unless entity_type.has_sensitive_types?
-            already_sanitized << entity_type
-            next
-          end
-
-          ns = Namespace.current
-
-          declaration = entity_type.declaration_data
-          sanitized_type_declaration = TypeDeclarations.remove_sensitive_types(declaration)
-
-          existing_type = ns.foobara_lookup(
-            entity_type.full_type_symbol,
-            mode: Namespace::LookupMode::ABSOLUTE_SINGLE_NAMESPACE
-          )
-
-          if existing_type
-            if existing_type.declaration_data == sanitized_type_declaration
-              already_sanitized << entity_type
-              already_sanitized << existing_type
-              next
-            else
-              # :nocov:
-              raise "Did not expect to be re-sanitizing #{entity_type.full_type_symbol}"
-              # :nocov:
-            end
-
-          end
-
-          # We want to make sure that any types that change due to having sensitive types
-          # has a corresponding registered type in the command registry domain if needed
-          # TODO: this all feels so messy and brittle.
-          Domain.current.foobara_type_from_declaration(sanitized_type_declaration)
-
-          already_sanitized << entity_type
-        end
-      end
-
       def to_type_declaration
         TypeDeclarations.remove_sensitive_types(from_type.declaration_data)
       end

data/version.rb

@@ -1,6 +1,6 @@
 module Foobara
   module Version
-    VERSION = "0.2.5".freeze
+    VERSION = "0.2.7".freeze
     MINIMUM_RUBY_VERSION = ">= 3.4.0".freeze
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: foobara
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.2.7
 platform: ruby
 authors:
 - Miles Georgi
@@ -214,6 +214,7 @@ files:
 - projects/command_connectors/src/desugarizers/attributes/reject_result.rb
 - projects/command_connectors/src/desugarizers/auth.rb
 - projects/command_connectors/src/desugarizers/rename_key.rb
+- projects/command_connectors/src/desugarizers/set_inputs.rb
 - projects/command_connectors/src/desugarizers/symbols_to_true.rb
 - projects/command_connectors/src/request_mutator.rb
 - projects/command_connectors/src/response_mutator.rb
@@ -273,6 +274,7 @@ files:
 - projects/detached_entity/src/extensions/type_declarations/handlers/extend_detached_entity_type_declaration/validate_primary_key_is_symbol.rb
 - projects/detached_entity/src/extensions/type_declarations/handlers/extend_detached_entity_type_declaration/validate_primary_key_present.rb
 - projects/detached_entity/src/extensions/type_declarations/handlers/extend_detached_entity_type_declaration/validate_primary_key_references_attribute.rb
+- projects/detached_entity/src/remove_sensitive_values_transformer_extensions.rb
 - projects/detached_entity/src/sensitive_type_removers/detached_entity.rb
 - projects/detached_entity/src/sensitive_value_removers/detached_entity.rb
 - projects/domain/lib/foobara/domain.rb
@@ -422,6 +424,7 @@ files:
 - projects/type_declarations/src/attributes_transformers/from_yaml.rb
 - projects/type_declarations/src/attributes_transformers/only.rb
 - projects/type_declarations/src/attributes_transformers/reject.rb
+- projects/type_declarations/src/attributes_transformers/set.rb
 - projects/type_declarations/src/caster.rb
 - projects/type_declarations/src/desugarizer.rb
 - projects/type_declarations/src/desugarizer_pipeline.rb