operations 0.6.3 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dc7557987e49805062efa789a9ecc5b0344839b5f8217b9a59fbd6904246ec8f
-  data.tar.gz: 801b5edbde46dba2c005ef8bad826691ca00ce7adda5654d04f602406d15847f
+  metadata.gz: 37feed93ae3f90b8e08f2ab960faf4195c8891e6bc4d60a78d03666c5c035de3
+  data.tar.gz: 29b2bad869d32e4bf22f188eb4c57a199300a315431f373d5cf988f15f63ab8b
 SHA512:
-  metadata.gz: bcec088edb29345af8934525274ddf100a5d0276545c2153ef1eeef4e6a255040dd0eabfd287afc5d68c3b041a4ac335ef8a258d653598cbb449eb2a78b94c63
-  data.tar.gz: b660a95428e98a9e6839f2b154623dd5226532c646a486f606f4c318c71bef8dd7861859a5775a28be47098ffeecd7c54974baaf31195246084d2ace7daeac08
+  metadata.gz: 186e9327e813bbf7ddd5d5aea52b5bf00cc7a62a9c8b235b7fd25f36585a2468192922df3ff9435d7320b164807e31acf73523eaf9b106c67de6f2f27da19400
+  data.tar.gz: 43d61db8dbe71a4f9269755a6fc73c46214ba3baddeed80e650a7ae2ced43c08fb361dd19cef005954504970c06bfa573a1a55f760e7ac711c68c19f4e34601b

data/.rubocop_todo.yml

@@ -1,6 +1,6 @@
 # This configuration was generated by
 # `rubocop --auto-gen-config`
-# on 2023-12-20 10:30:23 UTC using RuboCop version 1.57.2.
+# on 2024-05-05 08:51:48 UTC using RuboCop version 1.59.0.
 # The point is for the user to remove these configuration records
 # one by one as the offenses are removed from the code base.
 # Note that changes in the inspected code, or installation of new
@@ -19,12 +19,23 @@ Gemspec/DevelopmentDependencies:
 Metrics/AbcSize:
   Max: 28
 
-# Offense count: 2
+# Offense count: 1
 # Configuration parameters: CountComments, CountAsOne.
 Metrics/ClassLength:
-  Max: 161
+  Max: 145
 
 # Offense count: 1
+# Configuration parameters: CountComments, CountAsOne.
+Metrics/ModuleLength:
+  Max: 142
+
+# Offense count: 2
 # Configuration parameters: CountKeywordArgs, MaxOptionalParameters.
 Metrics/ParameterLists:
   Max: 7
+
+# Offense count: 1
+# Configuration parameters: IgnoreNameless, IgnoreSymbolicNames.
+RSpec/VerifiedDoubles:
+  Exclude:
+    - 'spec/operations/form_spec.rb'

data/CHANGELOG.md

@@ -1,6 +1,15 @@
 # Changelog
 
-## [0.6.3](https://github.com/BookingSync/operations/tree/main)
+## [0.7.0](https://github.com/BookingSync/operations/tree/main)
+
+### Added
+
+- Implement new forms system detaching it from operations [\#47](https://github.com/BookingSync/operations/pull/47) ([pyromaniac](https://github.com/pyromaniac))
+
+### Improvements
+
+- Better inspect for all the opjects [\#45](https://github.com/BookingSync/operations/pull/45) ([pyromaniac](https://github.com/pyromaniac))
+- Use #to_hash instead of #as_json [\#44](https://github.com/BookingSync/operations/pull/44) ([pyromaniac](https://github.com/pyromaniac))
 
 ### Fixes
 

data/README.md

@@ -262,7 +262,7 @@ end
 
 The operation body can be any callable object (respond to the `call` method), even a lambda. But it is always better to define it as a class since there might be additional instance methods and [dependency injections](#dependency-injection).
 
-In any event, the operation body should return a Dry::Monad::Result instance. In case of a Failure, it will be converted into an `Operation::Result#error` and in case of Success(), its content will be merged into the operation context.
+In any event, the operation body should return a Dry::Monads::Result instance. In case of a Failure, it will be converted into an `Operation::Result#error` and in case of Success(), its content will be merged into the operation context.
 
 **Important:** since the Success result payload is merged inside of a context, it is supposed to be a hash.
 
@@ -305,7 +305,7 @@ end
 
 Dependency injection can be used to provide IO clients with the operation. It could be DB repositories or API clients. The best way is to use Dry::Initializer for it since it provides the ability to define acceptable types.
 
-If you still prefer to use ActiveRecord, it is worth creating a wrapper around it providing Dry::Monad-compatible interfaces.
+If you still prefer to use ActiveRecord, it is worth creating a wrapper around it providing Dry::Monads-compatible interfaces.
 
 ```ruby
 class ActiveRecordRepository
@@ -858,31 +858,38 @@ While we normally recommend using frontend-backend separation, it is still possi
 ```ruby
 class PostsController < ApplicationController
   def edit
-    @post_update = Post::Update.default.callable(
-      { post_id: params[:id] },
-      current_user: current_user
-    )
+    @post_update_form = Post::Update.default_form.build(params, current_user: current_user)
 
-    respond_with @post_update
+    respond_with @post_update_form
   end
 
   def update
-    # With operations we don't need strong parameters as the operation contract takes care of this.
-    @post_update = Post::Update.default.call(
-      { **params[:post_update_default_form], post_id: params[:id] },
-      current_user: current_user
-    )
+    @post_update_form = Post::Update.default_form.persist(params, current_user: current_user)
+
+    respond_with @post_update_form, location: edit_post_url(@post_update_form.operation_result.context[:post])
+  end
+end
+```
+
+Where the form class is defined this way:
+
+```ruby
+class Post::Update
+  def self.default
+    @default ||= Operations::Command.new(...)
+  end
 
-    respond_with @post_update, location: edit_post_url(@post_update.context[:post])
+  def self.default_form
+    @default_form ||= Operations::Form.new(default)
   end
 end
 ```
 
-The key here is to use `Operations::Result#form` method for the form builder.
+Then, the form can be used as any other form object:
 
 ```erb
 # views/posts/edit.html.erb
-<%= form_for @post_update.form, url: post_url(@post_update.context[:post]), method: :patch do |f| %>
+<%= form_for @post_update_form, url: post_url(@post_update_form.operation_result.context[:post]) do |f| %>
   <%= f.input :title %>
   <%= f.text_area :body %>
 <% end %>
@@ -892,16 +899,16 @@ In cases when we need to populate the form data, it is possible to pass `form_hy
 
 ```ruby
 class Post::Update
-  def self.default
-    @default ||= Operations::Command.new(
-      ...,
-      form_hydrator: Post::Update::Hydrator.new
+  def self.default_form
+    @default_form ||= Operations::Form.new(
+      default,
+      hydrator: Post::Update::Hydrator.new
     )
   end
 end
 
 class Post::Update::Hydrator
-  def call(form_class, params, post:, **)
+  def call(form_class, params, post:, **_context)
     value_attributes = form_class.attributes.keys - %i[post_id]
     data = value_attributes.index_with { |name| post.public_send(name) }
 
@@ -912,23 +919,80 @@ end
 
 The general idea here is to figure out attributes we have in the contract (those attributes are also defined automatically in a generated form class) and then fetch those attributes from the model and merge them with the params provided within the request.
 
-Also, in the case of, say, [simple_form](https://github.com/heartcombo/simple_form), we need to provide additional attributes information, like data type. It is possible to do this with an optional `form_model_map:` operation option:
+Also, in the case of, say, [simple_form](https://github.com/heartcombo/simple_form), we need to provide additional attributes information, like data type. It is possible to do this with `model_map:` option:
 
 ```ruby
 class Post::Update
-  def self.default
-    @default ||= Operations::Command.new(
-      ...,
-      form_hydrator: Post::Update::Hydrator.new,
-      form_model_map: {
-        [%r{.+}] => "Post"
-      }
+  def self.default_form
+    @default_form ||= Operations::Form.new(
+      default,
+      model_map: Post::Update::ModelMap.new,
+      hydrator: Post::Update::Hydrator.new
     )
   end
 end
+
+class Post::Update::ModelMap
+  def call(_path)
+    Post
+  end
+end
 ```
 
-Here we define all the fields mapping to a model class with a regexp or just string values.
+In forms, params input is already transformed to extract the nested data with the form name. `form_for @post_update_form` will generate the form that send params nested under the `params[:post_update_form]` key. By default operation forms extract this form data and send it to the operation at the top level, so `{ id: 42, post_update_form: { title: "Post Title" } }` params will be sent to the operation as `{ id: 42, title: "Post Title" }`. Strong params are also accepted by the form, though they are being converted with `to_unsafe_hash`.
+
+It is possible to add more params transfomations to the form in cases when operation contract is different from the params structure:
+
+```ruby
+class Post::Update
+  def self.default_form
+    @default_form ||= Operations::Form.new(
+      default,
+      model_name: "post_update_form", # form name can be customized
+      params_transformations: [
+        ParamsMap.new(id: :post_id),
+        NestedAttributes.new(:sections)
+      ]
+    )
+  end
+
+  contract do
+    required(:post_id).filled(:integer)
+    optional(:title).filled(:string)
+    optional(:sections).array(:hash) do
+      optional(:id).filled(:integer)
+      optional(:content).filled(:string)
+      optional(:_destroy).filled(:bool)
+    end
+  end
+end
+
+# This will transform `{ id: 42, title: "Post Title" }` params to `{ post_id: 42, title: "Post Title" }`
+class ParamsMap
+  extend Dry::Initializer
+
+  param :params_map
+
+  def call(_form_class, params, **_context)
+    params.transform_keys { |key| params_map[key] || key }
+  end
+end
+
+# And this will transform nested attributes hash from the form to an array acceptable by the operation:
+# from
+#   `{ id: 42, sections_attributes: { '0' => { id: 1, content: "First paragraph" }, 'new' => { content: 'New Paragraph' } } }`
+# into
+#   `{ id: 42, sections: [{ id: 1, content: "First paragraph" }, { content: 'New Paragraph' }] }`
+class NestedAttributes
+  extend Dry::Initializer
+
+  param :name, Types::Coercible::Symbol
+
+  def call(_form_class, params, **_context)
+    params[name] = params[:"#{name}_attrbutes"].values
+  end
+end
+```
 
 ## Development
 

data/lib/operations/command.rb

@@ -125,15 +125,14 @@ require "operations/components/on_failure"
 # which contains all the artifacts and the information about the errors
 # should they ever happen.
 class Operations::Command
-  UNDEFINED = Object.new.freeze
-  EMPTY_HASH = {}.freeze
   COMPONENTS = %i[contract policies idempotency preconditions operation on_success on_failure].freeze
   FORM_HYDRATOR = ->(_form_class, params, **_context) { params }
 
+  extend Dry::Initializer
+  include Dry::Core::Constants
   include Dry::Monads[:result]
   include Dry::Monads::Do.for(:call_monad, :callable_monad, :validate_monad, :execute_operation)
   include Dry::Equalizer(*COMPONENTS)
-  extend Dry::Initializer
 
   # Provides message and meaningful sentry context for failed operations
   class OperationFailed < StandardError
@@ -158,17 +157,14 @@ class Operations::Command
   option :preconditions, Operations::Types::Array.of(Operations::Types.Interface(:call)), default: -> { [] }
   option :on_success, Operations::Types::Array.of(Operations::Types.Interface(:call)), default: -> { [] }
   option :on_failure, Operations::Types::Array.of(Operations::Types.Interface(:call)), default: -> { [] }
-  option :form_model_map, Operations::Types::Hash.map(
-    Operations::Types::Coercible::Array.of(
-      Operations::Types::String | Operations::Types::Symbol | Operations::Types.Instance(Regexp)
-    ),
-    Operations::Types::String
-  ), default: proc { {} }
-  option :form_base, Operations::Types::Class, default: proc { ::Operations::Form }
-  option :form_class, Operations::Types::Class.optional, default: proc {}
+  option :form_model_map, Operations::Form::DeprecatedLegacyModelMapImplementation::TYPE, default: proc { {} }
+  option :form_base, Operations::Types::Class, default: proc { ::Operations::Form::Base }
+  option :form_class, Operations::Types::Class.optional, default: proc {}, reader: false
   option :form_hydrator, Operations::Types.Interface(:call), default: proc { FORM_HYDRATOR }
   option :configuration, Operations::Configuration, default: proc { Operations.default_config }
 
+  include Operations::Inspect.new(dry_initializer.attributes(self).keys)
+
   # A short-cut to initialize operation by convention:
   #
   # Namespace::OperationName - operation
@@ -194,16 +190,15 @@ class Operations::Command
   end
 
   def initialize(
-    operation, policy: UNDEFINED, policies: [UNDEFINED],
+    operation, policy: Undefined, policies: [Undefined],
     precondition: nil, preconditions: [], after: [], **options
   )
     policies_sum = Array.wrap(policy) + policies
-    result_policies = policies_sum - [UNDEFINED] unless policies_sum == [UNDEFINED, UNDEFINED]
+    result_policies = policies_sum - [Undefined] unless policies_sum == [Undefined, Undefined]
     options[:policies] = result_policies if result_policies
 
     preconditions.push(precondition) if precondition.present?
     super(operation, preconditions: preconditions, on_success: after, **options)
-    @form_class ||= build_form_class
   end
 
   # Instantiates a new command with the given fields updated.
@@ -276,32 +271,21 @@ class Operations::Command
     validate(*args, **kwargs).success?
   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(*)
+  def to_hash
     {
-      **main_components_as_json,
-      **form_components_as_json,
-      configuration: configuration.as_json
+      **main_components_to_hash,
+      **form_components_to_hash,
+      configuration: configuration
     }
   end
 
+  def form_class
+    @form_class ||= build_form_class
+  end
+
   private
 
-  def main_components_as_json
+  def main_components_to_hash
     {
       operation: operation.class.name,
       contract: contract.class.name,
@@ -313,7 +297,7 @@ class Operations::Command
     }
   end
 
-  def form_components_as_json
+  def form_components_to_hash
     {
       form_model_map: form_model_map,
       form_base: form_base.name,
@@ -401,9 +385,9 @@ class Operations::Command
       .new(base_class: form_base)
       .build(
         key_map: contract.class.schema.key_map,
+        model_map: Operations::Form::DeprecatedLegacyModelMapImplementation.new(form_model_map),
         namespace: operation.class,
-        class_name: form_class_name,
-        model_map: form_model_map
+        class_name: form_class_name
       )
   end
 

data/lib/operations/contract/messages_resolver.rb

@@ -6,6 +6,6 @@ class Operations::Contract::MessagesResolver < Dry::Validation::Messages::Resolv
   def call(message:, meta: Dry::Schema::EMPTY_HASH, **rest)
     meta = meta.merge(code: message) if message.is_a?(Symbol)
 
-    super(message: message, meta: meta, **rest)
+    super
   end
 end

data/lib/operations/form/attribute.rb

@@ -5,14 +5,15 @@
 # legacy UI.
 class Operations::Form::Attribute
   extend Dry::Initializer
-  include Dry::Equalizer(:name, :collection, :form, :model_name)
+  include Dry::Equalizer(:name, :collection, :model_name, :form)
+  include Operations::Inspect.new(:name, :collection, :model_name, :form)
 
   param :name, type: Operations::Types::Coercible::Symbol
-  option :collection, type: Operations::Types::Bool, optional: true, default: proc { false }
-  option :form, type: Operations::Types::Class, optional: true
+  option :collection, type: Operations::Types::Bool, default: proc { false }
   option :model_name,
-    type: Operations::Types::String | Operations::Types.Instance(Class).constrained(lt: ActiveRecord::Base),
-    optional: true
+    type: (Operations::Types::String | Operations::Types.Instance(Class).constrained(lt: ActiveRecord::Base)).optional,
+    default: proc {}
+  option :form, type: Operations::Types::Class.optional, default: proc {}
 
   def model_type
     @model_type ||= owning_model.type_for_attribute(string_name) if model_name

data/lib/operations/form/base.rb

@@ -0,0 +1,264 @@
+# 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::Base
+#     attribute :name
+#   end
+#
+#   class PostForm < Operations::Form::Base
+#     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::Base
+  BUILD_ASSOCIATION_PREFIX = "build_"
+  NESTED_ATTRIBUTES_SUFFIX = "_attributes="
+
+  # :nodoc:
+  module ClassMethods
+    def self.extended(base)
+      base.singleton_class.include Operations::Inspect.new(:attributes)
+
+      base.extend Dry::Initializer
+      base.include Dry::Equalizer(:attributes, :errors)
+      base.include Operations::Inspect.new(:attributes, :errors)
+
+      base.param :data,
+        type: Operations::Types::Hash.map(Operations::Types::Symbol, Operations::Types::Any),
+        default: proc { {} },
+        reader: :private
+      base.option :messages,
+        type: Operations::Types::Hash.map(
+          Operations::Types::Nil | Operations::Types::Coercible::Symbol,
+          Operations::Types::Any
+        ),
+        default: proc { {} },
+        reader: :private
+      base.option :operation_result, default: proc {}
+
+      base.class_attribute :attributes, instance_accessor: false, default: {}
+      base.class_attribute :primary_key, instance_accessor: false, default: :id
+
+      base.define_method :initialize do |*args, **kwargs|
+        args.empty? && kwargs.present? ? super(kwargs, **{}) : super(*args, **kwargs)
+      end
+    end
+
+    def attribute(name, **options)
+      attribute = Operations::Form::Attribute.new(name, **options)
+
+      self.attributes = attributes.merge(
+        attribute.name => attribute
+      )
+    end
+
+    def 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 validators_on(name)
+      attributes[name.to_sym]&.model_validators || []
+    end
+
+    def model_name
+      @model_name ||= ActiveModel::Name.new(self)
+    end
+
+    def reflect_on_association(...); end
+  end
+
+  # :nodoc:
+  module InstanceMethods
+    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
+
+    # For now we gracefully return nil for unknown methods
+    def method_missing(name, *args, **kwargs)
+      build_attribute_name = build_attribute_name(name)
+      build_attribute = self.class.attributes[build_attribute_name]
+      plural_build_attribute = self.class.attributes[build_attribute_name.to_s.pluralize.to_sym]
+
+      if has_attribute?(name)
+        read_attribute(name)
+      elsif build_attribute&.form
+        build_attribute.form.new(*args, **kwargs)
+      elsif plural_build_attribute&.form
+        plural_build_attribute.form.new(*args, **kwargs)
+      end
+    end
+
+    def respond_to_missing?(name, *)
+      has_attribute?(name) ||
+        build_nested_form?(build_attribute_name(name)) ||
+        self.class.attributes[nested_attribute_name(name)]&.form
+    end
+
+    def model_name
+      self.class.model_name
+    end
+
+    def persisted?
+      !has_attribute?(self.class.primary_key) || read_attribute(self.class.primary_key).present?
+    end
+
+    def new_record?
+      !persisted?
+    end
+
+    def _destroy
+      Operations::Types::Params::Bool.call(read_attribute(:_destroy)) { false }
+    end
+    alias_method :marked_for_destruction?, :_destroy
+
+    # 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
+    alias_method :read_attribute_for_validation, :read_attribute
+
+    def to_hash
+      {
+        attributes: attributes,
+        errors: errors
+      }
+    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
+
+    def build_attribute_name(name)
+      name.to_s.delete_prefix(BUILD_ASSOCIATION_PREFIX).to_sym if name.to_s.start_with?(BUILD_ASSOCIATION_PREFIX)
+    end
+
+    def nested_attribute_name(name)
+      name.to_s.delete_suffix(NESTED_ATTRIBUTES_SUFFIX).to_sym if name.to_s.end_with?(NESTED_ATTRIBUTES_SUFFIX)
+    end
+
+    def build_nested_form?(name)
+      !!(self.class.attributes[name]&.form ||
+        self.class.attributes[name.to_s.pluralize.to_sym]&.form)
+    end
+  end
+
+  extend ClassMethods
+  include InstanceMethods
+end

data/lib/operations/form/builder.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 # Traverses the passed {Dry::Schema::KeyMap} and generates
-# {Operations::Form} classes on the fly. Handles nested structures.
+# {Operations::Form::Base} classes on the fly. Handles nested structures.
 #
-# @see Operations::Form
+# @see Operations::Form::Base
 class Operations::Form::Builder
   extend Dry::Initializer
 
@@ -11,38 +11,49 @@ class Operations::Form::Builder
 
   option :base_class, Operations::Types::Instance(Class)
 
-  def build(key_map:, namespace:, class_name:, model_map:)
+  def build(key_map:, model_map:, namespace: nil, class_name: nil, model_name: nil)
     return namespace.const_get(class_name) if namespace && class_name && namespace.const_defined?(class_name)
 
-    traverse(key_map, namespace, class_name, model_map, [])
+    traverse(key_map, model_map, namespace, class_name, model_name, [])
   end
 
   private
 
-  def traverse(key_map, namespace, class_name, model_map, path)
+  def traverse(key_map, model_map, namespace, class_name, model_name, path)
     form = Class.new(base_class)
-    namespace.const_set(class_name, form) if namespace && class_name
+    namespace.const_set(class_name, form) if namespace&.name && class_name
+    define_model_name(form, model_name) if model_name && !form.name
 
-    key_map.each do |key|
-      key_path = path + [key.name]
+    key_map.each { |key| define_attribute(form, model_map, key, path) }
+    form
+  end
 
-      case key
-      when Dry::Schema::Key::Array
-        nested_form = traverse(key.member, form, key.name.to_s.underscore.classify, model_map, key_path)
-        form.attribute(key.name, form: nested_form, collection: true, **model_name(key_path, model_map))
-      when Dry::Schema::Key::Hash
-        traverse_hash(form, key, model_map, path)
-      when Dry::Schema::Key
-        form.attribute(key.name, **model_name(key_path, model_map))
-      else
-        raise "Unknown key_map key: #{key.class}"
-      end
+  def define_model_name(form, model_name)
+    form.define_singleton_method :model_name do
+      @model_name ||= ActiveModel::Name.new(self, nil, model_name)
     end
+  end
 
-    form
+  def define_attribute(form, model_map, key, path)
+    case key
+    when Dry::Schema::Key::Array
+      traverse_array(form, model_map, key, path)
+    when Dry::Schema::Key::Hash
+      traverse_hash(form, model_map, key, path)
+    when Dry::Schema::Key
+      form.attribute(key.name, model_name: model_map&.call(path + [key.name]))
+    else
+      raise "Unknown key_map key: #{key.class}"
+    end
+  end
+
+  def traverse_array(form, model_map, key, path)
+    key_path = path + [key.name]
+    nested_form = traverse(key.member, model_map, form, key.name.to_s.underscore.classify, key.name.to_s, key_path)
+    form.attribute(key.name, form: nested_form, collection: true, model_name: model_map&.call(key_path))
   end
 
-  def traverse_hash(form, hash_key, model_map, path)
+  def traverse_hash(form, model_map, hash_key, path)
     nested_attributes_suffix = hash_key.name.match?(NESTED_ATTRIBUTES_SUFFIX)
     nested_attributes_collection = hash_key.members.all?(Dry::Schema::Key::Hash) &&
       hash_key.members.map(&:members).uniq.size == 1
@@ -55,8 +66,8 @@ class Operations::Form::Builder
     form.define_method :"#{hash_key.name}=", proc { |attributes| attributes } if nested_attributes_suffix
 
     key_path = path + [name]
-    nested_form = traverse(members, form, name.underscore.camelize, model_map, key_path)
-    form.attribute(name, form: nested_form, collection: collection, **model_name(key_path, model_map))
+    nested_form = traverse(members, model_map, form, name.underscore.camelize, name.to_s.singularize, key_path)
+    form.attribute(name, form: nested_form, collection: collection, model_name: model_map&.call(key_path))
   end
 
   def specify_form_attributes(hash_key, nested_attributes_suffix, nested_attributes_collection)
@@ -68,18 +79,4 @@ class Operations::Form::Builder
       [hash_key.name, hash_key.members, false]
     end
   end
-
-  def model_name(path, model_map)
-    _, model_name = model_map.find do |pathspec, _model|
-      path.size == pathspec.size && path.zip(pathspec).all? do |slug, pattern|
-        pattern.is_a?(Regexp) ? pattern.match?(slug) : slug == pattern
-      end
-    end
-
-    if model_name
-      { model_name: model_name }
-    else
-      {}
-    end
-  end
 end

data/lib/operations/form/deprecated_legacy_model_map_implementation.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+# Traverses the passed {Dry::Schema::KeyMap} and generates
+# {Operations::Form::Base} classes on the fly. Handles nested structures.
+#
+# This class will be removed along with Operations::Command#form_model_map
+# option removal along with the rest of form-related stuff.
+#
+# Don't use this class in you code, instead, copy it and modify to you liking.
+#
+# @see Operations::Form::Base
+class Operations::Form::DeprecatedLegacyModelMapImplementation
+  extend Dry::Initializer
+
+  TYPE = Operations::Types::Hash.map(
+    Operations::Types::Coercible::Array.of(
+      Operations::Types::String | Operations::Types::Symbol | Operations::Types.Instance(Regexp)
+    ),
+    Operations::Types::String
+  )
+
+  param :model_map_hash, TYPE, default: proc { {} }
+
+  def call(path)
+    model_map_hash.find do |pathspec, _model|
+      path.size == pathspec.size && path.zip(pathspec).all? do |slug, pattern|
+        pattern.is_a?(Regexp) ? pattern.match?(slug) : slug == pattern
+      end
+    end&.second
+  end
+end

data/lib/operations/form.rb

@@ -1,194 +1,96 @@
 # 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}
+# Configures and defines a form object factory.
+# Forms can be defined on top of commants and used in the user-facing controllers.
+# Form objects are Rails-specific and support everything that is needed for Rails'
+# form rendering helpers. They are designed to replace direct usage of ActiveRecord
+# models in controllers and views and act as an integration bridge from Rails
+# application to the Operations framework.
+#
 # @example
 #
-#   class AuthorForm < Operations::Form
-#     attribute :name
-#   end
+#   command = Operations::Command.new(...)
+#   form = Operations::Form.new(command)
+#
+#   @form_object = form.build(params)
 #
-#   class PostForm < Operations::Form
-#     attribute :title
-#     attribute :tags, collection: true
-#     attribute :author, form: AuthorForm
-#   end
+#   form_for @form_object, url: ...
 #
-#   PostForm.new({ tags: ["foobar"], author: { name: "Batman" } })
-#   # => #<PostForm attributes={:title=>nil, :tags=>["foobar"], :author=>#<AuthorForm attributes={:name=>"Batman"}>}>
+#   @form_object = form.persist(params)
+#   respond_with @form_object
 #
-# @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
+  include Dry::Core::Constants
+  include Dry::Equalizer(:command, :model_map, :params_transformations, :hydrator, :form_class)
+  include Operations::Inspect.new(:model_name, :model_map, :params_transformations, :hydrator, :form_class)
 
-  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
+  # We need to make deprecated inheritance from Operations::Form act exactly the
+  # same way as from Operations::Form::Base. In order to do this, we are encapsulating all the
+  # inheritable functionality in 2 modules and removing methods defined in Operations::Form
+  # from the result class.
+  def self.inherited(subclass)
+    super
 
-  def localized_attr_name_for(name, locale)
-    self.class.attributes[name.to_sym].model_localized_attr_name(locale)
-  end
+    return unless self == Operations::Form
 
-  def has_attribute?(name) # rubocop:disable Naming/PredicateName
-    self.class.attributes.key?(name.to_sym)
-  end
+    ActiveSupport::Deprecation.new.warn("Inheritance from Operations::Form is deprecated and will be " \
+      "removed in 1.0.0. Please inherit from Operations::Form::Base instead")
 
-  def attributes
-    self.class.attributes.keys.to_h do |name|
-      [name, read_attribute(name)]
+    (Operations::Form.instance_methods - Object.instance_methods).each do |method|
+      subclass.undef_method(method)
     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)
+    subclass.extend Operations::Form::Base::ClassMethods
+    subclass.prepend Operations::Form::Base::InstanceMethods
   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
+  include Dry::Initializer.define(lambda do
+    param :command, type: Operations::Types.Interface(:operation, :contract, :call)
+    option :model_name, type: Operations::Types::String.optional, default: proc {}, reader: false
+    option :model_map, type: Operations::Types.Interface(:call).optional, default: proc {}
+    option :params_transformations, type: Operations::Types::Coercible::Array.of(Operations::Types.Interface(:call)),
+      default: proc { [] }
+    option :hydrator, type: Operations::Types.Interface(:call).optional, default: proc {}
+    option :base_class, type: Operations::Types::Class, default: proc { ::Operations::Form::Base }
+  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
+  def build(params = EMPTY_HASH, **context)
+    instantiate_form(command.callable(transform_params(params, **context), **context))
   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
+  def persist(params = EMPTY_HASH, **context)
+    instantiate_form(command.call(transform_params(params, **context), **context))
   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
+  def form_class
+    @form_class ||= Operations::Form::Builder.new(base_class: base_class)
+      .build(key_map: key_map, model_map: model_map, model_name: model_name)
   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])
+  def transform_params(params, **context)
+    params = params.to_unsafe_hash if params.respond_to?(:to_unsafe_hash)
+    params = params.deep_symbolize_keys
+    params = params.merge(params[form_class.model_name.param_key.to_sym] || {})
+    params_transformations.inject(params) do |value, transformation|
+      transformation.call(form_class, value, **context)
     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])
+  def instantiate_form(operation_result)
+    form_class.new(
+      hydrator&.call(form_class, operation_result.params, **operation_result.context) || {},
+      messages: operation_result.errors.to_h,
+      operation_result: operation_result
+    )
   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
+  def key_map
+    @key_map ||= command.contract.schema.key_map
   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
+  def model_name
+    @model_name ||= ("#{command.operation.class.name.underscore}_form" if command.operation.class.name)
   end
 end

data/lib/operations/inspect.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# Configures inspect/pretty_print methods on object.
+class Operations::Inspect < Module
+  extend Dry::Initializer
+
+  param :attributes, Operations::Types::Coercible::Array.of(Operations::Types::Symbol), reader: false
+  param :value_methods, Operations::Types::Hash.map(Operations::Types::Symbol, Operations::Types::Symbol)
+
+  def initialize(*attributes, **kwargs)
+    super(attributes.flatten(1), kwargs)
+
+    define_pretty_print(@attributes, @value_methods)
+  end
+
+  private
+
+  def define_pretty_print(attributes, value_methods)
+    define_method(:pretty_print) do |pp|
+      object_group_method = self.class.name ? :object_group : :object_address_group
+      pp.public_send(object_group_method, self) do
+        pp.seplist(attributes, -> { pp.text "," }) do |name|
+          pp.breakable " "
+          pp.group(1) do
+            pp.text name.to_s
+            pp.text "="
+            pp.pp __send__(value_methods[name] || name)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/operations/result.rb

@@ -6,9 +6,9 @@
 # execution).
 # Also able to spawn a form object basing on the operation params and errors.
 class Operations::Result
+  extend Dry::Initializer
   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)
@@ -19,6 +19,8 @@ class Operations::Result
   option :errors, type: Operations::Types.Interface(:call) | Operations::Types::Instance(Dry::Validation::MessageSet),
     default: proc { Dry::Validation::MessageSet.new([]).freeze }
 
+  include Operations::Inspect.new(dry_initializer.attributes(self).keys)
+
   # Instantiates a new result with the given fields updated
   def merge(**changes)
     self.class.new(**self.class.dry_initializer.attributes(self), **changes)
@@ -77,31 +79,20 @@ class Operations::Result
     )
   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
+  def as_json(options = {})
+    to_hash(**options.slice(:include_command))
   end
 
-  def as_json(*, include_command: false, **)
+  def to_hash(include_command: false)
     hash = {
       component: component,
       params: params,
-      context: context_as_json,
+      context: context_to_hash,
       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[:command] = operation&.to_hash if include_command
     hash
   end
 
@@ -112,7 +103,7 @@ class Operations::Result
     (errors.map { |error| error.meta[:code] } & names).present?
   end
 
-  def context_as_json
+  def context_to_hash
     context.transform_values do |context_value|
       next context_value.class.name unless context_value.respond_to?(:id)
 

data/lib/operations/version.rb

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

data/lib/operations.rb

@@ -11,15 +11,18 @@ require "active_model/naming"
 require "after_commit_everywhere"
 require "operations/version"
 require "operations/types"
+require "operations/inspect"
 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/base"
 require "operations/form/attribute"
 require "operations/form/builder"
+require "operations/form/deprecated_legacy_model_map_implementation"
+require "operations/command"
+require "operations/result"
 
 # The root gem module
 module Operations

data/operations.gemspec

@@ -29,14 +29,14 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "appraisal"
   spec.add_development_dependency "database_cleaner-active_record"
-  spec.add_development_dependency "sqlite3"
+  spec.add_development_dependency "sqlite3", "~> 1.4"
 
-  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.add_dependency "activerecord", ">= 5.2.0"
+  spec.add_dependency "activesupport", ">= 5.2.0"
+  spec.add_dependency "after_commit_everywhere"
+  spec.add_dependency "dry-monads"
+  spec.add_dependency "dry-struct"
+  spec.add_dependency "dry-validation"
   spec.metadata = {
     "rubygems_mfa_required" => "true"
   }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: operations
 version: !ruby/object:Gem::Version
-  version: 0.6.3
+  version: 0.7.0
 platform: ruby
 authors:
 - Arkadiy Zabazhanov
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-12-20 00:00:00.000000000 Z
+date: 2024-07-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: appraisal
@@ -42,16 +42,16 @@ dependencies:
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.4'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.4'
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
@@ -180,7 +180,10 @@ files:
 - lib/operations/convenience.rb
 - lib/operations/form.rb
 - lib/operations/form/attribute.rb
+- lib/operations/form/base.rb
 - lib/operations/form/builder.rb
+- lib/operations/form/deprecated_legacy_model_map_implementation.rb
+- lib/operations/inspect.rb
 - lib/operations/result.rb
 - lib/operations/test_helpers.rb
 - lib/operations/types.rb
@@ -206,7 +209,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.7
+rubygems_version: 3.4.19
 signing_key:
 specification_version: 4
 summary: Operations framework