params_ready 0.0.1

data/lib/params_ready/query/predicate.rb

@@ -0,0 +1,203 @@
+require_relative '../extensions/registry'
+require_relative '../parameter/array_parameter'
+require_relative '../parameter/hash_set_parameter'
+require_relative '../helpers/arel_builder'
+
+module ParamsReady
+  module Query
+    class AbstractPredicateBuilder < AbstractBuilder
+      module HavingType
+        def type(type_name, *args, **opts, &block)
+          name, altn = data_object_handles
+          builder = type_builder_instance(type_name, name, *args, altn: altn, **opts)
+          builder.instance_eval(&block) unless block.nil?
+          @definition.set_type builder.fetch
+        end
+
+        def type_builder_instance(type_name, name, *args, altn:, **opts)
+          AbstractPredicateBuilder.type(type_name)
+                                  .instance(name, *args, altn: altn, **opts)
+        end
+      end
+
+      module HavingAttribute
+        def associations(*arr)
+          arr.each do |name|
+            @definition.add_association name
+          end
+        end
+
+        def attribute(name: nil, expression: nil, &block)
+          expression = if expression
+            raise ParamsReadyError, 'Block unexpected' unless block.nil?
+            expression
+          else
+            raise ParamsReadyError, 'Expression unexpected' unless expression.nil?
+            block
+          end
+          @definition.set_attribute(name, expression)
+        end
+      end
+
+      include HavingArelTable
+
+      extend Extensions::Registry
+      registry :types, as: :type, getter: true
+      register_type :value, Parameter::ValueParameterBuilder
+      register_type :array, Parameter::ArrayParameterBuilder
+      register_type :hash_set, Parameter::HashSetParameterBuilder
+    end
+
+    class AbstractPredicateDefinition < Parameter::AbstractDefinition
+      late_init :arel_table, obligatory: false, freeze: false
+
+      module HavingAttribute
+        def self.included(base)
+          base.collection :associations, :association
+        end
+
+        def set_attribute(name, select_expression)
+          @attribute_name = name
+          @select_expression = select_expression
+        end
+
+        def attribute_name
+          @attribute_name || @name
+        end
+
+        def select_expression
+          @select_expression || attribute_name
+        end
+
+        def build_select_expression(arel_table, context)
+          arel_builder = Helpers::ArelBuilder.instance(select_expression, arel_table: @arel_table)
+          arel = arel_builder.to_arel(arel_table, context, self)
+
+          arel
+        end
+
+        def alias_select_expression(arel_table, context)
+          build_select_expression(arel_table, context).as(attribute_name.to_s)
+        end
+      end
+    end
+
+    module Predicate
+      module HavingChildren
+        def context_for_predicates(context)
+          intent_for_children(context)
+        end
+      end
+
+      module HavingAssociations
+        def dig(record, associations)
+          associations.reduce(record) do |record, assoc|
+            next record if record.nil?
+
+            record.send assoc
+          end
+        end
+      end
+
+      module HavingAttribute
+        extend Forwardable
+        def_delegators :definition, :build_select_expression, :alias_select_expression
+        include HavingAssociations
+
+        def to_query(arel_table, context: Restriction.blanket_permission)
+          table = definition.arel_table || arel_table
+          select_expression = build_select_expression(table, context)
+          build_query(select_expression, context: context)
+        end
+
+        def context_for_predicates(context)
+          # We consider a an attribute having parameter atomic
+          # so it's permitted per se including its contents
+          context.permit_all
+        end
+
+        def test(record)
+          return nil unless is_definite?
+
+          attribute_name = definition.attribute_name
+          record = dig(record, definition.associations)
+
+          perform_test(record, attribute_name)
+        end
+      end
+
+      module DelegatingPredicate
+        def self.included(base)
+          base.include Parameter::DelegatingParameter
+        end
+
+        def eligible_for_query?(_table, context)
+          return false unless context.permitted? self
+
+          is_definite?
+        end
+
+        def to_query_if_eligible(arel_table, context:)
+          return unless eligible_for_query?(arel_table, context)
+
+          context = context_for_predicates(context)
+          to_query(arel_table, context: context)
+        end
+        attr_reader :data
+
+      end
+    end
+
+    class PredicateRegistry
+      extend Extensions::Registry
+
+      registry :operator_names, as: :operator_by_name, name_method: :name
+      registry :operator_alt_names, as: :operator_by_alt_name, name_method: :altn
+      registry :predicates, as: :predicate, getter: true
+
+      def self.operator_by(identifier, format)
+        if format.alternative?
+          @@operator_alt_names[identifier]
+        else
+          @@operator_names[identifier]
+        end
+      end
+
+      def self.operator(identifier, format, collision_check = false)
+        operator = find_operator(identifier, format, collision_check)
+        if operator.nil? && !collision_check
+          raise("No such operator: #{identifier}")
+        end
+
+        operator
+      end
+
+      def self.find_operator(identifier, format, collision_check)
+        operator = operator_by(identifier, format)
+        if operator.nil?
+          name_as_string = identifier.to_s
+          invertor = if format.alternative?
+            'n_'
+          else
+            'not_'
+          end
+          if !collision_check && name_as_string.start_with?(invertor)
+            bare_name = name_as_string[invertor.length..-1].to_sym
+            inverted = PredicateRegistry.operator(bare_name, format)
+            if inverted.nil?
+              nil
+            elsif inverted.inverse_of.nil?
+              Not.new(inverted)
+            else
+              operator(inverted.inverse_of, format)
+            end
+          else
+            nil
+          end
+        else
+          operator
+        end
+      end
+    end
+  end
+end

data/lib/params_ready/query/predicate_operator.rb

@@ -0,0 +1,132 @@
+require_relative 'predicate'
+
+module ParamsReady
+  module Query
+    class PredicateOperator
+      def self.dup
+        self
+      end
+
+      def self.define_operator(name, altn, arel: nil, test: nil, inverse_of: nil)
+        define_singleton_method :name do
+          name
+        end
+
+        define_singleton_method :altn do
+          altn
+        end
+
+        if arel
+          define_singleton_method :to_query do |attribute, value|
+            attribute.send(arel, value)
+          end
+        end
+
+        if test
+          define_singleton_method :test do |record, attribute_name, value|
+            attribute = record.send attribute_name
+            attribute.send test, value
+          end
+        end
+
+        define_singleton_method :inverse_of do
+          inverse_of
+        end
+
+        unless PredicateRegistry.operator(self.name, Format.instance(:backend), true).nil?
+          raise ParamsReadyError, "Operator name taken #{self.name}"
+        end
+
+        unless PredicateRegistry.operator(self.altn, Format.instance(:frontend), true).nil?
+          raise ParamsReadyError, "Operator altn taken #{self.name}"
+        end
+
+        PredicateRegistry.register_operator_by_name self
+        PredicateRegistry.register_operator_by_alt_name self
+      end
+
+      def altn
+        self.class.altn
+      end
+    end
+
+    class In < PredicateOperator
+      define_operator :in, :in, arel: :in
+
+      def self.test(record, attribute_name, values)
+        attribute = record.send attribute_name
+        values.include? attribute
+      end
+    end
+
+
+    class ComparisonPredicateOperator < PredicateOperator; end
+
+    class Like < ComparisonPredicateOperator
+      define_operator :like, :lk
+
+      def self.to_query(attribute_name, value)
+        attribute_name.matches("%#{value}%")
+      end
+
+      def self.test(record, attribute_name, value)
+        attribute = record.send attribute_name
+        result = Regexp.new(value, Regexp::IGNORECASE) =~ attribute
+        result.nil? ? false : true
+      end
+    end
+
+    class Equal < ComparisonPredicateOperator
+      define_operator :equal, :eq, arel: :eq, test: :==
+    end
+
+    class NotEqual < ComparisonPredicateOperator
+      define_operator :not_equal, :neq, arel: :not_eq, test: :!=
+    end
+
+    class GreaterThan < ComparisonPredicateOperator
+      define_operator :greater_than, :gt, arel: :gt, test: :>, inverse_of: :less_than_or_equal
+
+      def self.test(record, attribute_name, value)
+        attribute = record.send attribute_name
+        attribute > value
+      end
+    end
+
+    class LessThan < ComparisonPredicateOperator
+      define_operator :less_than, :lt, arel: :lt, test: :<, inverse_of: :greater_than_or_equal
+    end
+
+    class GraterThanOrEqual < ComparisonPredicateOperator
+      define_operator :greater_than_or_equal, :gteq, arel: :gteq, test: :>=, inverse_of: :less_than
+    end
+
+    class LessThanOrEqual < ComparisonPredicateOperator
+      define_operator :less_than_or_equal, :lteq, arel: :lteq, test: :<=, inverse_of: :greater_than
+    end
+
+    class Not
+      def initialize(operator)
+        @operator = operator
+      end
+
+      def name
+        "not_#{@operator.name}"
+      end
+
+      def altn
+        "n#{@operator.altn}"
+      end
+
+      def test(*args)
+        result = @operator.test *args
+        !result
+      end
+
+      def to_query(*args)
+        result = @operator.to_query(*args)
+        result.not
+      end
+    end
+  end
+end

data/lib/params_ready/query/relation.rb

@@ -0,0 +1,337 @@
+require 'forwardable'
+require_relative 'structured_grouping'
+require_relative 'join_clause'
+require_relative '../pagination/offset_pagination'
+require_relative '../pagination/keyset_pagination'
+require_relative '../pagination/direction'
+require_relative '../ordering/ordering'
+
+module ParamsReady
+  module Query
+    class Relation < StructuredGrouping
+      module PageAccessors
+        def page_accessor(name, delegate = nil)
+          delegate ||= "#{name}_page"
+
+          define_method name do |*args|
+            send(delegate, *args)&.for_frontend
+          end
+          ruby2_keywords name
+        end
+
+        def self.extended(mod)
+          mod.page_accessor :current
+          mod.page_accessor :first
+          mod.page_accessor :last
+          mod.page_accessor :previous
+          mod.page_accessor :next
+          mod.page_accessor :before
+          mod.page_accessor :after
+          mod.page_accessor :limit_at, :limited_at
+          mod.page_accessor :toggle, :toggled_order
+          mod.page_accessor :reorder, :reordered
+        end
+      end
+
+      extend PageAccessors
+      extend Forwardable
+
+      def_delegators :pagination, :offset, :limit, :num_pages, :page_no, :has_previous?, :has_next?, :has_page?
+
+      def child_is_definite?(name)
+        return false unless definition.has_child?(name)
+        return false if self[name].nil?
+        return false unless self[name].is_definite?
+
+        true
+      end
+
+      def pagination
+        self[:pagination]
+      end
+
+      def ordering
+        self[:ordering]
+      end
+
+      def ordering_or_nil
+        return unless child_is_definite?(:ordering)
+
+        self[:ordering]
+      end
+
+      def new_offset(delta)
+        pagination.new_offset(delta)
+      end
+
+      def page(delta, count: nil)
+        return nil unless pagination.can_yield_page?(delta, count: count)
+        return self if delta == 0
+
+        new_offset = pagination.new_offset(delta)
+
+        update_in(new_offset, [:pagination, 0])
+      end
+
+      def current_page(count: nil)
+        page(0, count: count)
+      end
+
+      def first_page
+        value = pagination.first_page_value
+        update_in(value, [:pagination])
+      end
+
+      def last_page(count:)
+        value = pagination.last_page_value(count: count)
+        return if value.nil?
+        update_in(value, [:pagination])
+      end
+
+      def previous_page(delta = 1)
+        value = pagination.previous_page_value(delta)
+        return if value.nil?
+        update_in(value, [:pagination])
+      end
+
+      def next_page(delta = 1, count: nil)
+        value = pagination.next_page_value(delta, count: count)
+        return if value.nil?
+        page(delta, count: count)
+      end
+
+      def before_page(keyset)
+        tuple = { direction: :bfr, limit: limit, keyset: keyset }
+        update_in(tuple, [:pagination])
+      end
+
+      def after_page(keyset)
+        tuple = { direction: :aft, limit: limit, keyset: keyset }
+        update_in(tuple, [:pagination])
+      end
+
+      def limited_at(limit)
+        update_in(limit, [:pagination, pagination.limit_key])
+      end
+
+      def toggled_order(column)
+        new_order = ordering.toggled_order_value(column)
+        toggled = update_in(new_order, [:ordering])
+        toggled.update_in(0, [:pagination, 0])
+      end
+
+      def reordered(column, direction)
+        new_order = ordering.reordered_value(column, direction)
+        reordered = update_in(new_order, [:ordering])
+        reordered.update_in(0, [:pagination, 0])
+      end
+
+      def model_class(default_model_class)
+        default_model_class || definition.model_class
+      end
+
+      def arel_table(default_model_class)
+        model_class(default_model_class).arel_table
+      end
+
+      def perform_count(scope: nil, context: Restriction.blanket_permission)
+        scope ||= definition.model_class if definition.model_class_defined?
+        group = predicate_group(scope.arel_table, context: context)
+        relation = scope.where(group)
+        relation = perform_joins(relation, context)
+        relation.count
+      end
+
+      def keysets(limit, direction, keyset, scope: nil, context: Restriction.blanket_permission, &block)
+        model_class = scope || definition.model_class
+        group = predicate_group(model_class.arel_table, context: context)
+        relation = model_class.where(group)
+        relation = perform_joins(relation, context)
+
+        sql_literal = pagination.keysets_for_relation(relation, limit, direction, keyset, ordering, context, &block)
+
+        array = model_class.connection.execute(sql_literal.to_s).to_a
+        Pagination::Direction.instance(direction).keysets(keyset, array, &block)
+      end
+
+      def build_relation(scope: nil, include: [], context: Restriction.blanket_permission, paginate: true)
+        model_class = scope || definition.model_class
+        group = predicate_group(model_class.arel_table, context: context)
+        relation = model_class.where(group)
+        relation = relation.includes(*include) unless include.empty?
+        relation = perform_joins(relation, context)
+
+        order_and_paginate_relation(relation, context, paginate)
+      end
+
+      def perform_joins(relation, context)
+        return relation if definition.joins.empty?
+
+        sql = joined_tables(relation.arel_table, context).join_sources.map(&:to_sql).join(' ')
+        relation.joins(sql)
+      end
+
+      def to_count(model_class: nil, context: Restriction.blanket_permission)
+        model_class = model_class || definition.model_class
+
+        arel_table = joined_tables(model_class.arel_table, context)
+
+        group = self.predicate_group(model_class.arel_table, context: context)
+
+        query = if group.nil?
+          arel_table
+        else
+          arel_table.where(group)
+        end
+        query.project(arel_table[:id].count)
+      end
+
+      def build_select(model_class: nil, context: Restriction.blanket_permission, select_list: Arel.star, paginate: true)
+        arel_table, query = build_query(model_class, context)
+        query = order_and_paginate_query(query, arel_table, context, paginate)
+        query.project(select_list)
+      end
+
+      def build_keyset_query(limit, direction, keyset, model_class: nil, context: Restriction.blanket_permission)
+        arel_table, query = build_query(model_class, context)
+        pagination.select_keysets(query, limit, direction, keyset, ordering, arel_table, context)
+      end
+
+      def build_query(model_class, context)
+        arel_table = arel_table(model_class)
+
+        group = self.predicate_group(arel_table, context: context)
+        joined = joined_tables(arel_table, context)
+
+        query = if group.nil?
+          joined
+        else
+          joined.where(group)
+        end
+
+        [arel_table, query]
+      end
+
+      def order_if_applicable(arel_table, context)
+        if child_is_definite?(:ordering) && (context.permitted?(ordering) || ordering.required?)
+          ordering = self.ordering.to_arel(arel_table, context: context)
+          yield ordering if ordering.length > 0
+        end
+      end
+
+      def paginate_if_applicable(paginate)
+        if paginate && child_is_definite?(:pagination)
+          pagination = self.pagination
+          yield pagination
+        end
+      end
+
+      def order_and_paginate_relation(relation, context, paginate)
+        paginate_if_applicable(paginate) do |pagination|
+          relation = pagination.paginate_relation(relation, ordering_or_nil, context)
+        end
+
+        order_if_applicable(relation.arel_table, context) do |ordering|
+          relation = relation.order(ordering)
+        end
+        relation
+      end
+
+      def order_and_paginate_query(query, arel_table, context, paginate)
+        paginate_if_applicable(paginate) do |pagination|
+          query = pagination.paginate_query(query, ordering_or_nil, arel_table, context)
+        end
+
+        order_if_applicable(arel_table, context) do |ordering|
+          query = query.order(*ordering)
+        end
+        query
+      end
+
+      def joined_tables(proper_table, context)
+        definition.joins.reduce(proper_table) do |table, join|
+          join.to_arel(table, context, self)
+        end
+      end
+    end
+
+    class RelationParameterBuilder < Builder
+      include GroupingLike
+      include Parameter::AbstractHashParameterBuilder::HashLike
+      include HavingModel
+
+      def self.instance(name, altn: nil)
+        new RelationDefinition.new(name, altn: altn)
+      end
+
+      register :relation
+      DEFAULT_LIMIT = 10
+
+      def paginate(limit = DEFAULT_LIMIT, max_limit = nil, method: :offset, &block)
+        case method
+        when :offset
+          raise ParamsReadyError, 'Block not expected' unless block.nil?
+          add Pagination::OffsetPaginationDefinition.new(0, limit, max_limit).finish
+        when :keyset
+          ordering_builder = @definition.init_ordering_builder(empty: true)
+          rcpb = Pagination::KeysetPaginationBuilder.new ordering_builder, limit, max_limit
+          add rcpb.build(&block)
+        else
+          raise "Unimplemented pagination method '#{method}'"
+        end
+      end
+
+      def order(&proc)
+        ordering_builder = @definition.init_ordering_builder(empty: false)
+        ordering_builder.instance_eval(&proc) unless proc.nil?
+        ordering = ordering_builder.build
+        add ordering
+      end
+
+      def join_table(arel_table, type, &block)
+        join = Join.new arel_table, type, &block
+        join.freeze
+        @definition.add_join(join)
+      end
+    end
+
+    class RelationDefinition < StructuredGroupingDefinition
+      late_init :model_class, obligatory: false, freeze: false, getter: false
+      collection :joins, :join
+
+      def model_class
+        raise ParamsReadyError, "Model class not set for #{name}" if @model_class.nil?
+        @model_class
+      end
+
+      def init_ordering_builder(empty:)
+        raise ParamsReadyError, 'Ordering already defined' if empty == true && !@ordering_builder.nil?
+        @ordering_builder ||= Ordering::OrderingParameterBuilder.instance
+      end
+
+      def arel_table
+        model_class.arel_table
+      end
+
+      def model_class_defined?
+        !@model_class.nil?
+      end
+
+      attr_reader :joins
+
+      def initialize(*args, **opts)
+        @joins = []
+        @ordering_builder = nil
+        super
+      end
+
+      def finish
+        raise ParamsReadyError, 'Ordering must be explicitly declared' if @ordering_builder&.open?
+        @ordering_builder = nil
+        super
+      end
+
+      parameter_class Relation
+    end
+  end
+end