foobara 0.2.7 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4f5b2b0f1316a7d5530778566c64df6cffafb44dfdb99e5fd4797de2fbe3b0a2
-  data.tar.gz: 9819421a3b7dafcb39ac4d3dadb3b7a8ee2967648abf9adad4cc2fd094769bf3
+  metadata.gz: 1889d43f30de1d85f60a3a6245feffbed013f4a2ad2b357fd9b61209e815ccd3
+  data.tar.gz: e57dfcd26cfb93c4f96084a61e33325644bddfd2d5d592f19e9c608f285244fe
 SHA512:
-  metadata.gz: 388210bea30291de942b1b42b80c5105c31a8f74a039e33ac42700c85f8052e7f229390eb57214a15d7cda3ba76767fa4934cf8c8bb2dae187dbce22ee72a631
-  data.tar.gz: bfb8114f0b127c60389fa83d0d6145178a6b3e6e28418ec2a7faaf645c16ff31d5075688edcd6005ea33fb67e02a76155286dc0cc4a93b5ad710787b2d93ad4d
+  metadata.gz: cd88755c0131cab9ee13fc46b38cafc779e5799aae3c33a8289198a809af9f9a021565ccaadc41d05b5a2c02aed22aad4e9ca0b3b664c0447e488ab8993c939e
+  data.tar.gz: b9c4090428c31817a87498f261a50a986594d90e8395dfd2250bd56c963373c44d10a8faa27ec0de7500c764ebfd90b6b0ee04d523d4cd7f061041727305e903

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+# [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

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

data/projects/command_connectors/src/command_connector.rb

@@ -4,6 +4,7 @@ module Foobara
     class AlreadyConnectedError < StandardError; end
 
     include Concerns::Desugarizers
+    include Concerns::Reflection
 
     class << self
       def find_builtin_command_class(command_class_name)
@@ -144,6 +145,68 @@ module Foobara
       end
     end
 
+    def connect(*args, **opts)
+      args, opts = desugarize_connect_args(args, opts)
+
+      registerable = args.first
+
+      if opts.key?(:authenticator)
+        authenticator = opts[:authenticator]
+        authenticator = self.class.to_authenticator(authenticator)
+        opts = opts.merge(authenticator:)
+      end
+
+      case registerable
+      when Class
+        unless registerable < Command
+          # :nocov:
+          raise "Don't know how to register #{registerable} (#{registerable.class})"
+          # :nocov:
+        end
+
+        command_registry.register(*args, **opts)
+      when Module
+        if registerable.foobara_organization?
+          args = args[1..]
+          registerable.foobara_domains.map do |domain|
+            connect(domain, *args, **opts)
+          end.flatten
+        elsif registerable.foobara_domain?
+          args = args[1..]
+          connected = []
+
+          registerable = registerable.foobara_all_command(mode: Namespace::LookupMode::DIRECT)
+
+          registerable.each do |command_class|
+            unless command_class.abstract?
+              connected << connect(command_class, *args, **opts)
+            end
+          end
+
+          connected.flatten
+        else
+          # :nocov:
+          raise "Don't know how to register #{registerable} (#{registerable.class})"
+          # :nocov:
+        end
+      when Symbol, String
+        connect_delayed(*args, **opts)
+      else
+        # :nocov:
+        raise "Don't know how to register #{registerable} (#{registerable.class})"
+        # :nocov:
+      end
+    end
+
+    # TODO: maybe introduce a Runner interface?
+    def run(...)
+      process_delayed_connections
+
+      request = build_request(...)
+
+      run_request(request)
+    end
+
     def find_builtin_command_class(command_class_name)
       self.class.find_builtin_command_class(command_class_name)
     end
@@ -166,6 +229,28 @@ module Foobara
       command_registry.foobara_lookup_command(name)
     end
 
+    def type_from_name(name)
+      Foobara.foobara_lookup_type(name, mode: Namespace::LookupMode::RELAXED)
+    end
+
+    def all_exposed_commands
+      process_delayed_connections
+
+      command_registry.foobara_all_command(mode: Namespace::LookupMode::ABSOLUTE_SINGLE_NAMESPACE)
+    end
+
+    def all_exposed_command_names
+      all_exposed_commands.map(&:full_command_name)
+    end
+
+    def command_connected?(original_command_class)
+      all_exposed_commands.any? do |command|
+        command.command_class == original_command_class
+      end
+    end
+
+    protected
+
     def request_to_command_class(request)
       action = request.action
       full_command_name = request.full_command_name
@@ -335,59 +420,6 @@ module Foobara
       delayed_connections.clear
     end
 
-    def connect(*args, **opts)
-      args, opts = desugarize_connect_args(args, opts)
-
-      registerable = args.first
-
-      if opts.key?(:authenticator)
-        authenticator = opts[:authenticator]
-        authenticator = self.class.to_authenticator(authenticator)
-        opts = opts.merge(authenticator:)
-      end
-
-      case registerable
-      when Class
-        unless registerable < Command
-          # :nocov:
-          raise "Don't know how to register #{registerable} (#{registerable.class})"
-          # :nocov:
-        end
-
-        command_registry.register(*args, **opts)
-      when Module
-        if registerable.foobara_organization?
-          args = args[1..]
-          registerable.foobara_domains.map do |domain|
-            connect(domain, *args, **opts)
-          end.flatten
-        elsif registerable.foobara_domain?
-          args = args[1..]
-          connected = []
-
-          registerable = registerable.foobara_all_command(mode: Namespace::LookupMode::DIRECT)
-
-          registerable.each do |command_class|
-            unless command_class.abstract?
-              connected << connect(command_class, *args, **opts)
-            end
-          end
-
-          connected.flatten
-        else
-          # :nocov:
-          raise "Don't know how to register #{registerable} (#{registerable.class})"
-          # :nocov:
-        end
-      when Symbol, String
-        connect_delayed(*args, **opts)
-      else
-        # :nocov:
-        raise "Don't know how to register #{registerable} (#{registerable.class})"
-        # :nocov:
-      end
-    end
-
     def desugarize_connect_args(args, opts)
       if self.class.desugarizer
         self.class.desugarizer.process_value!([args, opts])
@@ -406,15 +438,6 @@ module Foobara
       end
     end
 
-    # TODO: maybe introduce a Runner interface?
-    def run(...)
-      process_delayed_connections
-
-      request = build_request(...)
-
-      run_request(request)
-    end
-
     def run_request(request)
       command_class = determine_command_class(request)
       request.command_class = command_class
@@ -495,192 +518,5 @@ module Foobara
 
       response
     end
-
-    def type_from_name(name)
-      Foobara.foobara_lookup_type(name, mode: Namespace::LookupMode::RELAXED)
-    end
-
-    def foobara_manifest
-      Namespace.use command_registry do
-        foobara_manifest_in_current_namespace
-      end
-    end
-
-    # 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 &&
-                            !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
-
-    def all_exposed_commands
-      process_delayed_connections
-
-      command_registry.foobara_all_command(mode: Namespace::LookupMode::ABSOLUTE_SINGLE_NAMESPACE)
-    end
-
-    def all_exposed_command_names
-      all_exposed_commands.map(&:full_command_name)
-    end
-
-    def all_exposed_type_names
-      # TODO: cache this or better yet cache #foobara_manifest
-      foobara_manifest[:type].keys.sort.map(&:to_s)
-    end
   end
 end

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

@@ -126,10 +126,6 @@ module Foobara
         @transformed_command_class = nil
       end
 
-      def _has_delegated_attributes?(type)
-        type&.extends?(BuiltinTypes[:model]) && type.target_class&.has_delegated_attributes?
-      end
-
       def full_command_name
         scoped_full_name
       end
@@ -191,6 +187,8 @@ module Foobara
                                        end
       end
 
+      private
+
       # TODO: what to do if the whole return type is sensitive? return nil?
       def result_has_sensitive_types?
         result_type = command_class.result_type
@@ -206,6 +204,10 @@ module Foobara
           command_class.result_type.has_sensitive_types?
         end
       end
+
+      def _has_delegated_attributes?(type)
+        type&.extends?(BuiltinTypes[:model]) && type.target_class&.has_delegated_attributes?
+      end
     end
   end
 end

data/projects/command_connectors/src/command_registry.rb

@@ -32,45 +32,11 @@ module Foobara
       create_exposed_command(command_class, **)
     end
 
-    def create_exposed_command(command_class, **)
-      full_domain_name = command_class.domain.scoped_full_name
-      exposed_domain = foobara_lookup_domain(full_domain_name,
-                                             mode: Namespace::LookupMode::ABSOLUTE_SINGLE_NAMESPACE) ||
-                       build_and_register_exposed_domain(full_domain_name)
-
-      exposed_command = create_exposed_command_without_domain(command_class, **)
-
-      exposed_domain.foobara_register(exposed_command)
-
-      exposed_command
-    end
-
     # TODO: eliminate this method
     def create_exposed_command_without_domain(command_class, **)
       ExposedCommand.new(command_class, **apply_defaults(**))
     end
 
-    def apply_defaults(
-      inputs_transformers: nil,
-      result_transformers: nil,
-      errors_transformers: nil,
-      pre_commit_transformers: nil,
-      serializers: nil,
-      allowed_rule: default_allowed_rule,
-      authenticator: nil,
-      **opts
-    )
-      opts.merge(
-        inputs_transformers: [*inputs_transformers, *default_inputs_transformers],
-        result_transformers: [*result_transformers, *default_result_transformers],
-        errors_transformers: [*errors_transformers, *default_errors_transformers],
-        pre_commit_transformers: [*pre_commit_transformers, *default_pre_commit_transformers],
-        serializers: [*serializers, *default_serializers],
-        allowed_rule: allowed_rule && to_allowed_rule(allowed_rule),
-        authenticator: authenticator || self.authenticator
-      )
-    end
-
     def build_and_register_exposed_domain(domain_full_name)
       domain_module = if domain_full_name.to_s == ""
                         GlobalDomain
@@ -211,6 +177,37 @@ module Foobara
       default_serializers << serializer
     end
 
+    def transformed_command_from_name(name)
+      foobara_lookup_command(name, mode: Namespace::LookupMode::RELAXED)&.transformed_command_class
+    end
+
+    def all_transformed_command_classes
+      foobara_all_command.map(&:transformed_command_class)
+    end
+
+    def each_transformed_command_class(&)
+      foobara_all_command.map(&:transformed_command_class).each(&)
+    end
+
+    def size
+      foobara_all_command.size
+    end
+
+    private
+
+    def create_exposed_command(command_class, **)
+      full_domain_name = command_class.domain.scoped_full_name
+      exposed_domain = foobara_lookup_domain(full_domain_name,
+                                             mode: Namespace::LookupMode::ABSOLUTE_SINGLE_NAMESPACE) ||
+                       build_and_register_exposed_domain(full_domain_name)
+
+      exposed_command = create_exposed_command_without_domain(command_class, **)
+
+      exposed_domain.foobara_register(exposed_command)
+
+      exposed_command
+    end
+
     def to_allowed_rule(*args)
       symbol, object = case args.size
                        when 1
@@ -289,20 +286,25 @@ module Foobara
       end
     end
 
-    def transformed_command_from_name(name)
-      foobara_lookup_command(name, mode: Namespace::LookupMode::RELAXED)&.transformed_command_class
-    end
-
-    def all_transformed_command_classes
-      foobara_all_command.map(&:transformed_command_class)
-    end
-
-    def each_transformed_command_class(&)
-      foobara_all_command.map(&:transformed_command_class).each(&)
-    end
-
-    def size
-      foobara_all_command.size
+    def apply_defaults(
+      inputs_transformers: nil,
+      result_transformers: nil,
+      errors_transformers: nil,
+      pre_commit_transformers: nil,
+      serializers: nil,
+      allowed_rule: default_allowed_rule,
+      authenticator: nil,
+      **opts
+    )
+      opts.merge(
+        inputs_transformers: [*inputs_transformers, *default_inputs_transformers],
+        result_transformers: [*result_transformers, *default_result_transformers],
+        errors_transformers: [*errors_transformers, *default_errors_transformers],
+        pre_commit_transformers: [*pre_commit_transformers, *default_pre_commit_transformers],
+        serializers: [*serializers, *default_serializers],
+        allowed_rule: allowed_rule && to_allowed_rule(allowed_rule),
+        authenticator: authenticator || self.authenticator
+      )
     end
   end
 end

data/projects/command_connectors/src/transformed_command.rb

@@ -425,52 +425,6 @@ module Foobara
         manifest
       end
 
-      def processors_to_manifest_symbols(processors)
-        return nil if processors.nil? || processors.empty?
-
-        to_include = TypeDeclarations.foobara_manifest_context_to_include || Set.new
-        include_processors = TypeDeclarations.include_processors?
-
-        processors.map do |processor|
-          if processor.respond_to?(:scoped_path_set?) && processor.scoped_path_set?
-            if include_processors
-              to_include << processor
-            end
-            processor.foobara_manifest_reference
-          elsif processor.is_a?(Value::Processor)
-            klass = processor.class
-
-            if klass.scoped_path_set?
-              if include_processors
-                to_include << klass
-              end
-              klass.foobara_manifest_reference
-              # TODO: Delete this nocov block
-              # TODO: make anonymous scoped path's have better names instead of random hexadecimal
-              # :nocov:
-            elsif processor.respond_to?(:symbol) && processor.symbol
-              processor.symbol
-            else
-              name = klass.name
-
-              while name.nil?
-                klass = klass.superclass
-                name = klass.name
-              end
-
-              "Anonymous#{Util.non_full_name(name)}"
-              # :nocov:
-            end
-          elsif processor.is_a?(::Proc)
-            "Proc"
-          else
-            # :nocov:
-            "Unknown"
-            # :nocov:
-          end
-        end
-      end
-
       def inputs_transformer
         return @inputs_transformer if defined?(@inputs_transformer)
 
@@ -581,6 +535,54 @@ module Foobara
           end
         end
       end
+
+      private
+
+      def processors_to_manifest_symbols(processors)
+        return nil if processors.nil? || processors.empty?
+
+        to_include = TypeDeclarations.foobara_manifest_context_to_include || Set.new
+        include_processors = TypeDeclarations.include_processors?
+
+        processors.map do |processor|
+          if processor.respond_to?(:scoped_path_set?) && processor.scoped_path_set?
+            if include_processors
+              to_include << processor
+            end
+            processor.foobara_manifest_reference
+          elsif processor.is_a?(Value::Processor)
+            klass = processor.class
+
+            if klass.scoped_path_set?
+              if include_processors
+                to_include << klass
+              end
+              klass.foobara_manifest_reference
+              # TODO: Delete this nocov block
+              # TODO: make anonymous scoped path's have better names instead of random hexadecimal
+              # :nocov:
+            elsif processor.respond_to?(:symbol) && processor.symbol
+              processor.symbol
+            else
+              name = klass.name
+
+              while name.nil?
+                klass = klass.superclass
+                name = klass.name
+              end
+
+              "Anonymous#{Util.non_full_name(name)}"
+              # :nocov:
+            end
+          elsif processor.is_a?(::Proc)
+            "Proc"
+          else
+            # :nocov:
+            "Unknown"
+            # :nocov:
+          end
+        end
+      end
     end
 
     attr_accessor :command, :untransformed_inputs, :transformed_inputs, :outcome, :request
@@ -626,23 +628,6 @@ module Foobara
       request.authenticated_credential
     end
 
-    def transform_inputs
-      transformer = self.class.inputs_transformer
-
-      self.transformed_inputs = if transformer&.applicable?(untransformed_inputs)
-                                  outcome = transformer.process_value(untransformed_inputs)
-
-                                  if outcome.success?
-                                    outcome.result
-                                  else
-                                    self.outcome = outcome
-                                    untransformed_inputs
-                                  end
-                                else
-                                  untransformed_inputs
-                                end
-    end
-
     def inputs
       return @inputs if defined?(@inputs)
 
@@ -727,6 +712,60 @@ module Foobara
       end
     end
 
+    def result
+      outcome.result
+    end
+
+    def errors
+      outcome.errors
+    end
+
+    # TODO: kill this
+    def serialize_result(body)
+      if serializer
+        serializer.process_value!(body)
+      else
+        body
+      end
+    end
+
+    def raw_inputs
+      untransformed_inputs
+    end
+
+    def method_missing(method_name, ...)
+      if command.respond_to?(method_name)
+        command.send(method_name, ...)
+      else
+        # :nocov:
+        super
+        # :nocov:
+      end
+    end
+
+    def respond_to_missing?(method_name, private = false)
+      command.respond_to?(method_name, private) || super
+    end
+
+    private
+
+    def transform_inputs
+      transformer = self.class.inputs_transformer
+
+      self.transformed_inputs = if transformer&.applicable?(untransformed_inputs)
+                                  outcome = transformer.process_value(untransformed_inputs)
+
+                                  if outcome.success?
+                                    outcome.result
+                                  else
+                                    self.outcome = outcome
+                                    untransformed_inputs
+                                  end
+                                else
+                                  untransformed_inputs
+                                end
+    end
+
     def construct_command
       self.command = command_class.new(transformed_inputs)
     end
@@ -804,18 +843,6 @@ module Foobara
       end
     end
 
-    def result
-      outcome.result
-    end
-
-    def errors
-      outcome.errors
-    end
-
-    def flush_transactions
-      request.opened_transactions&.reverse&.each(&:flush!)
-    end
-
     def transform_outcome
       if outcome.success?
         # can we do this while still in the transaction of the command???
@@ -825,31 +852,8 @@ module Foobara
       end
     end
 
-    # TODO: kill this
-    def serialize_result(body)
-      if serializer
-        serializer.process_value!(body)
-      else
-        body
-      end
-    end
-
-    def raw_inputs
-      untransformed_inputs
-    end
-
-    def method_missing(method_name, ...)
-      if command.respond_to?(method_name)
-        command.send(method_name, ...)
-      else
-        # :nocov:
-        super
-        # :nocov:
-      end
-    end
-
-    def respond_to_missing?(method_name, private = false)
-      command.respond_to?(method_name, private) || super
+    def flush_transactions
+      request.opened_transactions&.reverse&.each(&:flush!)
     end
   end
 end

data/projects/command_connectors/src/transformers/load_atoms_transformer.rb

@@ -6,6 +6,8 @@ module Foobara
           load_atoms(object)
         end
 
+        private
+
         def load_atoms(object)
           case object
           when Entity

data/projects/command_connectors/src/transformers/load_delegated_attributes_entities_pre_commit_transformer.rb

@@ -14,6 +14,8 @@ module Foobara
           request
         end
 
+        private
+
         def load_delegated_attribute_entities(object)
           case object
           when Entity

data/projects/model_attribute_helpers/src/attribute_helpers.rb

@@ -18,7 +18,7 @@ module Foobara
       # foobara_primary_key_type (nil if not an entity type)
       # foobara_associations
       module AttributeHelpers
-        include Foobara::Concern
+        include Concern
 
         module ClassMethods
           def foobara_has_primary_key?
@@ -46,15 +46,15 @@ module Foobara
 
             Namespace.use foobara_attributes_type.created_in_namespace do
               unless includes_primary_key
-                declaration = Foobara::TypeDeclarations::Attributes.reject(declaration, foobara_primary_key_attribute)
+                declaration = TypeDeclarations::Attributes.reject(declaration, foobara_primary_key_attribute)
               end
 
               unless include_private
-                declaration = Foobara::TypeDeclarations::Attributes.reject(declaration, *private_attribute_names)
+                declaration = TypeDeclarations::Attributes.reject(declaration, *private_attribute_names)
               end
 
               unless include_delegates
-                declaration = Foobara::TypeDeclarations::Attributes.reject(declaration, *foobara_delegates.keys)
+                declaration = TypeDeclarations::Attributes.reject(declaration, *foobara_delegates.keys)
               end
 
               Domain.current.foobara_type_from_declaration(declaration)

data/projects/namespace/src/is_namespace.rb

@@ -181,7 +181,7 @@ module Foobara
 
           if candidates.size > 1
             # :nocov:
-            raise AmbiguousNameError,
+            raise AmbiguousLookupError,
                   "#{path} is ambiguous. Matches the following: #{candidates.map(&:scoped_full_name)}"
             # :nocov:
           end

data/projects/namespace/src/namespace/lookup_mode.rb

@@ -30,6 +30,12 @@ module Foobara
     # Maybe use bitmasks for the above 3 places to look instead of a list of 7 lookup types? (There should be 8...)
     module LookupMode
       GENERAL = :general
+      # Relaxed will allow you to find registered entries without prefixes as long as it's not ambiguous
+      # So if there is a SomeOrg::SomeDomain::SomeCommand `GlobalOrganization.foobara_lookup(:SomeCommand)`
+      # will return nil but
+      # `GlobalOrganization.foobara_lookup(:SomeCommand, mode: Foobara::Namespace::LookupMode::RELAXED)`
+      # will return SomeOrg::SomeDomain::SomeCommand even though we didn't specify the necessary prefixes
+      # to navigate to it.
       RELAXED = :relaxed
       DIRECT = :direct
       STRICT = :strict

data/projects/nested_transactionable/lib/foobara/nested_transactionable.rb

@@ -1,7 +1,5 @@
 module Foobara
   module NestedTransactionable
-    include Concern
-
     class << self
       def relevant_entity_classes_for_type(type)
         entity_classes = []

data/version.rb

@@ -1,6 +1,6 @@
 module Foobara
   module Version
-    VERSION = "0.2.7".freeze
+    VERSION = "0.3.0".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.7
+  version: 0.3.0
 platform: ruby
 authors:
 - Miles Georgi
@@ -190,6 +190,7 @@ files:
 - projects/command_connectors/src/command_connector/commands/ping.rb
 - projects/command_connectors/src/command_connector/commands/query_git_commit_info.rb
 - projects/command_connectors/src/command_connector/concerns/desugarizers.rb
+- projects/command_connectors/src/command_connector/concerns/reflection.rb
 - projects/command_connectors/src/command_connector/invalid_context_error.rb
 - projects/command_connectors/src/command_connector/no_command_found_error.rb
 - projects/command_connectors/src/command_connector/no_command_or_type_found_error.rb