pact_broker 2.122.0 → 2.124.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f515fab91233eb259d233ef8ff18b35014c55dfebb10a5cec183283bbe760d54
-  data.tar.gz: 2f35f5f3f748d3df875df0ce5b8270f2b1e4b2cf8682804fda41def6d31b88a1
+  metadata.gz: 3a0262f7dd8bce1f0c350ce3ec9b2b6920e8e36ec672bc34c327cd24adfaaf6a
+  data.tar.gz: b3a306b5074d7370d6693f4c5d4219a0c4a069a304035226eff502d6bd9ed3f6
 SHA512:
-  metadata.gz: 6eaefdf8cd5b2b9856bb076579bf034889b7fdab56cfe159c6e1ed56e74d72dca7929ca983290238e32f280e8d7e9b9bc53b9512b4d1562bde122de035e2f50b
-  data.tar.gz: fe3c3008fa385b8585d7b2faa08e8196194e92fdfc496a813f0208373905abacdcded76e0eb4b8dc115b588b20be7e5cd32580ec78c4cbddfc7db15222936b73
+  metadata.gz: 6d363ce226b34c06e1cf6659d876c4699900598c6df64d9f5bc8c06a5a4b3d514431f4873307d71189fcfd5cd992f8caf582b26af92d2c5bc36cc61ad50a4a17
+  data.tar.gz: dcbce49bf421fb8f0294aba8bdf22be64d49e23f74a671531d9bf802717aefdbc58b154b4bfcc02a84e7fcd00709626e898a492f07c7cdd10e30b3d894398f38

data/CHANGELOG.md

@@ -1,3 +1,56 @@
+## [2.124.0] _2026-11-11_
+
+### 🚀 Features
+
+-   _(matrix)_ Add matrix_max_limit to cap the matrix query limit
+
+### 🐛 Bug Fixes
+
+-   _(matrix)_ Support an environment in a selector alongside a version or latest
+
+## [2.123.0] _2026-11-11_
+
+### 🚀 Features
+
+-   Add fallbackToMainBranch consumer version selector option
+
+### 🐛 Bug Fixes
+
+-   Stop the consumer version verification summary querying per verification
+-   Apply fallbackTag per consumer
+-   Honour fallbackBranch in consumer version selectors
+
+### 🚜 Refactor
+
+-   Name the fallback resolver for tags and branches
+
+### ⚡️ Performance
+
+-   Speed up publishing large contracts (PACT-7601) ([#1067](https://github.com/pact-foundation/pact_broker/issues/1067))
+    > **Migration note:** when contracts are published with /contracts/publish,
+    > the configured sha_generator is now called with a second argument,
+-   Exclude consumers in the fallback tag query
+-   Exclude consumers in the fallback branch query
+
+### 📚 Documentation
+
+-   Say fallbackTag applies per consumer
+-   Say fallbackBranch applies per consumer
+
+### 🧪 Testing
+
+-   Share one SQL query counter across feature specs
+-   Pin fallbackTag semantics in a table
+-   Cover fallbackTag dedup, branches and notices
+-   Pin fallbackBranch semantics in a table
+-   Cover the fallbackBranch request and notices end to end
+-   Pin fallbackToMainBranch semantics in the fallback branch table
+-   Cover the fallbackToMainBranch request and notices end to end
+
+### 🛠️ Miscellaneous Tasks
+
+-   Drop a TODO the selector contract already resolves
+
 ## [2.122.0] _2026-10-01_
 
 ### 🚀 Features

data/docs/CONFIGURATION.md

@@ -703,6 +703,18 @@ and at large numbers, the graph will not render due to browser performance issue
 **Default:** `150`<br/>
 **Allowed values:** A positive integer<br/>
 
+### matrix_max_limit
+
+The maximum value accepted for the `limit` parameter of a matrix query (`/matrix`).
+A request with a larger `limit` is rejected with a 400 response. Very large limits can cause expensive database queries.
+When not set, there is no maximum. A matrix query without a `limit` uses a limit of 100,
+so the value must be 100 or greater, or the Pact Broker will not start.
+
+**Environment variable name:** `PACT_BROKER_MATRIX_MAX_LIMIT`<br/>
+**YAML configuration key name:** `matrix_max_limit`<br/>
+**Default:** No maximum<br/>
+**Allowed values:** An integer of 100 or greater<br/>
+
 <br/>
 
 ## Miscellaneous

data/lib/pact_broker/api/contracts/consumer_version_selector_contract.rb

@@ -6,7 +6,7 @@ module PactBroker
       class ConsumerVersionSelectorContract < BaseContract
         option :parent # the parent hash in which the ConsumerVersionSelector is embedded
 
-        BRANCH_KEYS = [:latest, :tag, :fallbackTag, :branch, :fallbackBranch, :matchingBranch, :mainBranch]
+        BRANCH_KEYS = [:latest, :tag, :fallbackTag, :branch, :fallbackBranch, :fallbackToMainBranch, :matchingBranch, :mainBranch]
         ENVIRONMENT_KEYS = [:environment, :deployed, :released, :deployedOrReleased]
         ALL_KEYS = BRANCH_KEYS + ENVIRONMENT_KEYS + [:consumer]
 
@@ -18,6 +18,7 @@ module PactBroker
           optional(:latest).filled(included_in?: [true, false])
           optional(:fallbackTag).filled(:str?)
           optional(:fallbackBranch).filled(:str?)
+          optional(:fallbackToMainBranch).filled(included_in?: [true])
           optional(:consumer).filled(:str?)
           optional(:deployed).filled(included_in?: [true])
           optional(:released).filled(included_in?: [true])
@@ -108,6 +109,21 @@ module PactBroker
           end
         end
 
+        # fallbackToMainBranch
+        rule(:fallbackToMainBranch, :fallbackBranch, :branch, :latest) do
+          if values[:fallbackToMainBranch] && !values[:branch]
+            base.failure(validation_message("pacts_for_verification_selector_fallback_to_main_branch_requires_branch"))
+          end
+
+          if values[:fallbackToMainBranch] && values[:fallbackBranch]
+            base.failure(validation_message("pacts_for_verification_selector_fallback_to_main_branch_and_fallback_branch_disallowed"))
+          end
+
+          if values[:fallbackToMainBranch] && values[:latest] == false
+            base.failure(validation_message("pacts_for_verification_selector_fallback_to_main_branch_and_latest_false_disallowed"))
+          end
+        end
+
         # branch/latest
         rule(:branch, :latest) do
           if values[:branch] && values[:latest] == false

data/lib/pact_broker/api/contracts/utf_8_validation.rb

@@ -5,7 +5,11 @@ module PactBroker
         extend self
 
         def fragment_before_invalid_utf_8_char(string)
-          string.force_encoding("UTF-8").each_char.with_index do | char, index |
+          # Iterating over each char allocates a String per char, which is very slow for large strings,
+          # so only do it to find the location of the invalid char once we know there is one.
+          return nil if string.force_encoding("UTF-8").valid_encoding?
+
+          string.each_char.with_index do | char, index |
             if !char.valid_encoding?
               fragment = index < 100 ? string[0...index] : string[index-100...index]
               return index + 1, fragment

data/lib/pact_broker/api/decorators/pacts_for_verification_query_decorator.rb

@@ -34,6 +34,7 @@ module PactBroker
             }
           property :fallback_tag
           property :fallback_branch
+          property :fallback_to_main_branch
           property :consumer
           property :environment_name, as: :environment
           property :currently_deployed, as: :deployed

data/lib/pact_broker/api/decorators/publish_contract_decorator.rb

@@ -11,10 +11,11 @@ module PactBroker
         property :provider_name
         property :specification
         property :content_type
-        property :decoded_content, setter: -> (fragment:, represented:, user_options:, **) {
+        property :decoded_content, setter: -> (fragment:, represented:, user_options:, doc:, **) {
           represented.decoded_content = fragment
-          # Set the pact version sha when we set the content
-          represented.pact_version_sha = user_options.fetch(:sha_generator).call(fragment)
+          # Set the pact version sha when we set the content, reusing the content that has already been
+          # parsed in the resource, as parsing very large pacts is expensive
+          represented.pact_version_sha = user_options.fetch(:sha_generator).call(fragment, parsed_content: doc["decodedParsedContent"])
         }
         property :on_conflict, default: "overwrite"
 

data/lib/pact_broker/api/decorators/verification_decorator.rb

@@ -24,7 +24,7 @@ module PactBroker
         end
 
         link :self do | options |
-          pact = options[:pact] || represented.latest_pact_publication
+          pact = pact_for(options)
           {
             title: "Verification result",
             name: "Verification result #{represented.number} for #{pact.name}",
@@ -33,7 +33,7 @@ module PactBroker
         end
 
         link "pb:pact-version" do | options |
-          pact = options[:pact] || represented.latest_pact_publication
+          pact = pact_for(options)
           {
             title: "Pact",
             name: pact.name,
@@ -47,6 +47,16 @@ module PactBroker
             href: verification_triggered_webhooks_url(represented, options.fetch(:base_url))
           }
         end
+
+        private
+
+        # A decorator rendering many verifications passes :pacts_by_pact_version_sha
+        # so each one avoids its own lookup.
+        def pact_for(options)
+          options[:pact] ||
+            options[:pacts_by_pact_version_sha]&.[](represented.pact_version_sha) ||
+            represented.latest_pact_publication
+        end
       end
     end
   end

data/lib/pact_broker/api/decorators/verification_summary_decorator.rb

@@ -25,6 +25,12 @@ module PactBroker
           }
         end
 
+        # representable passes through the kwargs from to_json as normal args
+        def to_hash(options)
+          user_options = options.fetch(:user_options, {}).merge(pacts_by_pact_version_sha: represented.pacts_by_pact_version_sha)
+          super(options.merge(user_options: user_options))
+        end
+
         def provider_summary
           OpenStruct.new(
             successful: represented.select(&:success).collect(&:provider_name),

data/lib/pact_broker/api/resources/publish_contracts.rb

@@ -56,16 +56,20 @@ module PactBroker
           @parsed_contracts ||= decorator_class(:publish_contracts_decorator).new(PactBroker::Contracts::ContractsToPublish.new).from_hash(params, { user_options: { sha_generator: PactBroker.configuration.sha_generator } } )
         end
 
+        # Memoized because decoding and parsing very large contracts is expensive,
+        # and this is called multiple times per request (validation, authorization and publication)
         def params
-          p = super(default: {}, symbolize_names: false)
-          if p["contracts"].is_a?(Array)
-            p["contracts"].each do | contract |
-              if contract.is_a?(Hash)
-                decode_and_parse_content(contract)
+          @params_with_decoded_contracts ||= begin
+            p = super(default: {}, symbolize_names: false)
+            if p["contracts"].is_a?(Array)
+              p["contracts"].each do | contract |
+                if contract.is_a?(Hash)
+                  decode_and_parse_content(contract)
+                end
               end
             end
+            p
           end
-          p
         end
 
         def schema

data/lib/pact_broker/config/runtime_configuration.rb

@@ -20,6 +20,7 @@ require "pact_broker/config/runtime_configuration_basic_auth_methods"
 require "pact_broker/string_refinements"
 require "pact_broker/hash_refinements"
 require "pact_broker/error"
+require "pact_broker/matrix/parse_query"
 
 module PactBroker
   module Config
@@ -97,9 +98,12 @@ module PactBroker
         semver_formats: ["%M.%m.%p%s%d", "%M.%m", "%M"],
         seed_example_data: true,
         network_diagram_max_pacticipants: 150,
+        matrix_max_limit: nil,
         features: {}
       )
 
+      on_load :validate_matrix_max_limit!
+
       def self.getter_and_setter_method_names
         extra_methods = [
           :warning_error_classes,
@@ -114,6 +118,7 @@ module PactBroker
       coerce_types(
         features: COERCE_FEATURES,
         network_diagram_max_pacticipants: :integer,
+        matrix_max_limit: :integer,
         webhook_certificates: COERCE_WEBHOOKS
       )
       sensitive_values(:database_url, :database_password)
@@ -226,6 +231,16 @@ module PactBroker
         end
       end
 
+      # A matrix query without a limit gets the default limit, so a lower matrix_max_limit
+      # would reject every request that does not set one.
+      # An empty or non-numeric value is coerced to 0, so it is rejected here too.
+      def validate_matrix_max_limit!
+        default_limit = PactBroker::Matrix::ParseQuery::DEFAULT_LIMIT
+        if matrix_max_limit && matrix_max_limit < default_limit
+          raise_validation_error("matrix_max_limit must be at least the default matrix limit (#{default_limit}), or not set")
+        end
+      end
+
       def raise_validation_error(msg)
         raise PactBroker::ConfigurationError, msg
       end

data/lib/pact_broker/doc/views/provider-pacts-for-verification.markdown

@@ -32,7 +32,15 @@ Example: This data structure represents the way a user might specify "I want to
 
 `consumerVersionSelectors.matchingBranch`: if the key is specified, can only be set to `true`. When true, returns the latest pact for any branch with the same name as the specified `providerVersionBranch`.
 
-`consumerVersionSelectors.fallbackBranch`: the name of the branch to fallback to if the specified `branch` does not exist. Use of this property is discouraged as it may allow a pact to pass on a feature branch while breaking backwards compatibility with the main branch, which is generally not desired. It is better to use two separate consumer version selectors, one with the main branch name, and one with the feature branch name, rather than use this property.
+`consumerVersionSelectors.fallbackBranch`: the name of the branch to fall back to for each consumer that has no pact from the specified `branch`. Use of this property is discouraged as it may allow a pact to pass on a feature branch while breaking backwards compatibility with the main branch, which is generally not desired. It is better to use two separate consumer version selectors, one with the main branch name, and one with the feature branch name, rather than use this property.
+
+`consumerVersionSelectors.fallbackToMainBranch`: if the key is specified, can only be set to `true`. Used with `branch`. For each consumer that has no pact for the specified `branch`, returns the latest pact from that consumer's configured `mainBranch` instead. Consumers without a configured `mainBranch` have no fallback. Use this instead of `fallbackBranch` when the consumers have different main branch names, or when a main branch may be renamed, so the provider does not need to know the name. It cannot be used together with `fallbackBranch`. The same caveat as `fallbackBranch` applies.
+
+    {
+      "consumerVersionSelectors": [
+        { "branch": "feat-x", "fallbackToMainBranch": true }
+      ]
+    }
 
 `consumerVersionSelectors.deployed`: if the key is specified, can only be set to `true`. Returns the pacts for all versions of the consumer that are currently deployed to any environment. Use of this selector requires that the deployment of the consumer application is recorded in the Pact Broker using the `pact-broker record-deployment` CLI.
 
@@ -48,7 +56,7 @@ Example: This data structure represents the way a user might specify "I want to
 
 `consumerVersionSelectors.tag`: the tag name(s) of the consumer versions to get the pacts for. *This field is still supported but it is recommended to use the `branch` in preference now.*
 
-`consumerVersionSelectors.fallbackTag`: the name of the tag to fallback to if the specified `tag` does not exist. This is useful when the consumer and provider use matching branch names to coordinate the development of new features. *This field is still supported but it is recommended to use two separate selectors - one with the main branch name and one with the feature branch name.*
+`consumerVersionSelectors.fallbackTag`: the name of the tag to fall back to for each consumer that has no pact with the specified `tag`. This is useful when the consumer and provider use matching branch names to coordinate the development of new features. *This field is still supported but it is recommended to use two separate selectors - one with the main branch name and one with the feature branch name.*
 
 `providerVersionBranch`: the repository branch name for the provider application version that will be published with the verification results. This is used by the Broker to determine whether or not a particular pact is in pending state or not.
 

data/lib/pact_broker/domain/version.rb

@@ -85,20 +85,24 @@ module PactBroker
           # end
         end
 
+        # Filters on a UNION of version ids so the versions dataset stays unwrapped for later criteria.
+        # An OR of two IN subqueries is equivalent, but cannot use the versions primary key index.
         def currently_in_environment(environment_name, pacticipant_name)
-          currently_deployed_to_environment(environment_name, pacticipant_name).union(currently_supported_in_environment(environment_name, pacticipant_name))
+          version_ids = version_ids_currently_deployed_to_environment(environment_name, pacticipant_name)
+                          .union(version_ids_currently_supported_in_environment(environment_name, pacticipant_name), from_self: false)
+          where(Sequel[:versions][:id] => version_ids)
         end
 
-        def currently_deployed_to_environment(environment_name, pacticipant_name)
+        def version_ids_currently_deployed_to_environment(environment_name, pacticipant_name)
           deployed_version_query = PactBroker::Deployments::DeployedVersion.currently_deployed.for_environment_name(environment_name)
           deployed_version_query = deployed_version_query.for_pacticipant_name(pacticipant_name) if pacticipant_name
-          where(id: deployed_version_query.select(:version_id))
+          deployed_version_query.select(:version_id)
         end
 
-        def currently_supported_in_environment(environment_name, pacticipant_name)
+        def version_ids_currently_supported_in_environment(environment_name, pacticipant_name)
           supported_version_query = PactBroker::Deployments::ReleasedVersion.currently_supported.for_environment_name(environment_name)
           supported_version_query = supported_version_query.for_pacticipant_name(pacticipant_name) if pacticipant_name
-          where(id: supported_version_query.select(:version_id))
+          supported_version_query.select(:version_id)
         end
 
         def currently_deployed

data/lib/pact_broker/hash_refinements.rb

@@ -80,8 +80,8 @@ module PactBroker
       def symbolize_keys_private(params)
         case params
         when Hash
-          params.inject({}) do |result, (key, value)|
-            result.merge(key.to_sym => symbolize_keys_private(value))
+          params.each_with_object({}) do |(key, value), result|
+            result[key.to_sym] = symbolize_keys_private(value)
           end
         when Array
           params.collect { |value| symbolize_keys_private(value) }

data/lib/pact_broker/locale/en.yml

@@ -97,6 +97,7 @@ en:
         cannot_set_currently_deployed_true: The currentlyDeployed property cannot be set back to true. Please record a new deployment.
         cannot_set_currently_supported_true: The currentlySupported property cannot be set back to true. Please record a new deployment.
         invalid_limit: The limit must be 1 or greater.
+        matrix_limit_exceeds_maximum: "The limit must be %{max_limit} or less."
         pacts_for_verification_selector_fallback_tag: "fallbackTag can only be set if latest is true"
         pacts_for_verification_selector_matching_branch_requires_provider_version_branch: the providerVersionBranch must be specified when the selector matchingBranch=true is used
         pacts_for_verification_selector_tag_and_branch_disallowed: "cannot specify both a tag and a branch"
@@ -105,6 +106,9 @@ en:
         pacts_for_verification_selector_branch_and_latest_false_disallowed: cannot specify a branch with latest=false
         pacts_for_verification_selector_main_branch_and_latest_false_disallowed: cannot specify mainBranch=true with latest=false
         pacts_for_verification_selector_fallback_branch_and_latest_false_disallowed: fallbackBranch can only be set if latest is true
+        pacts_for_verification_selector_fallback_to_main_branch_requires_branch: "a branch must be specified when fallbackToMainBranch=true is specified"
+        pacts_for_verification_selector_fallback_to_main_branch_and_fallback_branch_disallowed: cannot specify both fallbackBranch and fallbackToMainBranch=true
+        pacts_for_verification_selector_fallback_to_main_branch_and_latest_false_disallowed: fallbackToMainBranch can only be set if latest is true
         pacts_for_verification_selector_required_params_missing: must specify a value for environment or tag or branch, or specify mainBranch=true, matchingBranch=true, latest=true, deployed=true, released=true or deployedOrReleased=true
         pacts_for_verification_selector_main_branch_with_other_param_disallowed: cannot specify mainBranch=true with any other criteria apart from consumer
         pacts_for_verification_selector_matching_branch_with_other_param_disallowed: cannot specify matchingBranch=true with any other criteria apart from consumer

data/lib/pact_broker/matrix/parse_query.rb

@@ -4,6 +4,8 @@ require "pact_broker/matrix/unresolved_selector"
 module PactBroker
   module Matrix
     class ParseQuery
+      DEFAULT_LIMIT = 100
+
       # rubocop: disable Metrics/CyclomaticComplexity
       # rubocop: disable Metrics/MethodLength
       def self.call query
@@ -34,7 +36,7 @@ module PactBroker
         if params.key?("limit") && params["limit"] != ""
           options[:limit] = params["limit"]
         else
-          options[:limit] = "100"
+          options[:limit] = DEFAULT_LIMIT.to_s
         end
 
         if params.key?("latest") && params["latest"] != ""

data/lib/pact_broker/matrix/service.rb

@@ -140,6 +140,11 @@ module PactBroker
           error_messages << message("errors.validation.invalid_limit")
         end
 
+        max_limit = PactBroker.configuration.matrix_max_limit
+        if max_limit && options[:limit] && options[:limit].to_i > max_limit
+          error_messages << message("errors.validation.matrix_limit_exceeds_maximum", max_limit: max_limit)
+        end
+
         error_messages
       end
       # rubocop: enable Metrics/CyclomaticComplexity

data/lib/pact_broker/pacts/generate_sha.rb

@@ -11,17 +11,20 @@ module PactBroker
       include PactBroker::Logging
 
       # @param [String] json_content
-      def self.call(json_content, _options = {})
+      # @param [Hash] options
+      # @option options [Hash] :parsed_content the result of parsing the json_content, if it has already been parsed.
+      #   Used to avoid parsing very large pacts again. Must be the parsed json_content, or the sha will be wrong.
+      def self.call(json_content, options = {})
         content_for_sha = if PactBroker.configuration.base_equality_only_on_content_that_affects_verification_results
-                            extract_verifiable_content_for_sha(json_content)
+                            extract_verifiable_content_for_sha(json_content, options[:parsed_content])
                           else
                             json_content
                           end
         measure_info("Generating SHA1 hexdigest for pact", payload: { length: content_for_sha.length } ){ Digest::SHA1.hexdigest(content_for_sha) }
       end
 
-      def self.extract_verifiable_content_for_sha(json_content)
-        objects = Content.from_json(json_content)
+      def self.extract_verifiable_content_for_sha(json_content, parsed_content = nil)
+        objects = parsed_content.is_a?(Hash) ? Content.from_hash(parsed_content) : Content.from_json(json_content)
         sorted_content = measure_info("Sorting content", payload: { length: json_content.length }){ objects.sort }
         sorted_content.content_that_affects_verification_results.to_json
       end

data/lib/pact_broker/pacts/pacts_for_verification_repository.rb

@@ -28,7 +28,9 @@ module PactBroker
       # @return [VerifiablePact] an array of VerifiablePact objects
       def find(provider_name, consumer_version_selectors)
         selected_pacts = find_pacts_by_selector(provider_name, consumer_version_selectors)
-        selected_pacts = selected_pacts + find_pacts_for_fallback_tags(selected_pacts, provider_name, consumer_version_selectors)
+        selected_pacts = selected_pacts +
+          find_pacts_for_fallback_tags(selected_pacts, provider_name, consumer_version_selectors) +
+          find_pacts_for_fallback_branches(selected_pacts, provider_name, consumer_version_selectors)
         merge_selected_pacts(selected_pacts)
       end
 
@@ -178,22 +180,32 @@ module PactBroker
         end
       end
 
+      # The fallback is applied per consumer, so a consumer without a pact for the tag
+      # still gets its fallback pact when another consumer does have a pact for the tag.
       def find_pacts_for_fallback_tags(selected_pacts, provider_name, consumer_version_selectors)
-        # TODO at the moment, the validation doesn't stop fallback being used with 'all' selectors
-        selectors_with_fallback_tags = consumer_version_selectors.select(&:fallback_tag?)
-        selectors_missing_a_pact = selectors_with_fallback_tags.reject do | selector |
-          selected_pacts.any? do | selected_pact |
-            selected_pact.latest_for_tag?(selector.tag)
+        consumer_version_selectors.select(&:fallback_tag?).flat_map do | selector |
+          consumer_ids_with_a_pact_for_the_tag = consumer_ids_of(selected_pacts.select { | selected_pact | selected_pact.latest_for_tag?(selector.tag) })
+          find_fallback_pacts(provider_name, selector, consumer_ids_with_a_pact_for_the_tag) do | query |
+            query.for_latest_consumer_versions_with_tag(selector.fallback_tag)
           end
         end
+      end
 
-        if selectors_missing_a_pact.any?
-          find_pacts_for_which_the_latest_version_for_the_fallback_tag_is_required(provider_name, selectors_missing_a_pact)
-        else
-          []
+      # The fallback is applied per consumer, so a consumer without a pact for the branch
+      # still gets its fallback pact when another consumer does have a pact for the branch.
+      def find_pacts_for_fallback_branches(selected_pacts, provider_name, consumer_version_selectors)
+        consumer_version_selectors.select { | selector | selector.fallback_branch? || selector.fallback_to_main_branch? }.flat_map do | selector |
+          consumer_ids_with_a_pact_for_the_branch = consumer_ids_of(selected_pacts.select { | selected_pact | selected_pact.latest_for_branch?(selector.branch) })
+          find_fallback_pacts(provider_name, selector, consumer_ids_with_a_pact_for_the_branch) do | query |
+            selector.fallback_to_main_branch? ? query.latest_for_main_branches : query.latest_for_consumer_branch(selector.fallback_branch)
+          end
         end
       end
 
+      def consumer_ids_of(selected_pacts)
+        selected_pacts.collect { | selected_pact | selected_pact.pact.consumer.id }.uniq
+      end
+
       def find_pacts_by_selector(provider_name, consumer_version_selectors)
         provider = pacticipant_repository.find_by_name(provider_name)
 
@@ -248,17 +260,25 @@ module PactBroker
         selectors
       end
 
-      def find_pacts_for_which_the_latest_version_for_the_fallback_tag_is_required(provider_name, selectors)
-        selectors.collect do | selector |
-          query = scope_for(PactPublication).eager_for_domain_with_content.for_provider_name(provider_name).for_latest_consumer_versions_with_tag(selector.fallback_tag)
-          query = query.for_consumer_name(selector.consumer) if selector.consumer
-          query.all.collect do | pact_publication |
-            SelectedPact.new(
-              pact_publication.to_domain,
-              Selectors.new(selector.resolve_for_fallback(pact_publication.consumer_version))
-            )
-          end
-        end.flatten
+      # Yields the provider's pacts so the caller can narrow them to the latest for the fallback.
+      def find_fallback_pacts(provider_name, selector, consumer_ids_to_exclude)
+        query = yield scope_for(PactPublication).eager_for_domain_with_content.for_provider_name(provider_name)
+        query = query.for_consumer_name(selector.consumer) if selector.consumer
+        query = query.exclude(Sequel[:pact_publications][:consumer_id] => consumer_ids_to_exclude) if consumer_ids_to_exclude.any?
+        query.all.collect do | pact_publication |
+          SelectedPact.new(
+            pact_publication.to_domain,
+            Selectors.new(resolve_selector_for_fallback(selector, pact_publication))
+          )
+        end
+      end
+
+      def resolve_selector_for_fallback(selector, pact_publication)
+        if selector.fallback_to_main_branch?
+          selector.resolve_for_fallback_to_main_branch(pact_publication.consumer_version, pact_publication.consumer.main_branch)
+        else
+          selector.resolve_for_fallback(pact_publication.consumer_version)
+        end
       end
 
       def find_provider_tags_for_which_pact_publication_id_is_pending(pact_publication, successfully_verified_head_pact_publication_ids_for_each_provider_tag)

data/lib/pact_broker/pacts/repository.rb

@@ -202,6 +202,7 @@ module PactBroker
       def find_by_consumer_version consumer_name, consumer_version_number
         scope_for(PactPublication)
           .eager_for_domain_with_content
+          .eager(pact_version: :latest_verification)
           .for_consumer_name_and_maybe_version_number(consumer_name, consumer_version_number)
           .remove_overridden_revisions_from_complete_query
           .all

data/lib/pact_broker/pacts/selected_pact.rb

@@ -57,6 +57,10 @@ module PactBroker
         selectors.latest_for_tag?(potential_tag)
       end
 
+      def latest_for_branch? potential_branch = nil
+        selectors.latest_for_branch?(potential_branch)
+      end
+
       def consumer_version_order
         pact.consumer_version.order
       end

data/lib/pact_broker/pacts/selector.rb

@@ -6,7 +6,7 @@ module PactBroker
     class Selector < Hash
       using PactBroker::HashRefinements
 
-      PROPERTY_NAMES = [:latest, :tag, :branch, :consumer, :consumer_version, :environment_name, :fallback_tag, :fallback_branch, :main_branch, :matching_branch, :currently_supported, :currently_deployed]
+      PROPERTY_NAMES = [:latest, :tag, :branch, :consumer, :consumer_version, :environment_name, :fallback_tag, :fallback_branch, :fallback_to_main_branch, :main_branch, :matching_branch, :currently_supported, :currently_deployed]
 
       def initialize(properties = {})
         properties.without(*PROPERTY_NAMES).tap { |it| warn("WARN: Unsupported property for #{self.class.name}: #{it.keys.join(", ")} at #{caller[0..3]}") if it.any? }
@@ -14,13 +14,19 @@ module PactBroker
       end
 
       def resolve(consumer_version)
-        ResolvedSelector.new(self.to_h.without(:fallback_tag, :fallback_branch), consumer_version)
+        ResolvedSelector.new(self.to_h.without(:fallback_tag, :fallback_branch, :fallback_to_main_branch), consumer_version)
       end
 
       def resolve_for_fallback(consumer_version)
         ResolvedSelector.new(self.to_h, consumer_version)
       end
 
+      # Records the consumer's main branch as the fallback branch, so the verification
+      # notice names the branch that was actually used.
+      def resolve_for_fallback_to_main_branch(consumer_version, main_branch)
+        ResolvedSelector.new(self.to_h.without(:fallback_to_main_branch).merge(fallback_branch: main_branch), consumer_version)
+      end
+
       def resolve_for_environment(consumer_version, environment, target = nil)
         ResolvedSelector.new(self.to_h.merge({ environment: environment, target: target }.compact), consumer_version)
       end
@@ -87,6 +93,10 @@ module PactBroker
         self[:fallback_branch] = fallback_branch
       end
 
+      def fallback_to_main_branch= fallback_to_main_branch
+        self[:fallback_to_main_branch] = fallback_to_main_branch
+      end
+
       def fallback_tag
         self[:fallback_tag]
       end
@@ -95,6 +105,10 @@ module PactBroker
         self[:fallback_branch]
       end
 
+      def fallback_to_main_branch
+        self[:fallback_to_main_branch]
+      end
+
       def consumer= consumer
         self[:consumer] = consumer
       end
@@ -235,6 +249,10 @@ module PactBroker
         !!fallback_branch
       end
 
+      def fallback_to_main_branch?
+        !!fallback_to_main_branch
+      end
+
       def main_branch
         self[:main_branch]
       end

data/lib/pact_broker/pacts/selectors.rb

@@ -59,6 +59,10 @@ module PactBroker
         any? { | selector | selector.latest_for_tag?(potential_tag) }
       end
 
+      def latest_for_branch? potential_branch = nil
+        any? { | selector | selector.latest_for_branch?(potential_branch) }
+      end
+
       def tag_names_of_selectors_for_all_pacts
         select(&:all_for_tag?).collect(&:tag).uniq
       end

data/lib/pact_broker/ui/controllers/can_i_deploy.rb

@@ -18,7 +18,7 @@ module PactBroker
         get "/:pacticipant_name/latest-version/:tag/can-i-deploy/to/:environment_tag" do
           # selector and options must be in sync with lib/pact_broker/api/resources/can_i_deploy_pacticipant_version_by_tag_to_tag_badge.rb
           selectors = [ PactBroker::Matrix::UnresolvedSelector.new(pacticipant_name: params[:pacticipant_name], latest: true, tag: params[:tag]) ]
-          options = { latestby: "cvp", limit: 100, tag: params[:to] }
+          options = { latestby: "cvp", limit: PactBroker::Matrix::ParseQuery::DEFAULT_LIMIT, tag: params[:to] }
           result = matrix_service.find(selectors, options)
           lines = PactBroker::UI::ViewModels::MatrixLines.new(result, base_url: base_url)
           locals = {

data/lib/pact_broker/ui/controllers/matrix.rb

@@ -17,7 +17,7 @@ module PactBroker
 
         get "/" do
           selectors = [OpenStruct.new, OpenStruct.new]
-          options = { limit: 100, latestby: nil }
+          options = { limit: PactBroker::Matrix::ParseQuery::DEFAULT_LIMIT, latestby: nil }
           locals = {
             lines: [],
             selectors: create_selector_objects(selectors),
@@ -50,7 +50,7 @@ module PactBroker
                         PactBroker::Matrix::UnresolvedSelector.new(pacticipant_name: params[:consumer_name]),
                         PactBroker::Matrix::UnresolvedSelector.new(pacticipant_name: params[:provider_name])
                       ]
-          options = { latestby: "cvpv", limit: 100 }
+          options = { latestby: "cvpv", limit: PactBroker::Matrix::ParseQuery::DEFAULT_LIMIT }
           lines = matrix_service.find(selectors, options)
           lines = PactBroker::UI::ViewModels::MatrixLines.new(lines, base_url: base_url)
           locals =  {

data/lib/pact_broker/verifications/repository.rb

@@ -99,7 +99,7 @@ module PactBroker
           .remove_verifications_for_overridden_consumer_versions
           .for_consumer_name_and_consumer_version_number(consumer_name, consumer_version_number)
           .latest_by_pact_version
-          .eager(:provider)
+          .eager(:provider, :consumer, :provider_version, :pact_version)
           .all
           .sort_by { | v | v.provider_name.downcase }
       end

data/lib/pact_broker/verifications/summary_for_consumer_version.rb

@@ -13,6 +13,10 @@ module PactBroker
         successful.count == pacts.count
       end
 
+      def pacts_by_pact_version_sha
+        pacts.to_h { | pact | [pact.pact_version_sha, pact] }
+      end
+
       def provider_summary
         OpenStruct.new(
           successful: successful,

data/lib/pact_broker/version.rb

@@ -1,3 +1,3 @@
 module PactBroker
-  VERSION = "2.122.0"
+  VERSION = "2.124.0"
 end

data/pact_broker.gemspec

@@ -64,7 +64,7 @@ Gem::Specification.new do |gem|
   gem.add_runtime_dependency "rack-protection", "~> 4.1"
   gem.add_runtime_dependency "table_print", "~> 1.5"
   gem.add_runtime_dependency "semantic_logger", "~> 5.0"
-  gem.add_runtime_dependency "sanitize", "~> 6.0"
+  gem.add_runtime_dependency "sanitize", "~> 7.0"
   gem.add_runtime_dependency "wisper", "~> 2.0"
   gem.add_runtime_dependency "anyway_config", "~> 2.1"
   gem.add_runtime_dependency "request_store", "~> 1.5"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pact_broker
 version: !ruby/object:Gem::Version
-  version: 2.122.0
+  version: 2.124.0
 platform: ruby
 authors:
 - Bethany Skurrie
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-01 00:00:00.000000000 Z
+date: 2026-11-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -228,14 +228,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '7.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '7.0'
 - !ruby/object:Gem::Dependency
   name: wisper
   requirement: !ruby/object:Gem::Requirement