params_ready_rails5 0.0.7

data/lib/params_ready/pagination/keyset_pagination.rb

@@ -0,0 +1,254 @@
+require_relative '../parameter/struct_parameter'
+require_relative '../value/constraint'
+require_relative '../helpers/arel_builder'
+require_relative 'abstract_pagination'
+require_relative 'direction'
+
+module ParamsReady
+  module Pagination
+    class KeysetPagination < Parameter::StructParameter
+      include AbstractPagination
+
+      def select_keysets(query, limit, direction, keyset, ordering, arel_table, context)
+        query = keyset_query(query, limit, direction, keyset, ordering, arel_table, context)
+        query.project(*cursor_columns_arel(ordering, arel_table, context))
+      end
+
+      def keyset_query(query, limit, direction, keyset, ordering, arel_table, context)
+        cursor, grouping = cursor_predicates(direction, keyset, ordering, arel_table, context)
+        cte = cursor.cte_for_query(query, arel_table) unless cursor.nil?
+        query = query.where(grouping) unless grouping.nil?
+
+        query = query.with(cte) unless cte.nil?
+        ordered = query.order(ordering_arel(direction, ordering, arel_table, context))
+        ordered.take(limit)
+      end
+
+      def keysets_for_relation(relation, limit, direction, keyset, ordering, context)
+        arel_table = relation.arel_table
+
+        cursor, predicates = cursor_predicates(direction, keyset, ordering, arel_table, context)
+        full_query = relation.where(predicates)
+                             .reorder(ordering_arel(direction, ordering, arel_table, context))
+                             .limit(limit)
+                             .select(*cursor_columns_arel(ordering, arel_table, context))
+        full_query = Arel::Nodes::SqlLiteral.new(full_query.to_sql)
+        with_cte(relation, full_query, cursor)
+      end
+
+      def paginate_relation(relation, ordering, context)
+        arel_table = relation.arel_table
+        cursor, predicates = cursor_predicates(direction, keyset, ordering, arel_table, context)
+
+        subselect = relation.where(predicates)
+                            .reorder(ordering_arel(direction, ordering, arel_table, context))
+                            .limit(limit)
+                            .select(primary_keys_arel(ordering, arel_table, context))
+
+        subselect_sql = Arel::Nodes::SqlLiteral.new(subselect.to_sql)
+        subselect_sql = with_cte_grouped(relation, subselect_sql, cursor)
+
+        exists = exists_predicate(subselect_sql, ordering, arel_table)
+        relation.where(exists)
+      end
+
+      def paginate_query(query, ordering, arel_table, context)
+        cursor, predicates = cursor_predicates(direction, keyset, ordering, arel_table, context)
+        cte = cursor.cte_for_query(query, arel_table) unless cursor.nil?
+        subquery = query.deep_dup
+        subquery = subquery.where(predicates) unless predicates.nil?
+        subquery = subquery.with(cte) unless cte.nil?
+
+        subselect = subquery.order(ordering_arel(direction, ordering, arel_table, context))
+          .take(limit)
+          .project(primary_keys_arel(ordering, arel_table, context))
+
+        exists = exists_predicate(subselect, ordering, arel_table)
+        query.where(exists)
+      end
+
+      def exists_predicate(subselect, ordering, arel_table)
+        table_alias = self.table_alias(arel_table)
+        aliased = arel_table.alias(table_alias)
+        select_manager = Arel::SelectManager.new.from(subselect.as(table_alias))
+        related = related_clause(arel_table, aliased, ordering.definition.primary_keys)
+        select_manager.where(related).project('1').exists
+      end
+
+      def related_clause(arel_table, aliased, primary_keys)
+        cursor_columns.reduce(nil) do |clause, name|
+          next clause unless primary_keys.member?(name)
+
+          predicate = arel_table[name].eq(aliased[name])
+          next predicate if clause.nil?
+
+          next clause.and(predicate)
+        end
+      end
+
+      def with_cte_grouped(relation, select, cursor)
+        with_cte = with_cte(relation, select, cursor)
+        Arel::Nodes::Grouping.new(with_cte)
+      end
+
+      def with_cte(relation, select, cursor)
+        return select if cursor.nil?
+
+        cte = cursor.cte_for_relation(relation)
+        return select if cte.nil?
+
+        Arel::Nodes::SqlLiteral.new([cte.to_sql, select].join(' '))
+      end
+
+      def table_alias(arel_table)
+        Helpers::ArelBuilder.safe_name "#{arel_table.name}_#{cursor_columns.join('_')}"
+      end
+
+      def ordering_arel(direction, ordering, arel_table, context)
+        inverted = Direction.instance(direction).invert_ordering?
+        ordering.to_arel(arel_table, context: context, inverted: inverted)
+      end
+
+      def cursor_predicates(direction, keyset, ordering, arel_table, context)
+        direction = Direction.instance(direction)
+        direction.cursor_predicates(keyset, ordering, arel_table, context)
+      end
+
+      def first_page_value
+        { limit: limit, direction: :aft, keyset: {} }
+      end
+
+      def last_page_value
+        { limit: limit, direction: :bfr, keyset: {} }
+      end
+
+      def before_page_value(keyset)
+        keyset ||= {}
+        { limit: limit, direction: :bfr, keyset: keyset }
+      end
+
+      def after_page_value(keyset)
+        keyset ||= {}
+        { limit: limit, direction: :aft, keyset: keyset }
+      end
+
+      def limit
+        self[:limit].unwrap
+      end
+
+      def limit_key
+        :limit
+      end
+
+      def direction
+        self[:direction].unwrap
+      end
+
+      def keyset
+        self[:keyset].unwrap
+      end
+
+      def cursor_columns
+        self[:keyset].names.keys
+      end
+
+      def cursor_columns_arel(ordering, arel_table, context, columns: cursor_columns)
+        columns.map do |name|
+          column = ordering.definition.columns[name]
+          column.attribute(name, arel_table, context)
+        end
+      end
+
+      def primary_keys_arel(ordering, arel_table, context)
+        columns = cursor_columns.lazy.select do |name|
+          ordering.definition.primary_keys.member? name
+        end
+
+        cursor_columns_arel(ordering, arel_table, context, columns: columns).force
+      end
+
+      def cursor
+        return nil unless is_definite?
+
+        keyset = self[:keyset]
+        keyset.names.keys.map do |column_name|
+          keyset[column_name].unwrap
+        end
+      end
+    end
+
+    class KeysetPaginationDefinition < Parameter::StructParameterDefinition
+      MIN_LIMIT = 1
+
+      parameter_class KeysetPagination
+
+      attr_reader :default_limit
+
+      def initialize(default_limit, max_limit = nil)
+        super :pagination,
+              altn: :pgn
+
+        @default_limit = default_limit
+
+        direction = Builder.define_symbol(:direction, altn: :dir) do
+          constrain :enum, [:bfr, :aft]
+        end
+
+        limit = Builder.define_integer(:limit, altn: :lmt) do
+          constrain Value::OperatorConstraint.new(:>=, MIN_LIMIT), strategy: :clamp
+          constrain Value::OperatorConstraint.new(:<=, max_limit), strategy: :clamp unless max_limit.nil?
+        end
+        add_child(direction)
+        add_child(limit)
+      end
+
+      def finish
+        keyset = names[:keyset]
+        raise ParamsReadyError, "No cursor defined" if keyset.nil? || keyset.names.length < 1
+        super
+      end
+    end
+
+    class KeysetPaginationBuilder
+      def initialize(ordering_builder, default_limit, max_limit = nil)
+        definition = KeysetPaginationDefinition.new(default_limit, max_limit)
+        @cursor_builder = Parameter::StructParameterBuilder.send :new, definition
+        @default = {
+          limit: default_limit,
+          direction: :aft,
+          keyset: {}
+        }
+        @ordering_builder = ordering_builder
+        @keyset = Parameter::StructParameterBuilder.instance(:keyset, altn: :ks)
+      end
+
+      def key(type, name, direction, &block)
+        add_to_cursor(type, name, &block)
+        @ordering_builder.column name, direction, required: true, pk: true
+      end
+
+      def column(type, name, direction, **opts, &block)
+        add_to_cursor(type, name, &block)
+        @ordering_builder.column name, direction, **opts
+      end
+
+      def base64
+        @cursor_builder.marshal using: :base64
+      end
+
+      def add_to_cursor(type, name, &block)
+        @keyset.add type, name do
+          optional
+          include(&block) unless block.nil?
+        end
+      end
+
+      def build(&block)
+        instance_eval(&block)
+        @cursor_builder.add @keyset.build
+        @cursor_builder.default @default
+        @cursor_builder.build
+      end
+    end
+  end
+end

data/lib/params_ready/pagination/keysets.rb

@@ -0,0 +1,70 @@
+module ParamsReady
+  module Pagination
+    class AbstractKeysets
+      attr_reader :keysets
+
+      def initialize(keysets, &block)
+        @keysets = keysets
+        @transform = block
+      end
+
+      def length
+        @keysets.length
+      end
+
+      def transform(raw)
+        return raw if @transform.nil?
+        @transform.call(raw)
+      end
+    end
+
+    class BeforeKeysets < AbstractKeysets
+      def page(delta, limit)
+        raise "Expected positive integer for limit, got: #{limit}" if limit < 1
+        raise "Expected non-negative integer for delta, got: #{delta}" if delta < 0
+
+        if delta == 0
+          transform(@keysets.first)
+        else
+          shift = delta * limit
+          diff = @keysets.length - shift
+          if diff > 0
+            transform(@keysets[shift])
+          elsif diff.abs < limit
+            {}
+          else
+            nil
+          end
+        end
+      end
+    end
+
+    class AfterKeysets < AbstractKeysets
+      attr_reader :last
+
+      def initialize(last, keysets, &block)
+        @last = last
+        super keysets, &block
+      end
+
+      def page(delta, limit)
+        raise "Expected positive integer for limit, got: #{limit}" if limit < 1
+        raise "Expected positive integer for delta, got: #{delta}" if delta < 1
+        return if @keysets.length.zero?
+
+        shift = (delta - 1) * limit
+
+        if shift == 0
+          @last
+        else
+          diff = @keysets.length - shift
+          if diff < 1
+            nil
+          else
+            transform(@keysets[shift - 1])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/params_ready/pagination/nulls.rb

@@ -0,0 +1,31 @@
+require_relative '../error'
+require_relative 'tendency'
+
+module ParamsReady
+  module Pagination
+    module Nulls
+      module First
+        def self.if_null_predicate(column, nested)
+          is_null_and_all = column.eq(nil).and(nested)
+          grouping = Arel::Nodes::Grouping.new(is_null_and_all)
+          is_not_null = column.not_eq(nil)
+          grouping.or(is_not_null)
+        end
+
+        def self.if_not_null_predicate(tendency, column, value, nested)
+          tendency.non_nullable_predicate(column, value, nested)
+        end
+      end
+
+      module Last
+        def self.if_null_predicate(column, nested)
+          Arel::Nodes::Grouping.new(column.eq(nil).and(nested))
+        end
+
+        def self.if_not_null_predicate(tendency, column, value, nested)
+          tendency.non_nullable_predicate(column, value, nested).or(column.eq(nil))
+        end
+      end
+    end
+  end
+end

data/lib/params_ready/pagination/offset_pagination.rb

@@ -0,0 +1,130 @@
+require_relative '../parameter/tuple_parameter'
+require_relative '../value/validator'
+require_relative 'abstract_pagination'
+
+module ParamsReady
+  module Pagination
+    class OffsetPagination < Parameter::TupleParameter
+      include AbstractPagination
+
+      def paginate_relation(relation, _, _)
+        relation.offset(offset).limit(limit)
+      end
+
+      def paginate_query(query, _, _, _)
+        query.skip(offset).take(limit)
+      end
+
+      def offset=(off)
+        self.first.set_value off
+      end
+
+      def offset
+        first.unwrap
+      end
+
+      def limit=(lmt)
+        self.second.set_value lmt
+      end
+
+      def limit
+        second.unwrap
+      end
+
+      def limit_key
+        1
+      end
+
+      def page_no
+        ((offset + limit - 1) / limit) + 1
+      end
+
+      def page_value(delta, count: nil)
+        return nil unless can_yield_page?(delta, count: count)
+
+        [new_offset(delta), limit]
+      end
+
+      def current_page_value
+        page_value(0)
+      end
+
+      def previous_page_value(delta = 1)
+        page_value(-delta)
+      end
+
+      def next_page_value(delta = 1, count: nil)
+        page_value(delta, count: count)
+      end
+
+      def first_page_value
+        [0, limit]
+      end
+
+      def last_page_value(count:)
+        num_pages = num_pages(count: count)
+        return nil if num_pages == 0
+
+        new_offset = (num_pages - 1) * limit
+        [new_offset, limit]
+      end
+
+      def new_offset(delta)
+        shift = delta * limit
+        no = offset + shift
+        return no if no >= 0
+        return 0 if shift.abs < offset + limit
+
+        nil
+      end
+
+      def has_previous?(delta = 1)
+        raise ParamsReadyError, 'Negative delta unexpected' if delta < 0
+        return false if offset == 0
+
+        delta * limit < offset + limit
+      end
+
+      def has_next?(delta = 1, count:)
+        raise ParamsReadyError, 'Nil count unexpected' if count.nil?
+        raise ParamsReadyError, 'Negative delta unexpected' if delta < 0
+
+        offset + (delta * limit) < count
+      end
+
+      def has_page?(delta, count: nil)
+        if delta > 0
+          has_next? delta, count: count
+        else
+          has_previous? -delta
+        end
+      end
+
+      def can_yield_page?(delta, count: nil)
+        return true if delta >= 0 && count.nil?
+
+        has_page?(delta, count: count)
+      end
+    end
+
+    class OffsetPaginationDefinition < Parameter::TupleParameterDefinition
+      MIN_LIMIT = 1
+      parameter_class OffsetPagination
+
+      def initialize(default_offset, default_limit, max_limit = nil)
+        offset = Builder.define_integer(:offset, altn: :off) do
+          constrain Value::OperatorConstraint.new(:>=, 0), strategy: :clamp
+        end
+        limit = Builder.define_integer(:limit, altn: :lmt) do
+          constrain Value::OperatorConstraint.new(:>=, MIN_LIMIT), strategy: :clamp
+          constrain Value::OperatorConstraint.new(:<=, max_limit), strategy: :clamp unless max_limit.nil?
+        end
+        super :pagination,
+              altn: :pgn,
+              marshaller: { using: :string, separator: '-' },
+              fields: [offset, limit],
+              default: [default_offset, default_limit]
+      end
+    end
+  end
+end

data/lib/params_ready/pagination/tendency.rb

@@ -0,0 +1,28 @@
+module ParamsReady
+  module Pagination
+    module Tendency
+      def non_nullable_predicate(column, value, nested)
+        if_equal = column.eq(value).and(nested)
+        grouping = Arel::Nodes::Grouping.new(if_equal)
+        comparison = comparison_predicate(column, value)
+        grouping.or(comparison)
+      end
+
+      module Growing
+        extend Tendency
+
+        def self.comparison_predicate(column, value)
+          column.gt(value)
+        end
+      end
+
+      module Falling
+        extend Tendency
+
+        def self.comparison_predicate(column, value)
+          column.lt(value)
+        end
+      end
+    end
+  end
+end