bcdd-result 0.13.0 → 1.0.0

data/Rakefile

@@ -15,7 +15,7 @@ Rake::TestTask.new(:test_configuration) do |t|
   t.test_files = FileList.new('test/**/configuration_test.rb')
 end
 
-Rake::TestTask.new(:test_transitions_duration) do |t|
+Rake::TestTask.new(:test_event_logs_duration) do |t|
   t.libs += %w[lib test]
 
   t.test_files = FileList.new('test/**/duration_test.rb')

data/Steepfile

@@ -10,7 +10,7 @@ target :lib do
   # check 'app/models/**/*.rb'        # Glob
   # ignore 'lib/templates/*.rb'
 
-  library 'singleton'                 # Standard libraries
+  # library 'singleton'               # Standard libraries
   # library 'strong_json'             # Gems
 
   # configure_code_diagnostics(D::Ruby.default)      # `default` diagnostics setting (applies by default)

data/examples/multiple_listeners/Rakefile

@@ -7,7 +7,7 @@ end
 
 # Usage:
 #
-# rake DISABLE_TRANSITIONS=t
+# rake DISABLE_EVENT_LOGS=t
 # rake DISABLE_LISTENER=t
 #
 # rake HIDE_GIVEN_AND_CONTINUE=t
@@ -17,19 +17,19 @@ end
 # rake BREAK_USER_TOKEN_CREATION=t
 #
 # rake BREAK_ACCOUNT_CREATION=t HIDE_GIVEN_AND_CONTINUE=t
-task default: %i[bcdd_result_transitions]
+task default: %i[bcdd_result_event_logs]
 
 desc 'creates an account and an owner user through BCDD::Result'
-task :bcdd_result_transitions do
+task :bcdd_result_event_logs do
   require_relative 'config'
 
   BCDD::Result.configuration do |config|
-    config.feature.disable!(:transitions) if ENV['DISABLE_TRANSITIONS']
+    config.feature.disable!(:event_logs) if ENV['DISABLE_EVENT_LOGS']
 
     unless ENV['DISABLE_LISTENER']
-      config.transitions.listener = BCDD::Result::Transitions::Listeners[
-        TransitionsListener::Stdout,
-        BCDD::Result::TransitionsRecord::Listener
+      config.event_logs.listener = BCDD::Result::EventLogs::Listeners[
+        EventLogsListener::Stdout,
+        BCDD::Result::EventLogsRecord::Listener
       ]
     end
   end
@@ -49,7 +49,7 @@ task :bcdd_result_transitions do
     nil
   end
 
-  puts "\nBCDD::Result::TransitionsRecord.count: #{BCDD::Result::TransitionsRecord.count}"
+  puts "\nBCDD::Result::EventLogsRecord.count: #{BCDD::Result::EventLogsRecord.count}"
 
   puts "\nBenchmark: #{bench}"
 end

data/examples/multiple_listeners/app/models/account/owner_creation.rb

@@ -6,7 +6,7 @@ class Account
     include BCDD::Result::RollbackOnFailure
 
     def call(**input)
-      BCDD::Result.transitions(name: self.class.name) do
+      BCDD::Result.event_logs(name: self.class.name) do
         Given(input)
           .and_then(:normalize_input)
           .and_then(:validate_input)

data/examples/multiple_listeners/app/models/user/creation.rb

@@ -6,7 +6,7 @@ class User
     include BCDD::Result::RollbackOnFailure
 
     def call(**input)
-      BCDD::Result.transitions(name: self.class.name) do
+      BCDD::Result.event_logs(name: self.class.name) do
         Given(input)
           .and_then(:normalize_input)
           .and_then(:validate_input)

data/examples/multiple_listeners/app/models/user/token/creation.rb

@@ -5,7 +5,7 @@ class User::Token
     include BCDD::Context.mixin
 
     def call(**input)
-      BCDD::Result.transitions(name: self.class.name) do
+      BCDD::Result.event_logs(name: self.class.name) do
         Given(input)
           .and_then(:normalize_input)
           .and_then(:validate_input)

data/examples/multiple_listeners/config/initializers/bcdd.rb

@@ -3,8 +3,6 @@
 BCDD::Result.config.then do |config|
   config.addon.enable!(:continue)
 
-  config.constant_alias.enable!('BCDD::Context')
-
   config.pattern_matching.disable!(:nil_as_valid_value_checking)
 
   # config.feature.disable!(:expectations) if Rails.env.production?

data/examples/multiple_listeners/config.rb

@@ -10,11 +10,11 @@ require_relative 'config/initializers/bcdd'
 require 'db/setup'
 
 require 'lib/bcdd/result/rollback_on_failure'
-require 'lib/bcdd/result/transitions_record'
+require 'lib/bcdd/result/event_logs_record'
 require 'lib/runtime_breaker'
 
-module TransitionsListener
-  require 'lib/transitions_listener/stdout'
+module EventLogsListener
+  require 'lib/event_logs_listener/stdout'
 end
 
 require 'app/models/account'

data/examples/multiple_listeners/db/setup.rb

@@ -10,13 +10,12 @@ ActiveRecord::Base.establish_connection(
 
 ActiveRecord::Schema.define do
   suppress_messages do
-    create_table :bcdd_result_transitions do |t|
+    create_table :bcdd_result_event_logs do |t|
       t.string :root_name, null: false, index: true
       t.string :trace_id, index: true
       t.integer :version, null: false
       t.integer :duration, null: false, index: true
-      t.json :ids_tree, null: false, default: []
-      t.json :ids_matrix, null: false, default: {}
+      t.json :ids, null: false, default: {}
       t.json :records, null: false, default: []
 
       t.timestamps

data/examples/multiple_listeners/lib/bcdd/result/event_logs_record.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class BCDD::Result::EventLogsRecord < ActiveRecord::Base
+  self.table_name = 'bcdd_result_event_logs'
+
+  class Listener
+    include ::BCDD::Result::EventLogs::Listener
+
+    def on_finish(event_logs:)
+        metadata = event_logs[:metadata]
+        root_name = event_logs.dig(:records, 0, :root, :name) || 'Unknown'
+
+        BCDD::Result::EventLogsRecord.create(
+          root_name: root_name,
+          trace_id: metadata[:trace_id],
+          version: event_logs[:version],
+          duration: metadata[:duration],
+          ids: metadata[:ids],
+          records: event_logs[:records]
+        )
+    rescue ::StandardError => e
+      err = "#{e.message} (#{e.class}); Backtrace: #{e.backtrace.join(', ')}"
+
+      ::Kernel.warn "Error on BCDD::Result::EventLogsRecord::Listener#on_finish: #{err}"
+    end
+  end
+end

data/examples/multiple_listeners/lib/event_logs_listener/stdout.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+class EventLogsListener::Stdout
+  include BCDD::Result::EventLogs::Listener
+
+  def initialize
+    @buffer = []
+  end
+
+  def on_start(scope:)
+    scope => { id:, name:, desc: }
+
+    @buffer << [id, "##{id} #{name} - #{desc}".chomp('- ')]
+  end
+
+  def on_record(record:)
+    record => { current: { id: }, result: { kind:, type: } }
+
+    method_name = record.dig(:and_then, :method_name)
+
+    @buffer << [id, " * #{kind}(#{type}) from method: #{method_name}".chomp('from method: ')]
+  end
+
+  MapNestedMessages = ->(event_logs, buffer, hide_given_and_continue) do
+    ids_level_parent = event_logs.dig(:metadata, :ids, :level_parent)
+
+    messages = buffer.filter_map { |(id, msg)| "#{'   ' * ids_level_parent[id].first}#{msg}" if ids_level_parent[id] }
+
+    messages.reject! { _1.match?(/\(_(given|continue)_\)/) } if hide_given_and_continue
+
+    messages
+  end
+
+  def on_finish(event_logs:)
+    messages = MapNestedMessages[event_logs, @buffer, ENV['HIDE_GIVEN_AND_CONTINUE']]
+
+    puts messages.join("\n")
+  end
+
+  def before_interruption(exception:, event_logs:)
+    messages = MapNestedMessages[event_logs, @buffer, ENV['HIDE_GIVEN_AND_CONTINUE']]
+
+    puts messages.join("\n")
+
+    bc = ::ActiveSupport::BacktraceCleaner.new
+    bc.add_filter { |line| line.gsub(__dir__.sub('/lib', ''), '').sub(/\A\//, '')}
+    bc.add_silencer { |line| /lib\/bcdd\/result/.match?(line) }
+    bc.add_silencer { |line| line.include?(RUBY_VERSION) }
+
+    dir = "#{FileUtils.pwd[1..]}/"
+
+    listener_filename = File.basename(__FILE__).chomp('.rb')
+
+    cb = bc.clean(exception.backtrace)
+    cb.each { _1.sub!(dir, '') }
+    cb.reject! { _1.match?(/block \(\d levels?\) in|in `block in|internal:kernel|#{listener_filename}/) }
+
+    puts "\nException:\n  #{exception.message} (#{exception.class})\n\nBacktrace:\n  #{cb.join("\n  ")}"
+  end
+end

data/examples/multiple_listeners/lib/runtime_breaker.rb

@@ -6,6 +6,6 @@ module RuntimeBreaker
   def self.try_to_interrupt(env:)
     return unless String(ENV[env]).strip.start_with?(/1|t/)
 
-    raise Interruption, "Runtime breaker activated (#{env})"
+    raise Interruption, "#{env}"
   end
 end

data/examples/service_objects/Rakefile

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+if RUBY_VERSION <= '3.1'
+  puts 'This example requires Ruby 3.1 or higher.'
+  exit! 1
+end
+
+task default: %i[bcdd_result_event_logs]
+
+task :config do
+  require_relative 'config'
+end
+
+desc 'creates an account and an owner user through BCDD::Result'
+task bcdd_result_event_logs: %i[config] do
+  result1 = Account::OwnerCreation.call(
+    owner: {
+      name: "\tJohn     Doe \n",
+      email: '   JOHN.doe@email.com',
+      password: '123123123',
+      password_confirmation: '123123123'
+    }
+  )
+
+  puts result1.inspect
+  puts
+
+  result2 = Account::OwnerCreation.call(
+    uuid: "",
+    owner: {}
+  ).on_failure(:invalid_input) do |output|
+    output[:input].errors.full_messages.each do |message|
+      puts message
+    end
+  end
+end

data/examples/service_objects/app/models/account/member.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class Account::Member < ActiveRecord::Base
+  self.table_name = 'account_members'
+
+  enum role: { owner: 0, admin: 1, contributor: 2 }
+
+  belongs_to :user, inverse_of: :memberships
+  belongs_to :account, inverse_of: :memberships
+end

data/examples/service_objects/app/models/account.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class Account < ActiveRecord::Base
+  has_many :memberships, inverse_of: :account, dependent: :destroy, class_name: '::Account::Member'
+  has_many :users, through: :memberships, inverse_of: :accounts
+
+  where_ownership = -> { where(account_members: {role: :owner}) }
+
+  has_one :ownership, where_ownership, dependent: nil, inverse_of: :account, class_name: '::Account::Member'
+  has_one :owner, through: :ownership, source: :user
+end

data/examples/service_objects/app/models/user/token.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class User::Token < ActiveRecord::Base
+  self.table_name = 'user_tokens'
+
+  belongs_to :user, inverse_of: :token
+end

data/examples/service_objects/app/models/user.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class User < ActiveRecord::Base
+  has_secure_password
+
+  has_many :memberships, inverse_of: :user, dependent: :destroy, class_name: '::Account::Member'
+  has_many :accounts, through: :memberships, inverse_of: :users
+
+  where_ownership = -> { where(account_members: { role: :owner }) }
+
+  has_one :ownership, where_ownership, inverse_of: :user, class_name: '::Account::Member'
+  has_one :account, through: :ownership, inverse_of: :owner
+
+  has_one :token, inverse_of: :user, dependent: :destroy, class_name: '::User::Token'
+end

data/examples/service_objects/app/services/account/owner_creation.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+class Account
+  class OwnerCreation < ApplicationService
+    input do
+      attribute :uuid, :string, default: -> { ::SecureRandom.uuid }
+      attribute :owner
+
+      before_validation do |input|
+        input.uuid = input.uuid.strip.downcase
+      end
+
+      validates :uuid, presence: true, format: { with: /\A[0-9a-f]{8}-([0-9a-f]{4}-){3}[0-9a-f]{12}\z/i }
+      validates :owner, presence: true, type: ::Hash
+    end
+
+    def call(attributes)
+      rollback_on_failure {
+        Given(attributes)
+          .and_then(:create_owner)
+          .and_then(:create_account)
+          .and_then(:link_owner_to_account)
+      }.and_expose(:account_owner_created, %i[user account])
+    end
+
+    private
+
+    def create_owner(owner:, **)
+      ::User::Creation.call(owner).handle do |on|
+        on.success { |output| Continue(user: output[:user], token: output[:token]) }
+        on.failure { |output| Failure(:invalid_owner, **output) }
+      end
+    end
+
+    def create_account(uuid:, **)
+      account = ::Account.create(uuid:)
+
+      account.persisted? ? Continue(account:) : Failure(:invalid_record, **account.errors.messages)
+    end
+
+    def link_owner_to_account(account:, user:, **)
+      Member.create!(account:, user:, role: :owner)
+
+      Continue()
+    end
+  end
+end

data/examples/service_objects/app/services/application_service.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+class ApplicationService
+  Error = ::Class.new(::StandardError)
+
+  class Input
+    def self.inherited(subclass)
+      subclass.include ::ActiveModel::API
+      subclass.include ::ActiveModel::Attributes
+      subclass.include ::ActiveModel::Dirty
+      subclass.include ::ActiveModel::Validations::Callbacks
+    end
+  end
+
+  class << self
+    def input=(klass)
+      const_defined?(:Input, false) and raise ArgumentError, "#{self}::Input class already defined"
+
+      unless klass.is_a?(::Class) && klass < Input
+        raise ArgumentError, 'must be a ApplicationService::Input subclass'
+      end
+
+      const_set(:Input, klass)
+    end
+
+    def input(&block)
+      return const_get(:Input, false) if const_defined?(:Input, false)
+
+      klass = ::Class.new(Input)
+      klass.class_eval(&block)
+
+      self.input = klass
+    end
+
+    def inherited(subclass)
+      subclass.include ::BCDD::Context.mixin(config: { addon: { continue: true } })
+    end
+
+    def call(arg)
+      new(input.new(arg)).call!
+    end
+  end
+
+  private_class_method :new
+
+  attr_reader :input
+
+  def initialize(input)
+    @input = input
+  end
+
+  def call!
+    ::BCDD::Result.event_logs(name: self.class.name) do
+      if input.invalid?
+        Failure(:invalid_input, input: input)
+      else
+        call(input.attributes.deep_symbolize_keys)
+      end
+    end
+  end
+
+  def call(attributes)
+    raise Error, 'must be implemented in a subclass'
+  end
+
+  private
+
+  def rollback_on_failure(model: ::ActiveRecord::Base)
+    result = nil
+
+    model.transaction do
+      result = yield
+
+      raise ::ActiveRecord::Rollback if result.failure?
+    end
+
+    result
+  end
+end

data/examples/service_objects/app/services/user/creation.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+class User
+  class Creation < ApplicationService
+    input do
+      attribute :uuid, :string, default: -> { ::SecureRandom.uuid }
+      attribute :name, :string
+      attribute :email, :string
+      attribute :password, :string
+      attribute :password_confirmation, :string
+
+      before_validation do |input|
+        input.uuid = input.uuid.strip.downcase
+        input.name = input.name.strip.gsub(/\s+/, ' ')
+        input.email = input.email.strip.downcase
+      end
+
+      validates :uuid, presence: true, format: { with: /\A[0-9a-f]{8}-([0-9a-f]{4}-){3}[0-9a-f]{12}\z/i }
+      validates :name, presence: true
+      validates :email, presence: true, format: { with: ::URI::MailTo::EMAIL_REGEXP }
+      validates :password, :password_confirmation, presence: true
+    end
+
+    def call(attributes)
+      Given(attributes)
+        .and_then(:validate_email_uniqueness)
+        .then { |result|
+          rollback_on_failure {
+            result
+              .and_then(:create_user)
+              .and_then(:create_user_token)
+          }
+        }
+        .and_expose(:user_created, %i[user token])
+    end
+
+    private
+
+    def validate_email_uniqueness(email:, **)
+      ::User.exists?(email:) ? Failure(:email_already_taken) : Continue()
+    end
+
+    def create_user(uuid:, name:, email:, password:, password_confirmation:)
+      user = ::User.create(uuid:, name:, email:, password:, password_confirmation:)
+
+      user.persisted? ? Continue(user:) : Failure(:invalid_record, **user.errors.messages)
+    end
+
+    def create_user_token(user:, **)
+      Token::Creation.call(user: user).handle do |on|
+        on.success { |output| Continue(token: output[:token]) }
+        on.failure { raise 'Token creation failed' }
+      end
+    end
+  end
+end

data/examples/service_objects/app/services/user/token/creation.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+class User::Token
+  class Creation < ApplicationService
+    input do
+      attribute :user
+      attribute :executed_at, :time, default: -> { ::Time.current }
+
+      validates :user, presence: true, type: ::User
+      validates :executed_at, presence: true
+    end
+
+    def call(attributes)
+      Given(attributes)
+        .and_then(:validate_token_existence)
+        .and_then(:create_token)
+        .and_expose(:token_created, %i[token])
+    end
+
+    private
+
+    def validate_token_existence(user:, **)
+      user.token.nil? ? Continue() : Failure(:token_already_exists)
+    end
+
+    def create_token(user:, executed_at:, **)
+      token = user.create_token(
+        access_token: ::SecureRandom.hex(24),
+        refresh_token: ::SecureRandom.hex(24),
+        access_token_expires_at: executed_at + 15.days,
+        refresh_token_expires_at: executed_at + 30.days
+      )
+
+      token.persisted? ? Continue(token:) : Failure(:token_creation_failed, **token.errors.messages)
+    end
+  end
+end

data/examples/service_objects/config/boot.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'bundler/inline'
+
+$LOAD_PATH.unshift(__dir__)
+
+gemfile do
+  source 'https://rubygems.org'
+
+  gem 'sqlite3', '~> 1.7'
+  gem 'bcrypt', '~> 3.1.20'
+  gem 'activerecord', '~> 7.1', '>= 7.1.3', require: 'active_record'
+  gem 'type_validator'
+  gem 'bcdd-result', path: '../../'
+end
+
+require 'active_support/all'

data/examples/service_objects/config/initializers/bcdd.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+BCDD::Result.config.then do |config|
+  config.addon.enable!(:continue)
+
+  config.pattern_matching.disable!(:nil_as_valid_value_checking)
+
+  # config.feature.disable!(:expectations) if Rails.env.production?
+end

data/examples/service_objects/config.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'bundler/inline'
+
+$LOAD_PATH.unshift(__dir__)
+
+require_relative 'config/boot'
+require_relative 'config/initializers/bcdd'
+
+require 'db/setup'
+
+require 'app/models/account'
+require 'app/models/account/member'
+require 'app/models/user'
+require 'app/models/user/token'
+
+require 'app/services/application_service'
+require 'app/services/account/owner_creation'
+require 'app/services/user/token/creation'
+require 'app/services/user/creation'

data/examples/service_objects/db/setup.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'active_support/all'
+
+ActiveRecord::Base.establish_connection(
+  host: 'localhost',
+  adapter: 'sqlite3',
+  database: ':memory:'
+)
+
+ActiveRecord::Schema.define do
+  suppress_messages do
+    create_table :accounts do |t|
+      t.string :uuid, null: false, index: {unique: true}
+
+      t.timestamps
+    end
+
+    create_table :users do |t|
+      t.string :uuid, null: false, index: {unique: true}
+      t.string :name, null: false
+      t.string :email, null: false, index: {unique: true}
+      t.string :password_digest, null: false
+
+      t.timestamps
+    end
+
+    create_table :user_tokens do |t|
+      t.belongs_to :user, null: false, foreign_key: true, index: true
+      t.string :access_token, null: false
+      t.string :refresh_token, null: false
+      t.datetime :access_token_expires_at, null: false
+      t.datetime :refresh_token_expires_at, null: false
+
+      t.timestamps
+    end
+
+    create_table :account_members do |t|
+      t.integer :role, null: false, default: 0
+      t.belongs_to :user, null: false, foreign_key: true, index: true
+      t.belongs_to :account, null: false, foreign_key: true, index: true
+
+      t.timestamps
+
+      t.index %i[account_id role], unique: true, where: "(role = 0)"
+      t.index %i[account_id user_id], unique: true
+    end
+  end
+end

data/examples/single_listener/Rakefile

@@ -7,7 +7,7 @@ end
 
 # Usage:
 #
-# rake DISABLE_TRANSITIONS=t
+# rake DISABLE_EVENT_LOGS=t
 # rake DISABLE_LISTENER=t
 #
 # rake HIDE_GIVEN_AND_CONTINUE=t
@@ -17,18 +17,18 @@ end
 # rake BREAK_USER_TOKEN_CREATION=t
 #
 # rake BREAK_ACCOUNT_CREATION=t HIDE_GIVEN_AND_CONTINUE=t
-task default: %i[bcdd_result_transitions]
+task default: %i[bcdd_result_event_logs]
 
 task :config do
   require_relative 'config'
 end
 
 desc 'creates an account and an owner user through BCDD::Result'
-task bcdd_result_transitions: %i[config] do
+task bcdd_result_event_logs: %i[config] do
   BCDD::Result.configuration do |config|
-    config.feature.disable!(:transitions) if ENV['DISABLE_TRANSITIONS']
+    config.feature.disable!(:event_logs) if ENV['DISABLE_EVENT_LOGS']
 
-    config.transitions.listener = SingleTransitionsListener unless ENV['DISABLE_LISTENER']
+    config.event_logs.listener = SingleEventLogsListener unless ENV['DISABLE_LISTENER']
   end
 
   result = nil