pact_broker 2.80.0 → 2.81.0

data/lib/pact_broker/pacts/pact_publication_dataset_module.rb

@@ -5,6 +5,18 @@ module PactBroker
     module PactPublicationDatasetModule
       include PactPublicationSelectorDatasetModule
 
+      def for_consumer_id_and_provider_id(consumer_id, provider_id)
+        where(Sequel[:pact_publications][:consumer_id] => consumer_id, Sequel[:pact_publications][:provider_id] => provider_id)
+      end
+
+      def for_provider_name(provider_name)
+        where(provider: PactBroker::Domain::Pacticipant.find_by_name(provider_name))
+      end
+
+      def for_consumer_name(consumer_name)
+        where(consumer: PactBroker::Domain::Pacticipant.find_by_name(consumer_name))
+      end
+
       def for_provider provider
         where(provider: provider)
       end
@@ -13,6 +25,18 @@ module PactBroker
         where(consumer: consumer)
       end
 
+      def for_consumer_version_tag tag_name
+        join(:tags, { version_id: :consumer_version_id, Sequel[:tags][:name] => tag_name })
+      end
+
+      def for_consumer_name_and_maybe_version_number(consumer_name, consumer_version_number)
+        if consumer_version_number
+          where(consumer_version: PactBroker::Domain::Version.where_pacticipant_name_and_version_number(consumer_name, consumer_version_number))
+        else
+          where(consumer: PactBroker::Domain::Pacticipant.find_by_name(consumer_name))
+        end
+      end
+
       def latest_by_consumer_branch
         versions_join = {
           Sequel[:pact_publications][:consumer_version_id] => Sequel[:cv][:id]
@@ -39,20 +63,25 @@ module PactBroker
       end
 
       def overall_latest
-        base_query = join_consumer_versions # won't need to do this when we add the order to latest_pact_publication_ids_for_consumer_versions
-
         self_join = {
           Sequel[:pact_publications][:consumer_id] => Sequel[:pp2][:consumer_id],
           Sequel[:pact_publications][:provider_id] => Sequel[:pp2][:provider_id]
         }
 
+        base_query = self
         base_query = base_query.select_all_qualified if no_columns_selected?
 
-        base_query.left_join(base_query.select(:consumer_id, :provider_id, :order), self_join, { table_alias: :pp2 } ) do
-          Sequel[:pp2][:order] > Sequel[:cv][:order]
+        base_query.left_join(base_query.select(:consumer_id, :provider_id, :consumer_version_order), self_join, { table_alias: :pp2 } ) do
+          Sequel[:pp2][:consumer_version_order] > Sequel[:pact_publications][:consumer_version_order]
         end
-        .where(Sequel[:pp2][:order] => nil)
-        .remove_overridden_revisions_from_complete_query
+        .where(Sequel[:pp2][:consumer_version_order] => nil)
+        .remove_overridden_revisions_from_complete_query # do we need this?
+      end
+
+      def overall_latest_for_consumer_id_and_provider_id(consumer_id, provider_id)
+        for_consumer_id_and_provider_id(consumer_id, provider_id)
+          .order(Sequel.desc(Sequel[:pact_publications][:consumer_version_order]), Sequel.desc(:revision_number))
+          .limit(1)
       end
 
       def latest_for_consumer_branch(branch)
@@ -151,13 +180,19 @@ module PactBroker
       end
 
       def remove_overridden_revisions(pact_publications_alias = :pact_publications)
-        join(:latest_pact_publication_ids_for_consumer_versions, { Sequel[:lp][:pact_publication_id] => Sequel[pact_publications_alias][:id] }, { table_alias: :lp})
+        base = self
+        base = base.select_all_qualified if no_columns_selected?
+        base.join(:latest_pact_publication_ids_for_consumer_versions, { Sequel[:lp][:pact_publication_id] => Sequel[pact_publications_alias][:id] }, { table_alias: :lp})
       end
 
       def remove_overridden_revisions_from_complete_query
-        from_self(alias: :p)
-        .select(Sequel[:p].*)
-        .remove_overridden_revisions(:p)
+        from_self(alias: :pact_publications)
+          .select(Sequel[:pact_publications].*)
+          .remove_overridden_revisions(:pact_publications)
+      end
+
+      def for_pact_version_id(pact_version_id)
+        where(Sequel[:pact_publications][:pact_version_id] => pact_version_id)
       end
 
       def join_consumer_versions(table_alias = :cv, extra_join_criteria = {}, &block)
@@ -198,6 +233,11 @@ module PactBroker
         join(:pact_versions, { Sequel[:pact_publications][:pact_version_id] => Sequel[:pact_versions][:id] })
       end
 
+      def for_pact_version_sha(pact_version_sha)
+        join_pact_versions
+          .where(Sequel[:pact_versions][:sha] => pact_version_sha)
+      end
+
       def eager_load_pact_versions
         eager(:pact_versions)
       end
@@ -228,7 +268,11 @@ module PactBroker
       end
 
       def order_by_consumer_version_order
-        order_append(Sequel[:cv][:order])
+        order_append(:consumer_version_order, :revision_number)
+      end
+
+      def latest
+        order(:consumer_version_order, :revision_number).last
       end
 
       def where_consumer_if_set(consumer)

data/lib/pact_broker/pacts/pact_publication_selector_dataset_module.rb

@@ -13,7 +13,9 @@ module PactBroker
           query = query.for_environment(selector.environment_name)
         end
 
+
         # 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.latest_for_consumer_branch(selector.branch) if selector.latest_for_branch?
         query = query.latest_for_consumer_tag(selector.tag) if selector.latest_for_tag?
         query = query.overall_latest if selector.overall_latest?
@@ -21,6 +23,24 @@ module PactBroker
       end
       # rubocop: enable Metrics/CyclomaticComplexity
 
+      def latest_for_main_branches
+        self_join = {
+          Sequel[:pact_publications][:provider_id] => Sequel[:pp2][:provider_id],
+          Sequel[:pact_publications][:consumer_id] => Sequel[:pp2][:consumer_id],
+          Sequel[:cv][:branch] => Sequel[:pp2][:branch]
+        }
+
+        base_query = join_consumers(:consumers)
+                      .join_consumer_versions(:cv, { Sequel[:cv][:branch] => Sequel[:consumers][:main_branch] })
+
+        base_query = base_query.select_all_qualified if no_columns_selected?
+
+        base_query.left_join(base_query.select(:provider_id, :consumer_id, Sequel[:cv][:branch], :consumer_version_order), self_join, { table_alias: :pp2 }) do
+          Sequel[:pp2][:consumer_version_order] > Sequel[:pact_publications][:consumer_version_order]
+        end
+        .where(Sequel[:pp2][:consumer_version_order] => nil)
+      end
+
       def for_currently_deployed_versions(environment_name)
         deployed_versions_join = {
           Sequel[:pact_publications][:consumer_version_id] => Sequel[:deployed_versions][:version_id]

data/lib/pact_broker/pacts/pact_version.rb

@@ -10,9 +10,18 @@ module PactBroker
 
       one_to_many :pact_publications, reciprocal: :pact_version
       one_to_many :verifications, reciprocal: :verification, order: :id, class: "PactBroker::Domain::Verification"
-      one_to_one :latest_verification, class: "PactBroker::Verifications::LatestVerificationForPactVersion", key: :pact_version_id, primary_key: :id
       associate(:many_to_one, :provider, class: "PactBroker::Domain::Pacticipant", key: :provider_id, primary_key: :id)
       associate(:many_to_one, :consumer, class: "PactBroker::Domain::Pacticipant", key: :consumer_id, primary_key: :id)
+      associate(:many_to_many, :consumer_versions, class: "PactBroker::Domain::Version", join_table: :pact_publications, left_key: :pact_version_id, right_key: :consumer_version_id, order: :order)
+
+      one_to_one(:latest_verification, class: "PactBroker::Domain::Verification", key: :pact_version_id, primary_key: :id) do | ds |
+        ds.unlimited.latest_by_pact_version
+      end
+
+      # do not eager load this - it won't work because of the limit(1)
+      one_through_one(:latest_consumer_version, class: "PactBroker::Domain::Version", join_table: :pact_publications, left_key: :pact_version_id, right_key: :consumer_version_id) do | ds |
+        ds.unlimited.order(Sequel.desc(:order)).limit(1)
+      end
 
       dataset_module do
         include PactBroker::Repositories::Helpers
@@ -50,23 +59,13 @@ module PactBroker
         pact_publications.last.consumer.name
       end
 
-      def latest_consumer_version
-        consumer_versions.last
-      end
-
       def latest_pact_publication
-        PactBroker::Pacts::LatestPactPublicationsByConsumerVersion
-          .where(pact_version_id: id)
-          .order(:consumer_version_order)
-          .last || PactBroker::Pacts::AllPactPublications
-          .where(pact_version_id: id)
-          .order(:consumer_version_order)
-          .last
+        PactBroker::Pacts::PactPublication
+          .for_pact_version_id(id)
+          .remove_overridden_revisions_from_complete_query
+          .latest || PactBroker::Pacts::PactPublication.for_pact_version_id(id).latest
       end
 
-      def consumer_versions
-        PactBroker::Domain::Version.where(id: PactBroker::Pacts::PactPublication.select(:consumer_version_id).where(pact_version_id: id)).order(:order)
-      end
 
       def latest_consumer_version_number
         latest_consumer_version.number

data/lib/pact_broker/pacts/pacts_for_verification_repository.rb

@@ -8,6 +8,7 @@ require "pact_broker/pacts/selected_pact"
 require "pact_broker/pacts/selector"
 require "pact_broker/pacts/selectors"
 require "pact_broker/feature_toggle"
+require "pact_broker/repositories/scopes"
 
 module PactBroker
   module Pacts
@@ -16,6 +17,7 @@ module PactBroker
       include PactBroker::Repositories
       include PactBroker::Services
       include PactBroker::Repositories::Helpers
+      include PactBroker::Repositories::Scopes
 
       def find(provider_name, consumer_version_selectors)
         selected_pacts = find_pacts_by_selector(provider_name, consumer_version_selectors) +
@@ -35,43 +37,43 @@ module PactBroker
       # provider tags they are pending for.
       # Don't include pact publications that were created before the provider tag was first used
       # (that is, before the provider's git branch was created).
-      def find_wip provider_name, provider_version_branch, provider_tags_names = [], options = {}
+      def find_wip provider_name, provider_version_branch, provider_tags_names, specified_pact_version_shas, options = {}
         # TODO not sure about this
-        return [] if provider_tags_names.empty? && provider_version_branch == nil
+        if provider_tags_names.empty? && provider_version_branch == nil
+          log_debug_for_wip do
+            logger.debug("No provider tags or branch provided. Cannot calculate WIP pacts. Returning an empty list.")
+          end
+          return []
+        end
 
         if provider_version_branch
-          return find_wip_pact_versions_for_provider_by_provider_branch(provider_name, provider_version_branch, options)
+          return find_wip_pact_versions_for_provider_by_provider_branch(provider_name, provider_version_branch, specified_pact_version_shas, options)
         end
 
         provider = pacticipant_repository.find_by_name(provider_name)
         wip_start_date = options.fetch(:include_wip_pacts_since)
-        provider_tags = provider_tag_objects_for(provider, provider_tags_names)
 
         wip_by_consumer_tags = find_wip_pact_versions_for_provider_by_provider_tags(
           provider,
           provider_tags_names,
-          provider_tags,
           wip_start_date,
-          :latest_by_consumer_tag)
+          specified_pact_version_shas,
+          :latest_by_consumer_tag
+        )
 
         wip_by_consumer_branches = find_wip_pact_versions_for_provider_by_provider_tags(
           provider,
           provider_tags_names,
-          provider_tags,
           wip_start_date,
-          :latest_by_consumer_branch)
+          specified_pact_version_shas,
+          :latest_by_consumer_branch
+        )
 
         deduplicate_verifiable_pacts(wip_by_consumer_tags + wip_by_consumer_branches).sort
       end
 
       private
 
-      # For the times when it doesn't make sense to use the scoped class, this is a way to
-      # indicate that it is an intentional use of the PactVersion class directly.
-      def unscoped(scope)
-        scope
-      end
-
       # Note: created_at is coming back as a string for sqlite
       # Can't work out how to to tell Sequel that this should be a date
       def to_datetime string_or_datetime
@@ -107,6 +109,7 @@ module PactBroker
                     else
                       consumer_version_selectors.select(&:latest_for_tag?) +
                         consumer_version_selectors.select(&:latest_for_branch?) +
+                        consumer_version_selectors.select(&:latest_for_main_branch?) +
                         consumer_version_selectors.select(&:overall_latest?) +
                         consumer_version_selectors.select(&:currently_deployed?) +
                         consumer_version_selectors.select(&:currently_supported?)
@@ -193,16 +196,19 @@ module PactBroker
       end
 
       # TODO ? find the WIP pacts by consumer branch
-      def find_wip_pact_versions_for_provider_by_provider_tags(provider, provider_tags_names, _provider_tags, wip_start_date, pact_publication_scope)
+      def find_wip_pact_versions_for_provider_by_provider_tags(provider, provider_tags_names, wip_start_date, specified_pact_version_shas, pact_publication_scope)
         potential_wip_pacts_by_consumer_tag_query = PactPublication.for_provider(provider).created_after(wip_start_date).send(pact_publication_scope)
-        potential_wip_pacts_by_consumer_tag = potential_wip_pacts_by_consumer_tag_query.all
+
+        log_debug_for_wip do
+          log_pact_publications("Potential WIP pacts for provider tag(s) #{provider_tags_names.join(", ")} created after #{wip_start_date} by #{pact_publication_scope}", potential_wip_pacts_by_consumer_tag_query)
+        end
 
         tag_to_pact_publications = provider_tags_names.each_with_object({}) do | provider_tag_name, tag_to_pact_publication |
           tag_to_pact_publication[provider_tag_name] = remove_non_wip_for_tag(
-            potential_wip_pacts_by_consumer_tag,
             potential_wip_pacts_by_consumer_tag_query,
             provider,
-            provider_tag_name
+            provider_tag_name,
+            specified_pact_version_shas
           )
         end
 
@@ -222,20 +228,30 @@ module PactBroker
         end
       end
 
-      def find_wip_pact_versions_for_provider_by_provider_branch(provider_name, provider_version_branch, options)
+      def find_wip_pact_versions_for_provider_by_provider_branch(provider_name, provider_version_branch, specified_pact_version_shas, options)
         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
+
+        log_debug_for_wip do
+          log_pact_publications("Potential WIP pacts for provider branch #{provider_version_branch} created after #{wip_start_date} by consumer branch", potential_wip_by_consumer_branch)
+          log_pact_publications("Potential WIP pacts for provider branch #{provider_version_branch} created after #{wip_start_date} by consumer tag", potential_wip_by_consumer_tag)
+        end
+
         wip_pact_publications_by_branch = remove_non_wip_for_branch(
-          PactPublication.for_provider(provider).created_after(wip_start_date).latest_by_consumer_branch,
+          potential_wip_by_consumer_branch,
           provider,
-          provider_version_branch
+          provider_version_branch,
+          specified_pact_version_shas
         )
 
         wip_pact_publications_by_tag = remove_non_wip_for_branch(
-          PactPublication.for_provider(provider).created_after(wip_start_date).latest_by_consumer_tag,
+          potential_wip_by_consumer_tag,
           provider,
-          provider_version_branch
+          provider_version_branch,
+          specified_pact_version_shas
         )
 
         verifiable_pacts = (wip_pact_publications_by_branch + wip_pact_publications_by_tag).collect do | pact_publication |
@@ -272,18 +288,57 @@ module PactBroker
           end
       end
 
-      def remove_non_wip_for_branch(pact_publications, provider, provider_version_branch)
-        remaining_pact_publications = PactPublication.subtract(pact_publications.all, pact_publications.successfully_verified_by_provider_branch_when_not_wip(provider.id, provider_version_branch).all)
-        PactPublication.subtract(remaining_pact_publications, pact_publications.successfully_verified_by_provider_another_branch_before_this_branch_first_created(provider.id, provider_version_branch).all)
+
+      def remove_non_wip_for_branch(pact_publications_query, provider, provider_version_branch, specified_pact_version_shas)
+        specified_explicitly = pact_publications_query.for_pact_version_sha(specified_pact_version_shas)
+        verified_by_this_branch = pact_publications_query.successfully_verified_by_provider_branch_when_not_wip(provider.id, provider_version_branch)
+        verified_by_other_branch = pact_publications_query.successfully_verified_by_provider_another_branch_before_this_branch_first_created(provider.id, provider_version_branch)
+
+        log_debug_for_wip do
+          log_pact_publications("Ignoring pacts explicitly specified in the selectors", specified_explicitly)
+          log_pact_publications("Ignoring pacts successfully verified by this provider branch when not WIP", verified_by_this_branch)
+          log_pact_publications("Ignoring pacts successfully verified by another provider branch when not WIP", verified_by_other_branch)
+        end
+
+        PactPublication.subtract(pact_publications_query.all, specified_explicitly.all, verified_by_this_branch.all, verified_by_other_branch.all)
       end
 
-      def remove_non_wip_for_tag(pact_publications, query, provider, tag)
-        pact_publications = PactPublication.subtract(pact_publications, query.successfully_verified_by_provider_tag_when_not_wip(provider.id, tag).all)
-        PactPublication.subtract(pact_publications, query.successfully_verified_by_provider_another_tag_before_this_tag_first_created(provider.id, tag).all)
+      def remove_non_wip_for_tag(pact_publications_query, provider, tag, specified_pact_version_shas)
+        specified_explicitly = pact_publications_query.for_pact_version_sha(specified_pact_version_shas)
+        verified_by_this_tag = pact_publications_query.successfully_verified_by_provider_tag_when_not_wip(provider.id, tag)
+        verified_by_another_tag = pact_publications_query.successfully_verified_by_provider_another_tag_before_this_tag_first_created(provider.id, tag)
+
+        log_debug_for_wip do
+          log_pact_publications("Ignoring pacts explicitly specified in the selectors", specified_explicitly)
+          log_pact_publications("Ignoring pacts successfully verified by this provider tag when not WIP", verified_by_this_tag)
+          log_pact_publications("Ignoring pacts successfully verified by another provider tag when not WIP", verified_by_another_tag)
+        end
+
+        PactPublication.subtract(pact_publications_query.all, specified_explicitly.all, verified_by_this_tag.all, verified_by_another_tag.all)
+      end
+
+      def collect_consumer_name_and_version_number(pact_publications_query)
+        pact_publications_query.eager(:provider).eager(:consumer).eager(:consumer_version).order(:consumer_version_order).all.sort.collect do |p|
+          tag_suffix = p.values[:tag_name] ? " (tag #{p.values[:tag_name]})" : ""
+          "#{p.consumer_name} #{p.consumer_version_number}" + tag_suffix
+        end
       end
 
-      def scope_for(scope)
-        PactBroker.policy_scope!(scope)
+      def log_pact_publications(message, pact_publications_query)
+        pact_publication_descriptions = collect_consumer_name_and_version_number(pact_publications_query)
+        if pact_publication_descriptions.any?
+          logger.debug("#{message}", payload: pact_publication_descriptions)
+        else
+          logger.debug("#{message} (none)")
+        end
+      end
+
+      def log_debug_for_wip
+        if logger.debug?
+          log_with_tag(:wip) do
+            yield
+          end
+        end
       end
     end
   end

data/lib/pact_broker/pacts/parse.rb

@@ -1,4 +1,5 @@
 require "pact_broker/json"
+require "json"
 
 module PactBroker
   module Pacts

data/lib/pact_broker/pacts/repository.rb

@@ -20,6 +20,7 @@ require "pact_broker/pacts/selector"
 require "pact_broker/pacts/selectors"
 require "pact_broker/feature_toggle"
 require "pact_broker/pacts/pacts_for_verification_repository"
+require "pact_broker/pacts/content"
 
 module PactBroker
   module Pacts
@@ -51,7 +52,8 @@ module PactBroker
           provider_id: params[:provider_id],
           consumer_id: params[:consumer_id],
           pact_version: pact_version,
-          revision_number: 1
+          revision_number: 1,
+          consumer_version_order: params.fetch(:version).order,
         ).upsert
         update_latest_pact_publication_ids(pact_publication)
         pact_publication.to_domain
@@ -71,6 +73,7 @@ module PactBroker
             provider_id: existing_model.provider_id,
             revision_number: next_revision_number(existing_model),
             consumer_id: existing_model.consumer_id,
+            consumer_version_order: existing_model.consumer_version_order,
             pact_version_id: pact_version.id,
             created_at: Sequel.datetime_class.now
           ).upsert
@@ -139,38 +142,36 @@ module PactBroker
         scope_for(PactVersion).where(consumer: consumer, provider: provider).delete
       end
 
-      def find_latest_pact_versions_for_provider provider_name, tag = nil
+      def find_latest_pacts_for_provider provider_name, tag = nil
+        query = scope_for(PactPublication)
+                  .for_provider_name(provider_name)
+                  .eager(:consumer)
+
         if tag
-          scope_for(LatestTaggedPactPublications).provider(provider_name).order_ignore_case(:consumer_name).where(tag_name: tag).collect(&:to_domain)
+          query = query.latest_for_consumer_tag(tag)
         else
-          scope_for(LatestPactPublications).provider(provider_name).order_ignore_case(:consumer_name).collect(&:to_domain)
+          query = query.overall_latest
         end
+
+        query.sort_by{ | p| p.consumer_name.downcase }.collect(&:to_head_pact)
       end
 
       def find_for_verification(provider_name, consumer_version_selectors)
         PactsForVerificationRepository.new.find(provider_name, consumer_version_selectors)
       end
 
-      def find_wip_pact_versions_for_provider provider_name, provider_version_branch, provider_tags_names = [], options = {}
-        PactsForVerificationRepository.new.find_wip(provider_name, provider_version_branch, provider_tags_names, options)
+      def find_wip_pact_versions_for_provider provider_name, provider_version_branch, provider_tags_names, specified_pact_version_shas, options = {}
+        PactsForVerificationRepository.new.find_wip(provider_name, provider_version_branch, provider_tags_names, specified_pact_version_shas, options)
       end
 
       def find_pact_versions_for_provider provider_name, tag = nil
-        if tag
-          scope_for(LatestPactPublicationsByConsumerVersion)
-            .join(:tags, {version_id: :consumer_version_id})
-            .provider(provider_name)
-            .order_ignore_case(:consumer_name)
-            .order_append(:consumer_version_order)
-            .where(Sequel[:tags][:name] => tag)
-            .collect(&:to_domain)
-        else
-          scope_for(LatestPactPublicationsByConsumerVersion)
-            .provider(provider_name)
-            .order_ignore_case(:consumer_name)
-            .order_append(:consumer_version_order)
-            .collect(&:to_domain)
-        end
+        query = scope_for(PactPublication)
+            .select_all_qualified
+            .for_provider_name(provider_name)
+            .eager(:consumer)
+            .eager(:provider)
+        query = query.for_consumer_version_tag(tag) if tag
+        query.collect(&:to_domain).sort
       end
 
       # Returns latest pact version for the consumer_version_number
@@ -189,7 +190,12 @@ module PactBroker
       end
 
       def find_latest_pacts
-        scope_for(LatestPactPublications).order(:consumer_name, :provider_name).collect(&:to_domain)
+        scope_for(PactPublication)
+          .overall_latest
+          .eager(:consumer)
+          .eager(:provider)
+          .collect(&:to_domain)
+          .sort
       end
 
       def find_latest_pact(consumer_name, provider_name, tag = nil)
@@ -220,29 +226,31 @@ module PactBroker
       end
 
       # rubocop: disable Metrics/CyclomaticComplexity, Metrics/MethodLength
-      def find_pact consumer_name, consumer_version, provider_name, pact_version_sha = nil
-        pact_publication_by_consumer_version = scope_for(LatestPactPublicationsByConsumerVersion)
-            .consumer(consumer_name)
-            .provider(provider_name)
-            .maybe_consumer_version_number(consumer_version)
+      def find_pact consumer_name, consumer_version_number, provider_name, pact_version_sha = nil
+        pact_publication_by_consumer_version = scope_for(PactPublication)
+            .select_all_qualified
+            .for_consumer_name_and_maybe_version_number(consumer_name, consumer_version_number)
+            .for_provider_name(provider_name)
+            .remove_overridden_revisions
             .limit(1)
 
-        latest_pact_publication_by_sha = scope_for(AllPactPublications)
-            .consumer(consumer_name)
-            .provider(provider_name)
-            .pact_version_sha(pact_version_sha)
+        latest_pact_publication_by_sha = scope_for(PactPublication)
+            .select_all_qualified
+            .for_consumer_name(consumer_name)
+            .for_provider_name(provider_name)
+            .for_pact_version_sha(pact_version_sha)
             .reverse_order(:consumer_version_order, :revision_number)
             .limit(1)
 
-        if consumer_version && !pact_version_sha
+        if consumer_version_number && !pact_version_sha
           pact_publication_by_consumer_version
             .eager(:tags)
             .collect(&:to_domain_with_content).first
-        elsif pact_version_sha && !consumer_version
+        elsif pact_version_sha && !consumer_version_number
           latest_pact_publication_by_sha
             .eager(:tags)
             .collect(&:to_domain_with_content).first
-        elsif consumer_version && pact_version_sha
+        elsif consumer_version_number && pact_version_sha
           pact_publication = pact_publication_by_consumer_version.all.first
           if pact_publication && pact_publication.pact_version.sha == pact_version_sha
             pact_publication.tags
@@ -261,12 +269,12 @@ module PactBroker
       end
       # rubocop: enable Metrics/CyclomaticComplexity, Metrics/MethodLength
 
-      def find_all_revisions consumer_name, consumer_version, provider_name
-        scope_for(AllPactPublications)
-          .consumer(consumer_name)
-          .provider(provider_name)
-          .consumer_version_number(consumer_version)
-          .order(:consumer_version_order, :revision_number).collect(&:to_domain_with_content)
+      def find_all_revisions consumer_name, consumer_version_number, provider_name
+        scope_for(PactPublication)
+          .for_provider_name(provider_name)
+          .for_consumer_name_and_maybe_version_number(consumer_name, consumer_version_number)
+          .order_by_consumer_version_order
+          .collect(&:to_domain_with_content)
       end
 
       def find_previous_pact pact, tag = nil
@@ -348,7 +356,9 @@ module PactBroker
           provider_id: provider_id,
           sha: sha,
           content: json_content,
-          created_at: Sequel.datetime_class.now
+          created_at: Sequel.datetime_class.now,
+          interactions_count: Content.from_json(json_content).interactions&.count || 0,
+          messages_count: Content.from_json(json_content).messages&.count || 0
         ).upsert
       end