restme 0.0.37

data/lib/restme/create/rules.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require_relative "../shared/user_role"
+require_relative "../shared/current_model"
+require_relative "../shared/controller_params"
+
+module Restme
+  module Create
+    # Defines create restrictions rules for a record.
+    module Rules
+      include ::Restme::Shared::ControllerParams
+      include ::Restme::Shared::CurrentModel
+      include ::Restme::Shared::UserRole
+
+      attr_reader :create_temp_record
+
+      private
+
+      def creatable_record
+        @creatable_record ||= begin
+          @create_temp_record = klass.new(controller_params)
+
+          set_create_temp_record_current_user
+
+          create_record_errors.presence || create_temp_record
+        end
+      end
+
+      def set_create_temp_record_current_user
+        return unless create_temp_record.respond_to?(:current_user)
+        return unless restme_current_user
+
+        create_temp_record.current_user = restme_current_user
+      end
+
+      def restme_create_status
+        return :unprocessable_entity if create_record_errors
+
+        :created
+      end
+
+      def create_record_errors
+        return unless creatable_current_action
+
+        return createable_unscoped_error_response unless createable_scope?
+
+        create_object! unless create_temp_record.persisted?
+
+        createable_object_errors_messages
+      end
+
+      def create_object!
+        ActiveRecord::Base.transaction do
+          create_temp_record.save!
+        end
+      rescue StandardError
+        nil
+      end
+
+      def createable_unscoped_error_response
+        { message: "Unscoped", body: controller_params }
+      end
+
+      def createable_scope?
+        return true unless restme_current_user
+
+        method_scope = "#{creatable_current_action}_#{user_role}_scope?"
+
+        createable_super_admin_scope? || create_rules_class.try(method_scope) || false
+      end
+
+      def createable_super_admin_scope?
+        restme_current_user.super_admin?
+      end
+
+      def createable_object_errors_messages
+        return if create_temp_record.errors.blank?
+
+        "#{current_action}_error_scope?".constantize
+      rescue StandardError
+        createable_default_error_response
+      end
+
+      def creatable_current_action
+        return true unless restme_current_user
+
+        current_action.presence_in create_rules_class.class::CREATABLE_ACTIONS_RULES
+      rescue StandardError
+        nil
+      end
+
+      def current_action
+        action_name.to_sym
+      end
+
+      def createable_default_error_response
+        {
+          message: "Error #{create_temp_record.errors.full_messages.to_sentence}",
+          body: controller_params
+        }
+      end
+
+      def create_rules_class
+        @create_rules_class ||=
+          "#{controller_class.to_s.split("::").last}::Create::Rules"
+          .constantize.new(create_temp_record, restme_current_user)
+      end
+    end
+  end
+end

data/lib/restme/restme.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "authorize/rules"
+require_relative "scope/rules"
+require_relative "create/rules"
+require_relative "update/rules"
+
+module Restme
+  # Defines the initialization rules for Restme.
+  module Restme
+    include ::Restme::Update::Rules
+    include ::Restme::Create::Rules
+    include ::Restme::Scope::Rules
+    include ::Restme::Authorize::Rules
+
+    attr_reader :restme_current_user
+
+    def initialize_restme
+      use_current_user
+
+      user_authorize
+    end
+
+    private
+
+    def use_current_user
+      @restme_current_user = try(:current_user)
+    end
+  end
+end

data/lib/restme/scope/field/attachable.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Restme
+  module Scope
+    module Field
+      # Defines the rules that determine which attachable fields can be attached.
+      module Attachable
+        def insert_attachments(scope)
+          unallowed_attachment_fields_error
+
+          return scope.uniq if attachment_fields_select.blank?
+
+          scope = scope.includes(attachment_fields_select_includes).uniq
+
+          scope.map do |record|
+            attachment_fields_select.each do |field|
+              @record = record.as_json.merge({ "#{field}": record.send(field).url })
+            end
+
+            @record
+          end
+        end
+
+        def attachment_fields_select_includes
+          attachment_fields_select.map { |field| { "#{field}_attachment": :blob } }
+        end
+
+        def model_attachment_fields
+          @model_attachment_fields ||= klass.attachment_reflections.map do |attachment|
+            attachment.last.name
+          end
+        end
+
+        def unallowed_attachment_fields_error
+          return if unallowed_attachment_fields.blank?
+
+          render json: {
+            body: unallowed_attachment_fields,
+            message: "Selected not allowed attachment fields"
+          }, status: :bad_request
+        end
+
+        def unallowed_attachment_fields
+          return if attachment_fields_select.blank?
+
+          attachment_fields_select - model_attachment_fields
+        end
+      end
+    end
+  end
+end

data/lib/restme/scope/field/rules.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require_relative "attachable"
+
+module Restme
+  module Scope
+    module Field
+      # Defines the rules that determine which fields can be attached.
+      module Rules
+        include Restme::Scope::Field::Attachable
+
+        def fieldable_scope(user_scope)
+          unallowed_select_fields_error
+
+          return user_scope unless select_any_field?
+
+          scoped = user_scope
+
+          scoped = user_scope.select(model_fields_select) if model_fields_select
+
+          scoped = select_nested_scope(scoped) if valid_nested_fields_select
+
+          insert_attachments(scoped)
+        end
+
+        def select_nested_scope(scoped)
+          scoped.joins(nested_fields_joins)
+                .left_joins(nested_fields_left_joins)
+                .preload(valid_nested_fields_select)
+                .select(nesteds_table)
+        end
+
+        def select_any_field?
+          fields_select || nested_fields_select || attachment_fields_select
+        end
+
+        def nesteds_table
+          valid_nested_fields_select&.map do |field|
+            table = nested_selectable_fields_keys.dig(field, :table_name)
+            table.present? ? "#{table}::text AS #{field}" : nil
+          end
+        end
+
+        def model_fields_select
+          @model_fields_select ||= begin
+            fields = fields_select&.split(",")
+            fields = fields&.map { |field| "#{klass.table_name}.#{field}" }&.join(",")
+            fields || model_attributes
+          end
+        end
+
+        def model_attributes
+          @model_attributes ||= klass.new.attributes.keys
+        end
+
+        def nested_fields_joins
+          @nested_fields_joins ||= valid_nested_fields_select.select do |field|
+            nested_selectable_fields_keys[field.to_sym][:join_type].blank?
+          end
+        end
+
+        def nested_fields_left_joins
+          @nested_fields_left_joins ||= valid_nested_fields_select.select do |field|
+            nested_selectable_fields_keys[field.to_sym][:join_type] == :left_joins
+          end
+        end
+
+        def valid_nested_fields_select
+          @valid_nested_fields_select ||=
+            nested_fields_select&.split(",")&.select do |field|
+              nested_selectable_fields_keys[field.to_sym].present?
+            end&.map(&:to_sym)
+        end
+
+        def unallowed_select_fields_error
+          return if unallowed_fields_selected.blank?
+
+          restme_scope_errors({ body: unallowed_fields_selected, message: "Selected not allowed fields" })
+
+          restme_scope_status(:bad_request)
+        end
+
+        def unallowed_fields_selected
+          unallowed_nested_fields_select + unallowed_fields_select
+        end
+
+        def unallowed_nested_fields_select
+          return [] if nested_fields_select.blank?
+
+          nested_fields_select.split(",").map(&:to_sym) - valid_nested_fields_select
+        end
+
+        def unallowed_fields_select
+          return [] if fields_select.blank?
+
+          fields_select.split(",").map(&:to_sym) - model_attributes.map(&:to_sym)
+        end
+
+        def fields_select
+          @fields_select ||= controller_query_params[:fields_select]
+        end
+
+        def nested_fields_select
+          @nested_fields_select ||= controller_query_params[:nested_fields_select]
+        end
+
+        def attachment_fields_select
+          @attachment_fields_select ||= controller_query_params[:attachment_fields_select]
+                                        &.split(",")&.map(&:to_sym)
+        end
+
+        def nested_selectable_fields_keys
+          @nested_selectable_fields_keys ||= field_class_rules::NESTED_SELECTABLE_FIELDS
+        rescue StandardError
+          {}
+        end
+
+        def field_class_rules
+          "#{controller_class.to_s.split("::").last}::Field::Rules".constantize
+        end
+      end
+    end
+  end
+end

data/lib/restme/scope/filter/rules.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require_relative "types/equal_filterable"
+require_relative "types/like_filterable"
+require_relative "types/bigger_than_filterable"
+require_relative "types/less_than_filterable"
+require_relative "types/bigger_than_or_equal_to_filterable"
+require_relative "types/less_than_or_equal_to_filterable"
+require_relative "types/in_filterable"
+
+module Restme
+  module Scope
+    module Filter
+      # Defines filter rules
+      module Rules
+        include ::Scope::Filter::Types::InFilterable
+        include ::Scope::Filter::Types::LessThanOrEqualToFilterable
+        include ::Scope::Filter::Types::BiggerThanOrEqualToFilterable
+        include ::Scope::Filter::Types::LessThanFilterable
+        include ::Scope::Filter::Types::BiggerThanFilterable
+        include ::Scope::Filter::Types::LikeFilterable
+        include ::Scope::Filter::Types::EqualFilterable
+
+        ID = :id
+
+        FILTERS_TYPES = %i[equal like bigger_than less_than
+                           bigger_than_or_equal_to less_than_or_equal_to in].freeze
+
+        private
+
+        def filterable_scope(user_scope)
+          return unallowed_filter_fields_response if unallowed_fields_to_filter?
+          return user_scope unless filterable_scope?
+
+          next_scope = where_equal(user_scope)
+          next_scope = where_like(next_scope)
+          next_scope = where_bigger_than(next_scope)
+          next_scope = where_less_than(next_scope)
+          next_scope = where_bigger_than_or_equal_to(next_scope)
+          next_scope = where_less_than_or_equal_to(next_scope)
+          where_in(next_scope)
+        end
+
+        def allowed_fields
+          @allowed_fields ||= controller_params_filters_fields.map do |param_key|
+            filter_type = FILTERS_TYPES.find do |filter_type|
+              param_key.to_s.end_with?(filter_type.to_s)
+            end
+
+            record_field = param_key.to_s.gsub("_#{filter_type}", "")&.to_sym
+
+            next unless filter_type
+            next unless filteable_fields.include?(record_field)
+
+            send(:"add_#{filter_type}_field", record_field)
+          end.compact.flatten
+        end
+
+        def params_filters
+          @params_filters ||= {}
+        end
+
+        def filteable_fields
+          @filteable_fields ||= Array.new(klass::FILTERABLE_FIELDS).push(ID)
+        rescue StandardError
+          [ID]
+        end
+
+        def unallowed_fields_to_filter?
+          try_insert_id_equal
+
+          filterable_scope? && unallowed_fields_to_filter.present?
+        end
+
+        def filterable_scope?
+          request.get? && controller_params_filters_fields.present?
+        end
+
+        def unallowed_fields_to_filter
+          @unallowed_fields_to_filter ||= controller_params_filters_fields - allowed_fields
+        end
+
+        def try_insert_id_equal
+          return if params[:id].blank?
+
+          controller_params_filters_fields.push(:id_equal)
+        end
+
+        def unallowed_filter_fields_response
+          render json: { message: "Unknown Filter Fields", body: unallowed_fields_to_filter },
+                 status: :bad_request
+        end
+
+        def controller_params_filters_fields
+          @controller_params_filters_fields ||= controller_query_params.keys.select do |item|
+            FILTERS_TYPES.any? { |filter| item.to_s.end_with?(filter.to_s) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/restme/scope/filter/types/bigger_than_filterable.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Scope
+  module Filter
+    module Types
+      # Defines the behavior of the "bigger than" filter in queries.
+      module BiggerThanFilterable
+        FIELD_SUFFIX = :bigger_than
+
+        private
+
+        def where_bigger_than(scope)
+          return scope if bigger_than_fields.blank?
+
+          scope.where(bigger_than_sql, bigger_than_fields)
+        end
+
+        def bigger_than_sql
+          bigger_than_fields.keys.map do |param|
+            "#{klass.table_name}.#{param} > :#{param}"
+          end.join(" AND ")
+        end
+
+        def add_bigger_than_field(field)
+          field_key = :"#{field}_#{FIELD_SUFFIX}"
+          field_value = controller_query_params[field_key]
+          bigger_than_fields[field] = field_value if field_value
+
+          field_key
+        end
+
+        def bigger_than_fields
+          params_filters[FIELD_SUFFIX] ||= {}
+        end
+      end
+    end
+  end
+end

data/lib/restme/scope/filter/types/bigger_than_or_equal_to_filterable.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Scope
+  module Filter
+    module Types
+      # Defines the behavior of the "bigger than or equal to" filter in queries.
+      module BiggerThanOrEqualToFilterable
+        FIELD_SUFFIX = :bigger_than_or_equal_to
+
+        private
+
+        def where_bigger_than_or_equal_to(scope)
+          return scope if bigger_than_or_equal_to_fields.blank?
+
+          scope.where(bigger_than_or_equal_to_sql, bigger_than_or_equal_to_fields)
+        end
+
+        def bigger_than_or_equal_to_sql
+          bigger_than_or_equal_to_fields.keys.map do |param|
+            "#{klass.table_name}.#{param} >= :#{param}"
+          end.join(" AND ")
+        end
+
+        def add_bigger_than_or_equal_to_field(field)
+          field_key = :"#{field}_#{FIELD_SUFFIX}"
+          field_value = controller_query_params[field_key]
+          bigger_than_or_equal_to_fields[field] = field_value if field_value
+
+          field_key
+        end
+
+        def bigger_than_or_equal_to_fields
+          params_filters[FIELD_SUFFIX] ||= {}
+        end
+      end
+    end
+  end
+end

data/lib/restme/scope/filter/types/equal_filterable.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Scope
+  module Filter
+    module Types
+      # Defines the behavior of the "equal" filter in queries.
+      module EqualFilterable
+        FIELD_SUFFIX = :equal
+
+        private
+
+        def where_equal(scope)
+          return scope if equal_fields.blank?
+
+          scope.where(equal_sql, equal_fields)
+        end
+
+        def equal_sql
+          equal_fields.keys.map do |param|
+            "#{klass.table_name}.#{param} = :#{param}"
+          end.join(" AND ")
+        end
+
+        def add_equal_field(field)
+          field_key = :"#{field}_#{FIELD_SUFFIX}"
+          field_value = controller_query_params[field_key] || params[field]
+          equal_fields[field] = field_value if field_value
+
+          field_key
+        end
+
+        def equal_fields
+          params_filters[FIELD_SUFFIX] ||= {}
+        end
+      end
+    end
+  end
+end

data/lib/restme/scope/filter/types/in_filterable.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Scope
+  module Filter
+    module Types
+      # Defines the behavior of the "in" filter in queries.
+      module InFilterable
+        FIELD_SUFFIX = :in
+
+        private
+
+        def where_in(scope)
+          return scope if in_fields.blank?
+
+          serialize_in_fields
+
+          scope.where(in_sql, in_fields)
+        end
+
+        def in_sql
+          in_fields.keys.map do |param|
+            "#{klass.table_name}.#{param} IN (:#{param})"
+          end.join(" AND ")
+        end
+
+        def serialize_in_fields
+          in_fields.each do |key, value|
+            in_fields[key] = value.split(",")
+          end
+        end
+
+        def add_in_field(field)
+          field_key = :"#{field}_#{FIELD_SUFFIX}"
+          field_value = controller_query_params[field_key]
+          in_fields[field] = field_value if field_value
+
+          field_key
+        end
+
+        def in_fields
+          params_filters[FIELD_SUFFIX] ||= {}
+        end
+      end
+    end
+  end
+end

data/lib/restme/scope/filter/types/less_than_filterable.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Scope
+  module Filter
+    module Types
+      # Defines the behavior of the "less than" filter in queries.
+      module LessThanFilterable
+        FIELD_SUFFIX = :less_than
+
+        private
+
+        def where_less_than(scope)
+          return scope if less_than_fields.blank?
+
+          scope.where(less_than_sql, less_than_fields)
+        end
+
+        def less_than_sql
+          less_than_fields.keys.map do |param|
+            "#{klass.table_name}.#{param} < :#{param}"
+          end.join(" AND ")
+        end
+
+        def add_less_than_field(field)
+          field_key = :"#{field}_#{FIELD_SUFFIX}"
+          field_value = controller_query_params[field_key]
+          less_than_fields[field] = field_value if field_value
+
+          field_key
+        end
+
+        def less_than_fields
+          params_filters[FIELD_SUFFIX] ||= {}
+        end
+      end
+    end
+  end
+end

data/lib/restme/scope/filter/types/less_than_or_equal_to_filterable.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Scope
+  module Filter
+    module Types
+      # Defines the behavior of the "less than or equal to" filter in queries.
+      module LessThanOrEqualToFilterable
+        FIELD_SUFFIX = :less_than_or_equal_to
+
+        private
+
+        def where_less_than_or_equal_to(scope)
+          return scope if less_than_or_equal_to_fields.blank?
+
+          scope.where(less_than_or_equal_to_sql, less_than_or_equal_to_fields)
+        end
+
+        def less_than_or_equal_to_sql
+          less_than_or_equal_to_fields.keys.map do |param|
+            "#{klass.table_name}.#{param} <= :#{param}"
+          end.join(" AND ")
+        end
+
+        def add_less_than_or_equal_to_field(field)
+          field_key = :"#{field}_#{FIELD_SUFFIX}"
+          field_value = controller_query_params[field_key]
+          less_than_or_equal_to_fields[field] = field_value if field_value
+
+          field_key
+        end
+
+        def less_than_or_equal_to_fields
+          params_filters[FIELD_SUFFIX] ||= {}
+        end
+      end
+    end
+  end
+end

data/lib/restme/scope/filter/types/like_filterable.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Scope
+  module Filter
+    module Types
+      # Defines the behavior of "like" filters used for partial matching in queries.
+      module LikeFilterable
+        FIELD_SUFFIX = :like
+
+        private
+
+        def where_like(scope)
+          return scope if like_fields.blank?
+
+          scope.where(like_sql, like_fields)
+        end
+
+        def like_sql
+          like_fields.keys.map do |param|
+            "CAST(#{klass.table_name}.#{param} AS TEXT) ILIKE :#{param}"
+          end.join(" AND ")
+        end
+
+        def add_like_field(field)
+          field_key = :"#{field}_#{FIELD_SUFFIX}"
+          field_value = controller_query_params[field_key].to_s
+
+          field_value = "%#{field_value}%" if field_value.present?
+          like_fields[field] = field_value if field_value.present?
+
+          field_key
+        end
+
+        def like_fields
+          params_filters[FIELD_SUFFIX] ||= {}
+        end
+      end
+    end
+  end
+end