pact_broker 2.109.1 → 2.111.0

data/lib/pact_broker/integrations/integration.rb

@@ -7,7 +7,17 @@ require "pact_broker/verifications/latest_verification_for_consumer_and_provider
 
 module PactBroker
   module Integrations
-    class Integration < Sequel::Model(Sequel::Model.db[:integrations].select(:id, :consumer_id, :provider_id, :contract_data_updated_at))
+    # The columns are explicitly specified for the Integration object so that the consumer_name and provider_name columns aren't included
+    # in the model.
+    # Those columns exist in the integrations table because the integrations table used to be an integrations view based on the
+    # pact_publications table, and those columns existed in the view.
+    # When the view was migrated to be a table (in db/migrations/20211102_create_table_temp_integrations.rb and the following migrations)
+    # the columns had to be maintained for backwards compatiblity.
+    # They are not used by the current code, however.
+    class Integration < Sequel::Model
+      INTEGRATION_COLUMNS = Sequel::Model.db.schema(:integrations).collect(&:first) - [:consumer_name, :provider_name]
+      set_dataset(Sequel::Model.db[:integrations].select(*INTEGRATION_COLUMNS))
+
       set_primary_key :id
       plugin :insert_ignore, identifying_columns: [:consumer_id, :provider_id]
       associate(:many_to_one, :consumer, :class => "PactBroker::Domain::Pacticipant", :key => :consumer_id, :primary_key => :id)

data/lib/pact_broker/integrations/repository.rb

@@ -28,6 +28,20 @@ module PactBroker
         nil
       end
 
+      # Ensure an Integration exists for each consumer/provider pair.
+      # Using SELECT ... INSERT IGNORE rather than just INSERT IGNORE so that we do not
+      # need to lock the table at all when the integrations already exist, which will
+      # be the most common use case. New integrations get created incredibly rarely.
+      # The INSERT IGNORE is used rather than just INSERT to handle race conditions
+      # when requests come in parallel.
+      # @param [Array<Object>] where each object has a consumer and a provider
+      def create_for_pacts(objects_with_consumer_and_provider)
+        published_integrations = objects_with_consumer_and_provider.collect{ |i| { consumer_id: i.consumer.id, provider_id: i.provider.id } }
+        existing_integrations = Sequel::Model.db[:integrations].select(:consumer_id, :provider_id).where(Sequel.|(*published_integrations) ).all
+        new_integrations = (published_integrations - existing_integrations).collect{ |i| i.merge(created_at: Sequel.datetime_class.now, contract_data_updated_at: Sequel.datetime_class.now) }
+        Integration.dataset.insert_ignore.multi_insert(new_integrations)
+      end
+
       def delete(consumer_id, provider_id)
         Integration.where(consumer_id: consumer_id, provider_id: provider_id).delete
       end
@@ -36,18 +50,43 @@ module PactBroker
       # @param [PactBroker::Domain::Pacticipant, nil] consumer the consumer for the integration, or nil if for a provider-only event (eg. Pactflow provider contract published)
       # @param [PactBroker::Domain::Pacticipant] provider the provider for the integration
       def set_contract_data_updated_at(consumer, provider)
-        Integration
-          .where({ consumer_id: consumer&.id, provider_id: provider.id }.compact )
-          .update(contract_data_updated_at: Sequel.datetime_class.now)
+        set_contract_data_updated_at_for_multiple_integrations([OpenStruct.new(consumer: consumer, provider: provider)])
       end
 
 
-      # Sets the contract_data_updated_at for the integrations as specified by an array of objects which each have a consumer and provider
-      # @param [Array<Object>] where each object has a consumer and a provider
+      # Sets the contract_data_updated_at for the integrations as specified by an array of objects which each have a consumer and provider.
+      #
+      # The contract_data_updated_at attribute is only ever used for ordering the list of integrations on the index page of the *Pact Broker* UI,
+      # so that the most recently updated integrations (the ones you're likely working on) are showed at the top of the first page.
+      # There is often contention around updating it however, which can cause deadlocks, and slow down API responses.
+      # Because it's not a critical field (eg. it won't change any can-i-deploy results), the easiest way to reduce this contention
+      # is to just not update it if the row is locked, because if it is locked, the value of contract_data_updated_at is already
+      # going to be a date from a few seconds ago, which is perfectly fine for the purposes for which we are using the value.
+      #
+      # Notes on SKIP LOCKED:
+      # SKIP LOCKED is only supported by Postgres.
+      # When executing SELECT ... FOR UPDATE SKIP LOCKED, the SELECT will run immediately, not waiting for any other transactions,
+      # and only return rows that are not already locked by another transaction.
+      # The FOR UPDATE is required to make it work this way - SKIP LOCKED on its own does not work.
+      #
+      # @param [Array<Object>] where each object MAY have a consumer and does have a provider (for Pactflow provider contract published there is no consumer)
       def set_contract_data_updated_at_for_multiple_integrations(objects_with_consumer_and_provider)
-        consumer_and_provider_ids = objects_with_consumer_and_provider.collect{ | object | [object.consumer.id, object.provider.id] }.uniq
+        consumer_and_provider_ids = objects_with_consumer_and_provider.collect{ | object | { consumer_id: object.consumer&.id, provider_id: object.provider.id }.compact }.uniq
+
+        # MySQL doesn't support an UPDATE with a subquery. FFS. Really need to do a major version release and delete the support code.
+        criteria =  if Integration.dataset.supports_skip_locked?
+                      integration_ids_to_update = Integration
+                                                  .select(:id)
+                                                  .where(Sequel.|(*consumer_and_provider_ids))
+                                                  .for_update
+                                                  .skip_locked
+                      { id: integration_ids_to_update }
+                    else
+                      Sequel.|(*consumer_and_provider_ids)
+                    end
+
         Integration
-          .where([:consumer_id, :provider_id] => consumer_and_provider_ids)
+          .where(criteria)
           .update(contract_data_updated_at: Sequel.datetime_class.now)
       end
     end

data/lib/pact_broker/integrations/service.rb

@@ -21,6 +21,7 @@ module PactBroker
       # @param [PactBroker::Domain::Pacticipant] consumer or nil
       # @param [PactBroker::Domain::Pacticipant] provider
       def self.handle_contract_data_published(consumer, provider)
+        integration_repository.create_for_pact(consumer.id, provider.id)
         integration_repository.set_contract_data_updated_at(consumer, provider)
       end
 
@@ -28,6 +29,7 @@ module PactBroker
       # Callback to invoke when a batch of contract data is published (eg. the publish contracts endpoint)
       # @param [Array<Object>] where each object has a consumer and a provider
       def self.handle_bulk_contract_data_published(objects_with_consumer_and_provider)
+        integration_repository.create_for_pacts(objects_with_consumer_and_provider)
         integration_repository.set_contract_data_updated_at_for_multiple_integrations(objects_with_consumer_and_provider)
       end
 

data/lib/pact_broker/labels/repository.rb

@@ -3,6 +3,11 @@ require "pact_broker/domain/label"
 module PactBroker
   module Labels
     class Repository
+
+      def get_all_unique_labels pagination_options = {}
+        PactBroker::Domain::Label.distinct.select(:name).all_with_pagination_options(pagination_options)
+      end
+
       def create args
         Domain::Label.new(name: args.fetch(:name), pacticipant: args.fetch(:pacticipant)).save
       end

data/lib/pact_broker/labels/service.rb

@@ -9,6 +9,10 @@ module PactBroker
 
       extend PactBroker::Repositories
 
+      def get_all_unique_labels pagination_options = {}
+        label_repository.get_all_unique_labels(pagination_options)
+      end
+
       def create args
         pacticipant = pacticipant_repository.find_by_name_or_create args.fetch(:pacticipant_name)
         label_repository.create pacticipant: pacticipant, name: args.fetch(:label_name)

data/lib/pact_broker/matrix/service.rb

@@ -22,6 +22,32 @@ module PactBroker
         QueryResultsWithDeploymentStatusSummary.new(query_results, DeploymentStatusSummary.new(query_results))
       end
 
+      def can_i_merge(pacticipant_name: nil, pacticipant: nil, latest_main_branch_version: nil)
+        # first we find the pacticipant by name (or use the one passed in) if pacticipant is nil
+        if pacticipant.nil?
+          pacticipant = pacticipant_service.find_pacticipant_by_name(pacticipant_name)
+          raise PactBroker::Error.new("No pacticipant found with name '#{pacticipant_name}'") unless pacticipant
+        else
+          pacticipant_name = pacticipant.name
+        end
+         
+        # then we find the latest version from the main branch if not passed in
+        if latest_main_branch_version.nil?
+          latest_main_branch_version = version_service.find_latest_version_from_main_branch(pacticipant)
+          raise PactBroker::Error.new("No main branch version found for pacticipant '#{pacticipant_name}'") unless latest_main_branch_version
+        end
+
+        selectors = PactBroker::Matrix::UnresolvedSelector.from_hash(
+          pacticipant_name: pacticipant_name, 
+          pacticipant_version_number: latest_main_branch_version.number
+        )
+         
+        options = { main_branch: true, latest: true, latestby: "cvp" }
+        query_results = can_i_deploy([selectors], options)
+   
+        query_results.deployable?
+      end
+
       def find selectors, options = {}
         logger.info "Querying matrix", selectors: selectors, options: options
         matrix_repository.find(selectors, options)

data/lib/pact_broker/pacticipants/repository.rb

@@ -102,7 +102,16 @@ module PactBroker
 
       def search_by_name(pacticipant_name)
         terms = pacticipant_name.split.map { |v| v.gsub("_", "\\_") }
-        string_match_query = Sequel.|( *terms.map { |term| Sequel.ilike(Sequel[:pacticipants][:name], "%#{term}%") })
+        columns = [:name, :display_name]
+        string_match_query = Sequel.|(
+          *terms.map do |term|
+            Sequel.|(
+              *columns.map do |column|
+                Sequel.ilike(Sequel[:pacticipants][column], "%#{term}%")
+              end
+            )
+          end
+        )
         scope_for(PactBroker::Domain::Pacticipant).where(string_match_query)
       end
 

data/lib/pact_broker/pacts/pact_publication_dataset_module.rb

@@ -57,7 +57,13 @@ module PactBroker
         end
       end
 
-      # TODO use the branch heads here
+      # Returns the latest pact for each branch, returning a pact for every branch, even if
+      # the most recent version of that branch does not have a pact.
+      # This is different from for_all_branch_heads, which will find the branch head versions,
+      # and return the pacts associated with those versions.
+      # This method should not be used for 'pacts for verification', because it will return
+      # a pact for branches where that integration should no longer exist.
+      # @return [Dataset<PactBroker::Pacts::PactPublication>]
       def latest_by_consumer_branch
         branch_versions_join = {
           Sequel[:pact_publications][:consumer_version_id] => Sequel[:branch_versions][:version_id]
@@ -112,10 +118,29 @@ module PactBroker
           .limit(1)
       end
 
-      # Return the pacts (if they exist) for the branch heads.
+      # Returns the pacts (if they exist) for all the branch heads.
+      # If the version for the branch head does not have a pact, then no pact is returned,
+      # (unlike latest_by_consumer_branch)
+      # This is much more performant than latest_by_consumer_branch and should be used
+      # for the 'pacts for verification' response
+      # @return [Dataset<PactBroker::Pacts::PactPublication>]
+      def for_all_branch_heads
+        base_query = self
+        base_query = base_query.join(:branch_heads, { Sequel[:bh][:version_id] => Sequel[:pact_publications][:consumer_version_id] }, { table_alias: :bh })
+
+        if no_columns_selected?
+          base_query = base_query.select_all_qualified.select_append(Sequel[:bh][:branch_name].as(:branch_name))
+        end
+
+        base_query.remove_overridden_revisions
+      end
+
+      # Return the pacts (if they exist) for the branch heads of the given branch names
       # This uses the new logic of finding the branch head and returning any associated pacts,
       # rather than the old logic of returning the pact for the latest version
       # on the branch that had a pact.
+      # @param [String] branch_name
+      # @return [Sequel::Dataset<PactBroker::Pacts::PactPublication>]
       def for_branch_heads(branch_name)
         branch_head_join = {
           Sequel[:pact_publications][:consumer_version_id] => Sequel[:branch_heads][:version_id],
@@ -174,7 +199,10 @@ module PactBroker
       # The latest pact publication for each tag
       # This uses the old logic of "the latest pact for a version that has a tag" (which always returns a pact)
       # rather than "the pact for the latest version with a tag"
-      # Need to see about updating this.
+      #
+      # For 'pacts for verification' this has been replaced by for_all_tag_heads
+      # This should only be used for the UI
+      # @return [Sequel::Dataset<PactBroker::Pacts::PactPublication>]
       def latest_by_consumer_tag
         tags_join = {
           Sequel[:pact_publications][:consumer_version_id] => Sequel[:tags][:version_id],
@@ -203,6 +231,7 @@ module PactBroker
       # This uses the old logic of "the latest pact for a version that has a tag" (which always returns a pact)
       # rather than "the pact for the latest version with a tag"
       # Need to see about updating this.
+      # @return [Sequel::Dataset<PactBroker::Pacts::PactPublication>]
       def latest_for_consumer_tag(tag_name)
         tags_join = {
           Sequel[:pact_publications][:consumer_version_id] => Sequel[:tags][:version_id],
@@ -253,6 +282,30 @@ module PactBroker
          .remove_overridden_revisions_from_complete_query
       end
 
+      # The pacts for the latest versions for each tag.
+      # Will not return a pact if the pact is no longer published for a particular tag
+      # NEW LOGIC
+      # @return [Sequel::Dataset<PactBroker::Pacts::PactPublication>]
+      def for_all_tag_heads
+        head_tags = PactBroker::Domain::Tag
+                      .select_group(:pacticipant_id, :name)
+                      .select_append{ max(version_order).as(:latest_version_order) }
+
+        head_tags_join = {
+          Sequel[:pact_publications][:consumer_id] => Sequel[:head_tags][:pacticipant_id],
+          Sequel[:pact_publications][:consumer_version_order] => Sequel[:head_tags][:latest_version_order]
+        }
+
+        base_query = self
+        if no_columns_selected?
+          base_query = base_query.select_all_qualified.select_append(Sequel[:head_tags][:name].as(:tag_name))
+        end
+
+        base_query
+          .join(head_tags, head_tags_join, { table_alias: :head_tags })
+         .remove_overridden_revisions_from_complete_query
+      end
+
       def in_environments
         currently_deployed_join = {
           Sequel[:pact_publications][:consumer_version_id] => Sequel[:currently_deployed_version_ids][:version_id]

data/lib/pact_broker/pacts/pact_publication_selector_dataset_module.rb

@@ -15,6 +15,7 @@ module PactBroker
 
         # Do the "latest" logic last so that the provider/consumer criteria get included in the "latest" query before the join, rather than after
         query = query.latest_for_main_branches if selector.latest_for_main_branch?
+        query = query.for_all_branch_heads if selector.latest_for_each_branch?
         query = query.latest_for_consumer_branch(selector.branch) if selector.latest_for_branch?
         query = query.for_latest_consumer_versions_with_tag(selector.tag) if selector.latest_for_tag?
         query = query.overall_latest if selector.overall_latest?

data/lib/pact_broker/pacts/pacts_for_verification_repository.rb

@@ -64,7 +64,7 @@ module PactBroker
           provider_tags_names,
           wip_start_date,
           explicitly_specified_verifiable_pacts,
-          :latest_by_consumer_tag
+          :for_all_tag_heads
         )
 
         wip_by_consumer_branches = find_wip_pact_versions_for_provider_by_provider_tags(
@@ -72,7 +72,7 @@ module PactBroker
           provider_tags_names,
           wip_start_date,
           explicitly_specified_verifiable_pacts,
-          :latest_by_consumer_branch
+          :for_all_branch_heads
         )
 
         deduplicate_verifiable_pacts(wip_by_consumer_tags + wip_by_consumer_branches).sort
@@ -229,8 +229,8 @@ module PactBroker
         provider = pacticipant_repository.find_by_name(provider_name)
         wip_start_date = options.fetch(:include_wip_pacts_since)
 
-        potential_wip_by_consumer_branch = PactPublication.for_provider(provider).created_after(wip_start_date).latest_by_consumer_branch
-        potential_wip_by_consumer_tag = PactPublication.for_provider(provider).created_after(wip_start_date).latest_by_consumer_tag
+        potential_wip_by_consumer_branch = PactPublication.for_provider(provider).created_after(wip_start_date).for_all_branch_heads
+        potential_wip_by_consumer_tag = PactPublication.for_provider(provider).created_after(wip_start_date).for_all_tag_heads
 
         log_debug_for_wip do
           log_pact_publications_from_query("Potential WIP pacts for provider branch #{provider_version_branch} created after #{wip_start_date} by consumer branch", potential_wip_by_consumer_branch)

data/lib/pact_broker/pacts/repository.rb

@@ -33,8 +33,8 @@ module PactBroker
         scope
       end
 
-      def create params
-        integration_repository.create_for_pact(params.fetch(:consumer_id), params.fetch(:provider_id))
+      # @return [PactBroker::Domain::Pact]
+      def create(params)
         pact_version = find_or_create_pact_version(
           params.fetch(:consumer_id),
           params.fetch(:provider_id),

data/lib/pact_broker/pacts/selector.rb

@@ -31,6 +31,8 @@ module PactBroker
       def type
         if latest_for_main_branch?
           :latest_for_main_branch
+        elsif latest_for_each_branch?
+          :latest_for_each_branch
         elsif latest_for_branch?
           :latest_for_branch
         elsif matching_branch?
@@ -265,12 +267,16 @@ module PactBroker
       # Not sure if the fallback_tag logic is needed
       def latest_for_branch? potential_branch = nil
         if potential_branch
-          !!(latest && branch == potential_branch)
+          latest == true && branch == potential_branch
         else
-          !!(latest && !!branch)
+          latest == true && branch.is_a?(String)
         end
       end
 
+      def latest_for_each_branch?
+        latest == true && branch == true
+      end
+
       def all_for_tag_and_consumer?
         !!(tag && !latest? && consumer)
       end

data/lib/pact_broker/tasks/clean_task.rb

@@ -1,3 +1,8 @@
+# This task is used to clean up old data in a Pact Broker database
+# to stop performance issues from slowing down responses when there is
+# too much data.
+# See https://docs.pact.io/pact_broker/administration/maintenance
+
 module PactBroker
   module DB
     class CleanTask < ::Rake::TaskLib
@@ -7,11 +12,13 @@ module PactBroker
       attr_accessor :version_deletion_limit
       attr_accessor :logger
       attr_accessor :dry_run
+      attr_accessor :use_lock # allow disabling of postgres lock if it is causing problems
 
       def initialize &block
         require "pact_broker/db/clean_incremental"
         @version_deletion_limit = 1000
         @dry_run = false
+        @use_lock = true
         @keep_version_selectors = PactBroker::DB::CleanIncremental::DEFAULT_KEEP_SELECTORS
         rake_task(&block)
       end
@@ -28,42 +35,77 @@ module PactBroker
           namespace :db do
             desc "Clean unnecessary pacts and verifications from database"
             task :clean do | _t, _args |
-
               instance_eval(&block)
 
-              require "pact_broker/db/clean_incremental"
-              require "pact_broker/error"
-              require "yaml"
-              require "benchmark"
+              with_lock do
+                perform_clean
+              end
+            end
+          end
+        end
+      end
+
+      def perform_clean
+        require "pact_broker/db/clean_incremental"
+        require "pact_broker/error"
+        require "yaml"
+        require "benchmark"
 
-              raise PactBroker::Error.new("You must specify the version_deletion_limit") unless version_deletion_limit
+        raise PactBroker::Error.new("You must specify the version_deletion_limit") unless version_deletion_limit
 
-              prefix = dry_run ? "[DRY RUN] " : ""
+        if keep_version_selectors.nil? || keep_version_selectors.empty?
+          raise PactBroker::Error.new("You must specify which versions to keep")
+        else
+          add_defaults_to_keep_selectors
+          output "Deleting oldest #{version_deletion_limit} versions, keeping versions that match the configured selectors", keep_version_selectors.collect(&:to_hash)
+        end
 
-              if keep_version_selectors.nil? || keep_version_selectors.empty?
-                raise PactBroker::Error.new("You must specify which versions to keep")
-              else
-                add_defaults_to_keep_selectors
-                output "#{prefix}Deleting oldest #{version_deletion_limit} versions, keeping versions that match the configured selectors", keep_version_selectors.collect(&:to_hash)
-              end
+        start_time = Time.now
+        results = PactBroker::DB::CleanIncremental.call(database_connection,
+          keep: keep_version_selectors,
+          limit: version_deletion_limit,
+          logger: logger,
+          dry_run: dry_run
+        )
+        end_time = Time.now
+        elapsed_seconds = (end_time - start_time).to_i
+        output "Results (#{elapsed_seconds} seconds)", results
+      end
 
-              start_time = Time.now
-              results = PactBroker::DB::CleanIncremental.call(database_connection,
-                keep: keep_version_selectors,
-                limit: version_deletion_limit,
-                logger: logger,
-                dry_run: dry_run
-              )
-              end_time = Time.now
-              elapsed_seconds = (end_time - start_time).to_i
-              output "Results (#{elapsed_seconds} seconds)", results
-            end
+      # Use a Postgres advisory lock to ensure that only one clean can run at a time.
+      # This allows a cron schedule to be used on the Pact Broker Docker image when deployed
+      # on a multi-instance architecture, without all the instances stepping on each other's toes.
+      #
+      # Any tasks that attempt to run while a clean job is running will skip the clean
+      # and exit with a message and a success code.
+      #
+      # To test that the lock works, run:
+      #   script/docker/db-start.sh
+      #   script/docker/db-migrate.sh
+      #   for i in {0..3}; do PACT_BROKER_TEST_DATABASE_URL=postgres://postgres:postgres@localhost/postgres bundle exec rake pact_broker:db:clean &;  done;
+      #
+      # There will be 3 messages saying "Clean was not performed" and output from one thread showing the clean is being done.
+      def with_lock
+        if use_lock
+          require "pact_broker/db/advisory_lock"
+
+          lock = PactBroker::DB::AdvisoryLock.new(database_connection, :clean, :pg_try_advisory_lock)
+          results = lock.with_lock do
+            yield
+          end
+
+          if !lock.lock_obtained?
+            output("Clean was not performed as a clean is already in progress. Exiting.")
           end
+          results
+        else
+          yield
         end
       end
 
-      def output string, payload = {}
-        logger ? logger.info(string, payload) : puts("#{string} #{payload.to_json}")
+      def output(string, payload = {})
+        prefix = dry_run ? "[DRY RUN] " : ""
+        logger ? logger.info("#{prefix}#{string}") : puts("#{prefix}#{string} #{payload.to_json}")
       end
 
       def add_defaults_to_keep_selectors

data/lib/pact_broker/test/test_data_builder.rb

@@ -43,7 +43,6 @@ module PactBroker
       include PactBroker::Services
       using PactBroker::StringRefinements
 
-
       attr_reader :pacticipant
       attr_reader :consumer
       attr_reader :provider
@@ -166,9 +165,16 @@ module PactBroker
 
       def create_pacticipant pacticipant_name, params = {}
         params.delete(:comment)
+        version_to_create = params.delete(:version)
+
         repository_url = "https://github.com/#{params[:repository_namespace] || "example-organization"}/#{params[:repository_name] || pacticipant_name}"
         merged_params = { name: pacticipant_name, repository_url: repository_url }.merge(params)
         @pacticipant = PactBroker::Domain::Pacticipant.create(merged_params)
+
+        version = create_pacticipant_version(version_to_create, @pacticipant) if version_to_create
+        main_branch = params[:main_branch]
+        PactBroker::Versions::BranchVersionRepository.new.add_branch(version, main_branch) if version && main_branch
+
         self
       end
 
@@ -192,8 +198,11 @@ module PactBroker
         self
       end
 
+      # Create an Integration object for the current consumer and provider
+      # @return [PactBroker::Test::TestDataBuilder]
       def create_integration
-        PactBroker::Integrations::Repository.new.create_for_pact(consumer.id, provider.id)
+        @integration = PactBroker::Integrations::Repository.new.create_for_pact(consumer.id, provider.id)
+        set_created_at_if_set(@now, :integrations, { consumer_id: consumer.id, provider_id: provider.id })
         self
       end
 
@@ -280,7 +289,9 @@ module PactBroker
         self
       end
 
-      def create_pact params = {}
+      # Creates a pact (and integration if one does not already exist) from the given params
+      # @return [PactBroker::Test::TestDataBuilder]
+      def create_pact(params = {})
         params.delete(:comment)
         json_content = params[:json_content] || default_json_content
         pact_version_sha = params[:pact_version_sha] || generate_pact_version_sha(json_content)
@@ -293,6 +304,7 @@ module PactBroker
           json_content: prepare_json_content(json_content),
           version: @consumer_version
         )
+        integration_service.handle_bulk_contract_data_published([@pact])
         pact_versions_count_after = PactBroker::Pacts::PactVersion.count
         set_created_at_if_set(params[:created_at], :pact_publications, id: @pact.id)
         set_created_at_if_set(params[:created_at], :pact_versions, sha: @pact.pact_version_sha) if pact_versions_count_after > pact_versions_count_before
@@ -634,8 +646,6 @@ module PactBroker
          }.to_json
       end
 
-      private
-
       def create_pacticipant_version(version_number, pacticipant, params = {})
         params.delete(:comment)
         tag_names = [params.delete(:tag_names), params.delete(:tag_name)].flatten.compact
@@ -660,6 +670,8 @@ module PactBroker
         version
       end
 
+      private
+
       def create_deployed_version(uuid: , currently_deployed: , version:, environment_name: , target: nil, created_at: nil)
         env = find_environment(environment_name)
         @deployed_version = PactBroker::Deployments::DeployedVersionService.find_or_create(uuid, version, env, target)

data/lib/pact_broker/version.rb

@@ -1,3 +1,3 @@
 module PactBroker
-  VERSION = "2.109.1"
+  VERSION = "2.111.0"
 end

data/lib/pact_broker/versions/repository.rb

@@ -57,29 +57,11 @@ module PactBroker
           .single_record
       end
 
-      # The eager loaded relations are hardcoded here to support the PactBroker::Api::Decorators::VersionDecorator
-      # Newer "find all" implementations for other models pass the relations to eager load in
-      # from the decorator via the resource.
-      def find_all_pacticipant_versions_in_reverse_order name, pagination_options = {}
-        pacticipant = pacticipant_repository.find_by_name!(name)
-        query = PactBroker::Domain::Version
-                  .where(pacticipant: pacticipant)
-                  .eager(:pacticipant)
-                  .eager(branch_versions: [:version, :branch_head, { branch: :pacticipant }])
-                  .eager(tags: :head_tag)
-                  .eager(:pact_publications)
-                  .reverse_order(:order)
-        query.all_with_pagination_options(pagination_options)
-      end
-
-      def find_pacticipant_versions_in_reverse_order(pacticipant_name, options = {}, pagination_options = {})
+      def find_pacticipant_versions_in_reverse_order(pacticipant_name, options = {}, pagination_options = {}, eager_load_associations = [])
         pacticipant = pacticipant_repository.find_by_name!(pacticipant_name)
         query = PactBroker::Domain::Version
                   .where(pacticipant: pacticipant)
-                  .eager(:pacticipant)
-                  .eager(branch_versions: [:version, :branch_head, { branch: :pacticipant }])
-                  .eager(tags: :head_tag)
-                  .eager(:pact_publications)
+                  .eager(*eager_load_associations)
                   .reverse_order(:order)
 
         if options[:branch_name]

data/lib/pact_broker/versions/service.rb

@@ -26,12 +26,8 @@ module PactBroker
         version_repository.find_latest_by_pacticipant_name_and_branch_name(pacticipant_name, branch_name)
       end
 
-      def self.find_all_pacticipant_versions_in_reverse_order(name, pagination_options = {})
-        version_repository.find_all_pacticipant_versions_in_reverse_order(name, pagination_options)
-      end
-
-      def self.find_pacticipant_versions_in_reverse_order(pacticipant_name, options, pagination_options = {})
-        version_repository.find_pacticipant_versions_in_reverse_order(pacticipant_name, options, pagination_options)
+      def self.find_pacticipant_versions_in_reverse_order(pacticipant_name, options, pagination_options = {}, eager_load_associations = [])
+        version_repository.find_pacticipant_versions_in_reverse_order(pacticipant_name, options, pagination_options, eager_load_associations)
       end
 
       def self.create_or_overwrite(pacticipant_name, version_number, version)

data/lib/pact_broker/webhooks/execution.rb

@@ -2,14 +2,14 @@ require "pact_broker/dataset"
 
 module PactBroker
   module Webhooks
-    class Execution < Sequel::Model(
-      Sequel::Model.db[:webhook_executions].select(
-        Sequel[:webhook_executions][:id],
-        :triggered_webhook_id,
-        :success,
-        :logs,
-        Sequel[:webhook_executions][:created_at])
-      )
+    class Execution < Sequel::Model(:webhook_executions)
+      # Ignore the columns that were used before the TriggeredWebhook class existed.
+      # It used to go Webhook -> Execution, and now it goes Webhook -> TriggeredWebhook -> Execution
+      # If we ever release a major version where we drop unused columns, those columns could be deleted.
+      EXECUTION_COLUMNS = Sequel::Model.db.schema(:webhook_executions).collect(&:first) - [:webhook_id, :pact_publication_id, :consumer_id, :provider_id]
+
+      set_dataset(Sequel::Model.db[:webhook_executions].select(*EXECUTION_COLUMNS))
+
       set_primary_key :id
       plugin :timestamps