solid-process 0.0.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f7f0a6aab80305b40e97489d58f9ad14663124dc8e0a82d9c71f7c3ae025e20f
-  data.tar.gz: a162e6cd3c7a71799e06e5ee104ee7913485c76a5e334e22fd219b805e3d79fe
+  metadata.gz: d4b6ab233b8f225123d7a74114c281011f94f7a186faeaee54b3d25e9ba51c2e
+  data.tar.gz: 57a1de84e07d74971640ce4c03b1e12812d1da7765eb83b6ebb460e92972d1bb
 SHA512:
-  metadata.gz: 2c00495ba7a86b10bd4637afc094f6f746257a4c4e36d4a9673ac025bd1a073123a13f994fade68a79f70e8102f39f40d888a6c1a135091fd4e5f92ff265eee7
-  data.tar.gz: 5675db51ae0032c7d4f41ea3b164a241b7c5addc534ae1b2ebfd94c6ce526b81409ebacd05f674e254ee6e1be08b827e0001f698e2510159005da77c49e7cc64
+  metadata.gz: 378aff92aaacc388198e4c72a5ce0fb72df788b1dd7763d2b0f11024629c8988d95e4e52015393dddd4cfbd1116539f1c6f5e1a541422e296117a27e7a7e778b
+  data.tar.gz: 0040c63c885ff1177dd11c864d208a64c2b46dec1bee9bf71ea2e7df5ac2340668ac8e524c848c30b736457c3a64051e0084e01c3d401cf3bbaf1293959e6764

data/CHANGELOG.md

@@ -1,5 +1,7 @@
 ## [Unreleased]
 
-## [0.1.0] - 2024-03-06
+## [0.2.0] - 2024-03-18
+
+## [0.1.0] - 2024-03-16
 
 - Initial release

data/README.md

@@ -1,20 +1,46 @@
-# Solid::Process
-
-TODO: Delete this and the text below, and describe your gem
-
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/solid/process`. To experiment with that code, run `bin/console` for an interactive prompt.
+<p align="center">
+  <h1 align="center" id="-solidprocess">🚄 Solid::Process</h1>
+  <p align="center"><i>Ruby on Rails + Business Processes</i></p>
+  <p align="center">
+    <a href="https://codeclimate.com/github/serradura/solid-process/maintainability"><img src="https://api.codeclimate.com/v1/badges/643a53e99bb591321c9f/maintainability" /></a>
+    <a href="https://codeclimate.com/github/serradura/solid-process/test_coverage"><img src="https://api.codeclimate.com/v1/badges/643a53e99bb591321c9f/test_coverage" /></a>
+    <img src="https://img.shields.io/badge/Ruby%20%3E%3D%202.7%2C%20%3C%3D%20Head-ruby.svg?colorA=444&colorB=333" alt="Ruby">
+    <img src="https://img.shields.io/badge/Rails%20%3E%3D%206.0%2C%20%3C%3D%20Edge-rails.svg?colorA=444&colorB=333" alt="Rails">
+  </p>
+</p>
+
+## Supported Ruby and Rails
+
+This library is tested against:
+
+| Ruby / Rails | 6.0 | 6.1 | 7.0 | 7.1 | Edge |
+|--------------|-----|-----|-----|-----|------|
+| 2.7          | ✅  | ✅  | ✅  | ✅   |      |
+| 3.0          | ✅  | ✅  | ✅  | ✅   |      |
+| 3.1          | ✅  | ✅  | ✅  | ✅   | ✅   |
+| 3.2          | ✅  | ✅  | ✅  | ✅   | ✅   |
+| 3.3          | ✅  | ✅  | ✅  | ✅   | ✅   |
+| Head         |    |    |    | ✅   | ✅   |
 
 ## Installation
 
-TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'solid-process'
+```
 
-Install the gem and add to the application's Gemfile by executing:
+And then execute:
 
-    $ bundle add UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+```bash
+$ bundle install
+```
 
-If bundler is not being used to manage dependencies, install the gem by executing:
+Or install it yourself as:
 
-    $ gem install UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+```bash
+$ gem install solid-process
+```
 
 ## Usage
 
@@ -22,13 +48,13 @@ TODO: Write usage instructions here
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bundle exec rake dev` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
 To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/solid-process. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/[USERNAME]/solid-process/blob/master/CODE_OF_CONDUCT.md).
+Bug reports and pull requests are welcome on GitHub at https://github.com/serradura/solid-process. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/serradura/solid-process/blob/master/CODE_OF_CONDUCT.md).
 
 ## License
 
@@ -36,4 +62,4 @@ The gem is available as open source under the terms of the [MIT License](https:/
 
 ## Code of Conduct
 
-Everyone interacting in the Solid::Process project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/solid-process/blob/master/CODE_OF_CONDUCT.md).
+Everyone interacting in the Solid::Process project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/serradura/solid-process/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -1,12 +1,24 @@
 # frozen_string_literal: true
 
 require "bundler/gem_tasks"
-require "minitest/test_task"
+require "rake/testtask"
 
-Minitest::TestTask.create
+Rake::TestTask.new(:test) do |t|
+  t.libs += %w[lib test]
 
-require "rubocop/rake_task"
+  t.test_files = FileList.new("test/**/*_test.rb")
+end
 
-RuboCop::RakeTask.new
+require "appraisal/task"
 
-task default: %i[test rubocop]
+Appraisal::Task.new
+
+require "standard/rake"
+
+task :dev do
+  exec "bundle exec appraisal rails-7-1 rake test"
+
+  Rake::Task[:standard].invoke
+end
+
+task default: %i[test]

data/examples/business_processes/.rubocop.yml

@@ -0,0 +1,3 @@
+inherit_gem:
+  standard:
+    - config/ruby-3.1.yml

data/examples/business_processes/.ruby-version

@@ -0,0 +1 @@
+3.2.2

data/examples/business_processes/.standard.yml

@@ -0,0 +1 @@
+ruby_version: 3.1

data/examples/business_processes/Gemfile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+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 "solid-process", path: "../../"
+
+gem "rake", "~> 13.0", require: false
+gem "standard", "~> 1.34", require: false

data/examples/business_processes/Rakefile

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+
+Bundler.require(:default)
+
+require "standard/rake"
+
+if RUBY_VERSION <= "3.1"
+  puts "This example requires Ruby 3.1 or higher."
+  exit! 1
+end
+
+task :config do
+  require_relative "config"
+end
+
+task default: %i[solid_result]
+
+desc "Do pattern matching in Solid::Result"
+task solid_result: %i[config] do
+  input = {
+    uuid: SecureRandom.uuid,
+    owner: {
+      name: "\tJohn     Doe \n",
+      email: "   JOHN.doe@email.com",
+      password: "123123123",
+      password_confirmation: "123123123"
+    }
+  }
+
+  case Account::OwnerCreation.call(input)
+  in Solid::Result(user:, account:)
+    puts "Account and owner user created: #{account.uuid} and #{user.uuid}"
+  in Solid::Result(type:, value:)
+    puts "Account creation failed: #{type} - #{value}"
+  end
+
+  # Different ways to match
+  #
+  # in Solid::Result(value: {user:, account:})
+  # in Solid::Result(type:, value: {user:, account:})
+  # in Solid::Result(type: :account_owner_created, value: {user:, account:})
+end
+
+desc "Do pattern matching in Solid::Output"
+task solid_output: %i[config] do
+  input = {
+    uuid: SecureRandom.uuid,
+    owner: {
+      name: "\tJohn     Doe \n",
+      email: "   JOHN.doe@email.com",
+      password: "123123123",
+      password_confirmation: "123123123"
+    }
+  }
+
+  case Account::OwnerCreation.call(input)
+  in Solid::Output(user:, account:)
+    puts "Account and owner user created: #{account.uuid} and #{user.uuid}"
+  in Solid::Output(type:, value:)
+    puts "Account creation failed: #{type} - #{value}"
+  end
+
+  # Different ways to match
+  #
+  # in Solid::Output(value: {user:, account:})
+  # in Solid::Output(type:, value: {user:, account:})
+  # in Solid::Output(type: :account_owner_created, value: {user:, account:})
+end
+
+desc "Do pattern matching in Solid::Success and Solid::Failure"
+task solid_success_and_failure: %i[config] do
+  input = {
+    uuid: SecureRandom.uuid,
+    owner: {
+      name: "\tJohn     Doe \n",
+      email: "   JOHN.doe@email.com",
+      password: "123123123",
+      password_confirmation: "123123123"
+    }
+  }
+
+  case Account::OwnerCreation.call(input)
+  in Solid::Success(user:, account:)
+    puts "Account and owner user created: #{account.uuid} and #{user.uuid}"
+  in Solid::Failure(type:, value:)
+    puts "Account creation failed: #{type} - #{value}"
+  end
+
+  # Different ways to match
+  #
+  # in Solid::Success(value: {user:, account:})
+  # in Solid::Success(type:, value: {user:, account:})
+  # in Solid::Success(type: :account_owner_created, value: {user:, account:})
+  #
+  # in Solid::Failure(input:)
+  # in Solid::Failure(value: {input:})
+  # in Solid::Failure(type: :invalid_input, value: {input:})
+end

data/examples/business_processes/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/business_processes/app/models/account/owner_creation.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+class Account
+  class OwnerCreation < Solid::Process
+    deps do
+      attribute :user_creation, default: ::User::Creation
+    end
+
+    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
+    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:, **)
+      case deps.user_creation.call(owner)
+      in Solid::Success(user:, token:)
+        Continue(user:, user_token: token)
+      in Solid::Failure(type:, value:)
+        Failure(:invalid_owner, **{type => value})
+      end
+    end
+
+    def create_account(uuid:, **)
+      account = ::Account.create(uuid:)
+
+      account.persisted? ? Continue(account:) : Failure(:invalid_account, account:)
+    end
+
+    def link_owner_to_account(account:, user:, **)
+      Member.create!(account:, user:, role: :owner)
+
+      Continue()
+    end
+  end
+end

data/examples/business_processes/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/business_processes/app/models/user/creation.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+class User
+  class Creation < Solid::Process
+    deps do
+      attribute :token_creation, default: ::User::Token::Creation
+    end
+
+    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:, **)
+      case deps.token_creation.call(user: user)
+      in Solid::Success(token:)
+        Continue(token:)
+      in Solid::Failure
+        raise "Token creation failed"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+class User::Token
+  class Creation < Solid::Process
+    input do
+      attribute :user
+      attribute :executed_at, :time, default: -> { ::Time.current }
+
+      validates :user, presence: true
+      validates :executed_at, presence: true
+    end
+
+    def call(attributes)
+      Given(attributes)
+        .and_then(:validate_token_existence)
+        .and_then(:create_token_if_not_exists)
+        .and_expose(:token_created, %i[token])
+    end
+
+    private
+
+    def validate_token_existence(user:, **)
+      token = user.token
+
+      token&.persisted? ? Success(:token_already_exists, token:) : Continue()
+    end
+
+    def create_token_if_not_exists(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/business_processes/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/business_processes/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/business_processes/config.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(__dir__)
+
+require "db/setup"
+
+require "app/models/account"
+require "app/models/account/member"
+require "app/models/user"
+require "app/models/user/token"
+
+require "app/models/user/token/creation"
+require "app/models/user/creation"
+require "app/models/account/owner_creation"

data/examples/business_processes/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/lib/solid/input.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative "model"
+
+class Solid::Input
+  include ::Solid::Model
+end

data/lib/solid/model/access.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Solid::Model
+  # Implementation based on ActiveModel::Access
+  # https://github.com/rails/rails/blob/7-1-stable/activemodel/lib/active_model/access.rb
+  module Access
+    # Returns a hash of the given methods with their names as keys and returned
+    # values as values.
+    #
+    #   person = Person.new(id: 1, name: "bob")
+    #   person.slice(:id, :name)
+    #   => { "id" => 1, "name" => "bob" }
+    def slice(*methods)
+      methods.flatten.index_with { |method| public_send(method) }.with_indifferent_access
+    end
+
+    # Returns an array of the values returned by the given methods.
+    #
+    #   person = Person.new(id: 1, name: "bob")
+    #   person.values_at(:id, :name)
+    #   => [1, "bob"]
+    def values_at(*methods)
+      methods.flatten.map! { |method| public_send(method) }
+    end
+  end
+end

data/lib/solid/model.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "model/access"
+
+module Solid::Model
+  extend ::ActiveSupport::Concern
+
+  included do
+    include ::ActiveModel.const_defined?(:Api, false) ? ::ActiveModel::Api : ::ActiveModel::Model
+    include ::ActiveModel.const_defined?(:Access, false) ? ::ActiveModel::Access : ::Solid::Model::Access
+
+    include ::ActiveModel::Attributes
+    include ::ActiveModel::Dirty
+    include ::ActiveModel::Validations::Callbacks
+  end
+
+  module ClassMethods
+    def [](...)
+      new(...)
+    end
+
+    def inherited(subclass)
+      subclass.include(::Solid::Model)
+    end
+  end
+
+  def inspect
+    "#<#{self.class.name} #{attributes.map { |k, v| "#{k}=#{v.inspect}" }.join(" ")}>"
+  end
+end

data/lib/solid/process/active_record.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+begin
+  require "active_record"
+rescue LoadError
+end
+
+module Solid
+  class Process
+    private
+
+    if defined?(::ActiveRecord)
+      def rollback_on_failure(model: ::ActiveRecord::Base)
+        result = nil
+
+        model.transaction do
+          result = yield
+
+          raise ::ActiveRecord::Rollback if result.failure?
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/solid/process/callbacks.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+class Solid::Process
+  module Callbacks
+    def self.included(subclass)
+      subclass.include ActiveSupport::Callbacks
+
+      subclass.define_callbacks(:call, :success, :failure)
+
+      subclass.extend ClassMethods
+    end
+
+    module ClassMethods
+      def before_call(*filters, &block)
+        set_callback(:call, :before, *filters, &block)
+      end
+
+      def around_call(*filters, &block)
+        set_callback(:call, :around, *filters, &block)
+      end
+
+      def after_call(*filters, &block)
+        set_callback(:call, :after, *filters, &block)
+      end
+
+      def after_success(*filters, &block)
+        set_callback(:success, :after, *filters, &block)
+      end
+
+      def after_failure(*filters, &block)
+        set_callback(:failure, :after, *filters, &block)
+      end
+    end
+  end
+end

data/lib/solid/process/caller.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# rubocop:disable Lint/RescueException
+class Solid::Process
+  module Caller
+    def call(arg = nil)
+      output_already_set! if output?
+
+      self.input = arg
+
+      run_callbacks(:call) do
+        ::BCDD::Result.event_logs(name: self.class.name) do
+          self.output =
+            if dependencies&.invalid?
+              Failure(:invalid_dependencies, dependencies: dependencies)
+            elsif input.invalid?
+              Failure(:invalid_input, input: input)
+            else
+              super(input.attributes.deep_symbolize_keys)
+            end
+        rescue ::Exception => exception
+          rescue_with_handler(exception) || raise
+
+          output
+        end
+      end
+
+      run_callbacks(:success) if output.success?
+      run_callbacks(:failure) if output.failure?
+
+      output
+    end
+  end
+end
+# rubocop:enable Lint/RescueException

data/lib/solid/process/class_methods.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+class Solid::Process
+  module ClassMethods
+    def input=(klass)
+      const_defined?(:Input, false) and raise Error, "#{const_get(:Input, false)} class already defined"
+
+      const_set(:Input, Config::SolidModel[klass])
+    end
+
+    def input(&block)
+      return const_get(:Input, false) if const_defined?(:Input, false)
+
+      block.nil? and raise Error, "#{self}::Input is undefined. Use #{self}.input { ... } to define it."
+
+      klass = ::Class.new(Config.instance.input_class)
+      klass.class_eval(&block)
+
+      self.input = klass
+    end
+
+    def dependencies=(klass)
+      const_defined?(:Dependencies, false) and raise Error, "#{const_get(:Dependencies, false)} class already defined"
+
+      const_set(:Dependencies, Config::SolidModel[klass])
+    end
+
+    def dependencies(&block)
+      return const_get(:Dependencies, false) if const_defined?(:Dependencies, false)
+
+      return if block.nil?
+
+      klass = ::Class.new(Config.instance.dependencies_class)
+      klass.class_eval(&block)
+
+      self.dependencies = klass
+    end
+
+    alias_method :deps, :dependencies
+    alias_method :deps=, :dependencies=
+  end
+end

data/lib/solid/process/config.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+class Solid::Process
+  class Config
+    SolidModel = ->(klass) do
+      return klass if klass.is_a?(::Class) && klass < ::Solid::Model
+
+      raise ArgumentError, "#{klass.inspect} must be a class that includes #{::Solid::Model}"
+    end
+
+    attr_reader :input_class, :dependencies_class
+
+    def initialize
+      self.input_class = ::Solid::Input
+      self.dependencies_class = ::Solid::Input
+    end
+
+    def input_class=(klass)
+      @input_class = SolidModel[klass]
+    end
+
+    def dependencies_class=(klass)
+      @dependencies_class = SolidModel[klass]
+    end
+
+    alias_method :deps_class, :dependencies_class
+    alias_method :deps_class=, :dependencies_class=
+
+    class << self
+      attr_reader :instance
+    end
+
+    @instance = new
+  end
+end

data/lib/solid/process/error.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Solid::Process
+  Error = ::Class.new(::StandardError)
+end

data/lib/solid/process/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Solid
-  module Process
-    VERSION = "0.0.0"
+  class Process
+    VERSION = "0.2.0"
   end
 end

data/lib/solid/process.rb

@@ -1,10 +1,140 @@
 # frozen_string_literal: true
 
-require_relative "process/version"
+require "active_support/all"
+require "active_model"
+require "bcdd/result"
 
 module Solid
-  module Process
-    class Error < StandardError; end
-    # Your code goes here...
+  require "solid/input"
+  require "solid/result"
+
+  class Process
+    require "solid/process/version"
+    require "solid/process/error"
+    require "solid/process/config"
+    require "solid/process/caller"
+    require "solid/process/callbacks"
+    require "solid/process/class_methods"
+    require "solid/process/active_record"
+
+    extend ClassMethods
+
+    include Callbacks
+    include ::ActiveSupport::Rescuable
+    include ::BCDD::Context.mixin(config: {addon: {continue: true}})
+
+    def self.inherited(subclass)
+      super
+
+      subclass.prepend(Caller)
+    end
+
+    def self.call(arg = nil)
+      new.call(arg)
+    end
+
+    def self.configuration(&block)
+      yield config
+
+      config.freeze
+    end
+
+    def self.config
+      Config.instance
+    end
+
+    attr_reader :output, :input, :dependencies
+
+    def initialize(arg = nil)
+      self.dependencies = arg
+    end
+
+    def call(_arg = nil)
+      raise Error, "#{self.class}#call must be implemented."
+    end
+
+    def with(dependencies)
+      self.class.new(dependencies.with_indifferent_access.with_defaults(deps&.attributes))
+    end
+
+    def new(dependencies = {})
+      with(dependencies)
+    end
+
+    def input?
+      !input.nil?
+    end
+
+    def output?(type = nil)
+      type.nil? ? !output.nil? : !!output&.is?(type)
+    end
+
+    def dependencies?
+      !dependencies.nil?
+    end
+
+    def success?(type = nil)
+      !!output&.success?(type)
+    end
+
+    def failure?(type = nil)
+      !!output&.failure?(type)
+    end
+
+    def inspect
+      "#<#{self.class.name} dependencies=#{dependencies.inspect} input=#{input.inspect} output=#{output.inspect}>"
+    end
+
+    def method_missing(name, *args, &block)
+      name.end_with?("?") ? output&.is?(name.to_s.chomp("?")) : super
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      name.end_with?("?") || super
+    end
+
+    alias_method :deps, :dependencies
+    alias_method :deps?, :dependencies?
+    alias_method :result, :output
+    alias_method :result?, :output?
+
+    private
+
+    def dependencies=(arg)
+      raise Error, "The `#{self.class}#dependencies` is already set." unless dependencies.nil?
+
+      @dependencies = self.class.dependencies&.then { arg.instance_of?(_1) ? arg : _1.new(arg) }
+    end
+
+    def input=(arg)
+      raise Error, "The `#{self.class}#input` is already set." unless input.nil?
+
+      @input = self.class.input.then { arg.instance_of?(_1) ? arg : _1.new(arg) }
+    end
+
+    def output_already_set!
+      raise Error, "The `#{self.class}#output` is already set. " \
+                   "Use `.output` to access the result or create a new instance to call again."
+    end
+
+    def output=(result)
+      output_already_set! unless output.nil?
+
+      raise Error, "The result #{result.inspect} must be a BCDD::Context." unless result.is_a?(::BCDD::Context)
+
+      @output = result
+    end
+
+    def Success!(...)
+      return self.output = Success(...) if output.nil?
+
+      raise Error, "`Success!()` cannot be called because the `#{self.class}#output` is already set."
+    end
+
+    def Failure!(...)
+      return self.output = Failure(...) if output.nil?
+
+      raise Error, "`Failure!()` cannot be called because the `#{self.class}#output` is already set."
+    end
   end
 end

data/lib/solid/result.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Solid
+  Output = ::BCDD::Context
+
+  Result = ::BCDD::Context
+  Success = Result::Success
+  Failure = Result::Failure
+
+  def self.Success(...)
+    Result::Success(...)
+  end
+
+  def self.Failure(...)
+    Result::Failure(...)
+  end
+end

data/lib/solid/validators/all.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative "instance_of_validator"
+require_relative "is_a_validator"
+require_relative "kind_of_validator"
+require_relative "respond_to_validator"
+require_relative "singleton_validator"
+
+require_relative "bool_validator"
+require_relative "email_validator"
+require_relative "persisted_validator"
+require_relative "uuid_validator"

data/lib/solid/validators/bool_validator.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class BoolValidator < ActiveModel::EachValidator
+  def validate_each(obj, attribute, value)
+    return if value == true || value == false
+
+    obj.errors.add attribute, (options[:message] || "is not a boolean")
+  end
+end

data/lib/solid/validators/email_validator.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class EmailValidator < ActiveModel::EachValidator
+  def validate_each(obj, attribute, value)
+    return if value.is_a?(String) && URI::MailTo::EMAIL_REGEXP.match?(value)
+
+    obj.errors.add attribute, (options[:message] || "is not an email")
+  end
+end

data/lib/solid/validators/instance_of_validator.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class InstanceOfValidator < ActiveModel::EachValidator
+  def validate_each(obj, attribute, value)
+    with_option = Array.wrap(options[:with] || options[:in])
+
+    return if with_option.any? { |type| value.instance_of?(type) }
+
+    expectation = with_option.map(&:name).join(" | ")
+
+    obj.errors.add(attribute, (options[:message] || "is not an instance of #{expectation}"))
+  end
+end

data/lib/solid/validators/is_a_validator.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative "kind_of_validator"
+
+class IsAValidator < KindOfValidator
+end

data/lib/solid/validators/kind_of_validator.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class KindOfValidator < ActiveModel::EachValidator
+  def validate_each(obj, attribute, value)
+    with_option = Array.wrap(options[:with] || options[:in])
+
+    return if with_option.any? { |type| value.is_a?(type) }
+
+    expectation = with_option.map(&:name).join(" | ")
+
+    obj.errors.add(attribute, (options[:message] || "is not a #{expectation}"))
+  end
+end

data/lib/solid/validators/persisted_validator.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class PersistedValidator < ActiveModel::EachValidator
+  def validate_each(record, attribute, value)
+    return if (options[:allow_nil] && value.nil?) || value.try(:persisted?)
+
+    record.errors.add(attribute, (options[:message] || "must be persisted"))
+  end
+end

data/lib/solid/validators/respond_to_validator.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class RespondToValidator < ActiveModel::EachValidator
+  def validate_each(obj, attribute, value)
+    with_option = Array.wrap(options[:with] || options[:in])
+
+    return if with_option.all? { value.respond_to?(_1) }
+
+    expectation = with_option.map(&:inspect).join(" & ")
+
+    obj.errors.add(attribute, (options[:message] || "does not respond to #{expectation}"))
+  end
+end

data/lib/solid/validators/singleton_validator.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class SingletonValidator < ActiveModel::EachValidator
+  def validate_each(obj, attribute, value)
+    with_option = Array.wrap(options[:with] || options[:in])
+
+    unless value.is_a?(Module)
+      return obj.errors.add(attribute, options[:message] || "is not a class or module")
+    end
+
+    is_valid = with_option.any? do |type|
+      type.is_a?(Module) or raise ArgumentError, "#{type.inspect} is not a class or module"
+
+      value == type || (value < type || value.is_a?(type))
+    end
+
+    expectation = with_option.map(&:name).join(" | ")
+
+    is_valid or obj.errors.add(attribute, (options[:message] || "is not #{expectation}"))
+  end
+end

data/lib/solid/validators/uuid_validator.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class UuidValidator < ActiveModel::EachValidator
+  PATTERN = "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}"
+  CASE_SENSITIVE = /\A#{PATTERN}\z/.freeze
+  CASE_INSENSITIVE = /\A#{PATTERN}\z/i.freeze
+
+  def validate_each(obj, attribute, value)
+    case_sensitive = options.fetch(:case_sensitive, true)
+
+    regexp = case_sensitive ? CASE_SENSITIVE : CASE_INSENSITIVE
+
+    return if value.is_a?(String) && value.match?(regexp)
+
+    message = options[:message] || "is not a valid UUID (case #{case_sensitive ? "sensitive" : "insensitive"})"
+
+    obj.errors.add(attribute, message)
+  end
+
+  private_constant :PATTERN
+end

metadata

@@ -1,31 +1,111 @@
 --- !ruby/object:Gem::Specification
 name: solid-process
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Rodrigo Serradura
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-03-06 00:00:00.000000000 Z
-dependencies: []
-description: Ruby on Rails/Business Processes
+date: 2024-03-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bcdd-result
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.0'
+- !ruby/object:Gem::Dependency
+  name: appraisal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+description: Ruby on Rails + Business Processes
 email:
 - rodrigo.serradura@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".rubocop.yml"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - LICENSE.txt
 - README.md
 - Rakefile
+- examples/business_processes/.rubocop.yml
+- examples/business_processes/.ruby-version
+- examples/business_processes/.standard.yml
+- examples/business_processes/Gemfile
+- examples/business_processes/Rakefile
+- examples/business_processes/app/models/account.rb
+- examples/business_processes/app/models/account/member.rb
+- examples/business_processes/app/models/account/owner_creation.rb
+- examples/business_processes/app/models/user.rb
+- examples/business_processes/app/models/user/creation.rb
+- examples/business_processes/app/models/user/token.rb
+- examples/business_processes/app/models/user/token/creation.rb
+- examples/business_processes/config.rb
+- examples/business_processes/db/setup.rb
+- lib/solid/input.rb
+- lib/solid/model.rb
+- lib/solid/model/access.rb
 - lib/solid/process.rb
+- lib/solid/process/active_record.rb
+- lib/solid/process/callbacks.rb
+- lib/solid/process/caller.rb
+- lib/solid/process/class_methods.rb
+- lib/solid/process/config.rb
+- lib/solid/process/error.rb
 - lib/solid/process/version.rb
-- sig/solid/process.rbs
+- lib/solid/result.rb
+- lib/solid/validators/all.rb
+- lib/solid/validators/bool_validator.rb
+- lib/solid/validators/email_validator.rb
+- lib/solid/validators/instance_of_validator.rb
+- lib/solid/validators/is_a_validator.rb
+- lib/solid/validators/kind_of_validator.rb
+- lib/solid/validators/persisted_validator.rb
+- lib/solid/validators/respond_to_validator.rb
+- lib/solid/validators/singleton_validator.rb
+- lib/solid/validators/uuid_validator.rb
 homepage: https://github.com/serradura/solid-process
 licenses:
 - MIT
@@ -49,8 +129,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
+rubygems_version: 3.1.6
 signing_key:
 specification_version: 4
-summary: Ruby on Rails/Business Processes
+summary: Ruby on Rails + Business Processes
 test_files: []

data/.rubocop.yml

@@ -1,13 +0,0 @@
-AllCops:
-  TargetRubyVersion: 2.6
-
-Style/StringLiterals:
-  Enabled: true
-  EnforcedStyle: double_quotes
-
-Style/StringLiteralsInInterpolation:
-  Enabled: true
-  EnforcedStyle: double_quotes
-
-Layout/LineLength:
-  Max: 120

data/sig/solid/process.rbs

@@ -1,6 +0,0 @@
-module Solid
-  module Process
-    VERSION: String
-    # See the writing guide of rbs: https://github.com/ruby/rbs#guides
-  end
-end