praxis 2.0.pre.6 → 2.0.pre.11

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

@@ -5,27 +5,43 @@ module Praxis
     module AttributeFiltering
       ALIAS_TABLE_PREFIX = ''
       require_relative 'active_record_patches'
+      # Helper class that can present an SqlLiteral string which we have already quoted
+      # ... but! that can properly provide a "to_sym" that has the value unquoted
+      # This is necessary as (the latest AR code):
+      # * does not carry over "references" in joins if they are not SqlLiterals
+      # * but, at the same time, it indexes the references using the .to_sym value (which is really expected to be the normal string, without quotes)
+      # If we pass a normal SqlLiteral, instead of our wrapper, without quoting the table, the current AR code will never quote it to form the 
+      # SQL string, as it's already a literal...so our "/" type separators as names won't work without quoting.
+      class QuasiSqlLiteral < Arel::Nodes::SqlLiteral
+        def initialize(quoted:, symbolized:)
+          @symbolized = symbolized
+          super(quoted)
+        end
+        def to_sym
+          @symbolized
+        end
+      end
 
       class ActiveRecordFilterQueryBuilder
-      attr_reader :query, :model, :attr_to_column
+      attr_reader :query, :model, :filters_map
 
         # Base query to build upon
         def initialize(query: , model:, filters_map:, debug: false)
           @query = query
           @model = model
-          @attr_to_column = filters_map
+          @filters_map = filters_map
           @logger = debug ? Logger.new(STDOUT) : nil
         end
         
-        def debug(msg)
-          @logger && @logger.puts(msg)
+        def debug_query(msg, query)
+          @logger.info(msg + query.to_sql) if @logger
         end
 
         def generate(filters)
           # Resolve the names and values first, based on filters_map
           root_node = _convert_to_treenode(filters)
           craft_filter_query(root_node, for_model: @model)
-          debug("SQL due to filters: #{@query.all.to_sql}")
+          debug_query("SQL due to filters: ", @query.all)
           @query
         end
 
@@ -45,13 +61,30 @@ module Praxis
 
         private
 
+        def _mapped_filter(name)
+          target = @filters_map[name]
+          unless target
+            if @model.attribute_names.include?(name.to_s)
+              # Cache it in the filters mapping (to avoid later lookups), and return it.
+              @filters_map[name] = name
+              target = name
+            end
+          end
+          return target
+        end
+
         # Resolve and convert from filters, to a more manageable and param-type-independent structure
         def _convert_to_treenode(filters)
           # Resolve the names and values first, based on filters_map
           resolved_array = []
           filters.parsed_array.each do |filter|
-            mapped_value = attr_to_column[filter[:name]]
-            raise "Filtering by #{filter[:name]} not allowed (no mapping found)" unless mapped_value
+            mapped_value = _mapped_filter(filter[:name])
+            unless mapped_value
+              msg = "Filtering by #{filter[:name]} is not allowed. No implementation mapping defined for it has been found \
+                and there is not a model attribute with this name either.\n" \
+                "Please add a mapping for #{filter[:name]} in the `filters_mapping` method of the appropriate Resource class"
+              raise msg
+            end
             bindings_array = \
               if mapped_value.is_a?(Proc)
                 result = mapped_value.call(filter)
@@ -85,7 +118,7 @@ module Praxis
         end
 
         def add_clause(column_prefix:, column_object:, op:, value:)
-          @query = @query.references(column_prefix) #Mark where clause referencing the appropriate alias
+          @query = @query.references(build_reference_value(column_prefix)) #Mark where clause referencing the appropriate alias
           likeval = get_like_value(value)
           case op
             when '!' # name! means => name IS NOT NULL (and the incoming value is nil)
@@ -165,6 +198,22 @@ module Praxis
             likeval
           end
         end
+
+        # The value that we need to stick in the references method is different in the latest Rails
+        maj, min, _ = ActiveRecord.gem_version.segments
+        if maj == 5 || (maj == 6 && min == 0)
+          # In AR 6 (and 6.0) the references are simple strings
+          def build_reference_value(column_prefix)
+            column_prefix
+          end
+        else
+          # The latest AR versions discard passing references to joins when they're not SqlLiterals ... so let's wrap it
+          # with our class, so that it is a literal (already quoted), but that can still provide the expected "symbol" without quotes
+          # so that our aliasing code can match it.
+          def build_reference_value(column_prefix)
+            QuasiSqlLiteral.new(quoted: query.connection.quote_table_name(column_prefix), symbolized: column_prefix.to_sym)
+          end
+        end
       end
     end
   end

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

@@ -103,7 +103,7 @@ module Praxis
         def self.construct(definition, **options)
           return self if definition.nil?
   
-          DSLCompiler.new(self, options).parse(*definition)
+          DSLCompiler.new(self, **options).parse(*definition)
           self
         end
   
@@ -166,7 +166,6 @@ module Praxis
             end
   
             attr_name = match[:attribute].to_sym
-            # TODO: we should coerce values if there's a mediatype defined?
             coerced = if media_type
               filter_components = attr_name.to_s.split('.').map(&:to_sym)
               attr, _enclosing_type = find_filter_attribute(filter_components, media_type)
@@ -217,21 +216,9 @@ module Praxis
               errors << "Operator #{item[:op]} not allowed for filter #{attr_name}"
             end
             value_type = attr_filters[:value_type]
-            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?(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 '#{item[:op]}' is not a #{value_type.name.split('::').last})"
-              end
-            end
-  
             next unless value_type == Attributor::String
+
+            value = item[:value]
             unless value.empty?
               fuzzy_match = attr_filters[:fuzzy_match]
               if (value[-1] == '*' || value[0] == '*') && !fuzzy_match

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

@@ -9,7 +9,7 @@ module Praxis
       class << self
         def for(definition)
           Class.new(self) do
-            @attr_to_column = case definition
+            @filters_map = case definition
                               when Hash
                                 definition
                               when Array
@@ -18,7 +18,7 @@ module Praxis
                                 raise "Cannot use FilterQueryBuilder.of without passing an array or a hash (Got: #{definition.class.name})"
                               end
             class << self
-              attr_reader :attr_to_column
+              attr_reader :filters_map
             end
           end
         end
@@ -33,13 +33,18 @@ module Praxis
       end
 
       # 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
+      # the attribute based on what's on the `filters_map` definition
       def generate(filters)
         raise "Not refactored yet!"
         seen_associations = Set.new
         filters.each do |(attr, spec)|
-          column_name = attr_to_column[attr]
-          raise "Filtering by #{attr} not allowed (no mapping found)" unless column_name
+          column_name = _mapped_filter(attr)
+          unless column_name
+            msg = "Filtering by #{attr} is not allowed. No implementation mapping defined for it has been found \
+              and there is not a model attribute with this name either.\n" \
+              "Please add a mapping for #{attr} in the `filters_mapping` method of the appropriate Resource class"
+            raise msg
+          end          
           if column_name.is_a?(Proc)
             bindings = column_name.call(spec)
             # A hash of bindings, consisting of a key with column name and a value to the query value
@@ -64,9 +69,16 @@ module Praxis
         add_clause(attr: column_name, op: op, value: value)
       end
 
-      def attr_to_column
-        # Class method defined by the subclassing Class (using .for)
-        self.class.attr_to_column
+      def _mapped_filter(name)
+        target = self.class.filters_map[name]
+        unless target
+          if @model.attribute_names.include?(name.to_s)
+            # Cache it in the filters mapping (to avoid later lookups), and return it.
+            self.class.filters_map[name] = name
+            target = name
+          end
+        end
+        return target
       end
 
       # Private to try to funnel all column names through `generate` that restricts

data/lib/praxis/extensions/field_expansion.rb

@@ -7,53 +7,20 @@ module Praxis
         Praxis::ActionDefinition.send(:include, ActionDefinitionExtension)
       end
 
-
       def expanded_fields
         @expansion ||= request.action.expanded_fields(self.request, self.media_type)
       end
 
-
       module ActionDefinitionExtension
         extend ActiveSupport::Concern
 
         def expanded_fields(request, media_type)
-          use_fields = self.params && self.params.attributes.key?(:fields)
-          use_view = self.params && self.params.attributes.key?(:view)
-
-          # Determine what, if any, fields to display.
-          fields = if use_fields
-            request.params.fields.fields
-          else
-            true
-          end
+          uses_fields = self.params && self.params.attributes.key?(:fields)
+          fields = uses_fields ? request.params.fields.fields : true
 
-          # Determine the view that COULD be applicable.
-          view = if use_view && (view_name = request.params.view)
-            media_type.views[view_name]
-          else
-            media_type.views[:default]
-          end
-
-          expandable = if fields == true
-            # We want to show ALL of the available fields.
-            # This can never be applied to the type (it's likely infinitely recursive).
-            # So use view_name determimed above.
-            view
-          else
-            # We want to show SOME of fields available on a view or type.
-            if use_view && request.params.view
-              # Use the requested view.
-              view
-            else
-              # Use the type.
-              media_type
-            end
-          end
-
-          Praxis::FieldExpander.expand(expandable,fields)
+          Praxis::FieldExpander.expand(media_type,fields)
         end
       end
-
     end
   end
 end

data/lib/praxis/extensions/pagination.rb

@@ -14,10 +14,9 @@ module Praxis
     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.
+      # pagination and order parameters so that one can call the domain model to craft the query
+      # `domain_model.craft_pagination_query(base_query, pagination: _pagination)`
+      # This will handle all the required logic for paginating, ordering and generating the Link and TotalCount headers.
       #
       # Here's a simple example on how to use it for a fake Items controller
       # class Items < V1::Controllers::BaseController
@@ -29,7 +28,8 @@ module Praxis
       #
       #   def index(filters: nil, pagination: nil, order: nil,  **_args)
       #     items = current_user.items.all
-      #     items = handle_pagination( query: items)
+      #     domain_model = self.media_type.domain_model
+      #     items = domain_model.craft_pagination_query( query: items, pagination: _pagination)
       #
       #     display(items)
       #   end
@@ -71,33 +71,6 @@ module Praxis
         @_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.

data/lib/praxis/extensions/pagination/ordering_params.rb

@@ -88,6 +88,10 @@ module Praxis
 
         attr_reader :items
 
+        def self.json_schema_type
+          :string
+        end
+
         def self.native_type
           self
         end
@@ -111,7 +115,7 @@ module Praxis
         def self.construct(pagination_definition, **options)
           return self if pagination_definition.nil?
 
-          DSLCompiler.new(self, options).parse(*pagination_definition)
+          DSLCompiler.new(self, **options).parse(*pagination_definition)
           self
         end
 

data/lib/praxis/extensions/pagination/pagination_params.rb

@@ -175,6 +175,10 @@ module Praxis
           end
         end
 
+        def self.json_schema_type
+          :string
+        end
+
         def self.native_type
           self
         end
@@ -198,7 +202,7 @@ module Praxis
         def self.construct(pagination_definition, **options)
           return self if pagination_definition.nil?
 
-          DSLCompiler.new(self, options).parse(*pagination_definition)
+          DSLCompiler.new(self, **options).parse(*pagination_definition)
           self
         end
 
@@ -217,10 +221,11 @@ module Praxis
 
                      selectable = mt_example.object.keys & simple_attrs.keys
                      by = selectable.sample(1).first
-                     from = media_type.attributes[by].example(parent: mt_example)
+                     from = media_type.attributes[by].example(parent: mt_example).to_s
                      # Make sure to encode the value of the from, as it can contain commas and such
-                     from = CGI.escape(from) if from.is_a? String
-                     "by=#{by},from=#{from},items=#{defaults[:page_size]}"
+                     # Only add the from parameter if it's not empty (an empty from is not allowed and it's gonna blow up in load)
+                     optional_from_component = (from && !from.empty?) ? ",from=#{CGI.escape(from)}" : ''
+                     "by=#{by}#{optional_from_component},items=#{defaults[:page_size]}"
                    else
                      "by=id,from=20,items=100"
                    end
@@ -356,6 +361,7 @@ module Praxis
                 else
                   s = "by=#{@by}"
                   s += ",from=#{@from}" if @from
+                  s
                 end
           str += ",items=#{items}" if @items
           str += ",total_count=true" if @total_count

data/lib/praxis/field_expander.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+module Praxis
+  class FieldExpander
+    def self.expand(object, fields = true)
+      new.expand(object, fields)
+    end
+
+    attr_reader :stack
+    attr_reader :history
+
+    def initialize
+      @stack = Hash.new do |hash, key|
+        hash[key] = Set.new
+      end
+      @history = Hash.new do |hash, key|
+        hash[key] = {}
+      end
+    end
+
+    def expand(object, fields = true)
+      if stack[object].include? fields
+        return history[object][fields] if history[object].include? fields
+        # We should probably never get here, since we should have a record
+        # of the history of an expansion if we're trying to redo it,
+        # but we should also be conservative and raise here just in case.
+        raise "Circular expansion detected for object #{object.inspect} with fields #{fields.inspect}"
+      else
+        stack[object] << fields
+      end
+
+      result = if object.is_a? Attributor::Attribute
+                 expand_type(object.type, fields)
+               else
+                 expand_type(object, fields)
+               end
+
+      result
+    ensure
+      stack[object].delete fields
+    end
+
+    def expand_fields(attributes, fields)
+      raise ArgumentError, 'expand_fields must be given a block' unless block_given?
+
+      unless fields == true
+        attributes = attributes.select do |k, _v|
+          fields.key?(k)
+        end
+      end
+
+      attributes.each_with_object({}) do |(name, dumpable), hash|
+        sub_fields = case fields
+                     when true
+                       true
+                     when Hash
+                       fields[name] || true
+                     end
+        hash[name] = yield(dumpable, sub_fields)
+      end
+    end
+
+    def expand_type(object, fields = true)
+      unless object.respond_to?(:attributes)
+        if object.respond_to?(:member_attribute)
+          return expand_type(object.member_attribute.type, fields)
+        else
+          return true
+        end
+      end
+
+      # just include the full thing if it has no attributes
+      return true if object.attributes.empty?
+
+      # True, expands to the default fieldset for blueprints
+      fields = object.default_fieldset if object < Praxis::Blueprint && fields == true
+
+      return history[object][fields] if history[object].include? fields
+
+      history[object][fields] = {}
+      result = expand_fields(object.attributes, fields) do |dumpable, sub_fields|
+        expand(dumpable.type, sub_fields)
+      end
+      unless fields == true 
+        non_matching = fields.keys - object.attributes.keys
+        raise "FieldExpansion error: attribute(s) #{non_matching} do not exist in #{object}" unless non_matching.empty?
+      end
+      history[object][fields].merge!(result)
+    end
+  end
+end