rhino_project_core 0.20.0.beta.18

data/lib/rhino/resource/routing.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Rhino
+  module Resource
+    module Routing
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :_route_key, default: nil
+        class_attribute :_route_path, default: nil
+        class_attribute :_route_singular, default: false
+
+        class_attribute :_rhino_routes, default: nil
+        class_attribute :_rhino_routes_except, default: []
+
+        class_attribute :controller_name, default: 'rhino/crud'
+
+        delegate :routes, to: :class
+      end
+
+      # rubocop:disable Style/RedundantSelf, Metrics/BlockLength
+      class_methods do
+        def route_key
+          self._route_key ||= if route_singular?
+            name.demodulize.underscore
+          else
+            name.demodulize.underscore.pluralize
+          end
+        end
+
+        def route_path
+          self._route_path ||= route_key
+        end
+
+        def route_singular?
+          self._route_singular
+        end
+
+        def route_path_frontend
+          route_path.camelize(:lower)
+        end
+
+        def route_frontend
+          "/#{route_path_frontend}"
+        end
+
+        def route_api
+          "/#{Rhino.namespace}/#{route_path}"
+        end
+
+        def routes
+          unless self._rhino_routes
+            if global_owner? # rubocop:disable Style/ConditionalAssignment
+              self._rhino_routes = %i[index show]
+            else
+              self._rhino_routes = %i[index create show update destroy]
+            end
+          end
+          self._rhino_routes - self._rhino_routes_except
+        end
+
+        def rhino_routing(**options)
+          self._route_key = options.delete(:key) if options.key?(:key)
+          self._route_path = options.delete(:path) if options.key?(:path)
+          self._route_singular = options.delete(:singular) if options.key?(:singular)
+
+          self._rhino_routes = options.delete(:only) if options.key?(:only)
+          self._rhino_routes_except = options.delete(:except) if options.key?(:except)
+        end
+
+        def rhino_controller(controller)
+          self.controller_name = "rhino/#{controller}"
+        end
+      end
+      # rubocop:enable Style/RedundantSelf, Metrics/BlockLength
+    end
+
+    def route_frontend # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      base_owner_pk = "#{Rhino.base_owner.table_name}.#{Rhino.base_owner.primary_key}"
+
+      joins = joins_for_base_owner
+      base_owner_id = if joins.empty?
+        # if this is Model is the base owner, we don't to include it in frontend url
+        nil
+      else
+        base_owner_ids = self.class.joins(joins).where(id:).pluck(base_owner_pk)
+        if base_owner_ids.length == 1
+          base_owner_ids.first
+        else
+          # if this Model doesn't have a clear single path to the base owner Model,
+          # we shouldn't include it in the frontend url
+          nil
+        end
+      end
+
+      if base_owner_id.nil?
+        "#{self.class.route_frontend}/#{id}"
+      else
+        "/#{base_owner_id}#{self.class.route_frontend}/#{id}"
+      end
+    end
+
+    def route_api
+      "#{self.class.route_api}/#{id}"
+    end
+  end
+end

data/lib/rhino/resource/serialization.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Rhino
+  module Resource
+    module Serialization
+      extend ActiveSupport::Concern
+
+      def to_caching_json
+        raise NotImplementedError, '#to_caching_json is not implemented'
+      end
+    end
+  end
+end

data/lib/rhino/resource/sieves.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Rhino
+  module Resource
+    module Sieves
+      extend ActiveSupport::Concern
+      include ArelHelpers::ArelTable
+
+      included do
+        class_attribute :_sieves
+        class_attribute :_built_sieves
+
+        delegate :sieves, to: :class
+      end
+
+      # rubocop:disable Style/RedundantSelf
+      class_methods do
+        def rhino_sieves
+          self._sieves = Rhino.sieves.dup unless self._sieves
+          self._sieves
+        end
+
+        def sieves
+          self._built_sieves = rhino_sieves.build(self) unless self._built_sieves
+
+          self._built_sieves
+        end
+
+        def resolve(scope, _params)
+          scope
+        end
+      end
+      # rubocop:enable Style/RedundantSelf
+    end
+  end
+end

data/lib/rhino/resource.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative 'resource/owner'
+require_relative 'resource/properties'
+require_relative 'resource/reference'
+require_relative 'resource/describe'
+require_relative 'resource/routing'
+require_relative 'resource/params'
+require_relative 'resource/serialization'
+require_relative 'resource/sieves'
+
+require_relative '../../app/policies/rhino/crud_policy'
+
+module Rhino
+  module Resource
+    extend ActiveSupport::Concern
+
+    include Rhino::Resource::Owner
+    include Rhino::Resource::Properties
+    include Rhino::Resource::Reference
+    include Rhino::Resource::Describe
+    include Rhino::Resource::Routing
+    include Rhino::Resource::Params
+    include Rhino::Resource::Serialization
+    include Rhino::Resource::Sieves
+
+    included do
+      class_attribute :_policy_class, default: Rhino::CrudPolicy
+
+      def owner
+        send self.class.resource_owned_by
+      end
+
+      def display_name
+        return name if respond_to? :name
+        return title if respond_to? :title
+
+        nil
+      end
+    end
+
+    class_methods do
+      def policy_class
+        _policy_class
+      end
+
+      def rhino_policy(policy)
+        self._policy_class = "rhino/#{policy}_policy".classify.safe_constantize || "#{policy}_policy".classify.safe_constantize
+
+        raise "Policy #{policy} not found for #{name}" unless _policy_class
+      end
+    end
+  end
+end

data/lib/rhino/sieve/filter.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module Rhino
+  module Sieve
+    class Filter # rubocop:disable Metrics/ClassLength
+      def initialize(app)
+        @app = app
+      end
+
+      # filter[blog_id]=1
+      def resolve(scope, params)
+        return @app.resolve(scope, params) unless params.key?(:filter)
+
+        filter = params[:filter].permit!.to_h
+        scope = scope.joins(get_joins(scope.klass, filter))
+        query = apply_filters(scope, scope.klass, filter).distinct(:id)
+        @app.resolve(query, params)
+      end
+
+      private
+      def get_joins_hash(base, filter)
+        res = []
+        filter.each do |key, val|
+          value_is_hash = val.is_a? Hash
+          # only consider a key for the join clause if it is a relationship a.k.a reflection
+          key_is_reflection = base.reflections.key? key
+
+          next unless value_is_hash && key_is_reflection
+
+          # in the next recursion, the associations will have to be checked against this current key, not the initial model
+          reflection_model = base.reflections[key.to_s].klass
+          res << { key => get_joins_hash(reflection_model, val) }
+        end
+        res
+      end
+
+      def get_joins(base, filter)
+        joins_hash = get_joins_hash(base, filter)
+        result = []
+        joins_hash.each do |entry|
+          entry.each do |key, value|
+            result << ArelHelpers.join_association(base, { key => value }, Arel::Nodes::OuterJoin, {})
+          end
+        end
+        result
+      end
+
+      def apply_filters(scope, base, filter)
+        filter.each do |key, val|
+          key = Sieve::Helpers.real_column_name(scope, key)
+          key_is_reflection = base.reflections.key? key
+          key_is_attribute = base.attribute_names.include? key
+          key_is_association_operator = ASSOCIATION_OPS.include? key
+          if key_is_association_operator
+            scope = apply_association_operator(base, scope, key, val)
+          elsif key_is_reflection || key_is_attribute
+            scope = apply_filter(scope, base, key, val)
+          end
+        end
+        scope
+      end
+
+      def apply_filter(scope, base, key, val)
+        reflection = base.reflections[key.to_s]
+        value_is_hash = val.is_a? Hash
+        if value_is_hash && reflection
+          # joined table filter, continue recursion, e.g. ?filter[blog][...]
+          association_base = reflection.klass
+          apply_filters(scope, association_base, val)
+        elsif reflection
+          # direct association id filter, e.g. ?filter[blog]=1
+          apply_association_filter(base, scope, key, val)
+        else
+          # column filter, e.g. ?filter[name]=...
+          apply_column_filter(base, scope, key, val)
+        end
+      end
+
+      def apply_association_filter(base, scope, key, value)
+        scope.where(base.arel_table[base.reflections[key].foreign_key].eq(value))
+      end
+
+      ASSOCIATION_OPS = %w[_is_empty].freeze
+      def apply_association_operator(base, scope, key, value)
+        if key == '_is_empty' && truthy?(value)
+          arel_node = base.arel_table['id']
+
+          where_clause = arel_node.eq(nil)
+          scope.where(where_clause)
+        else
+          scope
+        end
+      end
+
+      def apply_column_filter(base, scope, column_name, column_value)
+        if column_value.is_a?(Hash)
+          # it is a more complex query, possibly using operators like gt, lt, etc.
+          # more than one operator per-field is allowed
+          column_value.each do |operation, value|
+            scope = merge_where_clause(base, scope, column_name, value, operation)
+          end
+        else
+          scope = merge_where_clause(base, scope, column_name, column_value)
+        end
+        scope
+      end
+
+      BASIC_AREL_OPS = %w[eq gt lt gteq lteq].freeze
+      BASIC_AREL_COALESCE_OPS = BASIC_AREL_OPS.map { |op| "#{op}_coalesce" }.freeze
+      def merge_where_clause(base, scope, column_name, value, operation = nil) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        arel_node = base.arel_table[column_name]
+        where_clause = case operation
+                       when *BASIC_AREL_OPS then arel_node.send(operation, value)
+                       when *BASIC_AREL_COALESCE_OPS
+                         coalesce = Arel::Nodes::NamedFunction.new('COALESCE', [arel_node, Arel::Nodes.build_quoted(value)])
+                         coalesce.send(operation.split('_').first, value)
+                       when 'diff' then arel_node.not_eq(value)
+                       when 'is_null' then apply_is_null(arel_node, value)
+                       when /^tree_(.*)/ then apply_tree(Regexp.last_match(1), base, column_name, arel_node, value)
+                       else
+                         if value.is_a? Array
+                           arel_node.in(value)
+                         else
+                           arel_node.eq(value)
+                         end
+        end
+        scope.where(where_clause)
+      end
+
+      def apply_is_null(arel_node, value)
+        if ActiveModel::Type::Boolean::FALSE_VALUES.include?(value)
+          arel_node.not_eq(nil)
+        else
+          arel_node.eq(nil)
+        end
+      end
+
+      def apply_tree(operation, base, column_name, arel_node, value)
+        subquery = base.where(column_name => value).map(&operation.to_sym).flatten.map(&column_name.to_sym)
+
+        arel_node.in(subquery)
+      end
+
+      def truthy?(value)
+        value.present? && ActiveModel::Type::Boolean::FALSE_VALUES.exclude?(value)
+      end
+    end
+  end
+end

data/lib/rhino/sieve/helpers.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Rhino
+  module Sieve
+    class Helpers
+      def self.real_column_name(scope, column_name)
+        scope.attribute_aliases[column_name] || column_name
+      end
+    end
+  end
+end

data/lib/rhino/sieve/limit.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Rhino
+  module Sieve
+    class Limit
+      attr_accessor :default_limit
+
+      def initialize(app, default_limit: 20)
+        @app = app
+
+        @default_limit = default_limit
+      end
+
+      # limit=20
+      def resolve(scope, params)
+        @app.resolve(scope.limit(params[:limit] || default_limit), params)
+      end
+    end
+  end
+end

data/lib/rhino/sieve/offset.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Rhino
+  module Sieve
+    class Offset
+      def initialize(app)
+        @app = app
+      end
+
+      # offset=20
+      def resolve(scope, params)
+        @app.resolve(scope.offset(params[:offset]), params)
+      end
+    end
+  end
+end

data/lib/rhino/sieve/order.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module Rhino
+  module Sieve
+    class Order
+      def initialize(app)
+        @app = app
+      end
+
+      # order=name
+      def resolve(scope, params)
+        @scope = scope
+        @param = params[:order]
+
+        # Always append id to the end of the order clause to ensure a stable sort for pagination
+        result = apply_order.order(:id)
+        @app.resolve(result, params)
+      end
+
+      private
+      def parse(param)
+        direction = parse_direction(param)
+        column_name = parse_column_name(param, direction)
+        [direction, column_name]
+      end
+
+      def parse_direction(param)
+        if param[0] == '-'
+          :desc
+        else
+          :asc
+        end
+      end
+
+      def parse_column_name(param, direction)
+        param = if direction == :asc
+                  param
+        else
+                  param[1..]
+        end
+        Sieve::Helpers.real_column_name(@scope, param)
+      end
+
+      def string?(param)
+        param.is_a? String
+      end
+
+      def get_joins(base, path, _last_base)
+        return {} if path.empty?
+
+        # Convert to nested hash
+        join_tables = path.reverse.inject({}) { |assigned_value, key| { key => assigned_value } }
+
+        # If InnerJoin was used instead of OuterJoin, a simple ORDER clause targeting an association's column
+        # would incur in a join being made, which in turn would exclude records with no association. This would
+        # be conceptually wrong, as an ORDER clause would be excluding records from the final result. In order to
+        # restore the previous behavior and exclude these records without parent, one could simply add a WHERE
+        # clause with something like `WHERE association.id IS NOT NULL`.
+        ArelHelpers.join_association(base, join_tables, Arel::Nodes::OuterJoin, {})
+      rescue StandardError
+        nil
+      end
+
+      def build_select_clause(model, path, field)
+        return model.arel_table[Arel.star] if path.empty?
+
+        model.arel_table[field]
+      end
+
+      def split_field_path(column_name)
+        chunks = column_name.split('.')
+        field = chunks.last
+        path = chunks.slice(0, chunks.length - 1)
+        [path, field]
+      end
+
+      def analyze(column_name)
+        path, field = split_field_path(column_name)
+
+        last_base = if path.last.blank?
+            @scope
+        else
+            path.last.classify.safe_constantize
+        end
+        return nil unless last_base&.attribute_names&.include? field
+
+        join_clauses = get_joins(@scope.klass, path, last_base)
+        select_clause = build_select_clause(last_base, path, field)
+
+        [join_clauses, last_base.arel_table[field], select_clause]
+      end
+
+      NULL_ORDERING = {
+        asc: :nulls_last,
+        desc: :nulls_first
+      }.freeze
+      def order(direction, column_name)
+        # nulls_last should generally be the desired user experience
+        join_clauses, order_clause, select_clause = analyze(column_name)
+        return nil unless join_clauses && order_clause
+
+        final_clause = order_clause
+                       .send(direction)
+                       .send(NULL_ORDERING[direction])
+        [join_clauses, final_clause, select_clause]
+      end
+
+      def build_clause(param)
+        return nil unless string?(param)
+
+        direction, column_name = parse(param)
+        order(direction, column_name)
+      end
+
+      def group_clauses(clauses)
+        join_clauses = clauses.map { |joins, _node, _select| joins }
+        order_clauses = clauses.map { |_joins, node, _select| node }
+        select_clauses = clauses.map { |_joins, _node, select| select }
+        [order_clauses, join_clauses, select_clauses]
+      end
+
+      def build_clauses
+        clauses = @param.split(',')
+                        .map { |el| build_clause(el) }
+                        .filter { |joins, node, select| joins && node && select }
+        group_clauses(clauses)
+      end
+
+      def apply_order
+        return @scope unless string?(@param)
+
+        order_clauses, join_clauses, select_clauses = build_clauses
+        if order_clauses.empty?
+          @scope
+        else
+          select_clauses << "#{@scope.klass.table_name}.*"
+          @scope = @scope.reorder(nil).select(select_clauses.uniq).joins(join_clauses)
+          order_clauses.inject(@scope) { |acc, el| acc.order(el) }
+        end
+      end
+    end
+  end
+end

data/lib/rhino/sieve/search.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Rhino
+  module Sieve
+    class Search
+      def initialize(app)
+        @app = app
+      end
+
+      # search='test'
+      def resolve(scope, params)
+        return @app.resolve(scope, params) unless scope.respond_to?(:search_text_fields) && params[:search].present?
+
+        # Re-order so that rank isn't the default
+        # FIXME: Should look at the order param for 'rank'
+        @app.resolve(scope.search_text_fields(params[:search]).reorder(''), params)
+      end
+    end
+  end
+end