operations 0.0.1 → 0.6.3

data/lib/operations/form.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+# This class implements Rails form object compatibility layer
+# It is possible to configure form object attributes automatically
+# basing on Dry Schema user {Operations::Form::Builder}
+# @example
+#
+#   class AuthorForm < Operations::Form
+#     attribute :name
+#   end
+#
+#   class PostForm < Operations::Form
+#     attribute :title
+#     attribute :tags, collection: true
+#     attribute :author, form: AuthorForm
+#   end
+#
+#   PostForm.new({ tags: ["foobar"], author: { name: "Batman" } })
+#   # => #<PostForm attributes={:title=>nil, :tags=>["foobar"], :author=>#<AuthorForm attributes={:name=>"Batman"}>}>
+#
+# @see Operations::Form::Builder
+class Operations::Form
+  extend Dry::Initializer
+  include Dry::Equalizer(:attributes, :errors)
+
+  param :data,
+    type: Operations::Types::Hash.map(Operations::Types::Symbol, Operations::Types::Any),
+    default: proc { {} },
+    reader: :private
+  option :messages,
+    type: Operations::Types::Hash.map(
+      Operations::Types::Nil | Operations::Types::Coercible::Symbol,
+      Operations::Types::Any
+    ),
+    default: proc { {} },
+    reader: :private
+
+  class_attribute :attributes, instance_accessor: false, default: {}
+
+  def self.attribute(name, **options)
+    attribute = Operations::Form::Attribute.new(name, **options)
+
+    self.attributes = attributes.merge(
+      attribute.name => attribute
+    )
+  end
+
+  def self.human_attribute_name(name, options = {})
+    if attributes[name.to_sym]
+      attributes[name.to_sym].model_human_name(options)
+    else
+      name.to_s.humanize
+    end
+  end
+
+  def self.validators_on(name)
+    attributes[name.to_sym]&.model_validators || []
+  end
+
+  def type_for_attribute(name)
+    self.class.attributes[name.to_sym].model_type
+  end
+
+  def localized_attr_name_for(name, locale)
+    self.class.attributes[name.to_sym].model_localized_attr_name(locale)
+  end
+
+  def has_attribute?(name) # rubocop:disable Naming/PredicateName
+    self.class.attributes.key?(name.to_sym)
+  end
+
+  def attributes
+    self.class.attributes.keys.to_h do |name|
+      [name, read_attribute(name)]
+    end
+  end
+
+  def assigned_attributes
+    (self.class.attributes.keys & data.keys).to_h do |name|
+      [name, read_attribute(name)]
+    end
+  end
+
+  def method_missing(name, *)
+    read_attribute(name)
+  end
+
+  def respond_to_missing?(name, *)
+    self.class.attributes.key?(name)
+  end
+
+  def model_name
+    ActiveModel::Name.new(self.class)
+  end
+
+  # This should return false if we want to use POST.
+  # Now it is going to generate PATCH form.
+  def persisted?
+    true
+  end
+
+  # Probably can be always nil, it is used in automated URL derival.
+  # We can make it work later but it will require additional concepts.
+  def to_key
+    nil
+  end
+
+  def errors
+    @errors ||= ActiveModel::Errors.new(self).tap do |errors|
+      self.class.attributes.each do |name, attribute|
+        add_messages(errors, name, messages[name])
+        add_messages_to_collection(errors, name, messages[name]) if attribute.collection
+      end
+
+      add_messages(errors, :base, messages[nil])
+    end
+  end
+
+  def valid?
+    errors.empty?
+  end
+
+  def read_attribute(name)
+    cached_attribute(name) do |value, attribute|
+      if attribute.collection && attribute.form
+        wrap_collection([name], value, attribute.form)
+      elsif attribute.form
+        wrap_object([name], value, attribute.form)
+      elsif attribute.collection
+        value.nil? ? [] : value
+      else
+        value
+      end
+    end
+  end
+
+  private
+
+  def add_messages(errors, key, messages)
+    return unless messages.is_a?(Array)
+
+    messages.each do |message|
+      message = message[:text] if message.is_a?(Hash) && message.key?(:text)
+      errors.add(key, message)
+    end
+  end
+
+  def add_messages_to_collection(errors, key, messages)
+    return unless messages.is_a?(Hash)
+
+    read_attribute(key).size.times do |i|
+      add_messages(errors, "#{key}[#{i}]", messages[i])
+    end
+  end
+
+  def cached_attribute(name)
+    name = name.to_sym
+    return unless self.class.attributes.key?(name)
+
+    nested_name = :"#{name}_attributes"
+    value = data.key?(nested_name) ? data[nested_name] : data[name]
+
+    (@attributes_cache ||= {})[name] ||= yield(value, self.class.attributes[name])
+  end
+
+  def wrap_collection(path, collection, form)
+    collection = [] if collection.nil?
+
+    case collection
+    when Hash
+      collection.values.map.with_index do |data, i|
+        wrap_object(path + [i], data, form)
+      end
+    when Array
+      collection.map.with_index do |data, i|
+        wrap_object(path + [i], data, form)
+      end
+    else
+      collection
+    end
+  end
+
+  def wrap_object(path, data, form)
+    data = {} if data.nil?
+
+    if data.is_a?(Hash)
+      nested_messages = messages.dig(*path)
+      nested_messages = {} unless nested_messages.is_a?(Hash)
+      form.new(data, messages: nested_messages)
+    else
+      data
+    end
+  end
+end

data/lib/operations/result.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+# This is a the result of the operation. Considered a failure if contains
+# any errors. Contains all the execution artifacts such as params and context
+# (the initial one merged with the result of contract and operation routine
+# execution).
+# Also able to spawn a form object basing on the operation params and errors.
+class Operations::Result
+  include Dry::Monads[:result]
+  include Dry::Equalizer(:operation, :component, :params, :context, :on_success, :errors)
+  extend Dry::Initializer
+
+  option :operation, type: Operations::Types::Instance(Operations::Command), optional: true
+  option :component, type: Operations::Types::Symbol.enum(*Operations::Command::COMPONENTS)
+  option :params, type: Operations::Types::Hash.map(Operations::Types::Symbol, Operations::Types::Any)
+  option :context, type: Operations::Types::Hash.map(Operations::Types::Symbol, Operations::Types::Any)
+  option :on_success, type: Operations::Types::Array.of(Operations::Types::Any), default: proc { [] }
+  option :on_failure, type: Operations::Types::Array.of(Operations::Types::Any), default: proc { [] }
+  option :errors, type: Operations::Types.Interface(:call) | Operations::Types::Instance(Dry::Validation::MessageSet),
+    default: proc { Dry::Validation::MessageSet.new([]).freeze }
+
+  # Instantiates a new result with the given fields updated
+  def merge(**changes)
+    self.class.new(**self.class.dry_initializer.attributes(self), **changes)
+  end
+
+  def errors(**options)
+    if @errors.respond_to?(:call)
+      @errors.call(**options)
+    else
+      options.empty? ? @errors : @errors.with([], options).freeze
+    end
+  end
+
+  def success?
+    errors.empty?
+  end
+  alias_method :callable?, :success?
+
+  def failure?
+    !success?
+  end
+
+  # Checks if ANY of the passed precondition or policy codes have failed
+  # If nothing is passed - checks that ANY precondition or policy have failed
+  def failed_precheck?(*error_codes)
+    failure? &&
+      %i[policies preconditions].include?(component) &&
+      (error_codes.blank? || errors_with_code?(*error_codes))
+  end
+  alias_method :failed_prechecks?, :failed_precheck?
+
+  # Checks if ANY of the passed policy codes have failed
+  # If nothing is passed - checks that ANY policy have failed
+  def failed_policy?(*error_codes)
+    component == :policies && failed_precheck?(*error_codes)
+  end
+  alias_method :failed_policies?, :failed_policy?
+
+  # Checks if ANY of the passed precondition codes have failed
+  # If nothing is passed - checks that ANY precondition have failed
+  def failed_precondition?(*error_codes)
+    component == :preconditions && failed_precheck?(*error_codes)
+  end
+  alias_method :failed_preconditions?, :failed_precondition?
+
+  def to_monad
+    success? ? Success(self) : Failure(self)
+  end
+
+  # A form object that can be used for rendering forms with `form_for`,
+  # `simple_form` and other view helpers.
+  def form
+    @form ||= operation.form_class.new(
+      operation.form_hydrator.call(operation.form_class, params, **context),
+      messages: errors.to_h
+    )
+  end
+
+  def pretty_print(pp)
+    attributes = self.class.dry_initializer.attributes(self)
+
+    pp.object_group(self) do
+      pp.seplist(attributes.keys, -> { pp.text "," }) do |name|
+        pp.breakable " "
+        pp.group(1) do
+          pp.text name.to_s
+          pp.text " = "
+          pp.pp send(name)
+        end
+      end
+    end
+  end
+
+  def as_json(*, include_command: false, **)
+    hash = {
+      component: component,
+      params: params,
+      context: context_as_json,
+      on_success: on_success.as_json,
+      on_failure: on_failure.as_json,
+      errors: errors(full: true).to_h
+    }
+    hash[:command] = operation.as_json if include_command
+    hash
+  end
+
+  private
+
+  def errors_with_code?(name, *names)
+    names = [name] + names
+    (errors.map { |error| error.meta[:code] } & names).present?
+  end
+
+  def context_as_json
+    context.transform_values do |context_value|
+      next context_value.class.name unless context_value.respond_to?(:id)
+
+      [context_value.class.name, context_value.id].join("#")
+    end
+  end
+end

data/lib/operations/test_helpers.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+# This module contains helpers for simplifaction of testing
+# of operation-related concerns.
+#
+# @example
+#   require "operations/test_helpers"
+#
+#   module RailsHelper
+#     config.include Operations::TestHelpers
+#   end
+module Operations::TestHelpers
+  def self.empty_contract
+    @empty_contract ||= OperationContract.build { schema { nil } }
+  end
+
+  # Used to test messages generated by preconditions
+  # If one calls `precondition.call` intests and it returns `Failure`
+  # there is no way to check is a proper text message will be rendered.
+  #
+  # @example
+  #   subject(:precondition) { described_class::Precondition.new }
+  #   let(:contract) { described_class::Contract.new }
+  #
+  #   describe "#call" do
+  #     subject(:errors) { precondition_errors(precondition, contract, **context) }
+  #
+  #     let(:context) { { entity: entity } }
+  #
+  #     context "when entity is pokable" do
+  #       let(:entity) { build_stubbed(:entity) }
+  #
+  #       it { is_expected.to be_empty }
+  #     end
+  #
+  #     context "when entity is not pokable" do
+  #       let(:entity) { build_stubbed(:entity) }
+  #
+  #       specify do
+  #         expect(errors).to eq({
+  #           nil => [{ code: :some_failure, text: "Unable to poke entity" }]
+  #         })
+  #       end
+  #     end
+  #   end
+  #
+  # We need to pass contract since preconditions are using the
+  # contract's message rendering and we want to ensure that the
+  # translation is placed correctly in the scope of the operation.
+  def precondition_errors(precondition, contract = Operations::TestHelpers.empty_contract, **context)
+    component = Operations::Components::Preconditions.new(
+      [precondition],
+      message_resolver: contract.message_resolver
+    )
+    result = component.call({}, context)
+    result.errors.to_h
+  end
+
+  # Works exactly the same way as {#precondition_errors} but
+  # for policies.
+  #
+  # @see #precondition_errors
+  def policy_errors(policy, contract = Operations::TestHelpers.empty_contract, **context)
+    component = Operations::Components::Policies.new(
+      [policy],
+      message_resolver: contract.message_resolver
+    )
+    result = component.call({}, context)
+    result.errors.to_h
+  end
+end

data/lib/operations/types.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+# Gem types root module
+module Operations::Types
+  include Dry::Types()
+end

data/lib/operations/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Operations
-  VERSION = "0.0.1"
+  VERSION = "0.6.3"
 end

data/lib/operations.rb

@@ -1,6 +1,46 @@
+# frozen_string_literal: true
+
+require "dry-monads"
+require "dry/monads/do"
+require "dry-validation"
+require "active_support/core_ext/array/wrap"
+require "active_support/core_ext/class/attribute"
+require "active_support/core_ext/module/delegation"
+require "active_support/inflector/inflections"
+require "active_model/naming"
+require "after_commit_everywhere"
 require "operations/version"
+require "operations/types"
+require "operations/configuration"
+require "operations/contract"
+require "operations/contract/messages_resolver"
+require "operations/convenience"
+require "operations/command"
+require "operations/result"
+require "operations/form"
+require "operations/form/attribute"
+require "operations/form/builder"
 
+# The root gem module
 module Operations
-  class Error < StandardError; end
-  # Your code goes here...
+  class Error < StandardError
+  end
+
+  DEFAULT_ERROR_REPORTER = ->(message, payload) { Sentry.capture_message(message, extra: payload) }
+  DEFAULT_TRANSACTION = ->(&block) { ActiveRecord::Base.transaction(requires_new: true, &block) }
+  DEFAULT_AFTER_COMMIT = ->(&block) { AfterCommitEverywhere.after_commit(&block) }
+
+  class << self
+    attr_reader :default_config
+
+    def configure(configuration = nil, **options)
+      @default_config = (configuration || Configuration).new(**options)
+    end
+  end
+
+  configure(
+    error_reporter: DEFAULT_ERROR_REPORTER,
+    transaction: DEFAULT_TRANSACTION,
+    after_commit: DEFAULT_AFTER_COMMIT
+  )
 end

data/operations.gemspec

@@ -1,4 +1,6 @@
-require_relative 'lib/operations/version'
+# frozen_string_literal: true
+
+require_relative "lib/operations/version"
 
 Gem::Specification.new do |spec|
   spec.name          = "operations"
@@ -10,7 +12,7 @@ Gem::Specification.new do |spec|
   spec.description   = "Operations framework"
   spec.homepage      = "https://github.com/BookingSync/operations"
   spec.license       = "MIT"
-  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.7.0")
 
   spec.metadata["homepage_uri"] = spec.homepage
   spec.metadata["source_code_uri"] = "https://github.com/BookingSync/operations"
@@ -18,10 +20,24 @@ Gem::Specification.new do |spec|
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
-    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    %x(git ls-files -z).split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   end
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "appraisal"
+  spec.add_development_dependency "database_cleaner-active_record"
+  spec.add_development_dependency "sqlite3"
+
+  spec.add_runtime_dependency "activerecord", ">= 5.2.0"
+  spec.add_runtime_dependency "activesupport", ">= 5.2.0"
+  spec.add_runtime_dependency "after_commit_everywhere"
+  spec.add_runtime_dependency "dry-monads"
+  spec.add_runtime_dependency "dry-struct"
+  spec.add_runtime_dependency "dry-validation"
+  spec.metadata = {
+    "rubygems_mfa_required" => "true"
+  }
 end