pact_broker 2.75.0 → 2.78.0

data/lib/pact_broker/db/data_migrations/helpers.rb

@@ -5,6 +5,10 @@ module PactBroker
         def column_exists?(connection, table, column)
           connection.table_exists?(table) && connection.schema(table).find{|col| col.first == column }
         end
+
+        def columns_exist?(connection, table, columns)
+          columns.all?{ | column | column_exists?(connection, table, column) }
+        end
       end
     end
   end

data/lib/pact_broker/db/data_migrations/set_extra_columns_for_tags.rb

@@ -0,0 +1,29 @@
+require 'pact_broker/db/data_migrations/helpers'
+
+module PactBroker
+  module DB
+    module DataMigrations
+      class SetExtraColumnsForTags
+        extend Helpers
+
+        def self.call(connection)
+          if columns_exist?(connection, :tags, [:version_id, :pacticipant_id]) &&
+              columns_exist?(connection, :versions, [:id, :pacticipant_id])
+            connection[:tags].update(
+              pacticipant_id: connection[:versions].select(:pacticipant_id)
+                                .where(Sequel[:versions][:id] => Sequel[:tags][:version_id])
+            )
+          end
+
+          if columns_exist?(connection, :tags, [:version_id, :version_order]) &&
+              columns_exist?(connection, :versions, [:id, :order])
+            connection[:tags].update(
+              version_order: connection[:versions].select(:order)
+                                .where(Sequel[:versions][:id] => Sequel[:tags][:version_id])
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pact_broker/db/migrate_data.rb

@@ -21,6 +21,7 @@ module PactBroker
         DataMigrations::DeleteDeprecatedWebhookExecutions.call(database_connection)
         DataMigrations::SetCreatedAtForLatestPactPublications.call(database_connection)
         DataMigrations::SetCreatedAtForLatestVerifications.call(database_connection)
+        DataMigrations::SetExtraColumnsForTags.call(database_connection)
       end
     end
   end

data/lib/pact_broker/db/seed_example_data.rb

@@ -16,25 +16,25 @@ module PactBroker
         PactBroker::Test::TestDataBuilder.new
           .create_consumer(consumer_name, created_at: days_ago(16))
           .create_provider(provider_name, created_at: days_ago(16))
-          .create_consumer_version("e15da45d3943bf10793a6d04cfb9f5dabe430fe2", created_at: days_ago(16))
+          .create_consumer_version("e15da45d3943bf10793a6d04cfb9f5dabe430fe2", branch: "main", created_at: days_ago(16))
           .create_consumer_version_tag("prod", created_at: days_ago(16))
-          .create_consumer_version_tag("master", created_at: days_ago(16))
+          .create_consumer_version_tag("main", created_at: days_ago(16))
           .create_pact(json_content: pact_1, created_at: days_ago(16))
-          .create_verification(provider_version: "1315e0b1924cb6f42751f977789be3559373033a", execution_date: days_ago(15))
-          .create_provider_version_tag("master", created_at: days_ago(14))
+          .create_verification(provider_version: "1315e0b1924cb6f42751f977789be3559373033a", branch: "main", execution_date: days_ago(15))
+          .create_provider_version_tag("main", created_at: days_ago(14))
           .create_provider_version_tag("prod", created_at: days_ago(14))
-          .create_verification(provider_version: "480e5aeb30467856ca995d0024d2c1800b0719e5", success: false, number: 2, execution_date: days_ago(14))
-          .create_provider_version_tag("master", created_at: days_ago(14))
-          .create_consumer_version("725c6ccb7cf7efc51b4394f9828585eea9c379d9", created_at: days_ago(7))
+          .create_verification(provider_version: "480e5aeb30467856ca995d0024d2c1800b0719e5", branch: "main", success: false, number: 2, execution_date: days_ago(14))
+          .create_provider_version_tag("main", created_at: days_ago(14))
+          .create_consumer_version("725c6ccb7cf7efc51b4394f9828585eea9c379d9", branch: "feat/new-thing", created_at: days_ago(7))
           .create_consumer_version_tag("feat-new-thing", created_at: days_ago(7))
           .create_pact(json_content: pact_2, created_at: days_ago(7))
-          .create_consumer_version("7bd4d9173522826dc3e8704fd62dde0424f4c827", created_at: days_ago(1))
-          .create_consumer_version_tag("master", created_at: days_ago(1))
+          .create_consumer_version("7bd4d9173522826dc3e8704fd62dde0424f4c827", branch: "main", created_at: days_ago(1))
+          .create_consumer_version_tag("main", created_at: days_ago(1))
           .create_pact(json_content: pact_3, created_at: days_ago(1))
-          .create_verification(provider_version: "4fdf20082263d4c5038355a3b734be1c0054d1e1", execution_date: days_ago(1))
-          .create_provider_version_tag("master", created_at: days_ago(1))
-          .create_consumer_version("5556b8149bf8bac76bc30f50a8a2dd4c22c85f30", created_at: days_ago(0.5))
-          .create_consumer_version_tag("master", created_at: days_ago(0.5))
+          .create_verification(provider_version: "4fdf20082263d4c5038355a3b734be1c0054d1e1", branch: "main", execution_date: days_ago(1))
+          .create_provider_version_tag("main", created_at: days_ago(1))
+          .create_consumer_version("5556b8149bf8bac76bc30f50a8a2dd4c22c85f30", branch: "main", created_at: days_ago(0.5))
+          .create_consumer_version_tag("main", created_at: days_ago(0.5))
           .republish_same_pact(created_at: days_ago(0.5))
       end
 

data/lib/pact_broker/deployments/environment.rb

@@ -0,0 +1,15 @@
+require 'sequel'
+require 'sequel/plugins/serialization'
+
+
+module PactBroker
+  module Deployments
+    class Environment < Sequel::Model
+      OPEN_STRUCT_TO_JSON = lambda { |thing| Sequel.object_to_json(thing.collect(&:to_h)) }
+      JSON_TO_OPEN_STRUCT = lambda { | json | Sequel.parse_json(json).collect{ | hash| OpenStruct.new(hash) } }
+      plugin :upsert, identifying_columns: [:uuid]
+      plugin :serialization
+      serialize_attributes [OPEN_STRUCT_TO_JSON, JSON_TO_OPEN_STRUCT], :contacts
+    end
+  end
+end

data/lib/pact_broker/deployments/environment_service.rb

@@ -0,0 +1,39 @@
+require 'pact_broker/deployments/environment'
+require 'securerandom'
+
+module PactBroker
+  module Deployments
+    module EnvironmentService
+
+      def self.next_uuid
+        SecureRandom.uuid
+      end
+
+      def self.create(uuid, environment)
+        environment.uuid = uuid
+        environment.save
+      end
+
+      def self.update(uuid, environment)
+        environment.uuid = uuid
+        environment.upsert
+      end
+
+      def self.find_all
+        PactBroker::Deployments::Environment.order(Sequel.function(:lower, :display_name)).all
+      end
+
+      def self.find(uuid)
+        PactBroker::Deployments::Environment.where(uuid: uuid).single_record
+      end
+
+      def self.find_by_name(name)
+        PactBroker::Deployments::Environment.where(name: name).single_record
+      end
+
+      def self.delete(uuid)
+        PactBroker::Deployments::Environment.where(uuid: uuid).delete
+      end
+    end
+  end
+end

data/lib/pact_broker/doc/controllers/app.rb

@@ -51,7 +51,7 @@ module PactBroker
           # https://www.acunetix.com/blog/articles/automated-detection-of-host-header-attacks/
           # Either use the explicitly configured base url or an empty string,
           # rather than request.base_url, which uses the X-Forwarded headers.
-          env["pactbroker.base_url"] || PactBroker.configuration.base_url || ''
+          env["pactbroker.base_url"] || ''
         end
       end
     end

data/lib/pact_broker/doc/views/index/environment.markdown

@@ -0,0 +1,37 @@
+# Environment
+
+Allowed methods: `GET`, `PUT`, `DELETE`
+
+Path: `/environment/{uuid}`
+
+## Viewing an environment
+
+Example:
+
+    curl http://${PACT_BROKER_HOST}/environments/79060381-269c-4769-9894-9ec3cab44729 \
+      -H "Accept: application/hal+json"
+    {
+      "uuid": "79060381-269c-4769-9894-9ec3cab44729",
+      "name": "test",
+      "displayName": "Test",
+      "production": false
+    }
+
+## Updating an environment
+
+Example:
+
+    curl -X PUT http://${PACT_BROKER_HOST}/environments/79060381-269c-4769-9894-9ec3cab44729 \
+      -H "Content-Type: application/json" \
+      -H "Accept: application/hal+json" \
+      -d '{
+          "name": "test",
+          "displayName": "Test",
+          "production": false
+        }'
+
+## Deleting an environment
+
+Example:
+
+    curl -v -X DELETE http://${PACT_BROKER_HOST}/environments/79060381-269c-4769-9894-9ec3cab44729

data/lib/pact_broker/doc/views/index/environments.markdown

@@ -0,0 +1,53 @@
+# Environments
+
+Allowed methods: `GET`, `POST`
+
+Path: `/environments`
+
+## Creating an environment
+
+Send a POST to `/environments` with the environment payload.
+
+Example:
+
+    curl http://${PACT_BROKER_HOST}/environments \
+      -H "Content-Type: application/json" \
+      -H "Accept: application/hal+json" \
+      -d '{
+          "name": "test",
+          "displayName": "Test",
+          "production": false
+        }'
+
+Alternatively, you can use the HAL Browser.
+
+* Click on the `API Browser` link at the top of the Pact Broker index page.
+* In the `Links` section on the left, locate the `pb:environments` relation, and click on the yellow `!` "Perform non-GET request" button.
+* In the `Body:` text box, fill in the required JSON properties.
+* Click `Make Request`.
+
+Properties:
+
+* `uuid`: System generated unique identifier.
+* `name`: Must be unique. No spaces allowed. This will be the name used in the `can-i-deploy` and `record-deployment` CLI commands. eg. "payments-sit-1"
+* `displayName`: A more verbose name for the environment. "Payments Team SIT 1"
+* `production`: Whether or not this environment is a production environment.
+
+If all the services in the Broker are deployed to the same "public" internet, then there only needs to be one Production environment. If there are multiple segregated production environments (eg. when maintaining on-premises software for multiple customers ) then you should create a separate production Environment for each logical deployment environment.
+
+## Listing environments
+
+`GET /environments`
+
+    {
+      "_embedded": {
+        "environments": [
+          {
+            "uuid": "79060381-269c-4769-9894-9ec3cab44729",
+            "name": "production",
+            "displayName": "Production",
+            "production": true
+          }
+        ]
+      }
+    }

data/lib/pact_broker/doc/views/index/latest-pact-versions.markdown

@@ -1,5 +1,5 @@
 # Latest pact versions
 
-Allowed methods: GET
+Allowed methods: `GET`
 
 A list of the latest pact versions for each consumer/provider pair. The "latest" is determined by inspecting the consumer version used when each pact was published.

data/lib/pact_broker/doc/views/index/pacticipant-version-tag.markdown

@@ -1,6 +1,7 @@
 # Pacticipant version tag
 
 Allowed methods: `GET`, `PUT`, `DELETE`
+
 Path: `/pacticipants/{pacticipant}/versions/{version}/tags/{tag}`
 
 To create a tag, send an empty request with the URL specified above and `Content-Type` of `application/json`.

data/lib/pact_broker/doc/views/index/pacticipant-version.markdown

@@ -0,0 +1,13 @@
+# Pacticipant version
+
+Allowed methods: `GET`, `PUT`, `DELETE`
+
+Path: `/pacticipants/{pacticipant}/versions/{version}`
+
+## Example
+
+    PUT http://broker/pacticipants/Bar/versions/1e70030c6579915e5ff56b107a0fd25cf5df7464
+    {
+      "branch": "main",
+      "buildUrl": "http://ci.mydomain/my-job/1"
+    }

data/lib/pact_broker/domain/index_item.rb

@@ -13,13 +13,13 @@ module PactBroker
         :latest_verification_latest_tags
 
       # rubocop:disable Metrics/ParameterLists
-      def self.create(consumer, provider, latest_pact, latest, latest_verification, webhooks = [], triggered_webhooks = [], tags = [], latest_verification_latest_tags = [])
-        new(consumer, provider, latest_pact, latest, latest_verification, webhooks, triggered_webhooks, tags, latest_verification_latest_tags)
+      def self.create(consumer, provider, latest_pact, latest, latest_verification, webhooks = [], triggered_webhooks = [], tags = [], latest_verification_latest_tags = [], latest_for_branch = nil)
+        new(consumer, provider, latest_pact, latest, latest_verification, webhooks, triggered_webhooks, tags, latest_verification_latest_tags, latest_for_branch)
       end
       # rubocop:enable Metrics/ParameterLists
 
       # rubocop:disable Metrics/ParameterLists
-      def initialize(consumer, provider, latest_pact = nil, latest = true, latest_verification = nil, webhooks = [], triggered_webhooks = [], tags = [], latest_verification_latest_tags = [])
+      def initialize(consumer, provider, latest_pact = nil, latest = true, latest_verification = nil, webhooks = [], triggered_webhooks = [], tags = [], latest_verification_latest_tags = [], latest_for_branch = nil)
         @consumer = consumer
         @provider = provider
         @latest_pact = latest_pact
@@ -29,6 +29,7 @@ module PactBroker
         @triggered_webhooks = triggered_webhooks
         @tags = tags
         @latest_verification_latest_tags = latest_verification_latest_tags
+        @latest_for_branch = latest_for_branch
       end
       # rubocop:enable Metrics/ParameterLists
 
@@ -37,7 +38,8 @@ module PactBroker
           other.latest_pact == latest_pact &&
           other.latest? == latest? &&
           other.latest_verification == latest_verification &&
-          other.webhooks == webhooks
+          other.webhooks == webhooks &&
+          other.latest_for_branch? == latest_for_branch?
       end
 
       def == other
@@ -68,6 +70,14 @@ module PactBroker
         @latest_pact.consumer_version
       end
 
+      def consumer_version_branch
+        consumer_version.branch
+      end
+
+      def latest_for_branch?
+        @latest_for_branch
+      end
+
       def provider_version
         @latest_verification ? @latest_verification.provider_version : nil
       end
@@ -76,6 +86,10 @@ module PactBroker
         @latest_verification ? @latest_verification.provider_version_number : nil
       end
 
+      def provider_version_branch
+        provider_version&.branch
+      end
+
       # these are the consumer tag names for which this pact publication
       # is the latest with that tag
       def tag_names

data/lib/pact_broker/domain/pacticipant.rb

@@ -27,6 +27,10 @@ module PactBroker
           filter = name_like(Sequel[:labels][:name], label_name)
           join(:labels, {pacticipant_id: :id}).where(filter)
         end
+
+        def find_by_name(name)
+          where(name_like(:name, name))
+        end
       end
 
       def before_destroy
@@ -51,17 +55,17 @@ module PactBroker
         messages << message('errors.validation.attribute_missing', attribute: 'name') unless name
         messages
       end
+
+      def any_versions?
+        PactBroker::Domain::Version.where(pacticipant: self).any?
+      end
     end
   end
 end
 
-
-
-
-
 # Table: pacticipants
 # Columns:
-#  id             | integer                     | PRIMARY KEY DEFAULT nextval('pacticipants_id_seq'::regclass)
+#  id             | integer                     | PRIMARY KEY GENERATED BY DEFAULT AS IDENTITY
 #  name           | text                        |
 #  repository_url | text                        |
 #  created_at     | timestamp without time zone | NOT NULL

data/lib/pact_broker/domain/tag.rb

@@ -1,5 +1,6 @@
 require 'pact_broker/db'
 require 'pact_broker/repositories/helpers'
+require 'pact_broker/tags/eager_loaders'
 
 module PactBroker
   module Domain
@@ -10,47 +11,43 @@ module PactBroker
       unrestrict_primary_key
       associate(:many_to_one, :version, :class => "PactBroker::Domain::Version", :key => :version_id, :primary_key => :id)
 
+      # The tag for the latest version that has a tag with a matching name
+      many_to_one :head_tag, read_only: true, key: [:name, :pacticipant_id],
+        class: Tag,
+        dataset: lambda {
+          Tag.where(name: name, pacticipant_id: pacticipant_id)
+            .order(Sequel.desc(:version_order))
+            .limit(1)
+        },
+        eager_loader: PactBroker::Tags::EagerLoaders::HeadTag
+
       dataset_module do
         include PactBroker::Repositories::Helpers
 
-        def latest_tags
-          tags_versions_join = {
-            Sequel[:tags][:version_id] => Sequel[:versions][:id],
-          }
+        def join_pact_publications
+          join(:pact_publications, { Sequel[:tags][:version_id] => Sequel[:pact_publications][:consumer_version_id] } )
+        end
 
-          latest_tags_versions_join = {
-            Sequel[:latest_tags][:name] => Sequel[:tags][:name],
-            Sequel[:latest_tags][:latest_order] => Sequel[:versions][:order],
-            Sequel[:latest_tags][:pacticipant_id] => Sequel[:versions][:pacticipant_id],
-          }
+        def for(pacticipant_name, version_number, tag_name)
+          where(
+            version_id: db[:versions].select(:id).where(
+              number: version_number,
+              pacticipant_id: db[:pacticipants].select(:id).where(name_like(:name, pacticipant_name))
+            ),
+            name: tag_name
+          ).single_record
+        end
 
-          latest_tags = PactBroker::Domain::Tag
-            .select_group(Sequel[:tags][:name], Sequel[:versions][:pacticipant_id])
-            .select_append{ max(order).as(latest_order) }
-            .join(:versions, tags_versions_join)
+        def latest_tags
+          self_join = {
+            Sequel[:tags][:pacticipant_id] => Sequel[:tags_2][:pacticipant_id],
+            Sequel[:tags][:name] => Sequel[:tags_2][:name]
+          }
 
           PactBroker::Domain::Tag
             .select_all_qualified
-            .join(:versions,
-              { Sequel[:tags][:version_id] => Sequel[:versions][:id] }
-            )
-            .join(latest_tags, latest_tags_versions_join, { table_alias: :latest_tags })
-        end
-
-        # Ron's fancy join
-        # performs every so slightly better
-        def latest_tags_2
-          tag_versions = PactBroker::Domain::Tag
-            .select_all_qualified
-            .select_append(Sequel[:versions][:pacticipant_id])
-            .select_append(Sequel[:versions][:order])
-            .join(:versions,
-              { Sequel[:tags][:version_id] => Sequel[:versions][:id] }
-            )
-
-          tag_versions
-            .left_join(tag_versions, { Sequel[:tags][:name] =>  Sequel[:tags_2][:name], Sequel[:versions][:pacticipant_id] => Sequel[:tags_2][:pacticipant_id] }, { table_alias: :tags_2 }) do | table, joined_table, js |
-              Sequel.qualify(table, :order) > Sequel.qualify(joined_table, :order)
+            .left_join(:tags, self_join, { table_alias: :tags_2 }) do
+              Sequel[:tags_2][:version_order] > Sequel[:tags][:version_order]
             end
             .where(Sequel[:tags_2][:name] => nil)
         end
@@ -58,32 +55,40 @@ module PactBroker
         # Does NOT care about whether or not there is a pact publication
         # for the version
         def latest_tags_for_pacticipant_ids(pacticipant_ids)
-          tags_versions_join = {
-            Sequel[:tags][:version_id] => Sequel[:versions][:id],
-            Sequel[:versions][:pacticipant_id] => pacticipant_ids
+          self_join = {
+            Sequel[:tags][:pacticipant_id] => Sequel[:tags_2][:pacticipant_id],
+            Sequel[:tags][:name] => Sequel[:tags_2][:name],
+            Sequel[:tags_2][:pacticipant_id] => pacticipant_ids,
           }
 
-          latest_tags_versions_join = {
-            Sequel[:latest_tags][:name] => Sequel[:tags][:name],
-            Sequel[:latest_tags][:latest_order] => Sequel[:versions][:order],
-            Sequel[:latest_tags][:pacticipant_id] => Sequel[:versions][:pacticipant_id],
-            Sequel[:versions][:pacticipant_id] => pacticipant_ids
-          }
+          Tag
+            .select_all_qualified
+            .left_join(:tags, self_join, { table_alias: :tags_2 }) do
+              Sequel[:tags_2][:version_order] > Sequel[:tags][:version_order]
+            end
+            .where(Sequel[:tags_2][:name] => nil)
+            .where(Sequel[:tags][:pacticipant_id] => pacticipant_ids)
+        end
 
-          latest_tags = PactBroker::Domain::Tag
-            .select_group(Sequel[:tags][:name], Sequel[:versions][:pacticipant_id])
-            .select_append{ max(order).as(latest_order) }
-            .join(:versions, tags_versions_join)
+        def latest_tags_for_pacticipant_ids_and_tag_names(pacticipant_ids, tag_names)
+          self_join = {
+            Sequel[:tags][:pacticipant_id] => Sequel[:tags_2][:pacticipant_id],
+            Sequel[:tags][:name] => Sequel[:tags_2][:name],
+            Sequel[:tags_2][:pacticipant_id] => pacticipant_ids,
+            Sequel[:tags_2][:name] => tag_names
+          }
 
-          PactBroker::Domain::Tag
+          Tag
             .select_all_qualified
-            .join(:versions,
-              { Sequel[:tags][:version_id] => Sequel[:versions][:id],
-                Sequel[:versions][:pacticipant_id] => pacticipant_ids
-              })
-            .join(latest_tags, latest_tags_versions_join, { table_alias: :latest_tags })
+            .left_join(:tags, self_join, { table_alias: :tags_2 }) do
+              Sequel[:tags_2][:version_order] > Sequel[:tags][:version_order]
+            end
+            .where(Sequel[:tags_2][:name] => nil)
+            .where(Sequel[:tags][:pacticipant_id] => pacticipant_ids)
+            .where(Sequel[:tags][:name] => tag_names)
         end
 
+        # ignores tags that don't have a pact publication
         def head_tags_for_consumer_id(consumer_id)
           lp = :latest_pact_publication_ids_for_consumer_versions
           tags_versions_join = {
@@ -98,7 +103,7 @@ module PactBroker
           # head tags for this consumer
           # the latest tag, pacticipant_id, version order
           # for versions that have a pact publication
-          PactBroker::Domain::Tag
+          Tag
             .select_group(Sequel[:tags][:name], Sequel[:versions][:pacticipant_id])
             .select_append{ max(order).as(latest_consumer_version_order) }
             .join(:versions, tags_versions_join)
@@ -106,25 +111,74 @@ module PactBroker
         end
 
         def head_tags_for_pact_publication(pact_publication)
-          head_tags_versions_join = {
-            Sequel[:head_tags][:latest_consumer_version_order] => Sequel[:versions][:order],
-            Sequel[:head_tags][:pacticipant_id] => Sequel[:versions][:pacticipant_id],
-            Sequel[:versions][:pacticipant_id] => pact_publication.consumer_id
-          }
+          Tag.where(version_id: pact_publication.consumer_version_id).all.select do | tag |
+            tag_pp_join = {
+              Sequel[:pact_publications][:consumer_version_id] => Sequel[:tags][:version_id],
+              Sequel[:pact_publications][:consumer_id] => pact_publication.consumer_id,
+              Sequel[:pact_publications][:provider_id] => pact_publication.provider_id,
+              Sequel[:tags][:name] => tag.name
+            }
+            Tag.join(:pact_publications, tag_pp_join) do
+              Sequel[:tags][:version_order] > tag.version_order
+            end
+            .where(pacticipant_id: pact_publication.consumer_id)
+            .limit(1)
+            .empty?
+          end
+        end
+      end
 
-          # Find the head tags that belong to this pact publication
-          # Note: The tag model has the name and version_id,
-          # but does not have the created_at value set - but don't need it for now
-          head_tags_for_consumer_id(pact_publication.consumer_id).from_self(alias: :head_tags)
-            .select(Sequel[:head_tags][:name], Sequel[:versions][:id].as(:version_id))
-            .join(:versions, head_tags_versions_join)
-            .where(Sequel[:versions][:id] => pact_publication.consumer_version_id)
+      def before_save
+        if version
+          if version.order && self.version_order.nil?
+            self.version_order = version.order
+          end
+
+          if self.pacticipant_id.nil?
+            if version.pacticipant_id
+              self.pacticipant_id = version.pacticipant_id
+            elsif version&.pacticipant&.id
+              self.pacticipant_id = version.pacticipant.id
+            end
+          end
+        end
+
+        if version_order.nil? || pacticipant_id.nil?
+          raise PactBroker::Error.new("Need to set version_order and pacticipant_id for tags now")
+        else
+          super
+        end
+      end
+
+      def latest_for_pacticipant?
+        head_tag == self
+      end
+
+      alias_method :latest?, :latest_for_pacticipant?
+
+      def latest_for_pact_publication?(pact_publication)
+        tag_pp_join = {
+          Sequel[:pact_publications][:consumer_version_id] => Sequel[:tags][:version_id],
+          Sequel[:pact_publications][:consumer_id] => pact_publication.consumer_id,
+          Sequel[:pact_publications][:provider_id] => pact_publication.provider_id,
+          Sequel[:tags][:name] => name
+        }
+        own_version_order = self.version_order
+        Tag.join(:pact_publications, tag_pp_join) do
+          Sequel[:tags][:version_order] > own_version_order
         end
+        .where(pacticipant_id: pact_publication.consumer_id)
+        .limit(1)
+        .empty?
       end
 
       def <=> other
         name <=> other.name
       end
+
+      def pacticipant
+        version.pacticipant
+      end
     end
   end
 end
@@ -132,12 +186,18 @@ end
 # Table: tags
 # Primary Key: (name, version_id)
 # Columns:
-#  name       | text                        |
-#  version_id | integer                     |
-#  created_at | timestamp without time zone | NOT NULL
-#  updated_at | timestamp without time zone | NOT NULL
+#  name           | text                        |
+#  version_id     | integer                     |
+#  created_at     | timestamp without time zone | NOT NULL
+#  updated_at     | timestamp without time zone | NOT NULL
+#  pacticipant_id | integer                     |
+#  version_order  | integer                     |
 # Indexes:
-#  tags_pk      | PRIMARY KEY btree (version_id, name)
-#  ndx_tag_name | btree (name)
+#  tags_pk                                           | PRIMARY KEY btree (version_id, name)
+#  ndx_tag_name                                      | btree (name)
+#  tags_pacticipant_id_index                         | btree (pacticipant_id)
+#  tags_pacticipant_id_name_version_order_desc_index | btree (pacticipant_id, name, version_order DESC)
+#  tags_version_id_index                             | btree (version_id)
+#  tags_version_order_index                          | btree (version_order)
 # Foreign key constraints:
 #  tags_version_id_fkey | (version_id) REFERENCES versions(id)