praxis 2.0.pre.2 → 2.0.pre.7

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
@@ -62,6 +61,10 @@ module Praxis
             end
           end
   
+          def json_schema_type
+            :string
+          end
+      
           def add_filter(name, operators:, fuzzy:)
             components = name.to_s.split('.').map(&:to_sym)
             attribute, enclosing_type = find_filter_attribute(components, media_type)
@@ -176,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
@@ -204,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
   
@@ -243,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

@@ -3,51 +3,45 @@ module Praxis
   module Extensions
     module FieldSelection
       class ActiveRecordQuerySelector
-        attr_reader :selector, :query, :top_model, :resolved, :root
+        attr_reader :selector, :query
         # Gets a dataset, a selector...and should return a dataset with the selector definition applied.
-        def initialize(query:, model:, selectors:, resolved:)
+        def initialize(query:, selectors:, debug: false)
           @selector = selectors
           @query = query
-          @top_model = model
-          @resolved = resolved
-          @seen = Set.new
-          @root = model.table_name
-        end
-
-        def add_select(query:, model:, table_name:)
-          if (fields = fields_for(model))
-            # Note, let's always add the pk fields so that associations can load properly
-            fields = fields | [model.primary_key.to_sym]
-            query.select(*fields)
-          else
-            query
-          end
+          @logger = debug ? Logger.new(STDOUT) : nil
         end
 
         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, model: top_model, table_name: root)
+          @query = add_select(query: query, selector_node: selector)
+          eager_hash = _eager(selector)
 
-          @query.includes(_eager(top_model, resolved) )
+          @query = @query.includes(eager_hash)          
+          explain_query(query, eager_hash) if @logger
+
+          @query
         end
 
-        def _eager(model, resolved)
-          tracks = only_assoc_for(model, resolved)
-          tracks.inject([]) do |dataset, track|
-            next dataset if @seen.include?([model, track])
-            @seen << [model, track]
-            assoc_model = model._praxis_associations[track][:model]
-            dataset << { track => _eager(assoc_model, resolved[track]) }
-          end
+        def add_select(query:, selector_node:)
+          # We're gonna always require the PK of the model, as it is a special case for AR, and the app itself 
+          # might assume it is always there and not be surprised by the fact that if it isn't, it won't blow up
+          # in the same way as any other attribute not being loaded...i.e., ActiveModel::MissingAttributeError: missing attribute: xyz
+          select_fields = selector_node.select + [selector_node.resource.model.primary_key.to_sym]
+          select_fields.empty? ? query : query.select(*select_fields)
         end
 
-        def only_assoc_for(model, hash)
-          hash.keys.reject { |assoc| model._praxis_associations[assoc].nil? }
+        def _eager(selector_node)
+          selector_node.tracks.each_with_object({}) do |(track_name, track_node), h|
+            h[track_name] = _eager(track_node)
+          end
         end
 
-        def fields_for(model)
-          selector[model][:select].to_a
+        def explain_query(query, 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
+          @logger.debug("Query plan end")
         end
       end
     end

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

@@ -7,6 +7,10 @@ module Praxis
           include Attributor::Type
           include Attributor::Dumpable
 
+          def self.json_schema_type
+            :string
+          end
+      
           def self.native_type
             self
           end

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

@@ -1,63 +1,56 @@
 # frozen_string_literal: true
+
+require 'sequel'
+
 module Praxis
   module Extensions
     module FieldSelection
       class SequelQuerySelector
-        attr_reader :selector, :ds, :top_model, :resolved, :root
+        attr_reader :selector, :query
         # Gets a dataset, a selector...and should return a dataset with the selector definition applied.
-        def initialize(query:, model:, selectors:, resolved:)
+        def initialize(query:, selectors:, debug: false)
           @selector = selectors
-          @ds = query
-          @top_model = model
-          @resolved = resolved
-          @seen = Set.new
-          @root = model.table_name
-        end
-
-        def add_select(ds:, model:, table_name:)
-          if (fields = fields_for(model))
-            # Note, let's always add the pk fields so that associations can load properly
-            fields = fields | model.primary_key | [:id]
-            qualified = fields.map { |f| Sequel.qualify(table_name, f) }
-            ds.select(*qualified)
-          else
-            ds
-          end
+          @query = query
+          @logger = debug ? Logger.new(STDOUT) : nil
         end
 
         def generate
-          @ds = add_select(ds: ds, model: top_model, table_name: root)
-
-          tracks = only_assoc_for(top_model, resolved)
-          @ds = tracks.inject(@ds) do |dataset, track|
-            next dataset if @seen.include?([top_model, track])
-            @seen << [top_model, track]
-            assoc_model = top_model._praxis_associations[track][:model]
-            #      hash[track] = _eager(assoc_model, resolved[track])
-            dataset.eager(track => _eager(assoc_model, resolved[track]))
+          @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 @logger
+          @query
         end
 
-        def _eager(model, resolved)
+        def _eager(selector_node)
           lambda do |dset|
-            d = add_select(ds: dset, model: model, table_name: model.table_name)
+            dset = add_select(query: dset, selector_node: selector_node)
 
-            tracks = only_assoc_for(model, resolved)
-            tracks.inject(d) do |dataset, track|
-              next dataset if @seen.include?([model, track])
-              @seen << [model, track]
-              assoc_model = model._praxis_associations[track][:model]
-              dataset.eager(track => _eager(assoc_model, resolved[track]))
+            dset = selector_node.tracks.inject(dset) do |ds, (track_name, track_node)|
+              ds.eager(track_name => _eager(track_node) )
             end
+
           end
         end
 
-        def only_assoc_for(model, hash)
-          hash.keys.reject { |assoc| model._praxis_associations[assoc].nil? }
+        def add_select(query:, selector_node:)
+          # We're gonna always require the PK of the model, as it is a special case for Sequel, and the app itself 
+          # might assume it is always there and not be surprised by the fact that if it isn't, it won't blow up
+          # in the same way as any other attribute not being loaded...i.e., NoMethodError: undefined method `foobar' for #<...>
+          select_fields = selector_node.select + [selector_node.resource.model.primary_key.to_sym]
+    
+          table_name = selector_node.resource.model.table_name
+          qualified = select_fields.map { |f| Sequel.qualify(table_name, f) }
+          query.select(*qualified)
         end
 
-        def fields_for(model)
-          selector[model][:select].to_a
+        def explain_query(ds)
+          @logger.debug("Query plan for ...#{selector.resource.model} with selectors: #{JSON.generate(selector.dump)}")
+          ds.all
+          @logger.debug("Query plan end")
         end
       end
     end