restme 0.0.37

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Restme
+  module Scope
+    module Paginate
+      # Defines pagination rules
+      module Rules
+        DEFAULT_PER_PAGE = ENV.fetch("PAGINATION_DEFAULT_PER_PAGE", 12)
+        DEFAULT_PAGE = ENV.fetch("PAGINATION_DEFAULT_PAGE", 1)
+        MAX_PER_PAGE = ENV.fetch("PAGINATION_MAX_PER_PAGE", 100)
+
+        def paginable_scope(user_scope)
+          per_page_error
+
+          user_scope.limit(per_page).offset(paginate_offset)
+        end
+
+        def page_no
+          params[:page]&.to_i || DEFAULT_PAGE
+        end
+
+        def pages(user_scope)
+          (total_items(user_scope) / per_page.to_f).ceil
+        end
+
+        def total_items(user_scope)
+          @total_items ||= user_scope.size
+        end
+
+        def per_page
+          params[:per_page]&.to_i || DEFAULT_PER_PAGE
+        end
+
+        def paginate_offset
+          (page_no - 1) * per_page
+        end
+
+        def per_page_error
+          return if per_page <= MAX_PER_PAGE
+
+          restme_scope_errors(
+            {
+              message: "Invalid per page value",
+              body: { per_page_max_value: MAX_PER_PAGE }
+            }
+          )
+
+          restme_scope_status(:bad_request)
+        end
+      end
+    end
+  end
+end

data/lib/restme/scope/rules.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require_relative "../shared/user_role"
+require_relative "../shared/current_model"
+require_relative "../shared/controller_params"
+require_relative "filter/rules"
+require_relative "sort/rules"
+require_relative "paginate/rules"
+require_relative "field/rules"
+
+module Restme
+  module Scope
+    # Defines the user scope when viewing records.
+    # It can apply pagination, field selection, sorting, and filtering.
+    # Returns records based on the user's contextual rules.
+    module Rules
+      include ::Restme::Scope::Field::Rules
+      include ::Restme::Scope::Paginate::Rules
+      include ::Restme::Scope::Sort::Rules
+      include ::Restme::Scope::Filter::Rules
+      include ::Restme::Shared::ControllerParams
+      include ::Restme::Shared::CurrentModel
+      include ::Restme::Shared::UserRole
+
+      attr_reader :filtered_scope, :sorted_scope, :paginated_scope, :fieldated_scope
+      attr_accessor :restme_scope_errors, :restme_scope_status
+
+      def pagination_response
+        @pagination_response ||= restme_response
+      end
+
+      def model_scope_object
+        @model_scope_object ||= model_scope.first
+      end
+
+      private
+
+      def restme_response
+        model_scope
+
+        restme_scope_errors.presence || {
+          objects: model_scope,
+          pagination: pagination
+        }
+      end
+
+      def model_scope
+        @model_scope ||= without_item_in_scope? ? user_scope : custom_scope
+      end
+
+      def pagination
+        {
+          page: page_no,
+          pages: pages(model_scope),
+          total_items: total_items(model_scope)
+        }
+      end
+
+      def restme_scope_errors(error = nil)
+        @restme_scope_errors ||= error
+      end
+
+      def restme_scope_status(status = :ok)
+        @restme_scope_status ||= status
+      end
+
+      def without_item_in_scope?
+        !user_scope.exists?
+      end
+
+      def custom_scope
+        @filtered_scope = filterable_scope(user_scope)
+        @sorted_scope = sortable_scope(filtered_scope)
+        @paginated_scope = paginable_scope(sorted_scope)
+        @fieldated_scope = fieldable_scope(paginated_scope)
+      end
+
+      def user_scope
+        @user_scope ||= super_admin_scope || scope_rules_class.try(method_scope) || none_scope
+      end
+
+      def super_admin_scope
+        klass.all if restme_current_user&.super_admin? || restme_current_user.blank?
+      end
+
+      def none_scope
+        klass.none
+      end
+
+      def method_scope
+        "#{user_role}_scope"
+      end
+
+      def scope_rules_class
+        "#{controller_class.to_s.split("::").last}::Scope::Rules"
+          .constantize.new(klass, restme_current_user, params)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Restme
+  module Scope
+    module Sort
+      # Defines the rules used to sort the records.
+      module Rules
+        ID = :id
+        SORT_KEY = "sort"
+        SORTABLE_TYPES = %w[asc desc].freeze
+
+        def sortable_scope(user_scope)
+          return user_scope unless sortable_scope?
+          return user_scope if unknown_sortable_fields_errors
+
+          user_scope.order(serialize_sort_params)
+        end
+
+        def sortable_scope?
+          request.get? && controller_params_sortable_fields.present?
+        end
+
+        def serialize_sort_params
+          @serialize_sort_params ||= controller_params_sortable_fields.map do |key, value|
+            key = key.to_s.gsub("_#{SORT_KEY}", "")
+
+            value = "asc" unless SORTABLE_TYPES.include?(value&.downcase)
+
+            { "#{key}": value&.downcase }
+          end
+        end
+
+        def controller_params_sortable_fields
+          @controller_params_sortable_fields ||= controller_query_params.select do |item|
+            item.to_s.end_with?(SORT_KEY)
+          end
+        end
+
+        def unknown_sortable_fields
+          @unknown_sortable_fields ||=
+            serialize_sort_params.map { |sort_param| sort_param.first.first } - sortable_fields
+        end
+
+        def unknown_sortable_fields_errors
+          return unless unknown_sortable_fields.present?
+
+          restme_scope_errors(
+            {
+              message: "Unknown Sort",
+              body: unknown_sortable_fields
+            }
+          )
+
+          restme_scope_status(:bad_request)
+
+          true
+        end
+
+        def sortable_fields
+          @sortable_fields ||= Array.new(klass::SORTABLE_FIELDS).push(ID)
+        rescue StandardError
+          [ID]
+        end
+      end
+    end
+  end
+end

data/lib/restme/shared/controller_params.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Restme
+  module Shared
+    # Returns both the query string parameters and the request body parameters received by the controller.
+    module ControllerParams
+      def controller_params
+        params_filtered.permit!.to_h.values.first.deep_symbolize_keys
+      rescue StandardError
+        params_filtered.permit!.to_h.deep_symbolize_keys
+      end
+
+      def controller_query_params
+        @controller_query_params ||= request.query_parameters.deep_symbolize_keys
+      end
+
+      private
+
+      def params_filtered
+        params.except(:controller, :action)
+      end
+    end
+  end
+end

data/lib/restme/shared/current_model.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Restme
+  module Shared
+    # Returns the model associated with the controller.
+    # It tries to determine the model dynamically or uses the MODEL_NAME constant if defined in the controller.
+    module CurrentModel
+      def klass
+        return defined_model_name if defined_model_name
+
+        controller_class.to_s.split("::").last.remove("sController").constantize
+      end
+
+      private
+
+      def defined_model_name
+        return unless controller_class.const_defined?(:MODEL_NAME)
+
+        controller_class::MODEL_NAME.constantize
+      end
+
+      def controller_class
+        self.class
+      end
+    end
+  end
+end

data/lib/restme/shared/user_role.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Restme
+  module Shared
+    # Returns the roles associated with the user, if any exist.
+    module UserRole
+      def user_role
+        restme_current_user&.role
+      end
+    end
+  end
+end

data/lib/restme/update/rules.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require_relative "../shared/user_role"
+require_relative "../shared/current_model"
+require_relative "../shared/controller_params"
+
+module Restme
+  module Update
+    # Defines update restrictions rules for a record.
+    module Rules
+      include ::Restme::Shared::ControllerParams
+      include ::Restme::Shared::CurrentModel
+      include ::Restme::Shared::UserRole
+
+      attr_reader :update_temp_record
+
+      private
+
+      def updateable_record
+        @updateable_record ||= begin
+          @update_temp_record = klass.find_by(id: params[:id])
+
+          set_update_temp_record_current_user
+
+          update_temp_record.assign_attributes(controller_params)
+
+          update_record_errors.presence || update_temp_record
+        end
+      end
+
+      def set_update_temp_record_current_user
+        return unless update_temp_record.respond_to?(:current_user)
+        return unless restme_current_user
+
+        update_temp_record.current_user = restme_current_user
+      end
+
+      def restme_update_status
+        return :unprocessable_entity if update_record_errors
+
+        :ok
+      end
+
+      def update_record_errors
+        return unless updateable_current_action
+
+        return updateable_not_found_error if update_temp_record.blank?
+        return updateable_unscoped_error_response unless updateable_scope?
+
+        update_object! unless @update_result
+
+        updateable_record_errors_messages
+      end
+
+      def update_object!
+        @update_result ||= ActiveRecord::Base.transaction do
+          update_temp_record.save!
+        end
+      rescue StandardError
+        nil
+      end
+
+      def updateable_not_found_error
+        {
+          message: "Not found object to id: #{params[:id]}",
+          body: controller_params
+        }
+      end
+
+      def updateable_unscoped_error_response
+        { message: "Unscoped", body: controller_params }
+      end
+
+      def updateable_scope?
+        return true unless restme_current_user
+
+        method_scope = "#{updateable_current_action}_#{user_role}_scope?"
+
+        updateable_super_admin_scope? || update_rules_class.try(method_scope) || false
+      end
+
+      def updateable_super_admin_scope?
+        restme_current_user&.super_admin?
+      end
+
+      def updateable_record_errors_messages
+        return if update_temp_record.errors.blank?
+
+        "#{current_action}_error_scope?".constantize
+      rescue StandardError
+        updateable_default_error_response
+      end
+
+      def updateable_current_action
+        return true unless restme_current_user
+
+        current_action.presence_in update_rules_class.class::UPDATABLE_ACTIONS_RULES
+      rescue StandardError
+        nil
+      end
+
+      def updateable_default_error_response
+        { message: "Error #{update_temp_record.errors.full_messages.to_sentence}" }
+      end
+
+      def current_action
+        action_name.to_sym
+      end
+
+      def update_rules_class
+        @update_rules_class ||= "#{controller_class.to_s.split("::").last}::Update::Rules"
+                                .constantize.new(update_temp_record, restme_current_user, controller_params)
+      end
+    end
+  end
+end

data/lib/restme/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Restme
+  VERSION = "0.0.37"
+end

data/lib/restme.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative "restme/version"
+require_relative "restme/restme"
+
+module Restme
+  class Error < StandardError; end
+  # Your code goes here...
+end

data/sig/restme.rbs

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

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: restme
+version: !ruby/object:Gem::Version
+  version: 0.0.37
+platform: ruby
+authors:
+- everson-ever
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Add filter/pagination/fields select/sort support to your API controllers
+email:
+- eversonsilva9799@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- Dockerfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- docker-compose.yml
+- lib/restme.rb
+- lib/restme/authorize/rules.rb
+- lib/restme/create/rules.rb
+- lib/restme/restme.rb
+- lib/restme/scope/field/attachable.rb
+- lib/restme/scope/field/rules.rb
+- lib/restme/scope/filter/rules.rb
+- lib/restme/scope/filter/types/bigger_than_filterable.rb
+- lib/restme/scope/filter/types/bigger_than_or_equal_to_filterable.rb
+- lib/restme/scope/filter/types/equal_filterable.rb
+- lib/restme/scope/filter/types/in_filterable.rb
+- lib/restme/scope/filter/types/less_than_filterable.rb
+- lib/restme/scope/filter/types/less_than_or_equal_to_filterable.rb
+- lib/restme/scope/filter/types/like_filterable.rb
+- lib/restme/scope/paginate/rules.rb
+- lib/restme/scope/rules.rb
+- lib/restme/scope/sort/rules.rb
+- lib/restme/shared/controller_params.rb
+- lib/restme/shared/current_model.rb
+- lib/restme/shared/user_role.rb
+- lib/restme/update/rules.rb
+- lib/restme/version.rb
+- sig/restme.rbs
+homepage: https://github.com/everson-ever/restme
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/everson-ever/restme
+  source_code_uri: https://github.com/everson-ever/restme
+  changelog_uri: https://github.com/everson-ever/restme/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: Rest API support
+test_files: []