praxis 2.0.pre.5 → 2.0.pre.6

data/lib/praxis/extensions/attribute_filtering/active_record_patches.rb

@@ -0,0 +1,15 @@
+require 'active_record'
+
+maj, min, _ = ActiveRecord.gem_version.segments
+
+if maj == 5
+  require_relative 'active_record_patches/5x.rb'
+elsif maj == 6
+  if min == 0
+    require_relative 'active_record_patches/6_0.rb'
+  else
+    require_relative 'active_record_patches/6_1_plus.rb'
+  end
+else
+  raise "Filtering only supported for ActiveRecord >= 5 && <= 6"  
+end

data/lib/praxis/extensions/attribute_filtering/active_record_patches/5x.rb

@@ -0,0 +1,90 @@
+require 'active_record'
+
+module ActiveRecord
+  PRAXIS_JOIN_ALIAS_PREFIX = Praxis::Extensions::AttributeFiltering::ALIAS_TABLE_PREFIX
+  class Relation
+    def construct_join_dependency
+      including = eager_load_values + includes_values
+       # Praxis: inject references into the join dependency
+      ActiveRecord::Associations::JoinDependency.new(
+        klass, table, including, references: references_values
+      )
+    end
+
+    def build_join_query(manager, buckets, join_type, aliases)
+      buckets.default = []
+
+      association_joins = buckets[:association_join]
+      stashed_joins     = buckets[:stashed_join]
+      join_nodes        = buckets[:join_node].uniq
+      string_joins      = buckets[:string_join].map(&:strip).uniq
+
+      join_list = join_nodes + convert_join_strings_to_ast(string_joins)
+      alias_tracker = alias_tracker(join_list, aliases)
+
+      # Praxis: inject references into the join dependency
+      join_dependency = ActiveRecord::Associations::JoinDependency.new(
+        klass, table, association_joins, references: references_values
+      )
+
+      joins = join_dependency.join_constraints(stashed_joins, join_type, alias_tracker)
+      joins.each { |join| manager.from(join) }
+
+      manager.join_sources.concat(join_list)
+
+      alias_tracker.aliases
+    end
+
+  end
+  module Associations
+    class JoinDependency
+      attr_accessor :references
+      private
+      def initialize(base, table, associations, references: )
+        tree = self.class.make_tree associations
+        @references = references # Save the references values into the instance (to use during build)
+        @join_root = JoinBase.new(base, table, build(tree, base))
+      end
+      
+      # Praxis: table aliases for is shared for 5x and 6.0
+      def table_aliases_for(parent, node)
+        node.reflection.chain.map do |reflection|
+          is_root_reflection = reflection == node.reflection
+          table = alias_tracker.aliased_table_for(
+            reflection.table_name,
+            table_alias_for(reflection, parent, !is_root_reflection),
+            reflection.klass.type_caster
+          )
+          # through tables do not need a special alias_path alias (as they shouldn't really referenced by the client)
+          if is_root_reflection && node.alias_path
+            table = table.left if table.is_a?(Arel::Nodes::TableAlias) #un-alias it if necessary
+            table = table.alias(node.alias_path.join('/')) 
+          end
+          table
+        end
+      end
+
+      # Praxis: build for is shared for 5x and 6.0
+      def build(associations, base_klass, path: [PRAXIS_JOIN_ALIAS_PREFIX])
+        associations.map do |name, right|
+          reflection = find_reflection base_klass, name
+          reflection.check_validity!
+          reflection.check_eager_loadable!
+
+          if reflection.polymorphic?
+            raise EagerLoadPolymorphicError.new(reflection)
+          end
+          # Praxis: set an alias_path in the JoinAssociation if its path matches a requested reference
+          child_path = (path && !path.empty?) ? path + [name] : nil
+          association = JoinAssociation.new(reflection, build(right, reflection.klass, path: child_path))
+          association.alias_path = child_path if references.include?(child_path.join('/'))
+          association            
+        end
+      end
+
+    end
+    class ActiveRecord::Associations::JoinDependency::JoinAssociation
+      attr_accessor :alias_path
+    end
+  end
+end

data/lib/praxis/extensions/attribute_filtering/active_record_patches/6_0.rb

@@ -0,0 +1,68 @@
+# FOR AR < 6.1
+module ActiveRecord
+  PRAXIS_JOIN_ALIAS_PREFIX = Praxis::Extensions::AttributeFiltering::ALIAS_TABLE_PREFIX
+  class Relation
+    def construct_join_dependency(associations, join_type) # :nodoc:
+      # Praxis: inject references into the join dependency
+      ActiveRecord::Associations::JoinDependency.new(
+        klass, table, associations, join_type, references: references_values
+      )
+    end
+  end
+
+  module Associations
+    class JoinDependency
+      attr_accessor :references
+
+      private
+      def initialize(base, table, associations, join_type, references: nil)
+        tree = self.class.make_tree associations
+        @references = references # Save the references values into the instance (to use during build)
+        built = build(tree, base)
+
+        @join_root = JoinBase.new(base, table, built)
+        @join_type = join_type
+      end
+
+      # Praxis: table aliases for is shared for 5x and 6.0
+      def table_aliases_for(parent, node)
+        node.reflection.chain.map do |reflection|
+          is_root_reflection = reflection == node.reflection
+          table = alias_tracker.aliased_table_for(
+            reflection.table_name,
+            table_alias_for(reflection, parent, !is_root_reflection),
+            reflection.klass.type_caster
+          )
+          # through tables do not need a special alias_path alias (as they shouldn't really referenced by the client)
+          if is_root_reflection && node.alias_path
+            table = table.left if table.is_a?(Arel::Nodes::TableAlias) #un-alias it if necessary
+            table = table.alias(node.alias_path.join('/')) 
+          end
+          table
+        end
+      end
+
+      # Praxis: build for is shared for 5x and 6.0
+      def build(associations, base_klass, path: [PRAXIS_JOIN_ALIAS_PREFIX])
+        associations.map do |name, right|
+          reflection = find_reflection base_klass, name
+          reflection.check_validity!
+          reflection.check_eager_loadable!
+
+          if reflection.polymorphic?
+            raise EagerLoadPolymorphicError.new(reflection)
+          end
+          # Praxis: set an alias_path in the JoinAssociation if its path matches a requested reference
+          child_path = (path && !path.empty?) ? path + [name] : nil
+          association = JoinAssociation.new(reflection, build(right, reflection.klass, path: child_path))
+          association.alias_path = child_path if references.include?(child_path.join('/'))
+          association            
+        end
+      end
+
+    end
+    class ActiveRecord::Associations::JoinDependency::JoinAssociation
+      attr_accessor :alias_path
+    end
+  end
+end

data/lib/praxis/extensions/attribute_filtering/active_record_patches/6_1_plus.rb

@@ -0,0 +1,58 @@
+# FOR AR >= 6.1
+module ActiveRecord
+  PRAXIS_JOIN_ALIAS_PREFIX = Praxis::Extensions::AttributeFiltering::ALIAS_TABLE_PREFIX
+  module Associations
+    class JoinDependency
+
+      private
+      def make_constraints(parent, child, join_type)
+        foreign_table = parent.table
+        foreign_klass = parent.base_klass
+        child.join_constraints(foreign_table, foreign_klass, join_type, alias_tracker) do |reflection|
+          table, terminated = @joined_tables[reflection]
+          root = reflection == child.reflection
+
+          if table && (!root || !terminated)
+            @joined_tables[reflection] = [table, root] if root
+            next table, true
+          end
+
+          table_name = @references[reflection.name.to_sym]
+          # Praxis: set an alias_path in the JoinAssociation if its path matches a requested reference
+          table_name = @references[child&.alias_path.join('/').to_sym] unless table_name
+
+          table = alias_tracker.aliased_table_for(reflection.klass.arel_table, table_name) do
+            name = reflection.alias_candidate(parent.table_name)
+            root ? name : "#{name}_join"
+          end
+
+          @joined_tables[reflection] ||= [table, root] if join_type == Arel::Nodes::OuterJoin
+          table
+        end.concat child.children.flat_map { |c| make_constraints(child, c, join_type) }
+      end
+
+      # Praxis: build for is shared for 5x and 6.0
+      def build(associations, base_klass, path: [PRAXIS_JOIN_ALIAS_PREFIX])
+        associations.map do |name, right|
+          reflection = find_reflection base_klass, name
+          reflection.check_validity!
+          reflection.check_eager_loadable!
+
+          if reflection.polymorphic?
+            raise EagerLoadPolymorphicError.new(reflection)
+          end
+          # Praxis: set an alias_path in the JoinAssociation if its path matches a requested reference
+          child_path = (path && !path.empty?) ? path + [name] : nil
+          association = JoinAssociation.new(reflection, build(right, reflection.klass, path: child_path))
+          #association.alias_path = child_path if references.include?(child_path.join('/'))
+          association.alias_path = child_path # ??? should be the line above no?
+          association            
+        end
+      end      
+    end
+    
+    class ActiveRecord::Associations::JoinDependency::JoinAssociation
+      attr_accessor :alias_path
+    end
+  end
+end

data/lib/praxis/extensions/attribute_filtering/filter_tree_node.rb

@@ -0,0 +1,35 @@
+module Praxis
+  module Extensions
+    module AttributeFiltering
+      class FilterTreeNode
+        attr_reader :path, :conditions, :children
+        #   # parsed_filters is an Array of {name: X, op: , value: } ... exactly the format of the FilteringParams.load method
+        def initialize(parsed_filters, path: [])
+          @path = path # Array that marks the tree 'path' to this node (with respect to the absolute root)
+          @conditions = [] # Conditions to apply directly to this node
+          @children = {} # Hash with a new NodeTree object value, keyed by name
+          children_data = {} # Hash with keys as names of the first level component of the children nodes (and values as array of matching filters)
+          parsed_filters.map do |hash|
+            *components = hash[:name].to_s.split('.')
+            if components.empty?
+              return
+            elsif components.size == 1
+              @conditions << hash.slice(:name, :op, :value)
+            else
+              children_data[components.first] ||= []
+              children_data[components.first] << hash
+            end
+          end
+          # An array of FilterTreeNodes corresponding to each children
+          @children = children_data.each_with_object({}) do |(name, arr), hash|
+            sub_filters = arr.map do |item|
+              _parent, *rest = item[:name].to_s.split('.')
+              item.merge(name: rest.join('.'))
+            end
+            hash[name] = self.class.new(sub_filters, path: path + [name] )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/praxis/extensions/attribute_filtering/filtering_params.rb

@@ -26,7 +26,6 @@ module Praxis
         include Attributor::Type
         include Attributor::Dumpable
   
-        # This DSL allows to define which attributes are allowed in the filters, and with which operators
         class DSLCompiler < Attributor::DSLCompiler
           # "account.id": { operators: ["=", "!="] },
           # name:         { operators: ["=", "!="], fuzzy_match: true },
@@ -38,8 +37,8 @@ module Praxis
         end
   
         VALUE_REGEX = /[^,&]*/
-        AVAILABLE_OPERATORS = Set.new(['!=', '>=', '<=', '=', '<', '>']).freeze
-        FILTER_REGEX = /(?<attribute>([^=!><])+)(?<operator>!=|>=|<=|=|<|>)(?<value>#{VALUE_REGEX}(,#{VALUE_REGEX})*)/
+        AVAILABLE_OPERATORS = Set.new(['!=', '>=', '<=', '=', '<', '>','!','!!']).freeze
+        FILTER_REGEX = /(?<attribute>([^=!><])+)(?<operator>!=|>=|<=|!!|=|<|>|!)(?<value>#{VALUE_REGEX}(,#{VALUE_REGEX})*)/
   
         # Abstract class, which needs to be used by subclassing it through the .for method, to set the allowed filters
         # definition should be a hash, keyed by field name, which contains a hash that can have two pieces of metadata
@@ -180,7 +179,7 @@ module Praxis
             else
               value
             end
-            arr.push(name: attr_name, specs: { op: match[:operator], value: coerced } )
+            arr.push(name: attr_name, op: match[:operator], value: coerced )
           end
           new(parsed)
         end
@@ -208,28 +207,27 @@ module Praxis
         def validate(_context = Attributor::DEFAULT_ROOT_CONTEXT)
           parsed_array.each_with_object([]) do |item, errors|
             attr_name = item[:name]
-            specs = item[:specs]
             attr_filters = allowed_filters[attr_name]
             unless attr_filters
               errors << "Filtering by #{attr_name} is not allowed. You can filter by #{allowed_filters.keys.map(&:to_s).join(', ')}"
               next
             end
             allowed_operators = attr_filters[:operators]
-            unless allowed_operators.include?(specs[:op])
-              errors << "Operator #{specs[:op]} not allowed for filter #{attr_name}"
+            unless allowed_operators.include?(item[:op])
+              errors << "Operator #{item[:op]} not allowed for filter #{attr_name}"
             end
             value_type = attr_filters[:value_type]
-            value = specs[:value]
+            value = item[:value]
             if value_type && !value_type.valid_type?(value)
               # Allow a collection of values of the right type for multimatch (if operators are = or !=)
-              if ['=','!='].include?(specs[:op])
+              if ['=','!='].include?(item[:op])
                 coll_type = Attributor::Collection.of(value_type)
                 if !coll_type.valid_type?(value)
                   errors << "Invalid type in filter/s value for #{attr_name} " +\
                             "(one or more of the multiple matches in #{value} are not  a #{value_type.name.split('::').last})"
                 end
               else
-                errors << "Invalid type in filter value for #{attr_name} (#{value} using '#{specs[:op]}' is not a #{value_type.name.split('::').last})"
+                errors << "Invalid type in filter value for #{attr_name} (#{value} using '#{item[:op]}' is not a #{value_type.name.split('::').last})"
               end
             end
   
@@ -247,8 +245,7 @@ module Praxis
         def dump
           parsed_array.each_with_object([]) do |item, arr|
             field = item[:name]
-            spec = item[:specs]
-            arr << "#{field}#{spec[:op]}#{spec[:value]}"
+            arr << "#{field}#{item[:op]}#{item[:value]}"
           end.join('&')
         end
   

data/lib/praxis/extensions/attribute_filtering/sequel_filter_query_builder.rb

@@ -34,7 +34,8 @@ module Praxis
 
       # By default we'll simply use the incoming op and value, and will map
       # the attribute based on what's on the `attr_to_column` hash
-      def build_clause(filters)
+      def generate(filters)
+        raise "Not refactored yet!"
         seen_associations = Set.new
         filters.each do |(attr, spec)|
           column_name = attr_to_column[attr]
@@ -68,7 +69,7 @@ module Praxis
         self.class.attr_to_column
       end
 
-      # Private to try to funnel all column names through `build_clause` that restricts
+      # Private to try to funnel all column names through `generate` that restricts
       # the attribute names better (to allow more difficult SQL injections )
       private def add_clause(attr:, op:, value:)
         # TODO: partial matching

data/lib/praxis/extensions/field_selection/active_record_query_selector.rb

@@ -5,19 +5,20 @@ module Praxis
       class ActiveRecordQuerySelector
         attr_reader :selector, :query
         # Gets a dataset, a selector...and should return a dataset with the selector definition applied.
-        def initialize(query:, selectors:)
+        def initialize(query:, selectors:, debug: false)
           @selector = selectors
           @query = query
+          @logger = debug ? Logger.new(STDOUT) : nil
         end
 
-        def generate(debug: false)
+        def generate
           # TODO: unfortunately, I think we can only control the select clauses for the top model 
           # (as I'm not sure ActiveRecord supports expressing it in the join...)
           @query = add_select(query: query, selector_node: selector)
           eager_hash = _eager(selector)
 
           @query = @query.includes(eager_hash)          
-          explain_query(query, eager_hash) if debug
+          explain_query(query, eager_hash) if @logger
 
           @query
         end
@@ -37,13 +38,10 @@ module Praxis
         end
 
         def explain_query(query, eager_hash)
-          prev = ActiveRecord::Base.logger
-          ActiveRecord::Base.logger = Logger.new(STDOUT)
-          ActiveRecord::Base.logger.debug("Query plan for ...#{selector.resource.model} with selectors: #{JSON.generate(selector.dump)}")
-          ActiveRecord::Base.logger.debug(" ActiveRecord query: #{selector.resource.model}.includes(#{eager_hash})")
+          @logger.debug("Query plan for ...#{selector.resource.model} with selectors: #{JSON.generate(selector.dump)}")
+          @logger.debug(" ActiveRecord query: #{selector.resource.model}.includes(#{eager_hash})")
           query.explain
-          ActiveRecord::Base.logger.debug("Query plan end")
-          ActiveRecord::Base.logger = prev
+          @logger.debug("Query plan end")
         end
       end
     end

data/lib/praxis/extensions/field_selection/sequel_query_selector.rb

@@ -8,19 +8,20 @@ module Praxis
       class SequelQuerySelector
         attr_reader :selector, :query
         # Gets a dataset, a selector...and should return a dataset with the selector definition applied.
-        def initialize(query:, selectors:)
+        def initialize(query:, selectors:, debug: false)
           @selector = selectors
           @query = query
+          @logger = debug ? Logger.new(STDOUT) : nil
         end
 
-        def generate(debug: false)
+        def generate
           @query = add_select(query: query, selector_node: @selector)
           
           @query = @selector.tracks.inject(@query) do |ds, (track_name, track_node)|
             ds.eager(track_name => _eager(track_node) )
           end
 
-          explain_query(query) if debug
+          explain_query(query) if @logger
           @query
         end
 
@@ -47,13 +48,9 @@ module Praxis
         end
 
         def explain_query(ds)
-          prev_loggers = Sequel::Model.db.loggers
-          stdout_logger = Logger.new($stdout)
-          Sequel::Model.db.loggers = [stdout_logger]
-          stdout_logger.debug("Query plan for ...#{selector.resource.model} with selectors: #{JSON.generate(selector.dump)}")
+          @logger.debug("Query plan for ...#{selector.resource.model} with selectors: #{JSON.generate(selector.dump)}")
           ds.all
-          stdout_logger.debug("Query plan end")
-          Sequel::Model.db.loggers = prev_loggers
+          @logger.debug("Query plan end")
         end
       end
     end

data/lib/praxis/extensions/pagination.rb

@@ -0,0 +1,130 @@
+begin
+  require 'link_header'
+rescue LoadError
+  warn "Praxis::Pagination requires the 'link_header' gem, which can not be found. " \
+       "Please make sure it's in your Gemfile or installed in your system."
+end
+require 'praxis/extensions/pagination/pagination_params'
+require 'praxis/extensions/pagination/ordering_params'
+require 'praxis/extensions/pagination/pagination_handler'
+require 'praxis/extensions/pagination/header_generator'
+
+module Praxis
+  module Extensions
+    module Pagination
+      extend ActiveSupport::Concern
+      # This PaginatedController concern should be added to controllers that have actions that define the
+      # pagination and order parameters so that calling `paginate( query: <base_query>, table: <main_table_name> )`
+      # would handle all the required logic for paginating, ordering and generating the Link and TotalCount headers.
+      # This assumes that the query object are chainable and based on ActiveRecord at the moment (although that logic)
+      # can be easily applied to other chainable query proxies.
+      #
+      # Here's a simple example on how to use it for a fake Items controller
+      # class Items < V1::Controllers::BaseController
+      #   include Praxis::Controller
+      #   include Praxis::Extensions::Rendering
+      #   implements V1::Endpoints::Items
+      #
+      #   include Praxis::Extensions::Pagination
+      #
+      #   def index(filters: nil, pagination: nil, order: nil,  **_args)
+      #     items = current_user.items.all
+      #     items = handle_pagination( query: items)
+      #
+      #     display(items)
+      #   end
+      # end
+      #
+      # This code will properly add the right clauses to the final query based on the pagination strategy and ordering
+      # and it will also generate the Link header with the appropriate relationships depending on the paging strategy.
+      # When total_count is requested in the pagination a header with TotalCount will also be included.
+
+      PaginationStruct = Struct.new(:paginator, :order, :total_count)
+
+      included do
+        after :action do |controller, _callee|
+          if controller.response.status < 300
+            # If this action has the pagination parameter defined,
+            # calculate and set the pagination headers (Link header and possibly Total-Count)
+            if controller._pagination.paginator
+              headers = controller.build_pagination_headers(
+                pagination: controller._pagination,
+                current_url: controller.request.path,
+                current_query_params: controller.request.query
+              )
+              controller.response.headers.merge! headers
+            end
+          end
+        end
+      end
+
+      # Will set the typed paginator and order object into a controller ivar
+      # This is lazily evaluated and memoized, so there's no need to only calculate things for actions that paginate/sort
+      def _pagination
+        return @_pagination if @_pagination
+
+        pagination = {}
+        attrs = request.action&.params&.type&.attributes
+        pagination[:paginator] = request.params.pagination if attrs&.key? :pagination
+        pagination[:order] = request.params.order if attrs&.key? :order
+
+        @_pagination = PaginationStruct.new(pagination[:paginator], pagination[:order])
+      end
+
+      # Main entrypoint: Handles all pagination pieces
+      # takes:
+      # * the query to build from and the table
+      # * the request (for link header generation)
+      # * requires the _pagination variable to be there (set by this module) to return the pagination struct
+      def handle_pagination(query:, type: :active_record)
+        handler_klass = \
+          case type
+          when :active_record
+            ActiveRecordPaginationHandler
+          when :sequel
+            SequelPaginationHandler
+          else
+            raise "Attempting to use pagination but Active Record or Sequel gems found"
+          end
+ 
+        # Gather and save the count if required
+        if _pagination.paginator&.total_count
+          _pagination.total_count = handler_klass.count(query.dup)
+        end
+        
+        query = handler_klass.order(query, _pagination.order)
+        # Maybe this is a class instance instead of a class method?...(of the appropriate AR/Sequel type)...
+        # self.class.paginate(query, table, _pagination)
+        handler_klass.paginate(query, _pagination)
+      end
+
+      def build_pagination_headers(pagination:, current_url:, current_query_params:)
+        links = if pagination.paginator.by
+                  # We're assuming that the last element has a "symbol/string" field with the same name of the "by" pagination.
+                  last_element = response.body.last
+                  if last_element
+                    last_value = last_element[pagination.paginator.by.to_sym] || last_element[pagination.paginator.by]
+                  end
+                  HeaderGenerator.build_cursor_headers(
+                    paginator: pagination.paginator,
+                    last_value: last_value,
+                    total_count: pagination.total_count
+                  )
+                else
+                  HeaderGenerator.build_paging_headers(
+                    paginator: pagination.paginator,
+                    total_count: pagination.total_count
+                  )
+                end
+
+        HeaderGenerator.generate_headers(
+          links: links,
+          current_url: current_url,
+          current_query_params: current_query_params,
+          total_count: pagination.total_count
+        )
+      end
+
+    end
+  end
+end