pact_broker 2.76.2 → 2.79.1

data/lib/pact_broker/pacts/latest_pact_publication_id_for_consumer_version.rb

@@ -15,17 +15,22 @@ module PactBroker
   end
 end
 
-# Table: latest_pact_publications_by_consumer_versions
+# Table: latest_pact_publication_ids_for_consumer_versions
+# Primary Key: (provider_id, consumer_version_id)
 # Columns:
-#  id                      | integer                     |
-#  consumer_id             | integer                     |
-#  consumer_name           | text                        |
-#  consumer_version_id     | integer                     |
-#  consumer_version_number | text                        |
-#  consumer_version_order  | integer                     |
-#  provider_id             | integer                     |
-#  provider_name           | text                        |
-#  revision_number         | integer                     |
-#  pact_version_id         | integer                     |
-#  pact_version_sha        | text                        |
-#  created_at              | timestamp without time zone |
+#  consumer_id         | integer                     | NOT NULL
+#  consumer_version_id | integer                     | NOT NULL
+#  provider_id         | integer                     | NOT NULL
+#  pact_publication_id | integer                     | NOT NULL
+#  pact_version_id     | integer                     | NOT NULL
+#  created_at          | timestamp without time zone |
+# Indexes:
+#  latest_pact_publication_ids_for_consume_pact_publication_id_key | UNIQUE btree (pact_publication_id)
+#  unq_latest_ppid_prov_conver                                     | UNIQUE btree (provider_id, consumer_version_id)
+#  lpp_provider_id_consumer_id_index                               | btree (provider_id, consumer_id)
+# Foreign key constraints:
+#  latest_pact_publication_ids_for_consum_consumer_version_id_fkey | (consumer_version_id) REFERENCES versions(id) ON DELETE CASCADE
+#  latest_pact_publication_ids_for_consum_pact_publication_id_fkey | (pact_publication_id) REFERENCES pact_publications(id) ON DELETE CASCADE
+#  latest_pact_publication_ids_for_consumer_v_pact_version_id_fkey | (pact_version_id) REFERENCES pact_versions(id) ON DELETE CASCADE
+#  latest_pact_publication_ids_for_consumer_versi_consumer_id_fkey | (consumer_id) REFERENCES pacticipants(id) ON DELETE CASCADE
+#  latest_pact_publication_ids_for_consumer_versi_provider_id_fkey | (provider_id) REFERENCES pacticipants(id) ON DELETE CASCADE

data/lib/pact_broker/pacts/lazy_loaders.rb

@@ -0,0 +1,14 @@
+module PactBroker
+  module Pacts
+    module LazyLoaders
+      HEAD_PACT_PUBLICATIONS_FOR_TAGS = lambda {
+          consumer_version_tag_names = PactBroker::Domain::Tag.select(:name).where(version_id: consumer_version_id)
+          PactPublication
+            .for_consumer(consumer)
+            .for_provider(provider)
+            .latest_for_consumer_tag(consumer_version_tag_names)
+            .from_self.order_by(:tag_name)
+          }
+    end
+  end
+end

data/lib/pact_broker/pacts/pact_publication.rb

@@ -4,6 +4,9 @@ require 'pact_broker/pacts/pact_version'
 require 'pact_broker/repositories/helpers'
 require 'pact_broker/integrations/integration'
 require 'pact_broker/tags/head_pact_tags'
+require 'pact_broker/pacts/pact_publication_dataset_module'
+require 'pact_broker/pacts/eager_loaders'
+require 'pact_broker/pacts/lazy_loaders'
 
 module PactBroker
   module Pacts
@@ -20,93 +23,25 @@ module PactBroker
       associate(:many_to_one, :pact_version, class: "PactBroker::Pacts::PactVersion", :key => :pact_version_id, :primary_key => :id)
       associate(:many_to_one, :integration, class: "PactBroker::Integrations::Integration", key: [:consumer_id, :provider_id], primary_key: [:consumer_id, :provider_id])
       one_to_one(:latest_verification, class: "PactBroker::Verifications::LatestVerificationForPactVersion", key: :pact_version_id, primary_key: :pact_version_id)
-      one_to_many(:head_pact_tags, class: "PactBroker::Tags::HeadPactTag", primary_key: :id, key: :pact_publication_id)
+
+      one_to_many(:head_pact_publications_for_tags,
+        class: PactPublication,
+        read_only: true,
+        dataset: PactBroker::Pacts::LazyLoaders::HEAD_PACT_PUBLICATIONS_FOR_TAGS,
+        eager_loader: PactBroker::Pacts::EagerLoaders::HeadPactPublicationsForTags
+      )
 
       plugin :upsert, identifying_columns: [:consumer_version_id, :provider_id, :revision_number]
       plugin :timestamps, update_on_create: true
 
       dataset_module do
         include PactBroker::Repositories::Helpers
+        include PactPublicationDatasetModule
+      end
 
-        def remove_overridden_revisions
-          join(:latest_pact_publication_ids_for_consumer_versions, { Sequel[:lp][:pact_publication_id] => Sequel[:pact_publications][:id] }, { table_alias: :lp})
-        end
-
-        def join_consumer_versions(table_alias = :cv)
-          join(:versions, { Sequel[:pact_publications][:consumer_version_id] => Sequel[table_alias][:id] }, { table_alias: table_alias })
-        end
-
-        def join_consumer_version_tags(table_alias = :ct)
-          join(:tags, { Sequel[table_alias][:version_id] => Sequel[:pact_publications][:consumer_version_id]}, { table_alias: table_alias })
-        end
-
-        def join_consumer_version_tags_with_names(consumer_version_tag_names)
-          join(:tags, {
-            Sequel[:ct][:version_id] => Sequel[:pact_publications][:consumer_version_id],
-            Sequel[:ct][:name] => consumer_version_tag_names
-          }, {
-            table_alias: :ct
-          })
-        end
-
-        def join_providers(table_alias = :providers)
-          join(:pacticipants, { Sequel[:pact_publications][:provider_id] => Sequel[table_alias][:id] }, { table_alias: table_alias })
-        end
-
-        def join_consumers(table_alias = :consumers)
-          join(:pacticipants, { Sequel[:pact_publications][:consumer_id] => Sequel[table_alias][:id] }, { table_alias: table_alias })
-        end
-
-        def join_pact_versions
-          join(:pact_versions, { Sequel[:pact_publications][:pact_version_id] => Sequel[:pact_versions][:id] })
-        end
-
-        def eager_load_pact_versions
-          eager(:pact_versions)
-        end
-
-        def tag tag_name
-          filter = name_like(Sequel.qualify(:tags, :name), tag_name)
-          join(:tags, {version_id: :consumer_version_id}).where(filter)
-        end
-
-        def provider_name_like(name)
-          where(name_like(Sequel[:providers][:name], name))
-        end
-
-        def consumer_name_like(name)
-          where(name_like(Sequel[:consumers][:name], name))
-        end
-
-        def consumer_version_number_like(number)
-          where(name_like(Sequel[:cv][:number], number))
-        end
-
-        def consumer_version_tag(tag)
-          where(Sequel[:ct][:name] => tag)
-        end
-
-        def order_by_consumer_name
-          order_append_ignore_case(Sequel[:consumers][:name])
-        end
-
-        def order_by_consumer_version_order
-          order_append(Sequel[:cv][:order])
-        end
-
-        def where_consumer_if_set(consumer)
-          if consumer
-            where(consumer: consumer)
-          else
-            self
-          end
-        end
-
-        def delete
-          require 'pact_broker/webhooks/triggered_webhook'
-          PactBroker::Webhooks::TriggeredWebhook.where(pact_publication: self).delete
-          super
-        end
+      def self.subtract(a, b)
+        b_ids = b.collect(&:id)
+        a.reject{ |pact_publication| b_ids.include?(pact_publication.id) }
       end
 
       def before_create
@@ -114,10 +49,16 @@ module PactBroker
         self.revision_number ||= 1
       end
 
+      def head_pact_tags
+        consumer_version.tags.select{ |tag| head_tag_names.include?(tag.name) }
+      end
+
       # The names of the tags for which this pact is the latest pact with that tag
       # (ie. it is not necessarily the pact for the latest consumer version with the given tag)
       def head_tag_names
-        @head_tag_names ||= PactBroker::Domain::Tag.head_tags_for_pact_publication(self).collect(&:name)
+        @head_tag_names ||= head_pact_publications_for_tags
+          .select { |head_pact_publication| head_pact_publication.id == id }
+          .collect { | head_pact_publication| head_pact_publication.values.fetch(:tag_name) }
       end
 
       def consumer_version_tags
@@ -128,6 +69,19 @@ module PactBroker
         pact_version.latest_verification
       end
 
+      def latest_for_branch?
+        return nil unless consumer_version.branch
+        self_order = self.consumer_version.order
+        versions_join = {
+          Sequel[:pact_publications][:consumer_version_id] => Sequel[:cv][:id]
+        }
+        PactPublication.where(consumer_id: consumer_id, provider_id: provider_id)
+          .join_consumer_versions(:cv, { Sequel[:cv][:branch] => consumer_version.branch} ) do
+            Sequel[:cv][:order] > self_order
+          end
+        .empty?
+      end
+
       def to_domain
         PactBroker::Domain::Pact.new(
           id: id,
@@ -160,11 +114,11 @@ module PactBroker
       end
 
       def to_version_domain
-        OpenStruct.new(number: consumer_version.number, pacticipant: consumer, tags: consumer_version.tags, order: consumer_version.order)
+        OpenStruct.new(number: consumer_version.number, pacticipant: consumer, tags: consumer_version.tags, order: consumer_version.order, branch: consumer_version.branch)
       end
 
       def to_version_domain_lightweight
-        OpenStruct.new(number: consumer_version.number, pacticipant: consumer, order: consumer_version.order)
+        OpenStruct.new(number: consumer_version.number, pacticipant: consumer, order: consumer_version.order, branch: consumer_version.branch)
       end
 
       private
@@ -178,7 +132,7 @@ end
 
 # Table: pact_publications
 # Columns:
-#  id                  | integer                     | PRIMARY KEY DEFAULT nextval('pact_publications_id_seq'::regclass)
+#  id                  | integer                     | PRIMARY KEY GENERATED BY DEFAULT AS IDENTITY
 #  consumer_version_id | integer                     | NOT NULL
 #  provider_id         | integer                     | NOT NULL
 #  revision_number     | integer                     | NOT NULL

data/lib/pact_broker/pacts/pact_publication_dataset_module.rb

@@ -0,0 +1,297 @@
+module PactBroker
+  module Pacts
+    module PactPublicationDatasetModule
+      def for_provider provider
+        where(provider: provider)
+      end
+
+      def for_consumer consumer
+        where(consumer: consumer)
+      end
+
+      def for_provider_and_consumer_version_selector provider, selector
+        # Does not yet support "all pacts for specified tag" - that code is still in the Pact::Repository
+        query = for_provider(provider)
+        query = query.for_consumer(PactBroker::Domain::Pacticipant.find_by_name(selector.consumer)) if selector.consumer
+        # Do this last so that the provider/consumer criteria get included in the "latest" query before the join, rather than after
+        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?
+        query
+      end
+
+      def latest_by_consumer_branch
+        versions_join = {
+          Sequel[:pact_publications][:consumer_version_id] => Sequel[:cv][:id]
+        }
+
+        base_query = join(:versions, versions_join, { table_alias: :cv }) do
+          Sequel.lit("cv.branch is not null")
+        end
+
+        self_join = {
+          Sequel[:pact_publications][:consumer_id] => Sequel[:pp2][:consumer_id],
+          Sequel[:cv][:branch] => Sequel[:pp2][:branch]
+        }
+
+        if no_columns_selected?
+          base_query = base_query.select_all_qualified.select_append(Sequel[:cv][:branch])
+        end
+
+        base_query.left_join(base_query.select(:consumer_id, :branch, :order), self_join, { table_alias: :pp2 } ) do
+          Sequel[:pp2][:order] > Sequel[:cv][:order]
+        end
+        .where(Sequel[:pp2][:order] => nil)
+        .remove_overridden_revisions_from_complete_query
+      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 = 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]
+        end
+        .where(Sequel[:pp2][:order] => nil)
+        .remove_overridden_revisions_from_complete_query
+      end
+
+      def latest_for_consumer_branch(branch)
+        versions_join = {
+          Sequel[:pact_publications][:consumer_version_id] => Sequel[:cv][:id],
+          Sequel[:cv][:branch] => branch
+        }
+
+        base_query = join(:versions, versions_join, { table_alias: :cv }) do
+          Sequel.lit("cv.branch is not null")
+        end
+
+        self_join = {
+          Sequel[:pact_publications][:consumer_id] => Sequel[:pp2][:consumer_id],
+          Sequel[:cv][:branch] => Sequel[:pp2][:branch]
+        }
+
+        if no_columns_selected?
+          base_query = base_query.select_all_qualified.select_append(Sequel[:cv][:branch])
+        end
+
+        base_query.left_join(base_query.select(:consumer_id, :branch, :order), self_join, { table_alias: :pp2 } ) do
+          Sequel[:pp2][:order] > Sequel[:cv][:order]
+        end
+        .where(Sequel[:pp2][:order] => nil)
+        .remove_overridden_revisions_from_complete_query
+      end
+
+      def latest_by_consumer_tag
+        tags_join = {
+          Sequel[:pact_publications][:consumer_version_id] => Sequel[:tags][:version_id]
+        }
+
+        base_query = join(:tags, tags_join)
+
+        if no_columns_selected?
+          base_query = base_query.select_all_qualified.select_append(Sequel[:tags][:name].as(:tag_name))
+        end
+
+        joined_query = base_query.select(
+          Sequel[:pact_publications][:consumer_id],
+          Sequel[:tags][:version_order],
+          Sequel[:tags][:name].as(:tag_name)
+        )
+
+        self_join = {
+          Sequel[:pact_publications][:consumer_id] => Sequel[:pp2][:consumer_id],
+          Sequel[:tags][:name] => Sequel[:pp2][:tag_name]
+        }
+        base_query.left_join(joined_query, self_join, { table_alias: :pp2 } ) do
+          Sequel[:pp2][:version_order] > Sequel[:tags][:version_order]
+        end
+        .where(Sequel[:pp2][:version_order] => nil)
+        .remove_overridden_revisions_from_complete_query
+      end
+
+      def latest_for_consumer_tag(tag_name)
+        tags_join = {
+          Sequel[:pact_publications][:consumer_version_id] => Sequel[:tags][:version_id],
+          Sequel[:tags][:name] => tag_name
+        }
+
+        base_query = self
+        if no_columns_selected?
+          base_query = base_query.select_all_qualified.select_append(Sequel[:tags][:name].as(:tag_name))
+        end
+
+        base_query = base_query
+          .join(:tags, tags_join)
+          .where(Sequel[:tags][:name] => tag_name)
+
+        joined_query = base_query.select(
+          Sequel[:pact_publications][:consumer_id],
+          Sequel[:tags][:name].as(:tag_name),
+          Sequel[:tags][:version_order]
+        )
+
+        self_join = {
+          Sequel[:pact_publications][:consumer_id] => Sequel[:pp2][:consumer_id],
+          Sequel[:tags][:name] => Sequel[:pp2][:tag_name]
+        }
+
+        base_query.left_join(joined_query, self_join, { table_alias: :pp2 } ) do
+          Sequel[:pp2][:version_order] > Sequel[:tags][:version_order]
+        end
+        .where(Sequel[:pp2][:version_order] => nil)
+        .remove_overridden_revisions_from_complete_query
+      end
+
+      def successfully_verified_by_provider_branch(provider_id, provider_version_branch)
+        verifications_join = {
+          pact_version_id: :pact_version_id,
+          Sequel[:verifications][:success] => true,
+          Sequel[:verifications][:wip] => false,
+          Sequel[:verifications][:provider_id] => provider_id
+        }
+        versions_join = {
+          Sequel[:verifications][:provider_version_id] => Sequel[:provider_versions][:id],
+          Sequel[:provider_versions][:branch] => provider_version_branch,
+          Sequel[:provider_versions][:pacticipant_id] => provider_id
+        }
+
+        from_self(alias: :pp).select(Sequel[:pp].*)
+          .join(:verifications, verifications_join)
+          .join(:versions, versions_join, { table_alias: :provider_versions } )
+          .where(Sequel[:pp][:provider_id] => provider_id)
+          .distinct
+      end
+
+      def successfully_verified_by_provider_tag(provider_id, provider_tag)
+        verifications_join = {
+          pact_version_id: :pact_version_id,
+          Sequel[:verifications][:success] => true,
+          Sequel[:verifications][:wip] => false,
+          Sequel[:verifications][:provider_id] => provider_id
+        }
+        tags_join = {
+          Sequel[:verifications][:provider_version_id] => Sequel[:provider_tags][:version_id],
+          Sequel[:provider_tags][:name] => provider_tag
+        }
+
+        from_self(alias: :pp).select(Sequel[:pp].*)
+          .join(:verifications, verifications_join)
+          .join(:tags, tags_join, { table_alias: :provider_tags } )
+          .where(Sequel[:pp][:provider_id] => provider_id)
+          .distinct
+      end
+
+      def created_after date
+        where(Sequel.lit("#{first_source_alias}.created_at > ?", date))
+      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})
+      end
+
+      def remove_overridden_revisions_from_complete_query
+        from_self(alias: :p)
+        .select(Sequel[:p].*)
+        .remove_overridden_revisions(:p)
+      end
+
+      def join_consumer_versions(table_alias = :cv, extra_join_criteria = {}, &block)
+        versions_join = {
+          Sequel[:pact_publications][:consumer_version_id] => Sequel[table_alias][:id]
+        }.merge(extra_join_criteria)
+        join(:versions, versions_join, { table_alias: table_alias }, &block)
+      end
+
+      def join_consumer_version_tags(table_alias = :ct)
+        join(:tags, { Sequel[table_alias][:version_id] => Sequel[:pact_publications][:consumer_version_id]}, { table_alias: table_alias })
+      end
+
+      def join_consumer_version_tags_with_names(consumer_version_tag_names)
+        join(:tags, {
+          Sequel[:ct][:version_id] => Sequel[:pact_publications][:consumer_version_id],
+          Sequel[:ct][:name] => consumer_version_tag_names
+        }, {
+          table_alias: :ct
+        })
+      end
+
+      def join_providers(table_alias = :providers, base_table = :pact_publications, extra_join_criteria = {})
+        provider_join = {
+          Sequel[base_table][:provider_id] => Sequel[table_alias][:id]
+        }.merge(extra_join_criteria)
+        join(:pacticipants, provider_join, { table_alias: table_alias })
+      end
+
+      def join_consumers(table_alias = :consumers, base_table = :pact_publications, extra_join_criteria = {})
+        consumer_join = {
+          Sequel[base_table][:consumer_id] => Sequel[table_alias][:id]
+        }.merge(extra_join_criteria)
+        join(:pacticipants, consumer_join, { table_alias: table_alias })
+      end
+
+      def join_pact_versions
+        join(:pact_versions, { Sequel[:pact_publications][:pact_version_id] => Sequel[:pact_versions][:id] })
+      end
+
+      def eager_load_pact_versions
+        eager(:pact_versions)
+      end
+
+      def tag tag_name
+        filter = name_like(Sequel.qualify(:tags, :name), tag_name)
+        join(:tags, {version_id: :consumer_version_id}).where(filter)
+      end
+
+      def provider_name_like(name)
+        where(name_like(Sequel[:providers][:name], name))
+      end
+
+      def consumer_name_like(name)
+        where(name_like(Sequel[:consumers][:name], name))
+      end
+
+      def consumer_version_number_like(number)
+        where(name_like(Sequel[:cv][:number], number))
+      end
+
+      def consumer_version_tag(tag)
+        where(Sequel[:ct][:name] => tag)
+      end
+
+      def order_by_consumer_name
+        order_append_ignore_case(Sequel[:consumers][:name])
+      end
+
+      def order_by_consumer_version_order
+        order_append(Sequel[:cv][:order])
+      end
+
+      def where_consumer_if_set(consumer)
+        if consumer
+          where(consumer: consumer)
+        else
+          self
+        end
+      end
+
+      def delete
+        require 'pact_broker/webhooks/triggered_webhook'
+        PactBroker::Webhooks::TriggeredWebhook.where(pact_publication: self).delete
+        super
+      end
+
+      private
+
+      def no_columns_selected?
+        opts[:select].nil?
+      end
+    end
+  end
+end