pact_broker 2.107.1 → 2.108.0

data/lib/pact_broker/domain/version.rb

@@ -1,26 +1,9 @@
-require "pact_broker/db"
+require "pact_broker/dataset"
 require "pact_broker/domain/order_versions"
-require "pact_broker/repositories/helpers"
-require "pact_broker/tags/tag_with_latest_flag"
 require "pact_broker/versions/eager_loaders"
 
 module PactBroker
   module Domain
-
-    # Same attributes as PactBroker::Tags::TagWithLatestFlag
-    class EagerTagWithLatestFlag < SimpleDelegator
-      attr_reader :latest
-
-      def initialize(tag, latest)
-        super(tag)
-        @latest = latest
-      end
-
-      def latest?
-        latest
-      end
-    end
-
     VERSION_COLUMNS = [:id, :number, :repository_ref, :pacticipant_id, :order, :created_at, :updated_at, :build_url]
 
     class Version < Sequel::Model(Sequel::Model.db[:versions].select(*VERSION_COLUMNS.collect{ | column | Sequel.qualify(:versions, column) }))
@@ -51,7 +34,7 @@ module PactBroker
         eager_loader: PactBroker::Versions::EagerLoaders::LatestVersionForPacticipant
 
       dataset_module do
-        include PactBroker::Repositories::Helpers
+        include PactBroker::Dataset
 
         def with_branch
           where(id: PactBroker::Versions::BranchVersion.select(:version_id))
@@ -214,6 +197,7 @@ module PactBroker
         end
 
         # rubocop: disable Metrics/CyclomaticComplexity
+        # @param [PactBroker::Matrix::UnresolvedSelector] selector
         def for_selector(selector)
           query = self
           query = query.where_pacticipant_name(selector.pacticipant_name) if selector.pacticipant_name
@@ -252,6 +236,15 @@ module PactBroker
         end
         # rubocop: enable Metrics/CyclomaticComplexity
 
+        # Return the IDs of the versions described by the given unresolved selectors
+        # @return Sequel::Dataset<PactBroker::Domain::Version>
+        def ids_for_selectors(unresolved_selectors)
+          # Need the select at the start and at the end to stop extra columns being returned (eg. branch name, environment name)
+          unresolved_selectors
+            .collect{ |selector| self.select(Sequel[:versions][:id]).for_selector(selector).select(:id) }
+            .reduce(&:union)
+        end
+
         def pacticipants_set
           from_self(alias: :v)
             .select_group(Sequel[:v][:pacticipant_id])

data/lib/pact_broker/errors/error_reporter.rb

@@ -0,0 +1,30 @@
+require "pact_broker/logging"
+require "pact_broker/errors"
+
+module PactBroker
+  module Errors
+    class ErrorReporter
+      include PactBroker::Logging
+
+      def initialize(api_error_reporters)
+        @api_error_reporters = api_error_reporters
+      end
+
+      def call error, error_reference, env
+        if PactBroker::Errors.reportable_error?(error)
+          api_error_reporters.each do | error_reporter |
+            begin
+              error_reporter.call(error, env: env, error_reference: error_reference)
+            rescue StandardError => e
+              log_error(e, "Error executing api_error_reporter")
+            end
+          end
+        end
+      end
+
+      private
+
+      attr_reader :api_error_reporters
+    end
+  end
+end

data/lib/pact_broker/errors.rb

@@ -1,28 +1,15 @@
-require "pact_broker/configuration"
-require "pact_broker/error"
-require "pact_broker/logging"
 require "securerandom"
 
 module PactBroker
   module Errors
-    include PactBroker::Logging
-
     def self.generate_error_reference
       SecureRandom.urlsafe_base64.gsub(/[^a-z]/i, "")[0,10]
     end
 
+    # Return true if the error is one that should be reported to an external bug tracking system
+    # @return [Boolean]
     def self.reportable_error?(error)
       error.is_a?(PactBroker::TestError) || (!error.is_a?(PactBroker::Error) && !error.is_a?(JSON::JSONError))
     end
-
-    def self.report error, error_reference, env
-      PactBroker.configuration.api_error_reporters.each do | error_notifier |
-        begin
-          error_notifier.call(error, env: env, error_reference: error_reference)
-        rescue StandardError => e
-          log_error(e, "Error executing api_error_reporter")
-        end
-      end
-    end
   end
 end

data/lib/pact_broker/events/subscriber.rb

@@ -32,11 +32,19 @@ module PactBroker
     extend self
 
     def subscribe(*args)
-      result = nil
-      TemporaryListeners.subscribe(*args) do
-        result = yield
+      if block_given?
+        result = nil
+        TemporaryListeners.subscribe(*args) do
+          result = yield
+        end
+        result
+      else
+        Wisper.subscribe(*args)
       end
-      result
+    end
+
+    def unsubscribe(*args)
+      Wisper.unsubscribe(*args)
     end
   end
 end

data/lib/pact_broker/feature_toggle.rb

@@ -15,7 +15,7 @@ module PactBroker
     end
 
     def self.feature_in_env_var?(feature)
-      PactBroker.configuration.features.include?(feature.to_s.downcase)
+      PactBroker.configuration.features[feature.to_s.downcase.to_sym] == true
     end
   end
 

data/lib/pact_broker/groups/service.rb

@@ -1,5 +1,5 @@
 require "pact_broker/repositories"
-require "pact_broker/relationships/groupify"
+require "pact_broker/domain/index_item"
 
 module PactBroker
   module Groups
@@ -8,13 +8,46 @@ module PactBroker
       extend PactBroker::Repositories
       extend PactBroker::Services
 
-      def find_group_containing pacticipant
-        groups.find { | group | group.include_pacticipant? pacticipant }
+      # Returns a list of all the integrations (PactBroker::Domain::IndexItem) that are connected to the given pacticipant.
+      # @param pacticipant [PactBroker::Domain::Pacticipant] the pacticipant for which to return the connected pacticipants
+      # @option max_pacticipants [Integer] the maximum number of pacticipants to return, or nil for no maximum. 40 is about the most applications you can meaningfully show in the circle network diagram.
+      # @return [PactBroker::Domain::Group]
+      def find_group_containing(pacticipant, max_pacticipants: nil)
+        PactBroker::Domain::Group.new(build_index_items(integrations_connected_to(pacticipant, max_pacticipants)))
       end
 
-      def groups
-        Relationships::Groupify.call(index_service.find_all_index_items)
+      def integrations_connected_to(pacticipant, max_pacticipants)
+        PactBroker::Integrations::Integration
+          .eager(:consumer, :provider)
+          .where(id: ids_of_integrations_connected_to(pacticipant, max_pacticipants))
+          .all
       end
+      private_class_method :integrations_connected_to
+
+      def build_index_items(integrations)
+        integrations.collect do | integration |
+          PactBroker::Domain::IndexItem.new(integration.consumer, integration.provider)
+        end
+      end
+      private_class_method :build_index_items
+
+      def ids_of_integrations_connected_to(pacticipant, max_pacticipants)
+        integrations = []
+        connected_pacticipants = Set.new([pacticipant.id])
+        new_connected_pacticipants = Set.new([pacticipant.id])
+
+        loop do
+          new_integrations = PactBroker::Integrations::Integration.including_pacticipant_id(new_connected_pacticipants.to_a).exclude(id: integrations.collect(&:id)).all
+          integrations.concat(new_integrations)
+          pacticipant_ids_for_new_integrations = Set.new(new_integrations.flat_map(&:pacticipant_ids))
+          new_connected_pacticipants = pacticipant_ids_for_new_integrations - connected_pacticipants
+          connected_pacticipants.merge(pacticipant_ids_for_new_integrations)
+          break if new_connected_pacticipants.empty? || (max_pacticipants && connected_pacticipants.size >= max_pacticipants)
+        end
+
+        integrations.collect(&:id).uniq
+      end
+      private_class_method :ids_of_integrations_connected_to
     end
   end
 end

data/lib/pact_broker/index/service.rb

@@ -1,7 +1,6 @@
 require "pact_broker/repositories"
 require "pact_broker/logging"
 require "pact_broker/domain/index_item"
-require "pact_broker/repositories/helpers"
 require "pact_broker/index/page"
 require "pact_broker/verifications/latest_verification_for_consumer_version_tag"
 require "pact_broker/string_refinements"
@@ -74,7 +73,7 @@ module PactBroker
           .eager(:provider)
           .eager(pact_version: { latest_verification: { provider_version: [{ current_deployed_versions: :environment }, { current_supported_released_versions: :environment }, :branch_heads, { tags: :head_tag } ] } })
           .eager(integration: [{latest_verification: :provider_version}, :latest_triggered_webhooks])
-          .eager(consumer_version: [{ current_deployed_versions: :environment }, { current_supported_released_versions: :environment }, :branch_heads, { tags: :head_tag }])
+          .eager(consumer_version: [{ current_deployed_versions: :environment }, { current_supported_released_versions: :environment }, :branch_versions, :branch_heads, { tags: :head_tag }])
           .eager(:head_pact_publications_for_tags)
 
         index_items = pact_publications.all.collect do | pact_publication |

data/lib/pact_broker/integrations/event_listener.rb

@@ -0,0 +1,23 @@
+require "pact_broker/services"
+
+# Listens for events that happen in the Pact Broker that are relevant to the Integrations objects.
+
+module PactBroker
+  module Integrations
+    class EventListener
+      include PactBroker::Services
+
+      # @param [Hash] params the params from the broadcast event
+      # @option params [PactBroker::Domain::Pact] :pact the newly published pact
+      def contract_published(params)
+        integration_service.handle_contract_data_published(params.fetch(:pact).consumer, params.fetch(:pact).provider)
+      end
+
+      # @param [Hash] params the params from the broadcast event
+      # @option params [PactBroker::Domain::Verification] :verification the newly published verification
+      def provider_verification_published(params)
+        integration_service.handle_contract_data_published(params.fetch(:verification).consumer, params.fetch(:verification).provider)
+      end
+    end
+  end
+end

data/lib/pact_broker/integrations/integration.rb

@@ -1,4 +1,4 @@
-require "pact_broker/db"
+require "pact_broker/dataset"
 require "pact_broker/verifications/pseudo_branch_status"
 require "pact_broker/domain/verification"
 require "pact_broker/webhooks/latest_triggered_webhook"
@@ -7,7 +7,7 @@ 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))
+    class Integration < Sequel::Model(Sequel::Model.db[:integrations].select(:id, :consumer_id, :provider_id, :contract_data_updated_at))
       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)
@@ -75,6 +75,20 @@ module PactBroker
         end
       end)
 
+      dataset_module do
+        include PactBroker::Dataset
+
+        def filter_by_pacticipant(query_string)
+          matching_pacticipants = PactBroker::Domain::Pacticipant.filter(:name, query_string)
+          pacticipants_join = Sequel.|({ Sequel[:integrations][:consumer_id] => Sequel[:p][:id] }, { Sequel[:integrations][:provider_id] => Sequel[:p][:id] })
+          join(matching_pacticipants, pacticipants_join, table_alias: :p)
+        end
+
+        def including_pacticipant_id(pacticipant_id)
+          where(consumer_id: pacticipant_id).or(provider_id: pacticipant_id)
+        end
+      end
+
       def self.compare_by_last_action_date a, b
         if b.latest_pact_or_verification_publication_date && a.latest_pact_or_verification_publication_date
           b.latest_pact_or_verification_publication_date <=> a.latest_pact_or_verification_publication_date
@@ -111,6 +125,14 @@ module PactBroker
       def provider_name
         provider.name
       end
+
+      def pacticipant_ids
+        [consumer_id, provider_id]
+      end
+
+      def to_s
+        "Integration: consumer #{associations[:consumer]&.name || consumer_id}/provider #{associations[:provider]&.name || provider_id}"
+      end
     end
   end
 end

data/lib/pact_broker/integrations/repository.rb

@@ -1,14 +1,28 @@
 require "pact_broker/integrations/integration"
+require "pact_broker/repositories/scopes"
 
 module PactBroker
   module Integrations
     class Repository
+
+      include PactBroker::Repositories::Scopes
+
+      def find(filter_options = {}, pagination_options = {}, eager_load_associations = [])
+        query = scope_for(PactBroker::Integrations::Integration).select_all_qualified
+        query = query.filter_by_pacticipant(filter_options[:query_string]) if filter_options[:query_string]
+        query
+          .eager(*eager_load_associations)
+          .order(Sequel.desc(:contract_data_updated_at, nulls: :last))
+          .all_with_pagination_options(pagination_options)
+      end
+
       def create_for_pact(consumer_id, provider_id)
         if Integration.where(consumer_id: consumer_id, provider_id: provider_id).empty?
           Integration.new(
             consumer_id: consumer_id,
             provider_id: provider_id,
-            created_at: Sequel.datetime_class.now
+            created_at: Sequel.datetime_class.now,
+            contract_data_updated_at: Sequel.datetime_class.now
           ).insert_ignore
         end
         nil
@@ -17,6 +31,25 @@ module PactBroker
       def delete(consumer_id, provider_id)
         Integration.where(consumer_id: consumer_id, provider_id: provider_id).delete
       end
+
+      # Sets the contract_data_updated_at for the integration(s) as specified by the consumer and provider
+      # @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)
+      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
+      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
+        Integration
+          .where([:consumer_id, :provider_id] => consumer_and_provider_ids)
+          .update(contract_data_updated_at: Sequel.datetime_class.now)
+      end
     end
   end
 end

data/lib/pact_broker/integrations/service.rb

@@ -3,7 +3,6 @@ require "pact_broker/repositories"
 require "pact_broker/logging"
 require "pact_broker/integrations/integration"
 require "pact_broker/db/models"
-require "pact_broker/repositories/helpers"
 require "pact_broker/repositories/scopes"
 
 module PactBroker
@@ -14,22 +13,22 @@ module PactBroker
       include PactBroker::Logging
       extend PactBroker::Repositories::Scopes
 
-      def self.find_all
-        # The only reason the pact_version needs to be loaded is that
-        # the Verification::PseudoBranchStatus uses it to determine if
-        # the pseudo branch is 'stale'.
-        # Because this is the status for a pact, and not a pseudo branch,
-        # the status can never be 'stale',
-        # so it would be better to create a Verification::PactStatus class
-        # that doesn't have the 'stale' logic in it.
-        # Then we can remove the eager loading of the pact_version
-        scope_for(PactBroker::Integrations::Integration)
-          .eager(:consumer)
-          .eager(:provider)
-          .eager(:latest_pact) # latest_pact eager loader is custom, can't take any more options
-          .eager(:latest_verification)
-          .all
-          .sort { | a, b| Integration.compare_by_last_action_date(a, b) }
+      def self.find_all(filter_options = {}, pagination_options = {}, eager_load_associations = [])
+        integration_repository.find(filter_options, pagination_options, eager_load_associations)
+      end
+
+      # Callback to invoke when a consumer contract, verification result (or provider contract in Pactflow) is published
+      # @param [PactBroker::Domain::Pacticipant] consumer or nil
+      # @param [PactBroker::Domain::Pacticipant] provider
+      def self.handle_contract_data_published(consumer, provider)
+        integration_repository.set_contract_data_updated_at(consumer, provider)
+      end
+
+
+      # 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.set_contract_data_updated_at_for_multiple_integrations(objects_with_consumer_and_provider)
       end
 
       def self.delete(consumer_name, provider_name)
@@ -49,7 +48,7 @@ module PactBroker
       def self.delete_all
         # TODO move all these into their own repositories
         PactBroker::DB.each_integration_model do | model |
-          if PactBroker::Repositories::Helpers.postgres?
+          if PactBroker::Dataset::Helpers.postgres?
             logger.info("Truncating ", model.table_name)
             model.truncate(cascade: true)
           else

data/lib/pact_broker/labels/repository.rb

@@ -1,22 +1,18 @@
 require "pact_broker/domain/label"
-require "pact_broker/repositories/helpers"
 
 module PactBroker
   module Labels
     class Repository
-
-      include PactBroker::Repositories::Helpers
-
       def create args
         Domain::Label.new(name: args.fetch(:name), pacticipant: args.fetch(:pacticipant)).save
       end
 
       def find args
         PactBroker::Domain::Label
-          .select(Sequel.qualify("labels", "name"), Sequel.qualify("labels", "pacticipant_id"), Sequel.qualify("labels", "created_at"), Sequel.qualify("labels", "updated_at"))
-          .join(:pacticipants, {id: :pacticipant_id})
-          .where(name_like(Sequel.qualify("labels", "name"), args.fetch(:label_name)))
-          .where(name_like(Sequel.qualify("pacticipants", "name"), args.fetch(:pacticipant_name)))
+          .select_all_qualified
+          .join(:pacticipants, { id: :pacticipant_id })
+          .where(Sequel.name_like(Sequel.qualify("labels", "name"), args.fetch(:label_name)))
+          .where(Sequel.name_like(Sequel.qualify("pacticipants", "name"), args.fetch(:pacticipant_name)))
           .single_record
       end
 

data/lib/pact_broker/locale/en.yml

@@ -59,7 +59,11 @@ en:
         verifications: Add Pact verification tests to the %{provider_name} build. See https://docs.pact.io/go/provider_verification
         webhooks: Configure separate %{provider_name} pact verification build and webhook to trigger it when the pact content changes. See https://docs.pact.io/go/webhooks
         version_branch: Configure the version branch to be the value of your repository branch.
+      branch:
+        bulk_delete: "Scheduled deletion of %{count} branches for pacticipant %{pacticipant_name}. Remaining branches are: %{remaining}"
     errors:
+      runtime:
+        with_error_reference: "An error has occurred. The details have been logged with the reference %{error_reference}"
       validation:
         no_spaces: "cannot contain spaces"
         single_line: "cannot contain multiple lines"
@@ -89,6 +93,7 @@ en:
         environment_with_name_not_found: "Environment with name '%{name}' does not exist"
         cannot_modify_version_branch: "The branch for a pacticipant version cannot be changed once set (currently '%{old_branch}', proposed value '%{new_branch}'). Your pact publication/verification publication configurations may be in conflict with each other if you are seeing this error. If the current branch value is incorrect, you must delete the pacticipant version resource at %{version_url} and publish the pacts/verification results again with a consistent branch name."
         invalid_content_for_content_type: "content could not be parsed as %{content_type}"
+        invalid_parsed_contract_class: "parsed content was expected to be a Hash but was a %{actual_class}"
         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.

data/lib/pact_broker/matrix/every_row.rb

@@ -1,13 +1,45 @@
-require "pact_broker/matrix/quick_row"
+require "pact_broker/matrix/matrix_row"
+require "pact_broker/matrix/matrix_row_dataset_module"
+require "pact_broker/matrix/matrix_row_instance_methods"
+require "pact_broker/matrix/matrix_row_verification_dataset_module"
 
+# Same as PactBroker::Matrix::MatrixRow
+# except the data is sourced from the pact_publications table, and contains
+# every pact publication, not just the latest publication for the consumer version.
+# This is used when there is no "latestby" in the matrix query.
 module PactBroker
   module Matrix
-    class EveryRow < PactBroker::Matrix::QuickRow
-      set_dataset(Sequel.as(:pact_publications, :p))
+    class EveryRow < Sequel::Model(Sequel.as(:pact_publications, :p))
 
-      P_V_JOIN = { Sequel[:p][:pact_version_id] => Sequel[:v][:pact_version_id] }
+      # Same as PactBroker::Matrix::MatrixRow::Verification
+      # except the data is sourced from the verifications table, and contains
+      # every verification, not just the latest verification for the pact version and the provider version.
+      # This is used when there is no "latestby" in the matrix query.
+      class Verification < Sequel::Model(:verifications)
+        dataset_module do
+          select(:select_verification_columns_with_aliases,
+            Sequel[:verifications][:id].as(:verification_id),
+            Sequel[:verifications][:provider_version_id],
+            Sequel[:verifications][:created_at].as(:provider_version_created_at),
+            Sequel[:verifications][:pact_version_id]
+          )
 
-      PACT_COLUMNS = [
+          include PactBroker::Matrix::MatrixRowVerificationDatasetModule
+        end
+      end
+
+      # Must be kept in sync with PactBroker::Matrix::MatrixRow
+      associate(:many_to_one, :pact_publication, :class => "PactBroker::Pacts::PactPublication", :key => :pact_publication_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_one, :consumer_version, :class => "PactBroker::Domain::Version", :key => :consumer_version_id, :primary_key => :id)
+      associate(:many_to_one, :provider_version, :class => "PactBroker::Domain::Version", :key => :provider_version_id, :primary_key => :id)
+      associate(:many_to_one, :pact_version, class: "PactBroker::Pacts::PactVersion", :key => :pact_version_id, :primary_key => :id)
+      associate(:many_to_one, :verification, class: "PactBroker::Domain::Verification", :key => :verification_id, :primary_key => :id)
+      associate(:one_to_many, :consumer_version_tags, :class => "PactBroker::Domain::Tag", primary_key: :consumer_version_id, key: :version_id)
+      associate(:one_to_many, :provider_version_tags, :class => "PactBroker::Domain::Tag", primary_key: :provider_version_id, key: :version_id)
+
+      PACT_COLUMNS_WITH_ALIASES = [
         Sequel[:p][:consumer_id],
         Sequel[:p][:provider_id],
         Sequel[:p][:consumer_version_id],
@@ -18,50 +50,36 @@ module PactBroker
         Sequel[:p][:id].as(:pact_order)
       ]
 
-      VERIFICATION_COLUMNS = [
-        Sequel[:v][:id].as(:verification_id),
+      ALL_COLUMNS_AFTER_JOIN = [
+        Sequel[:p][:consumer_id],
+        Sequel[:p][:provider_id],
+        Sequel[:p][:consumer_version_id],
+        Sequel[:p][:pact_publication_id],
+        Sequel[:p][:pact_version_id],
+        Sequel[:p][:pact_revision_number],
+        Sequel[:p][:consumer_version_created_at],
+        Sequel[:p][:pact_order],
+        Sequel[:v][:verification_id],
         Sequel[:v][:provider_version_id],
-        Sequel[:v][:created_at].as(:provider_version_created_at)
+        Sequel[:v][:provider_version_created_at]
       ]
 
-      JOINED_VERIFICATION_COLUMNS = [:id, :pact_version_id, :provider_id, :provider_version_id, :created_at]
-
-      ALL_COLUMNS = PACT_COLUMNS + VERIFICATION_COLUMNS
-
-      SELECT_ALL_COLUMN_ARGS = [:select_all_columns] + ALL_COLUMNS
-
       dataset_module do
-        select(*SELECT_ALL_COLUMN_ARGS)
+        include PactBroker::Matrix::MatrixRowDatasetModule
 
-        def join_verifications
-          left_outer_join(:verifications, P_V_JOIN, { table_alias: :v } )
-        end
+        select(:select_pact_columns_with_aliases, *PACT_COLUMNS_WITH_ALIASES)
+        select(:select_all_columns_after_join, *ALL_COLUMNS_AFTER_JOIN)
 
-        def inner_join_verifications
-          join(:verifications, P_V_JOIN, { table_alias: :v } )
-        end
-
-        def inner_join_verifications_matching_one_selector_provider_or_provider_version(query_ids)
-          verifications = db[:verifications]
-            .select(*JOINED_VERIFICATION_COLUMNS)
-            .where {
-              QueryBuilder.provider_or_provider_version_matches(query_ids)
-            }
-
-          join(verifications, P_V_JOIN, { table_alias: :v } )
+        def verification_dataset
+          EveryRow::Verification
         end
+      end
 
-        def verifications_for(query_ids)
-          db[:verifications]
-            .select(*JOINED_VERIFICATION_COLUMNS)
-            .where {
-              Sequel.&(
-                QueryBuilder.consumer_in_pacticipant_ids(query_ids),
-                QueryBuilder.provider_or_provider_version_matches(query_ids)
-              )
-            }
-        end
+      def pact_publication_id
+        return_or_raise_if_not_set(:pact_publication_id)
       end
+
+      include PactBroker::Matrix::MatrixRowInstanceMethods
     end
   end
 end