ru.Bee 2.0.0 → 2.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fd4247baa0c82fd81b4be82e8e63446b8b0d7934cee6243dda47ea3b350d4213
-  data.tar.gz: 1ba2c534bcebc7e898408fcf9d4e594c9535ca6fc218a5de8d51895edadc9d7f
+  metadata.gz: cc6a4fbeb28a460ca66f75ccf1f5c97fe1572f422392f9ee1b72d082e05cb287
+  data.tar.gz: f4dbeaf7338af243f6e225a2a798a87de75b001fa4196bed94345d78887ba8ea
 SHA512:
-  metadata.gz: cff63aa019e6f5895908a7b1fd7122cefd3986c9a4c1aede556aee667cb750ca82ec95727babda0bd4a234a54b3b159fac5668e9a07de7f7974913015b7dcca5
-  data.tar.gz: b4ae2fb9d36dc6c06d87da67d479029fb7c4399f18b26dd57e10ad176a4135a81e2c7840f92393441287e29d470859ef9ec15043dad06b414cf13b680980e35c
+  metadata.gz: 996510c80521425797e17a1b641d767d6319877e127883692d519457c7573835ae2670a8ed17950f302b1934a0aae1270d8b065acfee079341935ddb8964a26f
+  data.tar.gz: 75a8ab899d3c98fd492a30ec5501982526318387c9214b78ebdf57ec2c39a91778268283db82cbeb5ae9072aa4c62507b1d175423e7f86beec892cddfea0bb90

data/lib/app/models/user.rb

@@ -2,7 +2,5 @@
 # If you remove or modify it, make sure all changes are inlined
 # with AuthTokenMiddleware and AuthTokenable modules
 class User < Rubee::SequelObject
-  include Rubee::PubSub::Publisher
-  include Rubee::PubSub::Subscriber
   attr_accessor :id, :email, :password, :created, :updated
 end

data/lib/rubee/extensions/hookable.rb

@@ -11,7 +11,7 @@ module Rubee
           hook = Module.new do
             define_method(method) do |*args, &block|
               if conditions_met?(options[:if], options[:unless])
-                handler.respond_to?(:call) ? handler.call : send(handler)
+                handler.respond_to?(:call) ? safe_call(handler, [self, args]) : send(handler)
               end
 
               super(*args, &block)
@@ -29,7 +29,7 @@ module Rubee
               result = super(*args, &block)
 
               if conditions_met?(options[:if], options[:unless])
-                handler.respond_to?(:call) ? handler.call : send(handler)
+                handler.respond_to?(:call) ? safe_call(handler, [self, args]) : send(handler)
               end
 
               result
@@ -47,7 +47,7 @@ module Rubee
               if conditions_met?(options[:if], options[:unless])
                 if handler.respond_to?(:call)
                   result = nil
-                  handler.call do
+                  safe_call(handler, [self, args]) do
                     result = super(*args, &block)
                   end
 
@@ -67,33 +67,74 @@ module Rubee
         end
       end
 
-      def conditions_met?(if_condition = nil, unless_condition = nil)
+      def conditions_met?(if_condition = nil, unless_condition = nil, instance = nil)
         return true if if_condition.nil? && unless_condition.nil?
-
         if_condition_result =
           if if_condition.nil?
             true
           elsif if_condition.respond_to?(:call)
-            if_condition.call
-          elsif respond_to?(if_condition)
-            send(if_condition)
+            safe_call(if_condition, [instance])
+          elsif instance.respond_to?(if_condition)
+            instance.send(if_condition)
           end
         unless_condition_result =
           if unless_condition.nil?
             false
           elsif unless_condition.respond_to?(:call)
-            unless_condition.call
-          elsif respond_to?(unless_condition)
-            send(unless_condition)
+            safe_call(unless_condition, [instance])
+          elsif instance.respond_to?(unless_condition)
+            instance.send(unless_condition)
           end
 
         if_condition_result && !unless_condition_result
       end
+
+      def safe_call(handler, call_args = [], &block)
+        if handler.is_a?(Proc)
+          wrapped = safe_lambda(handler, &block)
+
+          # Forward block to the handler lambda if present
+          if block
+            wrapped.call(*call_args, &block)
+          else
+            wrapped.call(*call_args)
+          end
+        else
+          handler.call
+          block&.call
+        end
+      end
+
+      def safe_lambda(strict_lambda, &block)
+        return strict_lambda unless strict_lambda.is_a?(Proc)
+        return strict_lambda unless strict_lambda.lambda?
+        return strict_lambda unless strict_lambda.arity >= 0
+
+        proc do |*call_args|
+          lambda_arity = strict_lambda.arity
+
+          # Take only what lambda can handle, pad missing ones with nil
+          args_for_lambda = call_args.first(lambda_arity)
+          if args_for_lambda.length < lambda_arity
+            args_for_lambda += Array.new(lambda_arity - args_for_lambda.length, nil)
+          end
+
+          strict_lambda.call(*args_for_lambda, &block)
+        end
+      end
     end
 
     module InstanceMethods
       def conditions_met?(if_condition = nil, unless_condition = nil)
-        self.class.conditions_met?(if_condition, unless_condition)
+        self.class.conditions_met?(if_condition, unless_condition, self)
+      end
+
+      def safe_lambda(strict_lambda)
+        self.class.safe_lambda(strict_lambda)
+      end
+
+      def safe_call(handler, call_args = [], &block)
+        self.class.safe_call(handler, call_args, &block)
       end
     end
   end

data/lib/rubee/extensions/serializable.rb

@@ -20,7 +20,8 @@ module Rubee
 
       def to_h
         instance_variables.each_with_object({}) do |var, hash|
-          hash[var.to_s.delete('@')] = instance_variable_get(var)
+          attr_name = var.to_s.delete('@')
+          hash[attr_name] = instance_variable_get(var) unless attr_name.start_with?('__')
         end
       end
     end

data/lib/rubee/extensions/validatable.rb

@@ -0,0 +1,169 @@
+module Rubee
+  module Validatable
+    class Error < StandardError; end
+
+    class State
+      attr_accessor :errors, :valid
+
+      def initialize
+        @valid = true
+        @errors = {}
+      end
+
+      def add_error(attribute, hash)
+        @valid = false
+        @errors[attribute] ||= {}
+        @errors[attribute].merge!(hash)
+      end
+
+      def has_errors_for?(attribute)
+        @errors.key?(attribute)
+      end
+    end
+
+    class RuleChain
+      attr_reader :instance, :attribute
+
+      def initialize(instance, attribute, state)
+        @instance = instance
+        @attribute = attribute
+        @state = state
+        @optional = false
+      end
+
+      def required(error_message = nil)
+        value = @instance.send(@attribute)
+
+        error_hash = assemble_error_hash(error_message, :required, attribute: @attribute)
+        if value.nil? || (value.respond_to?(:empty?) && value.empty?)
+          @state.add_error(@attribute, error_hash)
+        end
+
+        self
+      end
+
+      def optional(*)
+        @optional = true
+
+        self
+      end
+
+      def attribute
+        self
+      end
+
+      def type(expected_class, error_message = nil)
+        return self if @state.has_errors_for?(@attribute)
+        value = @instance.send(@attribute)
+        return self if @optional && value.nil?
+
+        error_hash = assemble_error_hash(error_message, :type, class: expected_class)
+        unless value.is_a?(expected_class)
+          @state.add_error(@attribute, error_hash)
+        end
+
+        self
+      end
+
+      def condition(handler, error_message = nil)
+        return self if @state.has_errors_for?(@attribute)
+        value = @instance.send(@attribute)
+        return self if @optional && value.nil?
+
+        error_hash = assemble_error_hash(error_message, :condition)
+        if handler.respond_to?(:call)
+          @state.add_error(@attribute, error_hash) unless handler.call
+        else
+          @instance.send(handler)
+        end
+
+        self
+      end
+
+      private
+
+      def assemble_error_hash(error_message, error_type, **options)
+        error_message ||= default_message(error_type, **options)
+        if error_message.is_a?(String)
+          error_message = { message: error_message }
+        end
+
+        error_message
+      end
+
+      def default_message(type, **options)
+        {
+          condition: "condition is not met",
+          required: "attribute '#{options[:attribute]}' is required",
+          type: "attribute must be #{options[:class]}",
+        }[type]
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.prepend(Initializer)
+      base.include(InstanceMethods)
+    end
+
+    module Initializer
+      def initialize(*)
+        @__validation_state = State.new
+        super
+        run_validations
+      end
+    end
+
+    module InstanceMethods
+      def valid?
+        run_validations
+        @__validation_state.valid
+      end
+
+      def invalid?
+        !valid?
+      end
+
+      def errors
+        run_validations
+        @__validation_state.errors
+      end
+
+      def run_validations
+        @__validation_state = State.new
+        if (block = self.class.validation_block)
+          instance_exec(&block)
+        end
+      end
+
+      def subject
+        @__validation_state.instance
+      end
+
+      def attribute(name)
+        RuleChain.new(self, name, @__validation_state).attribute
+      end
+
+      def required(attribute, options)
+        error_message = options
+        RuleChain.new(self, attribute, @__validation_state).required(error_message)
+      end
+
+      def optional(attribute)
+        RuleChain.new(self, attribute, @__validation_state).optional
+      end
+
+      def add_error(attribute, hash)
+        @__validation_state.add_error(attribute, hash)
+      end
+    end
+
+    module ClassMethods
+      attr_reader :validation_block
+
+      def validate(&block)
+        @validation_block = block
+      end
+    end
+  end
+end

data/lib/rubee/models/database_objectable.rb

@@ -8,6 +8,7 @@ module Rubee
 
       base.include(Rubee::Hookable)
       base.include(Rubee::Serializable)
+      base.include(Rubee::Validatable)
     end
 
     module ClassMethods

data/lib/rubee/models/sequel_object.rb

@@ -33,12 +33,11 @@ module Rubee
 
       else
         begin
-          created_object = self.class.create(args)
+          created_id = self.class.dataset.insert(args)
         rescue StandardError => _e
           return false
         end
-        self.id = created_object.id
-
+        self.id = created_id
       end
       true
     end
@@ -208,9 +207,9 @@ module Rubee
         if dataset.columns.include?(:created) && dataset.columns.include?(:updated)
           attrs.merge!(created: Time.now, updated: Time.now)
         end
-
-        out_id = Rubee::DBTools.with_retry { dataset.insert(**attrs) }
-        new(**attrs.merge(id: out_id))
+        instance = new(**attrs)
+        Rubee::DBTools.with_retry { instance.save }
+        instance
       end
 
       def destroy_all(cascade: false)
@@ -225,6 +224,15 @@ module Rubee
           klass.new(**klass_attributes)
         end
       end
+
+      def validate_before_persist!
+        before(:save, proc { |model| raise Rubee::Validatable::Error, model.errors.to_s }, if: :invalid?)
+        before(:update, proc do |model, args|
+          if (instance = model.class.new(*args)) && instance.invalid?
+            raise Rubee::Validatable::Error, instance.errors.to_s
+          end
+        end)
+      end
     end
   end
 end

data/lib/rubee.rb

@@ -17,7 +17,7 @@ module Rubee
   CSS_DIR = File.join(APP_ROOT, LIB, 'css') unless defined?(CSS_DIR)
   ROOT_PATH = File.expand_path(File.join(__dir__, '..')) unless defined?(ROOT_PATH)
 
-  VERSION = '2.0.0'
+  VERSION = '2.1.1'
 
   require_relative 'rubee/router'
   require_relative 'rubee/logger'

data/lib/tests/models/account_model_test.rb

@@ -15,5 +15,21 @@ describe 'Account model' do
         _(account.user.id).must_equal(user.id)
       end
     end
+
+    describe '#validate_before_persist' do
+      it 'rasies error if account is not valid' do
+        Account.validate do
+          required(:addres, required: "address is required")
+            .type(String, type: "address must be string")
+        end
+        Account.validate_before_persist!
+        user = User.new(email: 'ok-test@test.com', password: '123')
+        _(raise_error { Account.create(addres: 1, user_id: user.id) }.is_a?(Rubee::Validatable::Error)).must_equal(true)
+        account = Account.create(addres: "13Th street", user_id: user.id)
+        _(account.persisted?).must_equal(true)
+        _(raise_error { account.update(addres: 1) }.is_a?(Rubee::Validatable::Error)).must_equal(true)
+        _(raise_error { Account.new(addres: 1, user_id: user.id).save }.is_a?(Rubee::Validatable::Error)).must_equal(true)
+      end
+    end
   end
 end

data/lib/tests/models/comment_model_test.rb

@@ -3,7 +3,7 @@ require_relative '../test_helper'
 describe 'Comment model' do
   describe 'owns_many :users, over: :posts' do
     before do
-      comment = Comment.new(text: 'test')
+      comment = Comment.new(text: 'test_enough')
       comment.save
       user = User.new(email: 'ok-test@test.com', password: '123')
       user.save
@@ -17,18 +17,18 @@ describe 'Comment model' do
 
     describe 'when there are associated comment records' do
       it 'returns all records' do
-        _(Comment.where(text: 'test').last.users.count).must_equal(1)
-        _(Comment.where(text: 'test').last.users.first.email).must_equal('ok-test@test.com')
+        _(Comment.where(text: 'test_enough').last.users.count).must_equal(1)
+        _(Comment.where(text: 'test_enough').last.users.first.email).must_equal('ok-test@test.com')
       end
     end
 
     describe 'sequel dataset query' do
       it 'returns all records' do
         result = Comment.dataset.join(:posts, comment_id: :id)
-          .where(comment_id: Comment.where(text: 'test').last.id)
+          .where(comment_id: Comment.where(text: 'test_enough').last.id)
           .then { |dataset| Comment.serialize(dataset) }
 
-        _(result.first.text).must_equal('test')
+        _(result.first.text).must_equal('test_enough')
       end
     end
   end
@@ -44,4 +44,183 @@ describe 'Comment model' do
       _(Comment.find(comment.id).text).must_equal('test 2')
     end
   end
+
+  describe 'validatable' do
+    def include_and_validate(required: true)
+      required_or_optional = required ? :required : :optional
+      required_or_optional_args = required ? [required: "text filed is required"] : []
+      Comment.validate do
+        attribute(:text).send(
+          required_or_optional, *required_or_optional_args
+        )
+          .type(String, type: "text field must be string")
+          .condition(proc { text.length > 4 }, { length: "text length must be greater than 4" })
+      end
+    end
+
+    it 'is valid' do
+      include_and_validate
+      comment = Comment.new(text: 'test it as valid')
+
+      _(comment.valid?).must_equal(true)
+    end
+
+    it 'is not valid length' do
+      include_and_validate
+      comment = Comment.new(text: 'test')
+
+      _(comment.valid?).must_equal(false)
+      _(comment.errors[:text]).must_equal({ length: "text length must be greater than 4" })
+    end
+
+    it 'is not valid type' do
+      include_and_validate
+      comment = Comment.new(text: 1)
+
+      _(comment.valid?).must_equal(false)
+      _(comment.errors[:text]).must_equal({ type: "text field must be string" })
+    end
+
+    it 'is not valid required' do
+      include_and_validate
+      comment = Comment.new(user_id: 1)
+
+      _(comment.valid?).must_equal(false)
+      _(comment.errors[:text]).must_equal({ required: "text filed is required" })
+    end
+
+    describe 'when first validation is optional' do
+      it 'no text should be valid' do
+        include_and_validate required: false
+
+        comment = Comment.new(user_id: 1)
+
+        _(comment.valid?).must_equal(true)
+        _(comment.errors[:test]).must_equal(nil)
+      end
+
+      it 'text is a number should be invalid' do
+        include_and_validate required: false
+        comment = Comment.new(text: 1)
+
+        _(comment.valid?).must_equal(false)
+        _(comment.errors[:text]).must_equal({ type: "text field must be string" })
+      end
+
+      it 'text is short should be invalid' do
+        include_and_validate required: false
+        comment = Comment.new(text: 'test')
+
+        _(comment.valid?).must_equal(false)
+        _(comment.errors[:text]).must_equal({ length: "text length must be greater than 4" })
+      end
+    end
+
+    describe 'before save must be valid' do
+      it 'does not persit if record is invalid' do
+        include_and_validate
+        Comment.before(
+          :save, proc { |comment| raise Rubee::Validatable::Error, comment.errors.to_s },
+          if: ->(comment) { comment&.invalid? }
+        )
+
+        comment = Comment.new(text: 'test')
+        _(raise_error { comment.save }.is_a?(Rubee::Validatable::Error)).must_equal(true)
+        _(comment.persisted?).must_equal(false)
+      end
+
+      describe 'when usig method' do
+        it 'does not persit if record is invalid' do
+          include_and_validate
+          Comment.before(:save, proc { |comment| raise Rubee::Validatable::Error, comment.errors.to_s }, if: :invalid?)
+
+          comment = Comment.new(text: 'test')
+          _(raise_error { comment.save }.is_a?(Rubee::Validatable::Error)).must_equal(true)
+          _(comment.persisted?).must_equal(false)
+        end
+      end
+    end
+
+    describe 'before create must be invalid' do
+      it 'does not create if record is invalid' do
+        include_and_validate
+        Comment.before(:save, proc { |comment| raise Rubee::Validatable::Error, comment.errors.to_s }, if: :invalid?)
+
+        initial_comments_count = Comment.count
+        _(raise_error { Comment.create(text: 'te') }.is_a?(Rubee::Validatable::Error)).must_equal(true)
+        assert_equal(initial_comments_count, Comment.count)
+      end
+    end
+
+    describe 'before update must be invalid' do
+      it 'does not update if record is invalid' do
+        include_and_validate
+        Comment.around(:update, proc do |_comment, args, &update_method|
+          com = Comment.new(*args)
+          raise Rubee::Validatable::Error, com.errors.to_s if com.invalid?
+          update_method.call
+        end)
+        comment = Comment.create(text: 'test123123')
+
+        initial_comments_count = Comment.count
+        _(raise_error { comment.update(text: 'te') }.is_a?(Rubee::Validatable::Error)).must_equal(true)
+        assert_equal(initial_comments_count, Comment.count)
+      end
+
+      it 'updates the record if record is valid' do
+        include_and_validate
+        Comment.before(:update, ->(model, args) do
+          if (instance = model.class.new(*args)) && instance.invalid?
+            raise Rubee::Validatable::Error, instance.errors.to_s
+          end
+        end)
+        comment = Comment.create(text: 'test123123')
+
+        comment.update(text: 'testerter')
+        assert_equal('testerter', comment.text)
+      end
+    end
+
+    describe 'default errors as error' do
+      it 'assembles error hash' do
+        Comment.validate do
+          attribute(:text).required.type(String).condition(-> { text.length > 4 })
+        end
+
+        comment = Comment.new(text: 'test')
+        _(comment.valid?).must_equal(false)
+        _(comment.errors[:text]).must_equal({ message: "condition is not met" })
+
+        comment = Comment.new(text: 123)
+        _(comment.valid?).must_equal(false)
+        _(comment.errors[:text]).must_equal({ message: "attribute must be String" })
+
+        comment = Comment.new(user_id: User.last)
+        _(comment.valid?).must_equal(false)
+        _(comment.errors[:text]).must_equal({ message: "attribute 'text' is required" })
+      end
+    end
+
+    describe 'message instead hash as error' do
+      it 'assembles error hash' do
+        Comment.validate do
+          attribute(:text)
+            .required("Text is a mandatory field").type(String, "Text must be a string")
+            .condition(-> { text.length > 4 }, "Text length must be greater than 4")
+        end
+
+        comment = Comment.new(text: 'test')
+        _(comment.valid?).must_equal(false)
+        _(comment.errors[:text]).must_equal({ message: "Text length must be greater than 4" })
+
+        comment = Comment.new(text: 123)
+        _(comment.valid?).must_equal(false)
+        _(comment.errors[:text]).must_equal({ message: "Text must be a string" })
+
+        comment = Comment.new(user_id: User.last)
+        _(comment.valid?).must_equal(false)
+        _(comment.errors[:text]).must_equal({ message: "Text is a mandatory field" })
+      end
+    end
+  end
 end

data/lib/tests/test_helper.rb

@@ -39,3 +39,9 @@ ensure
   $stdout = old_stdout
 end
 
+def raise_error
+  yield
+rescue => e
+  e
+end
+

data/readme.md

@@ -6,9 +6,9 @@
 ![GitHub Repo stars](https://img.shields.io/github/stars/nucleom42/rubee?style=social)
 
 
-# <img src="lib/images/rubee.svg" alt="RUBEE" height="40"> ... RUBEE
+# <img src="lib/images/rubee.svg" alt="ru.Bee" height="40"> ... ru.Bee
 
-RUBEE is a Ruby-based web framework designed to streamline the development of modular monolith web applications. \
+ru.Bee is a Ruby-based web framework designed to streamline the development of modular monolith web applications. \
 Under the hood, it leverages the power of Ruby and Rack backed by Puma, offering a clean, efficient, and flexible architecture. \
 It offers a structured approach to building scalable, maintainable, and React-ready projects, \
 making it an ideal choice for developers seeking a balance between monolithic simplicity and modular flexibility.
@@ -17,9 +17,13 @@ Want to get a quick API server up and runing? You can do it for real quick!
 <br />
 [![Watch the demo](https://img.youtube.com/vi/ko7H70s7qq0/hqdefault.jpg)](https://www.youtube.com/watch?v=ko7H70s7qq0)
 
+Starting from ru.Bee 2.0.0, ru.Bee supports Websocket, which is a feature that allows you to build real-time applications with ease. \
+<br />
+[![Watch the demo](https://img.youtube.com/vi/gp8IheKBNm4/hqdefault.jpg)](https://www.youtube.com/watch?v=gp8IheKBNm4)
+
 ## Production ready
 
-Take a look on the RUBEE demo site with all documentation stored in there: https://rubee.dedyn.io/
+Take a look on the ru.Bee demo site with all documentation stored in there: https://rubee.dedyn.io/
 Want to explore how it built? https://github.com/nucleom42/rubee-site
 
 ## Stress tested
@@ -41,17 +45,17 @@ Transfer/sec:    140.07KB
 - Average latency: ~305 ms
 - Total requests handled: 9,721
 - Hardware: Raspberry Pi 5(8 Gb) (single board computer)
-- Server: RUBEE app hosted via Nginx + HTTPS
+- Server: ru.Bee app hosted via Nginx + HTTPS
 
-This demonstrate RUBEE’s efficient architecture and suitability for lightweight deployments — even on low-power hardware.
+This demonstrate ru.Bee’s efficient architecture and suitability for lightweight deployments — even on low-power hardware.
 
 ## Comparison
-Here below is a **short web frameworks comparison** built with Ruby, so you can evaluate your choice with RUBEE.
+Here below is a **short web frameworks comparison** built with Ruby, so you can evaluate your choice with ru.Bee.
 
 **Disclaimer:**
 The comparison is based on a very generic and subjective information open in the Internet and is not a real benchmark. The comparison is aimed to give you a general idea of the differences between the frameworks and Rubee and not to compare the frameworks directly.
 
-| Feature / Framework | **RUBEE** | Rails | Sinatra | Hanami | Padrino | Grape |
+| Feature / Framework | **ru.Bee** | Rails | Sinatra | Hanami | Padrino | Grape |
 |---------------------|-----------|-------|---------|--------|---------|-------|
 | **React readiness** | Built-in React integration (route generator can scaffold React components that fetch data via controllers) | React via webpacker/importmap, but indirect | No direct React support | Can integrate React | Can integrate via JS pipelines | API-focused, no React support |
 | **Routing style**   | Explicit, file-based routes with clear JSON/HTML handling | DSL, routes often implicit inside controllers | Explicit DSL, inline in code | Declarative DSL | Rails-like DSL | API-oriented DSL |
@@ -73,6 +77,7 @@ The comparison is based on a very generic and subjective information open in the
 - [Database](#database)
 - [Views](#views)
 - [Hooks](#hooks)
+- [Validations](#validations)
 - [JWT based authentification](#jwt-based-authentification)
 - [OAuth2 based authentification](#oauth-authentification)
 - [Rubee commands](#rubee-commands)
@@ -83,12 +88,10 @@ The comparison is based on a very generic and subjective information open in the
 - [Background jobs](#background-jobs)
 - [Modular](#modualar-application)
 - [Logger](#logger)
+- [Websocket](#websocket)
 
 You can read it on the demo: [site](https://rubee.dedyn.io/)
 
-🚧 The doc site is on update mode now. We are working on it.
-Please refer to the documentation shown below.
-
 ## Features
 
 Lightweight – A minimal footprint focused on serving Ruby applications efficiently.
@@ -106,9 +109,9 @@ Databases – Supports SQLite3, PostgreSQL, MySQL, and more via the Sequel gem.
 <br>
 Views – JSON, ERB, and plain HTML out of the box.
 <br>
-React Ready – React is supported as a first-class RUBEE view engine.
+React Ready – React is supported as a first-class ru.Bee view engine.
 <br>
-Bundlable – Charge your RUBEE app with any gem you need. Update effortlessly via Bundler.
+Bundlable – Charge your ru.Bee app with any gem you need. Update effortlessly via Bundler.
 <br>
 ORM-agnostic – Models are native ORM objects, but you can use them as blueprints for any data source.
 <br>
@@ -123,10 +126,14 @@ Asyncable – Plug in async adapters and use any popular background job engine.
 Console – Start an interactive console and reload on the fly.
 <br>
 Background Jobs – Schedule and process background jobs using your preferred async stack.
+<br>
+Websocket – Serve and handle WebSocket connections.
+<br>
+Logger – Use any logger you want.
 
 ## Installation
 
-1. Install RUBEE
+1. Install ru.Bee
 ```bash
 gem install ru.Bee
 ```
@@ -216,7 +223,7 @@ This will generate the following files
 [Back to content](#content)
 
 ## Model
-Model in RUBEE is just simple ruby object that can be serilalized in the view
+Model in ru.Bee is just simple ruby object that can be serilalized in the view
 in the way it required (ie json).
 Here below is a simple example on how it can be used by rendering json from in memory object
 
@@ -355,7 +362,7 @@ irb(main):023> User.all
 => []
 ```
 
-Use complex queries chains and when ready serialize it back to RUBEE object.
+Use complex queries chains and when ready serialize it back to ru.Bee object.
 ```Ruby
 # user model
 class User < Rubee::SequelObject
@@ -392,7 +399,7 @@ irb(main):009>  .where(comment_id: Comment.where(text: "test").last.id)
 irb(main):010>  .then { |dataset| Comment.serialize(dataset) }
 => [#<Comment:0x0000000121889998 @id=30, @text="test", @user_id=702, @created=2025-09-28 22:03:07.011332 -0400, @updated=2025-09-28 22:03:07.011332 -0400>]
 ```
-This is recommended when you want to run one query and serialize it back to RUBEE object only once.
+This is recommended when you want to run one query and serialize it back to ru.Bee object only once.
 So it may safe some resources.
 
 [Back to content](#content)
@@ -408,7 +415,7 @@ If you feel comfortable you can play with retry configuration parameters:
   config.db_busy_timeout = { env:, value: 1000 } # this is busy timeout in ms, before raising bussy error
 ```
 
-For RUBEE model class persist methods create and update retry will be added automatically. However, \
+For ru.Bee model class persist methods create and update retry will be added automatically. However, \
 if you want to do it with Sequel dataset you need to do it yourself:
 
 ```ruby
@@ -417,7 +424,7 @@ if you want to do it with Sequel dataset you need to do it yourself:
 [Back to content](#content)
 
 ## Routing
-RUBEE uses explicit routes. In the routes.rb yout can define routes for any of the main HTTP methods. \
+ru.Bee uses explicit routes. In the routes.rb yout can define routes for any of the main HTTP methods. \
 You can also add any matched parameter denoted by a pair of `{ }` in the path of the route. \
 Eg. `/path/to/{a_key}/somewhere`
 
@@ -443,7 +450,7 @@ route.{http_method} {path}, to: "{controller}#{action}",
 ```
 
 ### Defining Model attributes in routes
-One of RUBEE's unique traits is where we can define our models for generation. \
+One of ru.Bee's unique traits is where we can define our models for generation. \
 You've seen above one possible way you can set up.
 
 ```ruby
@@ -572,7 +579,7 @@ Will generate:
 
 ### Modualar application
 
-You can also use RUBEE to create modular applications.\
+You can also use ru.Bee to create modular applications.\
 And attach as many subprojects you need.
 Main philosophy of attach functinality is to keep the main project clean and easy to maintain. It will still\
 share data with the main app. So where to define a border between the main app and subprojects is up to developer.
@@ -649,7 +656,7 @@ rubee start # or rubee start_dev for development
 [Back to content](#content)
 
 ## Views
-View in RUBEE is just a plain html/erb/react file that can be rendered from the controller.
+View in ru.Bee is just a plain html/erb/react file that can be rendered from the controller.
 
 ## Templates over erb
 
@@ -794,7 +801,7 @@ function Users() {
 
 ## Object hooks
 
-In RUBEE by extending Hookable module any Ruby object can be charged with hooks (logic),
+In ru.Bee by extending Hookable module any Ruby object can be charged with hooks (logic),
 that can be executed before, after and around a specific method execution.
 
 Here below a controller example. However it can be used in any Ruby object, like Model etc.
@@ -859,6 +866,106 @@ world!
 
 [Back to content](#content)
 
+## Validations
+
+In ru.Bee any class can be charged with validations. This is done by including Validatable module.
+Please note, ru.Bee model is validatable by default. No need to include it explicitly.
+```ruby
+class Foo
+  include Rubee::Validatable
+
+  attr_accessor :name, :age
+
+  def initialize(name, age)
+    @name = name
+    @age = age
+  end
+
+  validate do
+    attribute(:name).required.type(String).condition(->{ name.length > 2 })
+
+    attribute(:age)
+      .required('Age is a manadatory field')
+      .type(Integer, error_message: 'Must be an integerRRRRRRrrr!')
+      .condition(->{ age > 18 }, fancy_error: 'You must be at least 18 years old, dude!')
+  end
+end
+```
+Then we can evaluate it in the ru.Bee console
+```bash
+=> #<Proc:0x000000010d389d80 (irb):32>
+irb(main):041> Foo.new("Test", 20)
+=> #<Foo:0x000000010d383fc0 @__validation_state=#<Rubee::Validatable::State:0x000000010d383de0 @errors={}, @valid=true>, @age=20, @name="Test">
+irb(main):042> Foo.new("Test", 1)
+=>
+#<Foo:0x000000010ce61c40
+ @__validation_state=#<Rubee::Validatable::State:0x000000010ce61bc8 @errors={age: {fancy_error: "You must be at least 18 years old, dude!"}}, @valid=false>,
+ @age=1,
+ @name="Test">
+irb(main):043> Foo.new("Test", nil)
+=>
+#<Foo:0x000000010c46f200
+ @__validation_state=#<Rubee::Validatable::State:0x000000010c46f070 @errors={age: {message: "Age is a manadatory field"}}, @valid=false>,
+ @age=nil,
+ @name="Test">
+irb(main):044> Foo.new("Te", 20)
+=>
+#<Foo:0x000000010cfe9270
+ @__validation_state=#<Rubee::Validatable::State:0x000000010cfe91f8 @errors={name: {message: "condition is not met"}}, @valid=false>,
+ @age=20,
+ @name="Te">
+irb(main):045> foo = Foo.new("Joe", "wrong")
+=>
+#<Foo:0x000000010d32eb38
+...
+irb(main):046> foo.valid?
+=> false
+irb(main):047> foo.errors
+=> {age: {error_message: "Must be an integerRRRRRRrrr!"}}
+```
+Model example
+```ruby
+class User < Rubee::SequelObject
+  attr_accessor :id, :email, :password, :created, :updated
+
+  validate_before_persist! # This will validate and raise error in case invalid before saving to DB
+  validate do
+    attribute(:email).required
+      .condition(
+        ->{ email.match?(/\A[\w+\-.]+@[a-z\d\-]+(\.[a-z\d\-]+)*\.[a-z]+\z/i) }, error: 'Wrong email format'
+      )
+  end
+end
+```
+```bash
+irb(main):074> user = User.new(email: "wrong", password: 123)
+=>
+#<User:0x000000010d2c3e78
+...
+irb(main):075> user.valid?
+=> false
+irb(main):076> user.errors
+=> {email: {error: "Wrong email format"}}
+irb(main):077> user.save
+=>{email: {error: "Wrong email format"}} (Rubee::Validatable::Error) ..
+irb(main):078> user.email = "ok@ok.com"
+=> "ok@ok.com"
+irb(main):079> user.valid?
+=> true
+irb(main):080> user.save
+=> true
+irb(main):081> user
+=>
+#<User:0x000000010d2c3e78
+ @__validation_state=#<Rubee::Validatable::State:0x000000010cb28628 @errors={}, @valid=true>,
+ @created=2025-11-30 17:18:52.254197 -0500,
+ @email="ok@ok.com",
+ @id=2260,
+ @password=123,
+ @updated=2025-11-30 17:18:52.254206 -0500>
+```
+[Back to content](#content)
+
 ## JWT based authentification
 
 Charge you rpoject with token based authentification system and customize it for your needs.
@@ -1004,7 +1111,7 @@ end
 
 [Back to content](#content)
 
-## RUBEE commands
+## ru.Bee commands
 ```bash
 rubee start # start the server
 rubee start_dev # start the server in dev mode, which restart server on changes
@@ -1026,7 +1133,7 @@ rubee db run:create_apples # where create_apples is the name of the migration fi
 rubee db structure # generate migration file for the database structure
 ```
 
-## RUBEE console
+## ru.Bee console
 ```bash
 rubee console # start the console
 # you can reload the console by typing reload, so it will pick up latest changes
@@ -1041,7 +1148,7 @@ rubee test auth_tokenable_test.rb # run specific tests
 [Back to content](#content)
 
 
-If you want to run any RUBEE command within a specific ENV make sure you added it before a command.
+If you want to run any ru.Bee command within a specific ENV make sure you added it before a command.
 For instance if you want to run console in test environment you need to run the following command
 
 ```bash
@@ -1173,9 +1280,126 @@ When you trigger the controller action, the logs will look like this:
 
 [Back to content](#content)
 
+## Websocket
+
+With ru.Bee 2.0.0 you can use Websocket with ease!
+
+Here are steps to get started:
+1. Make sure redis server is installed and running
+````bash
+sudo apt-get install -y redis # linux
+brew install redis # osx
+````
+2. Enable websocket and redis to your Gemfile
+```bash
+gem 'ru.Bee'
+gem 'redis'
+gem 'websocket'
+```
+3. Add the redis url to your configuration file, unless it connects to 127.0.0.1:6379
+```ruby
+# config/base_configuration.rb
+Rubee::Configuration.setup(env=:development) do |config|
+#...
+  config.redis_url = { url: "redis://localhost:6378/0", env: }
+end
+```
+3. Add webscoket entry connection route
+```ruby
+# config/routes.rb
+Rubee::Router.draw do |router|
+#...
+  router.get('/ws', to: 'users#websocket') # entry point to start websocket session
+  # So, const ws = new WebSocket("ws://website/ws"); on the client side, should establish the connection
+end
+```
+4. Make model pubsubable
+```ruby
+# app/models/user.rb
+class User < Rubee::BaseModel
+  include Rubee::PubSub::Publisher
+  include Rubee::PubSub::Subscriber
+  #...
+end
+```
+5. Enable websocket in your controller and implement required methods
+```ruby
+# app/controllers/users_controller.rb
+class UsersController < Rubee::BaseController
+  attach_websocket! # this will handle websocket connections and direct them to the controller methods: publish, subscribe, unsubscribe
+
+
+  # Subscribe is expected to get next params from the client:
+  # { action: 'subscribe', 'channel': 'default', 'id': '123', 'subscriber': 'User' }
+  # where
+  # - action corresponds to the method name
+  # - channel is the name of the channel
+  # - id is the id of the user
+  # - subscriber is the name of the model
+  def subscribe
+    channel = params[:channel]
+    sender_id = params[:options][:id] # id moved to options
+    io = params[:options][:io] # io is a websocket connection
+
+    User.sub(channel, sender_id, io) do |channel, args| # subscribe the user for the channel updates
+      websocket_connections.register(channel, args[:io]) # register the websocket connection
+    end
+    # return websocket response
+    response_with(object: { type: 'system', channel: params[:channel], status: :subscribed }, type: :websocket)
+  rescue StandardError => e
+    response_with(object: { type: 'system', error: e.message }, type: :websocket)
+  end
+
+  # Unsubscribe is expected to get next params from the client:
+  # { action: 'unsubscribe', 'channel': 'default', 'id': '123', 'subscriber': 'User' }
+  # where
+  # - action corresponds to the method name
+  # - channel is the name of the channel
+  # - id is the id of the user
+  # - subscriber is the name of the model
+  def unsubscribe
+    channel = params[:channel]
+    sender_id = params[:options][:id]
+    io = params[:options][:io]
+
+    User.unsub(channel, sender_id, io) do |channel, args|
+      websocket_connections.remove(channel, args[:io])
+    end
+
+    response_with(object: params.merge(type: 'system', status: :unsubscribed), type: :websocket)
+  rescue StandardError => e
+    response_with(object: { type: 'system', error: e.message }, type: :websocket)
+  end
+  # Publish is expected to get next params from the client:
+  # { action: 'publish', 'channel': 'default', 'message': 'Hello world', 'id': '123', 'subscriber': 'User' }
+  # where
+  # - action corresponds to the method name
+  # - channel is the name of the channel
+  # - id is the id of the user
+  # - subscriber is the name of the model
+  def publish
+    args = {}
+    User.pub(params[:channel], message: params[:message]) do |channel|
+      # Here we pack args with any additional data client might need
+      user = User.find(params[:options][:id])
+      args[:message] = params[:message]
+      args[:sender] = params[:options][:id]
+      args[:sender_name] = user.email
+      websocket_connections.stream(channel, args)
+    end
+
+    response_with(object: { type: 'system', message: params[:message], status: :published }, type: :websocket)
+  rescue StandardError => e
+    response_with(object: { type: 'system', error: e.message }, type: :websocket)
+  end
+end
+```
+If you are interested to see chat app example, please check [chat](https://github.com/nucleom42/rubee-chat)
+
+[Back to content](#content)
 ### Contributing
 
-If you are interested in contributing to RUBEE,
+If you are interested in contributing to ru.Bee,
 please read the [Contributing]()https://github.com/nucleom42/rubee/blob/main/contribution.md) guide.
 Also feel free to open an [issue](https://github.com/nucleom42/rubee/issues) if you apot one.
 Have an idea or you wnat to discuss something?

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ru.Bee
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.1.1
 platform: ruby
 authors:
 - Oleg Saltykov
@@ -256,6 +256,7 @@ files:
 - lib/rubee/controllers/middlewares/auth_token_middleware.rb
 - lib/rubee/extensions/hookable.rb
 - lib/rubee/extensions/serializable.rb
+- lib/rubee/extensions/validatable.rb
 - lib/rubee/features.rb
 - lib/rubee/generator.rb
 - lib/rubee/logger.rb