params_ready_rails5 0.0.7

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(base_table, context)
+        definition.joins.reduce(base_table) do |joined_table, join|
+          join.to_arel(joined_table, base_table, context, self)
+        end
+      end
+    end
+
+    class RelationParameterBuilder < Builder
+      include GroupingLike
+      include Parameter::AbstractStructParameterBuilder::StructLike
+      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

data/lib/params_ready/query/structured_grouping.rb

@@ -0,0 +1,58 @@
+require_relative '../parameter/struct_parameter'
+require_relative '../parameter/value_parameter'
+require_relative 'fixed_operator_predicate'
+require_relative 'nullness_predicate'
+require_relative 'grouping'
+
+module ParamsReady
+  module Query
+    class StructuredGrouping < Parameter::StructParameter
+      include Parameter::GroupingLike
+      def predicates
+        return [] if is_nil?
+
+        definition.predicates.keys.map do |name|
+          parameter = child(name)
+          next nil unless parameter.is_definite?
+          parameter
+        end.compact
+      end
+
+      def operator
+        self[:operator].unwrap
+      end
+
+      def context_for_predicates(restriction)
+        intent_for_children(restriction)
+      end
+    end
+
+    class StructuredGroupingBuilder < Builder
+      include GroupingLike
+      include Parameter::AbstractStructParameterBuilder::StructLike
+      PredicateRegistry.register_predicate :structured_grouping_predicate, self
+
+      def self.instance(name, altn: nil)
+        new StructuredGroupingDefinition.new(name, altn: altn)
+      end
+    end
+
+    class StructuredGroupingDefinition < Parameter::StructParameterDefinition
+      attr_reader :arel_table, :predicates
+
+      def initialize(*args, **opts)
+        @predicates = {}
+        super *args, **opts
+      end
+
+      def add_predicate(predicate)
+        raise ParamsReadyError, "Predicate name taken: '#{predicate.name}" if predicates.key? predicate.name
+        predicates[predicate.name] = predicate
+      end
+
+      parameter_class StructuredGrouping
+
+      freeze_variables :predicates
+    end
+  end
+end

data/lib/params_ready/query/variable_operator_predicate.rb

@@ -0,0 +1,125 @@
+require_relative 'predicate'
+require_relative '../parameter/struct_parameter'
+require_relative '../parameter/value_parameter'
+require_relative '../value/validator'
+require_relative 'predicate_operator'
+
+module ParamsReady
+  module Query
+    class VariableOperatorPredicate < Parameter::AbstractParameter
+      include Predicate::DelegatingPredicate
+      include Predicate::HavingAttribute
+
+      def initialize(definition)
+        super definition
+        @data = definition.struct_parameter.create
+      end
+
+      def build_query(select_expression, context: nil)
+        operator.to_query(select_expression, value)
+      end
+
+      def perform_test(record, attribute_name)
+        operator.test(record, attribute_name, value)
+      end
+
+      def value
+        @data[:value].unwrap
+      end
+
+      def operator
+        @data[:operator].unwrap
+      end
+
+      def inspect_content
+        op, val = if is_definite?
+          @data[:operator].unwrap_or(nil)&.name || '?'
+          @data[:value].unwrap_or('?')
+        else
+          %w[? ?]
+        end
+        "#{definition.attribute_name} #{op} #{val}"
+      end
+    end
+
+    class OperatorCoder < Value::Coder
+      def self.coerce(value, context)
+        return value if value.class == Class && value < PredicateOperator
+        identifier = value.to_sym
+        PredicateRegistry.operator(identifier, context)
+      end
+
+      def self.format(value, intent)
+        intent.hash_key(value)
+      end
+
+      def self.strict_default?
+        false
+      end
+    end
+
+    Parameter::ValueParameterBuilder.register_coder :predicate_operator, OperatorCoder
+
+    class VariableOperatorPredicateBuilder < AbstractPredicateBuilder
+      PredicateRegistry.register_predicate :variable_operator_predicate, self
+      include HavingType
+      include HavingAttribute
+      include DelegatingBuilder[:struct_parameter_builder]
+
+      def self.instance(name, altn: nil, attr: nil)
+        new VariableOperatorPredicateDefinition.new name, altn: altn, attribute_name: attr
+      end
+
+      def data_object_handles
+        [:value, :val]
+      end
+
+      def operators(*arr, &block)
+        @definition.set_operators(arr, &block)
+      end
+    end
+
+    class VariableOperatorPredicateDefinition < AbstractPredicateDefinition
+      include HavingAttribute
+
+      attr_reader :struct_parameter_builder
+      attr_reader :struct_parameter
+
+      def initialize(*args, attribute_name: nil, **opts)
+        super *args, **opts
+        @attribute_name = attribute_name
+        @struct_parameter_builder = Builder.builder(:struct).instance(name, altn: altn)
+        @operator_parameter_builder = Builder.builder(:predicate_operator).instance(:operator, altn: :op)
+      end
+
+      def set_type(type)
+        @type = type
+        @struct_parameter_builder.add @type.finish
+      end
+
+      def set_operators(array, &block)
+        context = Format.instance(:backend)
+
+        operators = array.map do |name|
+          PredicateRegistry.operator(name, context)
+        end
+        @operator_parameter_builder.include do
+          constrain :enum, operators
+        end
+        @operator_parameter_builder.include(&block) unless block.nil?
+        @struct_parameter_builder.add @operator_parameter_builder.build
+      end
+
+      def finish
+        @struct_parameter = @struct_parameter_builder.build
+        @struct_parameter_builder = nil
+        @operator_parameter_builder = nil
+        @type = nil
+
+        super
+      end
+
+      parameter_class VariableOperatorPredicate
+    end
+  end
+end

data/lib/params_ready/query_context.rb

@@ -0,0 +1,21 @@
+require 'forwardable'
+require_relative 'restriction'
+
+module ParamsReady
+  class QueryContext
+    include Restriction::Wrapper
+    extend Forwardable
+    attr_reader :data
+    def_delegator :data, :[]
+
+    def initialize(restriction, data = {})
+      @data = data.freeze
+      raise ParamsReadyError, "Restriction expected, got: #{restriction.inspect}" unless restriction.is_a? Restriction
+      @restriction = restriction.freeze
+    end
+
+    def clone(restriction:)
+      QueryContext.new restriction, data
+    end
+  end
+end