opera 0.2.7 → 0.2.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b5bbb67e42e162ac6cbea3ac242a707d270110035cf618f84ea8cc5e33a60de8
-  data.tar.gz: 512a3bf21c0a6e686e41e9eb25ed21634612f4e004bd7ece8c3e3177664bcbcd
+  metadata.gz: 84e206c0f8da7dd69e6a4132a7228b87cbe3b79e7eeb3e936659554d7ac8a69a
+  data.tar.gz: b962b7656ff7ddcfd0d964bd622027f4b431b2ddf9cb0d8ad59ec97a045eb6bc
 SHA512:
-  metadata.gz: 8d55665d552e5be5d23f150d17f121700b958fc8dfdd92ef1c4cc82d9d4329b03e8a4c08c8204bff87897e65d0c2858c06df8677748b9a437795476e47b6dd62
-  data.tar.gz: 939e7abdc56c89ff03131ff98d9721dde54224891711923073bc5377a7389f46c660b7a8f909e13204ec74f565be6217a21c12e00e522dc18ecf1cbff42a6dc6
+  metadata.gz: 1159a0ffc970a9365ca78fde1589f49eb34ee73ebbcbc5bde0b895ce13cbd48c6ea361d4468002d39a9d00b6ffad377bf0ccbe3f4340be19882d07e780772a2d
+  data.tar.gz: 85136103bf11201f4f0f877ef556c913b0d7031fc8e4ef10d42bcdcf30f3e0a7504eeea285b047397006a0ec54e8a383c80b7d51bc0c667a3348c42b48ef7876

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Opera Changelog
 
+### 0.2.10 - June 1, 2022
+
+- `finish!` does not break transaction
+
+### 0.2.9 - May 16, 2022
+
+- Improve executions for failing operations
+
+### 0.2.8 - December 7, 2021
+
+- Fix issue with default value
+- Update Readme
+
 ### 0.2.7 - October 29, 2021
 
 - Adds `finish_if` step to DSL

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    opera (0.2.7)
+    opera (0.2.10)
 
 GEM
   remote: https://rubygems.org/
@@ -81,4 +81,4 @@ DEPENDENCIES
   rspec (~> 3.0)
 
 BUNDLED WITH
-   2.2.15
+   2.2.32

data/README.md

@@ -702,7 +702,7 @@ class Profile::Create < Opera::Operation::Base
 end
 ```
 
-#### Example with information (real and total) from benchmark
+#### Example output for success block
 
 ```ruby
 Profile::Create.call(params: {

data/lib/opera/operation/base.rb

@@ -60,7 +60,11 @@ module Opera
               check_method_availability!(attribute)
 
               define_method(attribute) do
-                value = send(method).key?(attribute) ? send(method)[attribute] : self.instance_exec(&options[:default])
+                value = if send(method).key?(attribute)
+                          send(method)[attribute]
+                        elsif options[:default]
+                          instance_exec(&options[:default])
+                        end
 
                 if send(method).frozen?
                   send(method)[attribute] || value

data/lib/opera/operation/instructions/executors/operation.rb

@@ -12,12 +12,13 @@ module Opera
 
             if operation_result.success?
               add_instruction_output(instruction, operation_result.output)
-              execution = result.executions.pop
-              result.executions << { execution => operation_result.executions }
             else
               result.add_errors(operation_result.errors)
               result.add_exceptions(operation_result.exceptions)
             end
+
+            execution = result.executions.pop
+            result.executions << { execution => operation_result.executions }
           end
 
           private

data/lib/opera/operation/instructions/executors/transaction.rb

@@ -12,11 +12,11 @@ module Opera
             transaction_class.send(*arguments) do
               super
 
-              return if !operation.finished? && result.success?
+              return if result.success?
 
-              raise(RollbackTransactionError)
+              raise(transaction_error)
             end
-          rescue RollbackTransactionError
+          rescue transaction_error
             nil
           end
 
@@ -31,6 +31,10 @@ module Opera
           def transaction_options
             config.transaction_options
           end
+
+          def transaction_error
+            RollbackTransactionError
+          end
         end
       end
     end

data/lib/opera/version.rb

@@ -1,3 +1,3 @@
 module Opera
-  VERSION = '0.2.7'
+  VERSION = '0.2.10'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: opera
 version: !ruby/object:Gem::Version
-  version: 0.2.7
+  version: 0.2.10
 platform: ruby
 authors:
 - ProFinda Development Team
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-11-03 00:00:00.000000000 Z
+date: 2022-06-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-validation
@@ -78,7 +78,6 @@ files:
 - lib/opera.rb
 - lib/opera/errors.rb
 - lib/opera/operation.rb
-- lib/opera/operation/README.md
 - lib/opera/operation/base.rb
 - lib/opera/operation/builder.rb
 - lib/opera/operation/config.rb

data/lib/opera/operation/README.md

@@ -1,786 +0,0 @@
-# Opera::Operation
-
-Simple DSL for services/interactions classes.
-
-# Installation
-
-```
-gem install pro_finda-operation
-```
-
-or in Gemfile:
-
-```
-gem 'pro_finda-operation', path: 'vendor/pro_finda-operation'
-```
-
-# Configuration
-
-```ruby
-Opera::Operation::Config.configure do |config|
-  config.transaction_class = ActiveRecord::Base
-  config.transaction_method = :transaction
-  config.reporter = if defined?(Rollbar) then Rollbar else Rails.logger
-end
-
-class A < Opera::Operation::Base
-
-  configure do |config|
-    config.transaction_class = Profile
-    config.reporter = Rails.logger
-  end
-
-  success :populate
-
-  operation :inner_operation
-
-  validate :profile_schema
-
-  transaction do
-    step :create
-    step :update
-    step :destroy
-  end
-
-  validate do
-    step :validate_object
-    step :validate_relationships
-  end
-
-  benchmark do
-    success :hal_sync
-  end
-
-  success do
-    step :send_mail
-    step :report_to_audit_log
-  end
-
-  step :output
-end
-```
-
-# Specs
-
-When using Opera::Operation inside an engine add the following
-configuration to your spec_helper.rb or rails_helper.rb:
-
-```
-Opera::Operation::Config.configure do |config|
-  config.transaction_class = ActiveRecord::Base
-end
-```
-
-Without this extra configuration you will receive:
-```
-NoMethodError:
-  undefined method `transaction' for nil:NilClass
-```
-
-# Debugging
-
-When you want to easily debug exceptions you can add this
-to your dummy.rb:
-
-```
-Rails.application.configure do
-  config.x.reporter = Logger.new(STDERR)
-end
-```
-
-This should display exceptions captured inside operations.
-
-You can also do it in Opera::Operation configuration block:
-
-```
-Opera::Operation::Config.configure do |config|
-  config.transaction_class = ActiveRecord::Base
-  config.reporter = Logger.new(STDERR)
-end
-```
-
-# Content
-[Basic operation](#user-content-basic-operation)
-
-[Example with sanitizing parameters](#user-content-example-with-sanitizing-parameters)
-
-[Example operation with old validations](#user-content-example-operation-with-old-validations)
-
-[Example with step that raises exception](#user-content-example-with-step-that-raises-exception)
-
-[Failing transaction](#user-content-failing-transaction)
-
-[Passing transaction](#user-content-passing-transaction)
-
-[Benchmark](#user-content-benchmark)
-
-[Success](#user-content-success)
-
-[Inner Operation](#user-content-inner-operation)
-
-[Inner Operations](#user-content-inner-operations)
-
-# Usage examples
-
-Some cases and example how to use new operations
-
-## Basic operation
-
-```ruby
-class Profile::Create < Opera::Operation::Base
-  validate :profile_schema
-
-  step :create
-  step :send_email
-  step :output
-
-  def profile_schema
-    Dry::Validation.Schema do
-      required(:first_name).filled
-    end.call(params)
-  end
-
-  def create
-    context[:profile] = dependencies[:current_account].profiles.create(params)
-  end
-
-  def send_email
-    dependencies[:mailer]&.send_mail(profile: context[:profile])
-  end
-
-  def output
-    result.output = { model: context[:profile] }
-  end
-end
-```
-
-#### Call with valid parameters
-
-```ruby
-Profile::Create.call(params: {
-  first_name: :foo,
-  last_name: :bar
-}, dependencies: {
-  mailer: ProfindaMailer,
-  current_account: Account.find(1)
-})
-
-#<Opera::Operation::Result:0x0000561636dced60 @errors={}, @exceptions={}, @information={}, @executions=[:profile_schema, :create, :send_email, :output], @output={:model=>#<Profile id: 30, user_id: nil, linkedin_uid: nil, picture: nil, headline: nil, summary: nil, first_name: "foo", last_name: "bar", created_at: "2018-12-14 16:04:08", updated_at: "2018-12-14 16:04:08", agree_to_terms_and_conditions: nil, registration_status: "", account_id: 1, start_date: nil, supervisor_id: nil, picture_processing: false, statistics: {}, data: {}, notification_timestamps: {}, suggestions: {}, notification_settings: {}, contact_information: []>}>
-```
-
-#### Call with INVALID parameters - missing first_name
-
-```ruby
-Profile::Create.call(params: {
-  last_name: :bar
-}, dependencies: {
-  mailer: ProfindaMailer,
-  current_account: Account.find(1)
-})
-
-#<Opera::Operation::Result:0x0000562d3f635390 @errors={:first_name=>["is missing"]}, @exceptions={}, @information={}, @executions=[:profile_schema]>
-```
-
-#### Call with MISSING dependencies
-
-```ruby
-Profile::Create.call(params: {
-  first_name: :foo,
-  last_name: :bar
-}, dependencies: {
-  current_account: Account.find(1)
-})
-
-#<Opera::Operation::Result:0x007f87ba2c8f00 @errors={}, @exceptions={}, @information={}, @executions=[:profile_schema, :create, :send_email, :output], @output={:model=>#<Profile id: 33, user_id: nil, linkedin_uid: nil, picture: nil, headline: nil, summary: nil, first_name: "foo", last_name: "bar", created_at: "2019-01-03 12:04:25", updated_at: "2019-01-03 12:04:25", agree_to_terms_and_conditions: nil, registration_status: "", account_id: 1, start_date: nil, supervisor_id: nil, picture_processing: false, statistics: {}, data: {}, notification_timestamps: {}, suggestions: {}, notification_settings: {}, contact_information: []>}>
-```
-
-## Example with sanitizing parameters
-
-```ruby
-class Profile::Create < Opera::Operation::Base
-  validate :profile_schema
-
-  step :create
-  step :send_email
-  step :output
-
-  def profile_schema
-    Dry::Validation.Schema do
-      configure { config.input_processor = :sanitizer }
-
-      required(:first_name).filled
-    end.call(params)
-  end
-
-  def create
-    context[:profile] = dependencies[:current_account].profiles.create(context[:profile_schema_output])
-  end
-
-  def send_email
-    return true unless dependencies[:mailer]
-    dependencies[:mailer].send_mail(profile: context[:profile])
-  end
-
-  def output
-    result.output = { model: context[:profile] }
-  end
-end
-```
-
-```ruby
-Profile::Create.call(params: {
-  first_name: :foo,
-  last_name: :bar
-}, dependencies: {
-  mailer: ProfindaMailer,
-  current_account: Account.find(1)
-})
-
-# NOTE: Last name is missing in output model
-#<Opera::Operation::Result:0x000055e36a1fab78 @errors={}, @exceptions={}, @information={}, @executions=[:profile_schema, :create, :send_email, :output], @output={:model=>#<Profile id: 44, user_id: nil, linkedin_uid: nil, picture: nil, headline: nil, summary: nil, first_name: "foo", last_name: nil, created_at: "2018-12-17 11:07:08", updated_at: "2018-12-17 11:07:08", agree_to_terms_and_conditions: nil, registration_status: "", account_id: 1, start_date: nil, supervisor_id: nil, picture_processing: false, statistics: {}, data: {}, notification_timestamps: {}, suggestions: {}, notification_settings: {}, contact_information: []>}>
-```
-
-## Example operation with old validations
-
-```ruby
-class Profile::Create < Opera::Operation::Base
-  validate :profile_schema
-
-  step :build_record
-  step :old_validation
-  step :create
-  step :send_email
-  step :output
-
-  def profile_schema
-    Dry::Validation.Schema do
-      required(:first_name).filled
-    end.call(params)
-  end
-
-  def build_record
-    context[:profile] = dependencies[:current_account].profiles.build(params)
-    context[:profile].force_name_validation = true
-  end
-
-  def old_validation
-    return true if context[:profile].valid?
-
-    result.add_information(missing_validations: "Please check dry validations")
-    result.add_errors(context[:profile].errors.messages)
-
-    false
-  end
-
-  def create
-    context[:profile].save
-  end
-
-  def send_email
-    dependencies[:mailer].send_mail(profile: context[:profile])
-  end
-
-  def output
-    result.output = { model: context[:profile] }
-  end
-end
-```
-
-#### Call with valid parameters
-
-```ruby
-Profile::Create.call(params: {
-  first_name: :foo,
-  last_name: :bar
-}, dependencies: {
-  mailer: ProfindaMailer,
-  current_account: Account.find(1)
-})
-
-#<Opera::Operation::Result:0x0000560ebc9e7a98 @errors={}, @exceptions={}, @information={}, @executions=[:profile_schema, :build_record, :old_validation, :create, :send_email, :output], @output={:model=>#<Profile id: 41, user_id: nil, linkedin_uid: nil, picture: nil, headline: nil, summary: nil, first_name: "foo", last_name: "bar", created_at: "2018-12-14 19:15:12", updated_at: "2018-12-14 19:15:12", agree_to_terms_and_conditions: nil, registration_status: "", account_id: 1, start_date: nil, supervisor_id: nil, picture_processing: false, statistics: {}, data: {}, notification_timestamps: {}, suggestions: {}, notification_settings: {}, contact_information: []>}>
-```
-
-#### Call with INVALID parameters
-
-```ruby
-Profile::Create.call(params: {
-  first_name: :foo
-}, dependencies: {
-  mailer: ProfindaMailer,
-  current_account: Account.find(1)
-})
-
-#<Opera::Operation::Result:0x0000560ef76ba588 @errors={:last_name=>["can't be blank"]}, @exceptions={}, @information={:missing_validations=>"Please check dry validations"}, @executions=[:build_record, :old_validation]>
-```
-
-## Example with step that raises exception
-
-```ruby
-class Profile::Create < Opera::Operation::Base
-  validate :profile_schema
-
-  step :build_record
-  step :exception
-  step :create
-  step :send_email
-  step :output
-
-  def profile_schema
-    Dry::Validation.Schema do
-      required(:first_name).filled
-    end.call(params)
-  end
-
-  def build_record
-    context[:profile] = dependencies[:current_account].profiles.build(params)
-    context[:profile].force_name_validation = true
-  end
-
-  def exception
-    raise StandardError, 'Example'
-  end
-
-  def create
-    context[:profile] = context[:profile].save
-  end
-
-  def send_email
-    return true unless dependencies[:mailer]
-
-    dependencies[:mailer].send_mail(profile: context[:profile])
-  end
-
-  def output
-    result.output(model: context[:profile])
-  end
-end
-```
-##### Call with step throwing exception
-```ruby
-result = Profile::Create.call(params: {
-  first_name: :foo,
-  last_name: :bar
-}, dependencies: {
-  current_account: Account.find(1)
-})
-
-#<Opera::Operation::Result:0x0000562ad0f897c8 @errors={}, @exceptions={"Profile::Create#exception"=>["Example"]}, @information={}, @executions=[:profile_schema, :build_record, :exception]>
-```
-
-## Example with step that finishes execution
-
-```ruby
-class Profile::Create < Opera::Operation::Base
-  validate :profile_schema
-
-  step :build_record
-  step :create
-  step :send_email
-  step :output
-
-  def profile_schema
-    Dry::Validation.Schema do
-      required(:first_name).filled
-    end.call(params)
-  end
-
-  def build_record
-    context[:profile] = dependencies[:current_account].profiles.build(params)
-    context[:profile].force_name_validation = true
-  end
-
-  def create
-    context[:profile] = context[:profile].save
-    finish
-  end
-
-  def send_email
-    return true unless dependencies[:mailer]
-
-    dependencies[:mailer].send_mail(profile: context[:profile])
-  end
-
-  def output
-    result.output(model: context[:profile])
-  end
-end
-```
-##### Call
-```ruby
-result = Profile::Create.call(params: {
-  first_name: :foo,
-  last_name: :bar
-}, dependencies: {
-  current_account: Account.find(1)
-})
-
-#<Opera::Operation::Result:0x007fc2c59a8460 @errors={}, @exceptions={}, @information={}, @executions=[:profile_schema, :build_record, :create]>
-```
-
-## Failing transaction
-
-```ruby
-class Profile::Create < Opera::Operation::Base
-  configure do |config|
-    config.transaction_class = Profile
-  end
-
-  validate :profile_schema
-
-  transaction do
-    step :create
-    step :update
-  end
-
-  step :send_email
-  step :output
-
-  def profile_schema
-    Dry::Validation.Schema do
-      required(:first_name).filled
-    end.call(params)
-  end
-
-  def create
-    context[:profile] = dependencies[:current_account].profiles.create(params)
-  end
-
-  def update
-    context[:profile].update(example_attr: :Example)
-  end
-
-  def send_email
-    return true unless dependencies[:mailer]
-
-    dependencies[:mailer].send_mail(profile: context[:profile])
-  end
-
-  def output
-    result.output = { model: context[:profile] }
-  end
-end
-```
-
-#### Example with non-existing attribute
-
-```ruby
-Profile::Create.call(params: {
-  first_name: :foo,
-  last_name: :bar
-}, dependencies: {
-  mailer: ProfindaMailer,
-  current_account: Account.find(1)
-})
-
-D, [2018-12-14T16:13:30.946466 #2504] DEBUG -- :   Account Load (0.5ms)  SELECT  "accounts".* FROM "accounts" WHERE "accounts"."deleted_at" IS NULL AND "accounts"."id" = $1 LIMIT $2  [["id", 1], ["LIMIT", 1]]
-D, [2018-12-14T16:13:30.960254 #2504] DEBUG -- :    (0.2ms)  BEGIN
-D, [2018-12-14T16:13:30.983981 #2504] DEBUG -- :   SQL (0.7ms)  INSERT INTO "profiles" ("first_name", "last_name", "created_at", "updated_at", "account_id") VALUES ($1, $2, $3, $4, $5) RETURNING "id"  [["first_name", "foo"], ["last_name", "bar"], ["created_at", "2018-12-14 16:13:30.982289"], ["updated_at", "2018-12-14 16:13:30.982289"], ["account_id", 1]]
-D, [2018-12-14T16:13:30.986233 #2504] DEBUG -- :    (0.2ms)  ROLLBACK
-#<Opera::Operation::Result:0x00005650e89b7708 @errors={}, @exceptions={"Profile::Create#update"=>["unknown attribute 'example_attr' for Profile."], "Profile::Create#transaction"=>["Opera::Operation::Base::RollbackTransactionError"]}, @information={}, @executions=[:profile_schema, :create, :update]>
-```
-
-## Passing transaction
-
-```ruby
-class Profile::Create < Opera::Operation::Base
-  configure do |config|
-    config.transaction_class = Profile
-  end
-
-  validate :profile_schema
-
-  transaction do
-    step :create
-    step :update
-  end
-
-  step :send_email
-  step :output
-
-  def profile_schema
-    Dry::Validation.Schema do
-      required(:first_name).filled
-    end.call(params)
-  end
-
-  def create
-    context[:profile] = dependencies[:current_account].profiles.create(params)
-  end
-
-  def update
-    context[:profile].update(updated_at: 1.day.ago)
-  end
-
-  def send_email
-    return true unless dependencies[:mailer]
-
-    dependencies[:mailer].send_mail(profile: context[:profile])
-  end
-
-  def output
-    result.output = { model: context[:profile] }
-  end
-end
-```
-
-#### Example with updating timestamp
-
-```ruby
-Profile::Create.call(params: {
-  first_name: :foo,
-  last_name: :bar
-}, dependencies: {
-  mailer: ProfindaMailer,
-  current_account: Account.find(1)
-})
-D, [2018-12-17T12:10:44.842392 #2741] DEBUG -- :   Account Load (0.7ms)  SELECT  "accounts".* FROM "accounts" WHERE "accounts"."deleted_at" IS NULL AND "accounts"."id" = $1 LIMIT $2  [["id", 1], ["LIMIT", 1]]
-D, [2018-12-17T12:10:44.856964 #2741] DEBUG -- :    (0.2ms)  BEGIN
-D, [2018-12-17T12:10:44.881332 #2741] DEBUG -- :   SQL (0.7ms)  INSERT INTO "profiles" ("first_name", "last_name", "created_at", "updated_at", "account_id") VALUES ($1, $2, $3, $4, $5) RETURNING "id"  [["first_name", "foo"], ["last_name", "bar"], ["created_at", "2018-12-17 12:10:44.879684"], ["updated_at", "2018-12-17 12:10:44.879684"], ["account_id", 1]]
-D, [2018-12-17T12:10:44.886168 #2741] DEBUG -- :   SQL (0.6ms)  UPDATE "profiles" SET "updated_at" = $1 WHERE "profiles"."id" = $2  [["updated_at", "2018-12-16 12:10:44.883164"], ["id", 47]]
-D, [2018-12-17T12:10:44.898132 #2741] DEBUG -- :    (10.3ms)  COMMIT
-#<Opera::Operation::Result:0x0000556528f29058 @errors={}, @exceptions={}, @information={}, @executions=[:profile_schema, :create, :update, :send_email, :output], @output={:model=>#<Profile id: 47, user_id: nil, linkedin_uid: nil, picture: nil, headline: nil, summary: nil, first_name: "foo", last_name: "bar", created_at: "2018-12-17 12:10:44", updated_at: "2018-12-16 12:10:44", agree_to_terms_and_conditions: nil, registration_status: "", account_id: 1, start_date: nil, supervisor_id: nil, picture_processing: false, statistics: {}, data: {}, notification_timestamps: {}, suggestions: {}, notification_settings: {}, contact_information: []>}>
-```
-
-## Benchmark
-
-```ruby
-class Profile::Create < Opera::Operation::Base
-  validate :profile_schema
-
-  step :create
-  step :update
-
-  benchmark do
-    step :send_email
-    step :output
-  end
-
-  def profile_schema
-    Dry::Validation.Schema do
-      required(:first_name).filled
-    end.call(params)
-  end
-
-  def create
-    context[:profile] = dependencies[:current_account].profiles.create(params)
-  end
-
-  def update
-    context[:profile].update(updated_at: 1.day.ago)
-  end
-
-  def send_email
-    return true unless dependencies[:mailer]
-
-    dependencies[:mailer].send_mail(profile: context[:profile])
-  end
-
-  def output
-    result.output = { model: context[:profile] }
-  end
-end
-```
-
-#### Example with information (real and total) from benchmark
-
-```ruby
-Profile::Create.call(params: {
-  first_name: :foo,
-  last_name: :bar
-}, dependencies: {
-  current_account: Account.find(1)
-})
-#<Opera::Operation::Result:0x007ff414a01238 @errors={}, @exceptions={}, @information={:real=>1.800013706088066e-05, :total=>0.0}, @executions=[:profile_schema, :create, :update, :send_email, :output], @output={:model=>#<Profile id: 30, user_id: nil, linkedin_uid: nil, picture: nil, headline: nil, summary: nil, first_name: "foo", last_name: "bar", created_at: "2018-12-19 10:46:00", updated_at: "2018-12-18 10:46:00", agree_to_terms_and_conditions: nil, registration_status: "", account_id: 1, start_date: nil, supervisor_id: nil, picture_processing: false, statistics: {}, data: {}, notification_timestamps: {}, suggestions: {}, notification_settings: {}, contact_information: []>}>
-```
-
-## Success
-
-```ruby
-class Profile::Create < Opera::Operation::Base
-  validate :profile_schema
-
-  success :populate
-
-  step :create
-  step :update
-
-  success do
-    step :send_email
-    step :output
-  end
-
-  def profile_schema
-    Dry::Validation.Schema do
-      required(:first_name).filled
-    end.call(params)
-  end
-
-  def populate
-    context[:attributes] = {}
-    context[:valid] = false
-  end
-
-  def create
-    context[:profile] = dependencies[:current_account].profiles.create(params)
-  end
-
-  def update
-    context[:profile].update(updated_at: 1.day.ago)
-  end
-
-  # NOTE: We can add an error in this step and it won't break the execution
-  def send_email
-    result.add_error('mailer', 'Missing dependency')
-    dependencies[:mailer]&.send_mail(profile: context[:profile])
-  end
-
-  def output
-    result.output = { model: context[:profile] }
-  end
-end
-```
-
-#### Example with information (real and total) from benchmark
-
-```ruby
-Profile::Create.call(params: {
-  first_name: :foo,
-  last_name: :bar
-}, dependencies: {
-  current_account: Account.find(1)
-})
-#<Opera::Operation::Result:0x007fd0248e5638 @errors={"mailer"=>["Missing dependency"]}, @exceptions={}, @information={}, @executions=[:profile_schema, :populate, :create, :update, :send_email, :output], @output={:model=>#<Profile id: 40, user_id: nil, linkedin_uid: nil, picture: nil, headline: nil, summary: nil, first_name: "foo", last_name: "bar", created_at: "2019-01-03 12:21:35", updated_at: "2019-01-02 12:21:35", agree_to_terms_and_conditions: nil, registration_status: "", account_id: 1, start_date: nil, supervisor_id: nil, picture_processing: false, statistics: {}, data: {}, notification_timestamps: {}, suggestions: {}, notification_settings: {}, contact_information: []>}>
-```
-
-## Inner Operation
-
-```ruby
-class Profile::Find < Opera::Operation::Base
-  step :find
-
-  def find
-    result.output = Profile.find(params[:id])
-  end
-end
-
-class Profile::Create < Opera::Operation::Base
-  validate :profile_schema
-
-  operation :find
-
-  step :create
-
-  step :output
-
-  def profile_schema
-    Dry::Validation.Schema do
-      optional(:id).filled
-    end.call(params)
-  end
-
-  def find
-    Profile::Find.call(params: params, dependencies: dependencies)
-  end
-
-  def create
-    return if context[:find_output]
-    puts 'not found'
-  end
-
-  def output
-    result.output = { model: context[:find_output] }
-  end
-end
-```
-
-#### Example with inner operation doing the find
-
-```ruby
-Profile::Create.call(params: {
-  id: 1
-}, dependencies: {
-  current_account: Account.find(1)
-})
-#<Opera::Operation::Result:0x007f99b25f0f20 @errors={}, @exceptions={}, @information={}, @executions=[:profile_schema, :find, :create, :output], @output={:model=>{:id=>1, :user_id=>1, :linkedin_uid=>nil, ...}}>
-```
-
-## Inner Operations
-Expects that method returns array of `Opera::Operation::Result`
-
-```ruby
-class Profile::Create < Opera::Operation::Base
-  step :validate
-  step :create
-
-  def validate; end
-
-  def create
-    result.output = { model: "Profile #{Kernel.rand(100)}" }
-  end
-end
-
-class Profile::CreateMultiple < Opera::Operation::Base
-  operations :create_multiple
-
-  step :output
-
-  def create_multiple
-    (0..params[:number]).map do
-      Profile::Create.call
-    end
-  end
-
-  def output
-    result.output = context[:create_multiple_output]
-  end
-end
-```
-
-```ruby
-Profile::CreateMultiple.call(params: { number: 3 })
-
-#<Opera::Operation::Result:0x0000564189f38c90 @errors={}, @exceptions={}, @information={}, @executions=[{:create_multiple=>[[:validate, :create], [:validate, :create], [:validate, :create], [:validate, :create]]}, :output], @output=[{:model=>"Profile 1"}, {:model=>"Profile 7"}, {:model=>"Profile 69"}, {:model=>"Profile 92"}]>
-```
-
-## Opera::Operation::Result - Instance Methods
-
-Sometimes it may be useful to be able to create an instance of the `Result` with preset `output`.
-It can be handy especially in specs. Then just include it in the initializer:
-
-```
-Opera::Operation::Result.new(output: 'success')
-```
-
->
-    - success? - [true, false] - Return true if no errors and no exceptions
-    - failure? - [true, false] - Return true if any error or exception
-    - output   - [Anything]    - Return Anything
-    - output=(Anything)        - Sets content of operation output
-    - add_error(key, value)    - Adds new error message
-    - add_errors(Hash)         - Adds multiple error messages
-    - add_exception(method, message, classname: nil) - Adds new exception
-    - add_exceptions(Hash)     - Adds multiple exceptions
-    - add_information(Hash)    - Adss new information - Useful informations for developers
-
-## Opera::Operation::Base - Class Methods
->
-    - step(Symbol)             - single instruction
-      - return [Truthly]       - continue operation execution
-      - return [False]         - stops operation execution
-      - raise Exception        - exception gets captured and stops operation execution
-    - operation(Symbol)        - single instruction - requires to return Opera::Operation::Result object
-      - return [Opera::Operation::Result] - stops operation STEPS execution if any error, exception
-    - validate(Symbol)         - single dry-validations - requires to return Dry::Validation::Result object
-      - return [Dry::Validation::Result] - stops operation STEPS execution if any error but continue with other validations
-    - transaction(*Symbols)    - list of instructions to be wrapped in transaction
-      - return [Truthly]       - continue operation execution
-      - return [False|Exception] - stops operation execution and breaks transaction/do rollback
-    - call(params: Hash, dependencies: Hash?)
-      - return [Opera::Operation::Result] - never raises an exception
-
-## Opera::Operation::Base - Instance Methods
->
-    - context [Hash]          - used to pass information between steps - only for internal usage
-    - params [Hash]           - immutable and received in call method
-    - dependencies [Hash]     - immutable and received in call method
-    - finish                  - this method interrupts the execution of steps after is invoked