foobara 0.2.6 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a3b6525afdbf01d8f0d56dce1f067430111781670ebac06dc4a90297e5fb1188
-  data.tar.gz: fc79448ff4613758061b9c6336855fed97b6328356d510b77eb438097d55c99d
+  metadata.gz: 1889d43f30de1d85f60a3a6245feffbed013f4a2ad2b357fd9b61209e815ccd3
+  data.tar.gz: e57dfcd26cfb93c4f96084a61e33325644bddfd2d5d592f19e9c608f285244fe
 SHA512:
-  metadata.gz: 46d2df3884c269014f64a0b040d867e63bf65bd4c0822a4d810e07a506f296a2c6a967be2437542e7d6b56af8080094f1510da9d8143e94880428bd816bf32ad
-  data.tar.gz: 878e815dad1a261fa6bf9fc64525d06ea6cef4c499770fa6f621487a1fce011a2781750e53b75c40f8f8d1d3db57ef4cd17e4c542fba899c2474ca3576e239ab
+  metadata.gz: cd88755c0131cab9ee13fc46b38cafc779e5799aae3c33a8289198a809af9f9a021565ccaadc41d05b5a2c02aed22aad4e9ca0b3b664c0447e488ab8993c939e
+  data.tar.gz: b9c4090428c31817a87498f261a50a986594d90e8395dfd2250bd56c963373c44d10a8faa27ec0de7500c764ebfd90b6b0ee04d523d4cd7f061041727305e903

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+# [0.3.0] - 2025-11-23
+
+- Fix bug caused by exposing errors with organizations as parents
+- Restructure code in some projects and make many more methods private
+
+# [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

data/README.md

@@ -1,12 +1,25 @@
-Foobara is a software framework to help you encapsulate your high-level
-domain operations in commands, and automatically expose machine-readable formal metadata about those
-commands so that integration code can be decoupled and abstracted away.
+Foobara is a software framework that is command-centric and discoverable.
 
-This, as well as some other features of foobara, help manage domain complexity and produce
-more flexible systems.
+Domain operations are
+encapsulated in commands, which serve as the public interface to systems, and which automatically
+provide machine-readable formal metadata about those commands.
 
-You can watch a video that gives a good overview of what Foobara is and its goals here:
-[Introduction to the Foobara software framework](https://youtu.be/SSOmQqjNSVY)
+This metadata makes your domain discoverable and can be used to abstract away integrations,
+such as HTTP, CLI, MCP, whatever. It also makes your domain logic
+forward-compatible with integrations you didn't know you needed or that might not even have
+existed yet when you built your commands.
+
+This metadata is also used to help export commands from one system and import them into another
+as remote commands. This means you can write your domain logic and automatically get a Ruby SDK or Typescript SDK for
+free.
+
+This also helps with rearchitecting efforts since a remote command has the same interface
+as the local command. Domain logic refactors are not required to relocate domain logic
+in/out of other systems. And this also helps a system communicate and impose its mental model
+on consuming systems.
+
+You can use Foobara as a full standalone framework or you can use it with existing code
+as a service-objects layer and leverage the integration features of Foobara when/if necessary.
 
 <!-- TOC -->
 * [Overview of Features/Concepts/Goals](#overview-of-featuresconceptsgoals)

data/projects/builtin_types/lib/foobara/builtin_types.rb

@@ -66,6 +66,7 @@ module Foobara
 
       def reset_all
         Foobara.raise_if_production!("reset_all")
+
         builtin_types.each do |builtin_type|
           builtin_type.foobara_each do |scoped|
             if scoped.scoped_namespace == builtin_type

data/projects/builtin_types/src/attributes/supported_processors/element_type_declarations.rb

@@ -35,9 +35,7 @@ module Foobara
               return Outcome.error(
                 build_error(
                   attributes_hash,
-                  message: "Unexpected attributes #{
-                  unexpected_attributes
-                }. Expected only #{allowed_attributes}",
+                  message: "Unexpected attributes #{unexpected_attributes}. Expected only #{allowed_attributes}",
                   context: {
                     unexpected_attributes:,
                     allowed_attributes:

data/projects/builtin_types/src/builtin_types.rb

@@ -5,10 +5,6 @@ module Foobara
 
   module BuiltinTypes
     class << self
-      def global_type_declaration_handler_registry
-        TypeDeclarations.global_type_declaration_handler_registry
-      end
-
       # TODO: break this up
       # TODO: much of this behavior is helpful to non-builtin types as well.
       def build_and_register!(
@@ -158,6 +154,12 @@ module Foobara
         type
       end
 
+      private
+
+      def global_type_declaration_handler_registry
+        TypeDeclarations.global_type_declaration_handler_registry
+      end
+
       def install_type_declaration_extensions_for(processor_class)
         extension_module = Util.constant_value(processor_class, :TypeDeclarationExtension)
 

data/projects/builtin_types/src/email/transformers/downcase.rb

@@ -2,8 +2,6 @@ module Foobara
   module BuiltinTypes
     module Email
       module Transformers
-        # Seems like it might be cleaner to just assemble these parts in one place instead of in different files?
-        # Hard to say.
         class Downcase < BuiltinTypes::String::SupportedTransformers::Downcase
         end
       end

data/projects/callback/src/block/concerns/keyword_argumentable_block.rb

@@ -13,6 +13,8 @@ module Foobara
                          end
           end
 
+          private
+
           def validate_original_block!
             super
 

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

@@ -59,8 +59,6 @@ module Foobara
             end
           end
         end
-
-        foobara_delegate :type_for_declaration, to: :class
       end
     end
   end

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

@@ -167,8 +167,6 @@ module Foobara
             end
           end
         end
-
-        foobara_delegate :type_for_declaration, to: :class
       end
     end
   end

data/projects/command_connectors/src/command_connector/concerns/reflection.rb

@@ -0,0 +1,187 @@
+module Foobara
+  class CommandConnector
+    module Concerns
+      module Reflection
+        include Concern
+
+        def foobara_manifest
+          Namespace.use command_registry do
+            foobara_manifest_in_current_namespace
+          end
+        end
+
+        # TODO: figure out how this is used
+        def all_exposed_type_names
+          # TODO: cache this or better yet cache #foobara_manifest
+          foobara_manifest[:type].keys.sort.map(&:to_s)
+        end
+
+        private
+
+        # TODO: try to break this giant method up
+        def foobara_manifest_in_current_namespace
+          process_delayed_connections
+
+          to_include = Set.new
+
+          to_include << command_registry.global_organization
+          to_include << command_registry.global_domain
+
+          command_registry.foobara_each_command(
+            mode: Namespace::LookupMode::ABSOLUTE_SINGLE_NAMESPACE
+          ) do |exposed_command|
+            to_include << exposed_command
+          end
+
+          included = Set.new
+
+          additional_to_include = Set.new
+
+          h = {
+            organization: {},
+            domain: {},
+            type: {},
+            command: {},
+            error: {}
+          }
+
+          if TypeDeclarations.include_processors?
+            h.merge!(
+              processor: {},
+              processor_class: {}
+            )
+          end
+
+          TypeDeclarations.with_manifest_context(to_include: additional_to_include, remove_sensitive: true) do
+            until to_include.empty? && additional_to_include.empty?
+              object = nil
+
+              if to_include.empty?
+                until additional_to_include.empty?
+                  o = additional_to_include.first
+                  additional_to_include.delete(o)
+
+                  if o.is_a?(::Module)
+                    if o.foobara_domain? || o.foobara_organization?
+                      unless o.foobara_root_namespace == command_registry
+                        next
+                      end
+                    elsif o.is_a?(::Class) && o < Foobara::Command
+                      next
+                    end
+                  elsif o.is_a?(Types::Type)
+                    if o.sensitive?
+                      # :nocov:
+                      raise UnexpectedSensitiveTypeInManifestError,
+                            "Unexpected sensitive type in manifest: #{o.scoped_full_path}. " \
+                            "Make sure these are not included."
+                      # :nocov:
+                    else
+
+                      mode = Namespace::LookupMode::ABSOLUTE_SINGLE_NAMESPACE
+                      domain_name = o.foobara_domain.scoped_full_name
+
+                      exposed_domain = command_registry.foobara_lookup_domain(domain_name, mode:)
+
+                      exposed_domain ||= command_registry.build_and_register_exposed_domain(domain_name)
+
+                      # Since we don't know which other domains/orgs creating this domain might have created,
+                      # we will just add them all to be included just in case
+                      command_registry.foobara_all_domain(mode:).each do |exposed_domain|
+                        additional_to_include << exposed_domain
+                      end
+
+                      command_registry.foobara_all_organization(mode:).each do |exposed_organization|
+                        additional_to_include << exposed_organization
+                      end
+                    end
+                  end
+
+                  object = o
+                  break
+                end
+              else
+                object = to_include.first
+                to_include.delete(object)
+              end
+
+              break unless object
+              next if included.include?(object)
+
+              manifest_reference = object.foobara_manifest_reference.to_sym
+
+              category_symbol = command_registry.foobara_category_symbol_for(object)
+
+              unless category_symbol
+                # :nocov:
+                raise "no category symbol for #{object}"
+                # :nocov:
+              end
+
+              namespace = if object.is_a?(Types::Type)
+                            object.created_in_namespace
+                          else
+                            Foobara::Namespace.current
+                          end
+
+              # TODO: do we really need to enter the namespace here for this?
+              h[category_symbol][manifest_reference] = Foobara::Namespace.use namespace do
+                object.foobara_manifest
+              end
+
+              included << object
+            end
+          end
+
+          h[:domain].each_value do |domain_manifest|
+            # TODO: hack, we need to trim types down to what is actually included in this manifest
+            domain_manifest[:types] = domain_manifest[:types].select do |type_name|
+              h[:type].key?(type_name.to_sym)
+            end
+          end
+
+          h = normalize_manifest(h)
+          patch_up_broken_parents_for_errors_with_missing_command_parents(h)
+        end
+
+        def normalize_manifest(manifest_hash)
+          manifest_hash.map do |key, entries|
+            [key, entries.sort.to_h]
+          end.sort.to_h
+        end
+
+        def patch_up_broken_parents_for_errors_with_missing_command_parents(manifest_hash)
+          root_manifest = Manifest::RootManifest.new(manifest_hash)
+
+          error_category = {}
+
+          root_manifest.errors.each do |error|
+            error_manifest = if (error.parent_category == :command || error.parent_category == :organization) &&
+                                !root_manifest.contains?(error.parent_name, error.parent_category)
+                               domain = error.domain
+                               index = domain.scoped_full_path.size
+
+                               fixed_scoped_path = error.scoped_full_path[index..]
+                               fixed_scoped_name = fixed_scoped_path.join("::")
+                               fixed_scoped_prefix = fixed_scoped_path[..-2]
+                               fixed_parent = [:domain, domain.reference]
+
+                               error.relevant_manifest.merge(
+                                 parent: fixed_parent,
+                                 scoped_path: fixed_scoped_path,
+                                 scoped_name: fixed_scoped_name,
+                                 scoped_prefix: fixed_scoped_prefix
+                               )
+                             else
+                               error.relevant_manifest
+                             end
+
+            error_category[error.scoped_full_name.to_sym] = error_manifest
+          end
+
+          manifest_hash.merge(error: error_category)
+        end
+      end
+    end
+  end
+end