foobara 0.5.6 → 0.5.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ea16151696626b19708aa3c7a211785a28b2a9a507b5ef882985bea42d87aa55
-  data.tar.gz: 32f4035f6239fc7d911baa3eaa1eefc9c064baa1d2848f3dd928d1d3a885ae70
+  metadata.gz: 7f3a7dee25a0ab1d7598ec72bbd71ec8807113d417cc758842cf4edd7b214d2a
+  data.tar.gz: f81bd84c70a9d41a8db414ee9424d5c2e2d9533887cfaa1ea0b436094873bc9a
 SHA512:
-  metadata.gz: 40adb5c61122aab04ced114b0d380e052e0994ff6177d703bb34071763e83ac1bf7bdfcf41c803d6350e72d0085b1ce61a4377294925013189464142ff1b0ab1
-  data.tar.gz: e9b55be0ed1beef28548794c3d383209ce1fa100cccb70fe46c604209300156687647a1f4fb3436fa38773c0e0381277b03cc61ef00442009b18fae713e71717
+  metadata.gz: 8819827dfdffb0ae2bef29f3bbbeb944cd3270cfd1a7938037d487373123ce50e2a8f832c5687c6b75ef8fd6e2ebd2016689e4b7208752a1f4a15bafa6eac10d
+  data.tar.gz: ba81595289f961c7c5f639d85fb16f7d05fe5b3d0aa3fcbeec1499030b7e56bbab75afc1cef58b6eafd5e6f115c3f2c4dbfb15ab29de8bc081095ccb4a8bd089

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+# [0.5.8] - 2026-03-04
+
+- Provide a way for allowed rules to be declared independently of connecting commands
+
+# [0.5.7] - 2026-02-25
+
+- Add a Manifest::Model.associations convenience method
+- Add Manifest::Tuple and various missing predicate methods
+- Add a query flag to the manifest
+
 # [0.5.6] - 2026-02-20
 
 - Introduce an official Query concept

data/projects/command_connectors/spec/allowed_rules_spec.rb

@@ -0,0 +1,77 @@
+RSpec.describe Foobara::CommandConnector do
+  after { Foobara.reset_alls }
+
+  let(:authenticator) { -> { :some_user } }
+
+  let(:response) { command_connector.run(full_command_name:, action:, inputs:) }
+  let(:parsed_response) { JSON.parse(response.body) }
+
+  let(:action) { "run" }
+  let(:full_command_name) { "ComputeExponent" }
+  let(:inputs) do
+    { base:, exponent: }
+  end
+
+  let(:command_class) do
+    stub_class(:ComputeExponent, Foobara::Command) do
+      inputs do
+        exponent :integer, :required
+        base :integer, :required
+      end
+
+      result :integer
+
+      attr_accessor :exponential
+
+      def execute
+        compute
+
+        exponential
+      end
+
+      def compute
+        self.exponential = 1
+
+        exponent.times do
+          self.exponential *= base
+        end
+      end
+    end
+  end
+
+  context "when independently setting the allowed rules" do
+    let(:command_connector) do
+      described_class.new(authenticator:,
+                          allow: { command_class => -> { base.even? } })
+    end
+
+    before do
+      command_connector.connect(command_class)
+    end
+
+    context "when allowed rule is met" do
+      let(:base) { 2 }
+      let(:exponent) { 3 }
+
+      it "runs the command" do
+        expect(response.status).to be(0)
+        expect(response.error).to be_nil
+        expect(response.body).to eq(8)
+      end
+    end
+
+    context "when allowed rule is not met" do
+      let(:base) { 3 }
+      let(:exponent) { 3 }
+
+      it "is not authorized" do
+        expect(response.status).to be(1)
+
+        errors = response.body
+
+        expect(errors.size).to eq(1)
+        expect(errors.first).to be_a(Foobara::CommandConnector::NotAllowedError)
+      end
+    end
+  end
+end

data/projects/command_connectors/src/authenticator_selector.rb

@@ -9,7 +9,7 @@ module Foobara
       def initialize(authenticators:, symbol: nil, explanation: nil, &block)
         self.authenticators = authenticators
 
-        symbol ||= authenticators.map(&:symbol).map(&:to_s).join("_or_").to_sym
+        symbol ||= authenticators.map(&:symbol).join("_or_").to_sym
         explanation ||= authenticators.map(&:explanation).join(", or ")
 
         super(symbol:, explanation:)

data/projects/command_connectors/src/command_connector.rb

@@ -199,7 +199,10 @@ module Foobara
                    default_pre_commit_transformers: nil,
                    auth_map: nil,
                    current_user: nil,
+                   # TODO: let's default this to true
                    requires_allowed_rule: false,
+                   allowed_rules: nil,
+                   allow: nil,
                    &block)
       authenticator = self.class.to_authenticator(authenticator)
 
@@ -216,6 +219,8 @@ module Foobara
 
       self.authenticator = authenticator
       self.command_registry = CommandRegistry.new(authenticator:)
+      allowed_rules&.each_pair { |symbol, rule| register_allowed_rule(symbol, rule) }
+      self.allow allow if allow
 
       self.capture_unknown_error = capture_unknown_error
       self.name = name
@@ -242,6 +247,10 @@ module Foobara
       end
     end
 
+    def allow(rules)
+      command_registry.allow rules
+    end
+
     def register_allowed_rule(*ruleish_args)
       command_registry.allowed_rule(*ruleish_args)
     end
@@ -632,7 +641,7 @@ module Foobara
     def run_command(request)
       command = request.command
 
-      if requires_allowed_rule
+      if requires_allowed_rule && command.is_a?(TransformedCommand) && command.class.requires_authentication != false
         unless command.allowed_rule
           raise NoAllowedRuleGivenError,
                 "Must connect #{command.full_command_name} with an `allowed_if:` " \

data/projects/command_connectors/src/command_registry.rb

@@ -9,9 +9,10 @@ module Foobara
     # Should we support different authenticators for different commands?
     # Might be a smell of two domains co-habitating in one? Or maybe one is just
     # passing another through and we should support that?
-    def initialize(authenticator: nil)
+    def initialize(authenticator: nil, allow: nil)
       self.scoped_path = []
       self.authenticator = authenticator
+      self.allow allow if allow
 
       customized = [:command]
 
@@ -193,15 +194,29 @@ module Foobara
       foobara_all_command.size
     end
 
+    def allow(rules = (no_args = true))
+      @allow ||= {}
+
+      if no_args
+        @allow
+      else
+        @allow = @allow.merge(rules)
+      end
+    end
+
     private
 
-    def create_exposed_command(command_class, **)
+    def create_exposed_command(command_class, **opts)
       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, **)
+      if !opts.key?(:allowed_rule) && allow&.key?(command_class)
+        opts = opts.merge(allowed_rule: allow[command_class])
+      end
+
+      exposed_command = create_exposed_command_without_domain(command_class, **opts)
 
       exposed_domain.foobara_register(exposed_command)
 
@@ -292,7 +307,7 @@ module Foobara
       errors_transformers: nil,
       pre_commit_transformers: nil,
       serializers: nil,
-      allowed_rule: default_allowed_rule,
+      allowed_rule: nil,
       authenticator: nil,
       **opts
     )

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

@@ -251,13 +251,11 @@ module Foobara
                 contains_associations?(element_type, false)
               end
             elsif type.extends?(BuiltinTypes[:attributes])
-
               type.element_types&.values&.any? do |element_type|
                 if !remove_sensitive || !element_type.sensitive?
                   contains_associations?(element_type, false)
                 end
               end
-
             elsif type.extends?(BuiltinTypes[:associative_array])
               element_types = type.element_types
 

data/projects/entities/projects/model/src/extensions/type_declarations/handlers/extend_model_type_declaration/symbolize_private.rb

@@ -18,7 +18,7 @@ module Foobara
           def desugarize(rawish_type_declaration)
             private = rawish_type_declaration[:private]
 
-            if private.any? { |key| key.is_a?(::String) }
+            if private.any?(::String)
               rawish_type_declaration[:private] = private.map(&:to_sym)
             end
 

data/projects/manifest/spec/associations_spec.rb

@@ -0,0 +1,67 @@
+# TODO: Get this out of here and into model project
+RSpec.describe Foobara::Manifest::Model do
+  after { Foobara.reset_alls }
+
+  describe ".associations" do
+    context "when the type has associations" do
+      before do
+        stub_class "SomeInnerInnerEntity", Foobara::Entity do
+          attributes do
+            id :integer
+            bar :string, :required
+          end
+          primary_key :id
+        end
+
+        stub_class "SomeOuterModel", Foobara::Model do
+          attributes do
+            some_inner_inner_entities [:SomeInnerInnerEntity, :SomeInnerInnerEntity]
+          end
+        end
+
+        stub_class("SomeInnerEntity", Foobara::Entity) do
+          attributes do
+            id :integer
+            foo :string, :required
+          end
+
+          primary_key :id
+        end
+
+        stub_class("SomeOuterEntity", Foobara::Entity) do
+          attributes do
+            id :integer
+            some_inner_entity :SomeInnerEntity
+          end
+
+          primary_key :id
+        end
+
+        Foobara::GlobalDomain.foobara_register_type(:some_type) do
+          some_array [SomeOuterEntity]
+          some_inner_model :SomeOuterModel
+        end
+      end
+
+      it "can reproduce association info from the underlying associations in the types" do
+        raw_manifest = Foobara.manifest
+
+        root_manifest = Foobara::Manifest::RootManifest.new(raw_manifest)
+
+        manifest_type = root_manifest.type_by_name(:some_type)
+
+        expect(manifest_type).to be_a(Foobara::Manifest::Type)
+
+        associations = described_class.associations(manifest_type)
+
+        expect(associations.keys).to contain_exactly(
+          "some_array.#",
+          "some_inner_model.some_inner_inner_entities.0",
+          "some_inner_model.some_inner_inner_entities.1"
+        )
+
+        expect(associations.values).to all be_a(Foobara::Manifest::Entity)
+      end
+    end
+  end
+end

data/projects/manifest/spec/manifest_spec.rb

@@ -71,7 +71,7 @@ RSpec.describe Foobara::Manifest do
       primary_key :id
     end
 
-    stub_class "SomeOrg::SomeDomain::QueryUser", Foobara::Command
+    stub_class "SomeOrg::SomeDomain::QueryUser", Foobara::Query
     stub_class "SomeOrg::SomeDomain::QueryUser::SomethingWentWrongError", Foobara::RuntimeError do
       class << self
         def context_type_declaration
@@ -259,8 +259,11 @@ RSpec.describe Foobara::Manifest do
     expect(attributes.sensitive).to be_falsey
     expect(attributes.sensitive_exposed).to be_falsey
 
+    expect(manifest.queries.map(&:command_name)).to contain_exactly("QueryUser")
+
     command = manifest.command_by_name("SomeOrg::SomeDomain::QueryUser")
 
+    expect(command).to be_query
     expect(command).to be_a(Foobara::Manifest::Command)
     expect(command.scoped_category).to eq(:command)
     expect(command.parent_category).to eq(:domain)

data/projects/manifest/spec/type_spec.rb

@@ -0,0 +1,30 @@
+RSpec.describe Foobara::Manifest::Type do
+  after { Foobara.reset_alls }
+
+  context "when it's an associative array" do
+    before do
+      Foobara::GlobalDomain.foobara_register_type(:some_type,
+                                                  type: :associative_array,
+                                                  value_type_declaration: :string,
+                                                  key_type_declaration: :integer)
+    end
+
+    describe "#associative_array?" do
+      it "is true" do
+        root_manifest = Foobara::Manifest::RootManifest.new(Foobara.manifest)
+        expect(root_manifest.type_by_name(:some_type)).to be_associative_array
+      end
+    end
+
+    describe "#to_type_declaration_from_declaration_data" do
+      it "gives an associative_array declaration" do
+        root_manifest = Foobara::Manifest::RootManifest.new(Foobara.manifest)
+        type = root_manifest.type_by_name(:some_type)
+        declaration = type.to_type_declaration_from_declaration_data
+
+        expect(declaration).to be_a(Foobara::Manifest::TypeDeclaration)
+        expect(declaration).to be_associative_array
+      end
+    end
+  end
+end

data/projects/manifest/src/base_manifest.rb

@@ -69,8 +69,6 @@ module Foobara
       end
 
       def domain
-        domain_reference = self[:domain]
-
         Domain.new(root_manifest, [:domain, domain_reference])
       end
 

data/projects/manifest/src/command.rb

@@ -21,6 +21,10 @@ module Foobara
         scoped_full_name
       end
 
+      def query?
+        self[:is_query]
+      end
+
       def inputs_type
         Attributes.new(root_manifest, [*manifest_path, :inputs_type])
       end

data/projects/manifest/src/model.rb

@@ -3,6 +3,44 @@ require_relative "type"
 module Foobara
   module Manifest
     class Model < Type
+      class << self
+        def associations(type, path = DataPath.new, result = {}, initial: true)
+          if type.detached_entity? && !initial
+            type = type.to_type if type.is_a?(TypeDeclaration)
+            result[path.to_s] = type
+          elsif type.model?
+            type = type.to_type if type.is_a?(TypeDeclaration)
+            associations(type.attributes_type, path, result, initial: false)
+          elsif type.tuple?
+            type = type.to_type_declaration_from_declaration_data if type.is_a?(Type)
+            type.element_types&.each&.with_index do |element_type, index|
+              associations(element_type, path.append(index), result, initial: false)
+            end
+          elsif type.array?
+            type = type.to_type_declaration_from_declaration_data if type.is_a?(Type)
+            element_type = type.element_type
+
+            if element_type
+              associations(element_type, path.append(:"#"), result, initial: false)
+            end
+          elsif type.attributes?
+            type = type.to_type_declaration_from_declaration_data if type.is_a?(Type)
+            type.attribute_declarations.each_pair do |attribute_name, element_type|
+              associations(element_type, path.append(attribute_name), result, initial: false)
+            end
+          # :nocov:
+          elsif type.associative_array?
+            if contains_associations?(type)
+              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
+          end
+          # :nocov:
+
+          result
+        end
+      end
+
       self.category_symbol = :type
 
       optional_keys :delegates

data/projects/manifest/src/root_manifest.rb

@@ -25,6 +25,10 @@ module Foobara
         organizations.map(&:commands).flatten
       end
 
+      def queries
+        commands.select(&:query?)
+      end
+
       def types
         @types ||= DataPath.value_at(:type, root_manifest).keys.map do |reference|
           Type.new(root_manifest, [:type, reference])

data/projects/manifest/src/tuple.rb

@@ -0,0 +1,15 @@
+require_relative "type_declaration"
+
+module Foobara
+  module Manifest
+    class Tuple < TypeDeclaration
+      alias tuple_manifest relevant_manifest
+
+      def element_types
+        @element_types ||= (0...element_type_declarations.size).map do |index|
+          TypeDeclaration.new(root_manifest, [*manifest_path, :element_type_declarations, index])
+        end
+      end
+    end
+  end
+end

data/projects/manifest/src/type.rb

@@ -38,6 +38,22 @@ module Foobara
         !builtin? && extends_symbol?(:model)
       end
 
+      def array?
+        !builtin? && extends_symbol?(:array)
+      end
+
+      def attributes?
+        !builtin? && extends_symbol?(:attributes)
+      end
+
+      def associative_array?
+        !builtin? && extends_symbol?(:associative_array)
+      end
+
+      def tuple?
+        !builtin? && extends_symbol?(:tuple)
+      end
+
       def base_type
         base_type_symbol = self[:base_type]
 

data/projects/manifest/src/type_declaration.rb

@@ -15,6 +15,8 @@ module Foobara
               Attributes.new(type_declaration.root_manifest, type_declaration.manifest_path)
             when :array
               Array.new(type_declaration.root_manifest, type_declaration.manifest_path)
+            when :tuple
+              Tuple.new(type_declaration.root_manifest, type_declaration.manifest_path)
             else
               type_declaration
             end
@@ -82,6 +84,14 @@ module Foobara
         type.to_sym == :array
       end
 
+      def tuple?
+        type.to_sym == :tuple
+      end
+
+      def associative_array?
+        type.to_sym == :associative_array
+      end
+
       def model?
         return @model if defined?(@model)
 

data/projects/typesystem/projects/common/src/error_collection.rb

@@ -83,9 +83,13 @@ module Foobara
     end
 
     def errors_hash
-      each_with_object({}) do |error, hash|
-        hash[error.key] = error.to_h
+      h = {}
+
+      each do |error|
+        h[error.key] = error.to_h
       end
+
+      h
     end
 
     def to_sentence

data/version.rb

@@ -1,6 +1,6 @@
 module Foobara
   module Version
-    VERSION = "0.5.6".freeze
+    VERSION = "0.5.8".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.5.6
+  version: 0.5.8
 platform: ruby
 authors:
 - Miles Georgi
@@ -106,6 +106,7 @@ files:
 - projects/command/src/state_machine.rb
 - projects/command_connectors/Guardfile
 - projects/command_connectors/lib/foobara/command_connectors.rb
+- projects/command_connectors/spec/allowed_rules_spec.rb
 - projects/command_connectors/spec/ambiguous_lookups_spec.rb
 - projects/command_connectors/spec/auth_mappers_spec.rb
 - projects/command_connectors/spec/command_connector_spec.rb
@@ -340,10 +341,12 @@ files:
 - projects/entities_plumbing/src/extensions/authenticator.rb
 - projects/manifest/Guardfile
 - projects/manifest/lib/foobara/manifest.rb
+- projects/manifest/spec/associations_spec.rb
 - projects/manifest/spec/manifest_spec.rb
 - projects/manifest/spec/model_spec.rb
 - projects/manifest/spec/spec_helper.rb
 - projects/manifest/spec/type_declaration_spec.rb
+- projects/manifest/spec/type_spec.rb
 - projects/manifest/src/array.rb
 - projects/manifest/src/attributes.rb
 - projects/manifest/src/base_manifest.rb
@@ -358,6 +361,7 @@ files:
 - projects/manifest/src/processor.rb
 - projects/manifest/src/processor_class.rb
 - projects/manifest/src/root_manifest.rb
+- projects/manifest/src/tuple.rb
 - projects/manifest/src/type.rb
 - projects/manifest/src/type_declaration.rb
 - projects/model_plumbing/lib/foobara/model_plumbing.rb