pact_broker 2.106.0 → 2.107.0.beta.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8cbd7d902684d2fc82497cc897310eabd8b9d9fdf1e8fd8073202349d659d82a
-  data.tar.gz: 3eaa5717c1bd08a4eda4bde312d120f18a95c7ed7a2297a603e351fed1bac93a
+  metadata.gz: 3783c3552a022360c2d78e4c3955aef888b18920d60f980ace930f7f03eef877
+  data.tar.gz: 0b327308a96b96c97fcd57b33b272b54d6a9106cac3d84ba7a49a45844d99fb3
 SHA512:
-  metadata.gz: 98abd64cec0b9ba9496de89d32aaf3598d4a7058e6e72e328fd9e8049d9ef9d2429dc0a9275b4e138c8b3a8dcde14ccb554b3b537fd00ae0ac6b06bd5a8b0e47
-  data.tar.gz: 2ad84a36e17e170bed9f617e3f5b93bd9fff140dbf47c36490cf2df46e2222677cca04aab6542f0808492f20494766a76fa69b765cd4ddb9ed1557b6741f830b
+  metadata.gz: e6caba3dfdc61ebef92e21b34dc77f363b8cace4382d8b51d274fa757462e9dc67bf7e9c33f2211a6f9197e83db8e59bdb7ce66027c8343ce3ecb2dedea46a47
+  data.tar.gz: cc1f0c8b8b300054f0c338a7a50dec6c41532c602254c6d8ca3236bc497f235846e0ba54b8c7b4a79ba6dce5205e7883c229dfdfac70070fd025b7d2830c2c50

data/CHANGELOG.md

@@ -1,3 +1,27 @@
+<a name="v2.107.0.beta.1"></a>
+### v2.107.0.beta.1 (2023-05-01)
+
+<a name="v2.107.0.beta.1"></a>
+### v2.107.0.beta.1 (2023-05-01)
+
+#### Features
+
+* add index to webhook_executions pact_publication_id column	 ([37d1a4cf](/../../commit/37d1a4cf))
+* update webmachine to support ruby 3	 ([9bb014e6](/../../commit/9bb014e6))
+* upgrade dry-validation gem in preparation for ruby 3 upgrade	 ([3b4b66bf](/../../commit/3b4b66bf))
+* restructure logs from DeleteOverwrittenData to match CleanIncremental	 ([f11a9417](/../../commit/f11a9417))
+* add branch_heads_branch_version_id_index	 ([b1b4cefb](/../../commit/b1b4cefb))
+
+#### Bug Fixes
+
+* **pacts for verification**
+  * do not allow empty string for provider version branch when it is required for calculating WIP/pending pacts	 ([412c4289](/../../commit/412c4289))
+
+* fix error raised when clean selectors include a selector with a max age and a selector with a max age and a branch	 ([53b171bd](/../../commit/53b171bd))
+
+* **can-i-deploy**
+  * correct logic for detecting when only the pacticipant name has been specified for a selector	 ([85bcdb35](/../../commit/85bcdb35))
+
 <a name="v2.106.0"></a>
 ### v2.106.0 (2023-01-31)
 

data/Gemfile

@@ -2,6 +2,9 @@ source "https://rubygems.org"
 
 gemspec
 
+# While https://github.com/brandonhilkert/sucker_punch/pull/253 is outstanding
+gem "sucker_punch", git: "https://github.com/pact-foundation/sucker_punch.git", ref: "fix/rename-is-singleton-class-method-2"
+
 gem "rake", "~>12.3.3"
 gem "sqlite3", "~>1.3"
 gem "conventional-changelog", "~>1.3"

data/db/migrations/20230131_add_cons_ver_id_ndx_to_latest_pp_id_for_cons_ver.rb

@@ -4,14 +4,18 @@ include PactBroker::MigrationHelper
 
 Sequel.migration do
   up do
-    alter_table(:latest_pact_publication_ids_for_consumer_versions) do
-      add_index([:consumer_version_id], name: "latest_pp_ids_for_cons_ver_con_ver_id_ndx")
+    if !mysql?
+      alter_table(:latest_pact_publication_ids_for_consumer_versions) do
+        add_index([:consumer_version_id], name: "latest_pp_ids_for_cons_ver_con_ver_id_ndx")
+      end
     end
   end
 
   down do
-    alter_table(:latest_pact_publication_ids_for_consumer_versions) do
-      drop_index([:consumer_version_id], name: "latest_pp_ids_for_cons_ver_con_ver_id_ndx")
+    if !mysql?
+      alter_table(:latest_pact_publication_ids_for_consumer_versions) do
+        drop_index([:consumer_version_id], name: "latest_pp_ids_for_cons_ver_con_ver_id_ndx")
+      end
     end
   end
 end

data/db/migrations/20230216_add_branch_heads_branch_version_id_index.rb

@@ -0,0 +1,21 @@
+require_relative "migration_helper"
+
+include PactBroker::MigrationHelper
+
+Sequel.migration do
+  up do
+    if !mysql?
+      alter_table(:branch_heads) do
+        add_index([:branch_version_id], name: "branch_heads_branch_version_id_index")
+      end
+    end
+  end
+
+  down do
+    if !mysql?
+      alter_table(:branch_heads) do
+        drop_index([:branch_version_id], name: "branch_heads_branch_version_id_index")
+      end
+    end
+  end
+end

data/db/migrations/20230428_add_index_for_webhook_executions_pact_publication_id.rb

@@ -0,0 +1,17 @@
+Sequel.migration do
+  up do
+    if !mysql?
+      alter_table(:webhook_executions) do
+        add_index([:pact_publication_id], name: "webhook_executions_pact_publication_id_index")
+      end
+    end
+  end
+
+  down do
+    if !mysql?
+      alter_table(:webhook_executions) do
+        drop_index([:pact_publication_id], name: "webhook_executions_pact_publication_id_index")
+      end
+    end
+  end
+end

data/lib/pact_broker/api/contracts/base_contract.rb

@@ -1,14 +1,29 @@
-require "reform"
-require "reform/form/dry"
-
-Reform::Form.class_eval do
-  feature Reform::Form::Dry
-end
+require "dry-validation"
+require "pact_broker/api/contracts/dry_validation_macros"
+require "pact_broker/api/contracts/dry_validation_methods"
+require "pact_broker/api/contracts/dry_validation_errors_formatter"
+require "pact_broker/messages"
+require "pact_broker/hash_refinements"
 
 module PactBroker
   module Api
     module Contracts
-      class BaseContract < Reform::Form
+      class BaseContract < Dry::Validation::Contract
+        include DryValidationMethods
+        extend DryValidationErrorsFormatter
+
+        using PactBroker::HashRefinements
+
+        # The entry method for all the Dry::Validation::Contract classes
+        # eg. MyContract.call(params)
+        # It takes the params (doesn't matter if they're string or symbol keys)
+        # executes the dry-validation validation, and formats the errors into the Pactflow format.
+        #
+        # @param [Hash] the parameters to validate
+        # @return [Hash] the validation errors to display to the user
+        def self.call(params)
+          format_errors(new.call(params&.symbolize_keys).errors)
+        end
       end
     end
   end

data/lib/pact_broker/api/contracts/can_i_deploy_query_schema.rb

@@ -0,0 +1,34 @@
+require "dry-validation"
+require "pact_broker/messages"
+require "pact_broker/project_root"
+require "pact_broker/string_refinements"
+
+module PactBroker
+  module Api
+    module Contracts
+      class CanIDeployQuerySchema < BaseContract
+        using PactBroker::StringRefinements
+
+        params do
+          required(:pacticipant).filled(:string)
+          required(:version).filled(:string)
+          optional(:to).filled(:string)
+          optional(:environment).filled(:string)
+        end
+
+        rule(:pacticipant).validate(:pacticipant_with_name_exists)
+        rule(:environment).validate(:environment_with_name_exists)
+
+        rule(:to, :environment) do
+          if provided?(values[:to]) && provided?(values[:environment])
+            base.failure(PactBroker::Messages.message("errors.validation.cannot_specify_tag_and_environment"))
+          end
+
+          if not_provided?(values[:to]) && not_provided?(values[:environment])
+            base.failure(PactBroker::Messages.message("errors.validation.must_specify_environment_or_tag"))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pact_broker/api/contracts/configuration.rb

@@ -1,5 +1,7 @@
 require "pact_broker/string_refinements"
 
+# Allow contracts to be accessed by name and configured/overridden for pf
+
 module PactBroker
   module Api
     module Contracts

data/lib/pact_broker/api/contracts/consumer_version_selector_contract.rb

@@ -0,0 +1,140 @@
+require "pact_broker/api/contracts/base_contract"
+
+module PactBroker
+  module Api
+    module Contracts
+      class ConsumerVersionSelectorContract < BaseContract
+        option :parent # the parent hash in which the ConsumerVersionSelector is embedded
+
+        BRANCH_KEYS = [:latest, :tag, :fallbackTag, :branch, :fallbackBranch, :matchingBranch, :mainBranch]
+        ENVIRONMENT_KEYS = [:environment, :deployed, :released, :deployedOrReleased]
+        ALL_KEYS = BRANCH_KEYS + ENVIRONMENT_KEYS + [:consumer]
+
+        json do
+          optional(:mainBranch).filled(included_in?: [true])
+          optional(:tag).filled(:str?)
+          optional(:branch).filled(:str?)
+          optional(:matchingBranch).filled(included_in?: [true])
+          optional(:latest).filled(included_in?: [true, false])
+          optional(:fallbackTag).filled(:str?)
+          optional(:fallbackBranch).filled(:str?)
+          optional(:consumer).filled(:str?)
+          optional(:deployed).filled(included_in?: [true])
+          optional(:released).filled(included_in?: [true])
+          optional(:deployedOrReleased).filled(included_in?: [true])
+          optional(:environment).filled(:str?)
+        end
+
+        rule(:consumer).validate(:not_blank_if_present)
+
+        # has minimum required params
+        rule(*ALL_KEYS) do
+          if not_provided?(values[:mainBranch]) &&
+              not_provided?(values[:tag]) &&
+              not_provided?(values[:branch]) &&
+              not_provided?(values[:environment]) &&
+              values[:matchingBranch] != true &&
+              values[:deployed] != true &&
+              values[:released] != true &&
+              values[:deployedOrReleased] != true &&
+              values[:latest] != true
+
+            base.failure(validation_message("pacts_for_verification_selector_required_params_missing"))
+          end
+        end
+
+        # mainBranch
+        rule(*ALL_KEYS) do
+          if values[:mainBranch] && values.slice(*ALL_KEYS - [:consumer, :mainBranch, :latest]).any?
+            base.failure(validation_message("pacts_for_verification_selector_main_branch_with_other_param_disallowed"))
+          end
+        end
+
+        # mainBranch/latest
+        rule(:mainBranch, :latest) do
+          if values[:mainBranch] && values[:latest] == false
+            base.failure(validation_message("pacts_for_verification_selector_main_branch_and_latest_false_disallowed"))
+          end
+        end
+
+        # matchingBranch
+        rule(*ALL_KEYS) do
+          if values[:matchingBranch] && values.slice(*ALL_KEYS - [:consumer, :matchingBranch]).any?
+            base.failure(validation_message("pacts_for_verification_selector_matching_branch_with_other_param_disallowed"))
+          end
+
+          if values[:matchingBranch] && not_provided?(parent[:providerVersionBranch])
+            base.failure(validation_message("pacts_for_verification_selector_matching_branch_requires_provider_version_branch"))
+          end
+        end
+
+        # tag and branch
+        rule(:tag, :branch) do
+          if values[:tag] && values[:branch]
+            base.failure(validation_message("pacts_for_verification_selector_tag_and_branch_disallowed"))
+          end
+        end
+
+        # branch/environment keys
+        rule(*ALL_KEYS) do
+          non_environment_fields = values.slice(*BRANCH_KEYS).keys.sort
+          environment_related_fields = values.slice(*ENVIRONMENT_KEYS).keys.sort
+
+          if (non_environment_fields.any? && environment_related_fields.any?)
+            base.failure("cannot specify the #{PactBroker::Messages.pluralize("field", non_environment_fields.count)} #{non_environment_fields.join("/")} with the #{PactBroker::Messages.pluralize("field", environment_related_fields.count)} #{environment_related_fields.join("/")}")
+          end
+        end
+
+        # fallbackTag
+        rule(:fallbackTag, :tag, :latest) do
+          if values[:fallbackTag] && !values[:latest]
+            base.failure(validation_message("pacts_for_verification_selector_fallback_tag"))
+          end
+
+          if values[:fallbackTag] && !values[:tag]
+            base.failure(validation_message("pacts_for_verification_selector_fallback_tag_requires_tag"))
+          end
+        end
+
+        # fallbackBranch
+        rule(:fallbackBranch, :branch, :latest) do
+          if values[:fallbackBranch] && !values[:branch]
+            base.failure(validation_message("pacts_for_verification_selector_fallback_branch_requires_branch"))
+          end
+
+
+          if values[:fallbackBranch] && values[:latest] == false
+            base.failure(validation_message("pacts_for_verification_selector_fallback_branch_and_latest_false_disallowed"))
+          end
+        end
+
+        # branch/latest
+        rule(:branch, :latest) do
+          if values[:branch] && values[:latest] == false
+            base.failure(validation_message("pacts_for_verification_selector_branch_and_latest_false_disallowed"))
+          end
+        end
+
+        # environment
+        rule(:environment) do
+          validate_environment_with_name_exists(value, key) if provided?(value)
+        end
+
+        # deployed, released, deployedOrReleased
+        rule(:deployed, :released, :deployedOrReleased) do
+          if values[:deployed] && values[:released]
+            base.failure(validation_message("pacts_for_verification_selector_deployed_and_released_disallowed"))
+          end
+
+          if values[:deployed] && values[:deployedOrReleased]
+            base.failure(validation_message("pacts_for_verification_selector_deployed_and_deployed_or_released_disallowed"))
+          end
+
+          if values[:released] && values[:deployedOrReleased]
+            base.failure(validation_message("pacts_for_verification_selector_released_and_deployed_or_released_disallowed"))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pact_broker/api/contracts/dry_validation_errors_formatter.rb

@@ -0,0 +1,50 @@
+require "pact_broker/error"
+
+module PactBroker
+  module Api
+    module Contracts
+      module DryValidationErrorsFormatter
+
+        # Formats the dry validation errors in the expected PactBroker error format of { :key => ["errors"] }
+        # where there are no nested hashes.
+        # @param [Dry::Validation::MessageSet] errors
+        # @return [Hash]
+        def format_errors(errors)
+          errors.each_with_object({}) do | error, errors_hash |
+            integers = error.path.select{ | k | k.is_a?(Integer) }
+
+            if integers.size > 1
+              raise PactBroker::Error,  "Cannot currently format an error message with more than one index"
+            end
+
+            if integers.empty?
+              key = error.path == [nil] ? nil : error.path.join(".").to_sym
+              add_error(errors_hash, key, error.text)
+            else
+              add_indexed_error(errors_hash, error)
+            end
+          end
+        end
+
+        # @private
+        def add_error(errors_hash, key, text)
+          errors_hash[key] ||= []
+          errors_hash[key] << text
+        end
+
+        # @private
+        def add_indexed_error(errors_hash, error)
+          error_path_classes = error.path.collect(&:class)
+          if error_path_classes == [Symbol, Integer, Symbol]
+            add_error(errors_hash, error.path.first, "#{error.path.last} #{error.text} (at index #{error.path[1]})")
+          elsif error_path_classes == [Symbol, Integer]
+            add_error(errors_hash, error.path.first, "#{error.text} (at index #{error.path[1]})")
+          else
+            # Don't have any usecases for this - will deal with it when it happens
+            raise PactBroker::Error, "Cannot currently format an error message with path classes #{error_path_classes}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pact_broker/api/contracts/dry_validation_macros.rb

@@ -0,0 +1,79 @@
+require "pact_broker/api/contracts/dry_validation_methods"
+
+Dry::Validation.register_macro(:not_multiple_lines) do
+  PactBroker::Api::Contracts::DryValidationMethods.validate_not_multiple_lines(value, key)
+end
+
+Dry::Validation.register_macro(:no_spaces_if_present) do
+  PactBroker::Api::Contracts::DryValidationMethods.validate_no_spaces_if_present(value, key)
+end
+
+Dry::Validation.register_macro(:not_blank_if_present) do
+  PactBroker::Api::Contracts::DryValidationMethods.validate_not_blank_if_present(value, key)
+end
+
+Dry::Validation.register_macro(:array_values_not_blank_if_any) do
+  value&.each_with_index do | item, index |
+    PactBroker::Api::Contracts::DryValidationMethods.validate_not_blank_if_present(item, key(path.keys + [index]))
+  end
+end
+
+Dry::Validation.register_macro(:valid_url_if_present) do
+  PactBroker::Api::Contracts::DryValidationMethods.validate_valid_url(value, key)
+end
+
+Dry::Validation.register_macro(:valid_version_number) do
+  PactBroker::Api::Contracts::DryValidationMethods.validate_version_number(value, key)
+end
+
+Dry::Validation.register_macro(:pacticipant_with_name_exists) do
+  PactBroker::Api::Contracts::DryValidationMethods.validate_pacticipant_with_name_exists(value, key)
+end
+
+Dry::Validation.register_macro(:environment_with_name_exists) do
+  PactBroker::Api::Contracts::DryValidationMethods.validate_environment_with_name_exists(value, key)
+end
+
+# Validate each object in an array with the specified contract,
+# and merge the errors into the appropriate path in the parent
+# validation results.
+# eg.
+#    rule(:myChildArray).validate(validate_each_with_contract: MyChildContract)
+#
+# If the child contract defines a option called `parent` then it can access the parent
+# hash for validation rules that need to work across the levels.
+# eg. ConsumerVersionSelectorContract for the matchingBranch rule
+#
+# Will not add any errors if the array is nil
+Dry::Validation.register_macro(:validate_each_with_contract) do |macro:|
+  value&.each_with_index do | item, index |
+    child_contract_class = macro.args[0]
+    messages = child_contract_class.new(parent: values).call(item).errors(full: true).to_hash.values.flatten
+    messages.each do | message |
+      key(path.keys + [index]).failure(message)
+    end
+  end
+end
+
+# Validate a child node with the specified contract,
+# and merge the errors into the appropriate path in the parent
+# validation results.
+# eg.
+#    rule(:myChildHash).validate(validate_with_contract: MyChildContract)
+#
+# If the child contract defines a option called `parent` then it can access the parent
+# hash for validation rules that need to work across the levels.
+# eg. ConsumerVersionSelectorContract for the matchingBranch rule
+#
+# Will not add any errors if the value is nil
+Dry::Validation.register_macro(:validate_with_contract) do |macro:|
+  if value
+    child_contract_class = macro.args[0]
+    errors = child_contract_class.new(parent: values).call(value).errors.to_hash
+    errors.each do | key, messages |
+      messages.each do | message |
+        key(path.keys + [key]).failure(message)
+      end
+    end
+  end
+end

data/lib/pact_broker/api/contracts/dry_validation_methods.rb

@@ -0,0 +1,71 @@
+require "pact_broker/api/contracts/validation_helpers"
+
+module PactBroker
+  module Api
+    module Contracts
+      module DryValidationMethods
+        extend self
+
+        def validation_message(key, params = {})
+          PactBroker::Messages.validation_message(key, params)
+        end
+
+        def provided?(value)
+          ValidationHelpers.provided?(value)
+        end
+
+        def not_provided?(value)
+          ValidationHelpers.not_provided?(value)
+        end
+
+        def validate_version_number(value, key)
+          if !PactBroker::Api::Contracts::ValidationHelpers.valid_version_number?(value)
+            key.failure(PactBroker::Messages.validation_message("invalid_version_number", value: value))
+          end
+        end
+
+        def validate_url(value, key)
+          if PactBroker::Api::Contracts::ValidationHelpers.valid_url?(value)
+            key.failure(PactBroker::Messages.validation_message("invalid_url"))
+          end
+        end
+
+        def validate_pacticipant_with_name_exists(value, key)
+          if ValidationHelpers.provided?(value) && !ValidationHelpers.pacticipant_with_name_exists?(value)
+            key.failure(PactBroker::Messages.validation_message("pacticipant_with_name_not_found"))
+          end
+        end
+
+        def validate_environment_with_name_exists(value, key)
+          if ValidationHelpers.provided?(value) && !ValidationHelpers.environment_with_name_exists?(value)
+            key.failure(PactBroker::Messages.validation_message("environment_not_found", value: value))
+          end
+        end
+
+        def validate_not_blank_if_present(value, key)
+          if value && ValidationHelpers.blank?(value)
+            key.failure(PactBroker::Messages.validation_message("blank"))
+          end
+        end
+
+        def validate_no_spaces_if_present(value, key)
+          if value && ValidationHelpers.includes_space?(value)
+            key.failure(PactBroker::Messages.validation_message("no_spaces"))
+          end
+        end
+
+        def validate_not_multiple_lines(value, key)
+          if value && ValidationHelpers.multiple_lines?(value)
+            key.failure(PactBroker::Messages.validation_message("single_line"))
+          end
+        end
+
+        def validate_valid_url(value, key)
+          if value && !ValidationHelpers.valid_url?(value)
+            key.failure(PactBroker::Messages.validation_message("invalid_url"))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pact_broker/api/contracts/environment_schema.rb

@@ -1,48 +1,34 @@
-require "dry-validation"
-require "pact_broker/api/contracts/dry_validation_workarounds"
-require "pact_broker/api/contracts/dry_validation_predicates"
-require "pact_broker/messages"
+require "pact_broker/api/contracts/base_contract"
 
 module PactBroker
   module Api
     module Contracts
-      class EnvironmentSchema
-        extend DryValidationWorkarounds
-        extend PactBroker::Messages
-        using PactBroker::HashRefinements
-
-        SCHEMA = Dry::Validation.Schema do
-          configure do
-            predicates(DryValidationPredicates)
-            config.messages_file = File.expand_path("../../../locale/en.yml", __FILE__)
-          end
-          required(:name).filled(:str?, :single_line?, :no_spaces?)
-          optional(:displayName).maybe(:str?, :single_line?)
+      class EnvironmentSchema < BaseContract
+        json do
+          optional(:uuid)
+          required(:name).filled(:string)
+          optional(:displayName).maybe(:string)
           required(:production).filled(included_in?: [true, false])
-          optional(:contacts).each do
-            schema do
-              required(:name).filled(:str?, :single_line?)
-              optional(:details).schema do
-              end
-            end
+          optional(:contacts).array(:hash) do
+            required(:name).filled(:string)
+            optional(:details).hash
           end
         end
 
-        def self.call(params_with_string_keys)
-          params = params_with_string_keys&.symbolize_keys
-          results = select_first_message(flatten_indexed_messages(SCHEMA.call(params).messages(full: true)))
-          validate_name(params, results)
-          results
-        end
+        rule(:name).validate(:not_multiple_lines, :no_spaces_if_present)
+        rule(:displayName).validate(:not_multiple_lines)
 
-        def self.validate_name(params, results)
-          if (environment_with_same_name = PactBroker::Deployments::EnvironmentService.find_by_name(params[:name]))
-            if environment_with_same_name.uuid != params[:uuid]
-              results[:name] ||= []
-              results[:name] << message("errors.validation.environment_name_must_be_unique", name: params[:name])
+        rule(:name, :uuid) do
+          if (environment_with_same_name = PactBroker::Deployments::EnvironmentService.find_by_name(values[:name]))
+            if environment_with_same_name.uuid != values[:uuid]
+              key.failure(validation_message("environment_name_must_be_unique", name: values[:name]))
             end
           end
         end
+
+        rule(:contacts).each do
+          validate_not_multiple_lines(value[:name], key(path.keys + [:name]))
+        end
       end
     end
   end

data/lib/pact_broker/api/contracts/pacticipant_create_schema.rb

@@ -3,25 +3,12 @@ require "pact_broker/api/contracts/pacticipant_schema"
 module PactBroker
   module Api
     module Contracts
-      class PacticipantCreateSchema
-        extend DryValidationWorkarounds
-        extend PactBroker::Messages
-        using PactBroker::HashRefinements
-
-        SCHEMA = Dry::Validation.Schema do
-          configure do
-            predicates(DryValidationPredicates)
-            config.messages_file = File.expand_path("../../../locale/en.yml", __FILE__)
-          end
-          required(:name).filled(:str?, :single_line?)
+      class PacticipantCreateSchema < PactBroker::Api::Contracts::PacticipantSchema
+        json do
+          required(:name).filled(:string)
         end
 
-        def self.call(params_with_string_keys)
-          params = params_with_string_keys&.symbolize_keys
-          update_errors = PacticipantSchema::SCHEMA.call(params).messages(full: true)
-          create_errors = SCHEMA.call(params).messages(full: true)
-          select_first_message(flatten_indexed_messages(update_errors.merge(create_errors)))
-        end
+        rule(:name).validate(:not_blank_if_present, :not_multiple_lines)
       end
     end
   end