praxis 2.0.pre.14 → 2.0.pre.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6af11de4fdf970e848d638ed6fd1f47db86dcd27562bca90e50805398a82b346
-  data.tar.gz: dd4b664b1b8afde291e0402eeb0bb57178214ac1d8d6a4dc691f532fff7ae29f
+  metadata.gz: 269b2403359c2a9ec0b591d695a5146ff648d16046d82ec52162086d0006bbb7
+  data.tar.gz: 3f28eebb4e3ceecd39a7ba5969df7ece5feafe93c3fd6b5d0dfb17df92f22fcd
 SHA512:
-  metadata.gz: 525c64c37e1cfe27fe74c1ddbd02d3c6e45860acd0f8a79a5d9a0832274368c728dacc8096b3b37f63c302fe265161793320a64dcf44a84d99ee5074d9de9da2
-  data.tar.gz: 79a70e175f17a14d98beddd66add981c03a8c720dd45855221b5b3223cb021d056381a5fd87880e3cbe2886755445182cf6cad3427de9f38b44220a26b23955d
+  metadata.gz: 800cf53e02f7322a8db37212c16b3e53827bc50acbf630a58d2027397120c2c9044c81ae919a2855b7c3635786113526712cb6b882e505fbc0c1f46042ed8f5c
+  data.tar.gz: bd0969b6aa8618b78d3a2f42b9e14d5c5f5d776019bd1b697a66e3dbbbe3a6535c475d806edb64f82d16b370ba76cf8effd4fe73d03adc5934cd48446e3096b5

data/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 ## next
 
+## 2.0.pre.18
+* Upgraded to newest Attributor, which cleans up the required: true semantics to only work on keys, and introduces null: true for nullability of values (independent from presence of keys or not)
+* Fixed a selector generator bug that would occur when using deep nested resource dependencies as strings 'foo.bar.baz.bam'. In this cases only partial tracking of relationships would be built, which could cause to not fully eager load DB queries.
+## 2.0.pre.17
+* Changed the Parameter Filtering to use left outer joins (and extra conditions), to allow for the proper results when OR clauses are involved in certain configurations.
+* Built support for allowing filtering directly on associations using `!` and `!!` operators. This allows to filter results where 
+there are no associated rows (`!!`) or if there are some associated rows (`!`)
+* Allow implicit definition of `filters_mapping` for filter names that match top-level associations of the model (i.e., like we do for the columns)
+## 2.0.pre.16
+
+* Updated `Resource.property` signature to only accept known named arguments (`dependencies` and `though` at this time) to spare anyone else from going insane wondering why their `depednencies` aren't working.
+* Fixed issue with Filtering Params, that occurred with using the ! or !! operators on String-typed fields.
+
 ## 2.0.pre.14
 
 * More encoding/decoding robustness for filters. 

data/bin/praxis

@@ -9,6 +9,12 @@ rescue Bundler::GemfileNotFound
   # no-op: we might be installed as a system gem
 end
 
+if ARGV[0] == "version"
+  require 'praxis/version'
+  puts "Praxis version #{Praxis::VERSION}"
+  exit 0
+end
+
 if ["routes","docs","console"].include? ARGV[0]
   require 'rake'
   require 'praxis'

data/lib/praxis/action_definition.rb

@@ -124,8 +124,8 @@ module Praxis
     def payload(type=Attributor::Struct, **opts, &block)
       return @payload if !block && ( opts.nil? || opts.empty? ) && type == Attributor::Struct
 
-      unless( opts.key? :required )
-        opts[:required] = true # Make the payload required by default
+      unless opts.key?(:required)
+        opts = {required: true, null: false}.merge(opts) # Make the payload required and non-nullable by default
       end
 
       if @payload

data/lib/praxis/api_definition.rb

@@ -97,8 +97,10 @@ module Praxis
         description( description || 'Standard response for successful HTTP requests.' )
 
         media_type media_type
-        location location
-        headers headers if headers
+        location if location
+        headers&.each do |(name, value)|
+          header(name: name, value: value)
+        end
       end
 
       api.response_template :created do |media_type: nil, location: nil, headers: nil, description: nil|
@@ -106,8 +108,10 @@ module Praxis
         description( description || 'The request has been fulfilled and resulted in a new resource being created.' )
 
         media_type media_type if media_type
-        location location
-        headers headers if headers
+        location if location
+        headers&.each do |(name, value)|
+          header(name: name, value: value)
+        end
       end
     end
 

data/lib/praxis/blueprint.rb

@@ -321,18 +321,33 @@ module Praxis
       @validating = true
 
       errors = []
-      self.class.attributes.each do |sub_attribute_name, sub_attribute|
-        sub_context = self.class.generate_subcontext(context, sub_attribute_name)
-        value = self.send(sub_attribute_name)
-        keys_with_values << sub_attribute_name unless value.nil?
+      keys_provided = []
+
+      self.class.attributes.each do |key, attribute|
+        sub_context = self.class.generate_subcontext(context, key)
+        value = _get_attr(key)
+        keys_provided << key if @object.key?(key)
 
         if value.respond_to?(:validating) # really, it's a thing with sub-attributes
           next if value.validating
         end
-        errors.concat(sub_attribute.validate(value, sub_context))
+
+        # Isn't this handled by the requirements validation? NO! we might want to combine
+        if attribute.options[:required] && !@object.key?(key)
+          errors.concat ["Attribute #{Attributor.humanize_context(sub_context)} is required."]
+        end
+        if @object[key].nil?
+          if !Attributor::Attribute.nullable_attribute?(attribute.options) && @object.key?(key) # It is only nullable if there's an explicite null: true (undefined defaults to false)
+            errors.concat ["Attribute #{Attributor.humanize_context(sub_context)} is not nullable."]
+          end
+          # No need to validate the attribute further if the key wasn't passed...(or we would get nullable errors etc..cause the attribute has no
+          # context if its containing key was even passed (and there might not be a containing key for a top level attribute anyways))
+        else
+          errors.concat attribute.validate(value, sub_context)
+        end
       end
-      self.class.attribute.type.requirements.each do |req|
-        validation_errors = req.validate(keys_with_values, context)
+      self.class.attribute.type.requirements.each do |requirement|
+        validation_errors = requirement.validate(keys_provided, context)
         errors.concat(validation_errors) unless validation_errors.empty?
       end
       errors

data/lib/praxis/collection.rb

@@ -32,5 +32,16 @@ module Praxis
       @member_type.domain_model
     end
 
+    def self.json_schema_type
+      :array
+    end
+
+    def self.as_json_schema(**args)
+      the_type = @attribute && @attribute.type || member_type
+      {
+        type: json_schema_type,
+        items: { '$ref': "#/components/schemas/#{the_type.id}" }
+      }
+    end
   end
 end

data/lib/praxis/dispatcher.rb

@@ -1,9 +1,9 @@
 module Praxis
 
   CONTEXT_FOR = {
-    params: [Attributor::AttributeResolver::ROOT_PREFIX, "params".freeze],
-    headers: [Attributor::AttributeResolver::ROOT_PREFIX, "headers".freeze],
-    payload: [Attributor::AttributeResolver::ROOT_PREFIX, "payload".freeze]
+    params: [Attributor::ROOT_PREFIX, "params".freeze],
+    headers: [Attributor::ROOT_PREFIX, "headers".freeze],
+    payload: [Attributor::ROOT_PREFIX, "payload".freeze]
   }.freeze
 
   class Dispatcher

data/lib/praxis/docs/open_api/response_object.rb

@@ -16,12 +16,27 @@ module Praxis
 
         def dump_response_headers_object( headers )
           headers.each_with_object({}) do |(name,data),accum|
-            # data is a hash with :value and :type keys
-            # How did we say in that must match a value in json schema again??
-            accum[name] = {
-              schema: SchemaObject.new(info: data[:type])
-              # allowed values:  [ data[:value] ] ??? is this the right json schema way?
-            }
+            # each header comes from Praxis::ResponseDefinition 
+            # the keys are the header names, and value can be:
+            #  "true"  => means it only needs to exist
+            #  String => which means that it has to fully match
+            #  Regex  => which means it has to regexp match it
+
+            # Get the schema from the type (defaulting to string in case the type doesn't have the as_json_schema defined)
+            schema = data[:attribute].type.as_json_schema rescue { type: :string }
+            hash = { description: data[:description] || '', schema: schema }
+            # Note, our Headers in response definition are not full types...they're basically only 
+            # strings, which can either match anything, match the exact word or match a regex
+            # they don't even have a description...
+            data_value = data[:value]
+            if data_value.is_a? String
+              hash[:pattern] = "^#{data_value}$" # Exact String match
+            elsif data_value.is_a? Regexp
+              sanitized_pattern = data_value.inspect[1..-2] #inspect returns enclosing '/' characters
+              hash[:pattern] = sanitized_pattern
+            end
+
+            accum[name] = hash
           end
         end
 

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

@@ -23,7 +23,8 @@ module Praxis
       end
 
       class ActiveRecordFilterQueryBuilder
-      attr_reader :model, :filters_map
+        REFERENCES_STRING_SEPARATOR = '/'
+        attr_reader :model, :filters_map
 
         # Base query to build upon
         def initialize(query: , model:, filters_map:, debug: false)
@@ -48,9 +49,8 @@ module Praxis
         end
 
         def craft_filter_query(nodetree, for_model:)
-          result = _compute_joins_and_conditions_data(nodetree, model: for_model)
+          result = _compute_joins_and_conditions_data(nodetree, model: for_model, parent_reflection: nil)
           return @initial_query if result[:conditions].empty?
-
           
           # Find the root group (usually an AND group) but can be an OR group, or nil if there's only 1 condition
           root_parent_group = result[:conditions].first[:node_object].parent_group || result[:conditions].first[:node_object]
@@ -59,21 +59,35 @@ module Praxis
           end
 
           # Process the joins
-          query_with_joins = result[:associations_hash].empty? ? @initial_query : @initial_query.joins(result[:associations_hash])
+          query_with_joins = result[:associations_hash].empty? ? @initial_query : @initial_query.left_outer_joins(result[:associations_hash])
 
           # Proc to apply a single condition
           apply_single_condition = Proc.new do |condition, associated_query|
             colo = condition[:model].columns_hash[condition[:name].to_s]
             column_prefix = condition[:column_prefix]
-            #Mark where clause referencing the appropriate alias
-            associated_query = associated_query.references(build_reference_value(column_prefix, query: associated_query))
+            association_key_column = \
+              if ref = condition[:parent_reflection]
+                # get the target model of the association(where the assoc pk is)
+                target_model = condition[:parent_reflection].klass
+                target_model.columns_hash[condition[:parent_reflection].association_primary_key]
+              else
+                nil
+              end
+
+            # Mark where clause referencing the appropriate alias IF it's not the root table, as there is no association to reference
+            # If we added root table as a reference, we better make sure it is not quoted, as it actually makes AR to see it as an 
+            # unmatched reference and eager loads the whole association (it means eager load ALL the things). Not good.
+            unless for_model.table_name == column_prefix
+              associated_query = associated_query.references(build_reference_value(column_prefix, query: associated_query))
+            end
             self.class.add_clause(
               query: associated_query, 
               column_prefix: column_prefix, 
               column_object: colo, 
               op: condition[:op], 
               value: condition[:value],
-              fuzzy: condition[:fuzzy]
+              fuzzy: condition[:fuzzy],
+              association_key_column: association_key_column,
             )
           end
 
@@ -138,7 +152,8 @@ module Praxis
         def _mapped_filter(name)
           target = @filters_map[name]
           unless target
-            if @model.attribute_names.include?(name.to_s)
+            filter_name = name.to_s
+            if (@model.attribute_names + @model.reflections.keys).include?(filter_name)
               # Cache it in the filters mapping (to avoid later lookups), and return it.
               @filters_map[name] = name
               target = name
@@ -176,32 +191,64 @@ module Praxis
         end
 
         # Calculate join tree and conditions array for the nodetree object and its children
-        def _compute_joins_and_conditions_data(nodetree, model:)
+        def _compute_joins_and_conditions_data(nodetree, model:, parent_reflection:)
           h = {}
           conditions = []
           nodetree.children.each do |name, child|
-            child_model = model.reflections[name.to_s].klass
-            result = _compute_joins_and_conditions_data(child, model: child_model)
-            h[name] = result[:associations_hash] 
+            child_reflection = model.reflections[name.to_s]
+            result = _compute_joins_and_conditions_data(child, model: child_reflection.klass, parent_reflection: child_reflection)
+            h[name] = result[:associations_hash]
+            
             conditions += result[:conditions]
           end
-          column_prefix = nodetree.path == [ALIAS_TABLE_PREFIX] ? model.table_name : nodetree.path.join('/')
-          #column_prefix = nodetree.path == [ALIAS_TABLE_PREFIX] ? nil : nodetree.path.join('/')
+          
+          column_prefix = nodetree.path == [ALIAS_TABLE_PREFIX] ? model.table_name : nodetree.path.join(REFERENCES_STRING_SEPARATOR)
           nodetree.conditions.each do |condition|
-            conditions += [condition.merge(column_prefix: column_prefix, model: model)]
+            # If it's a final ! or !! operation on an association from the parent, it means we need to add a condition
+            # on the existence (or lack of) of the whole associated table
+            ref = model.reflections[condition[:name].to_s]
+            if ref && ['!','!!'].include?(condition[:op])
+              cp = (nodetree.path + [condition[:name].to_s]).join(REFERENCES_STRING_SEPARATOR)
+              conditions += [condition.merge(column_prefix: cp, model: model, parent_reflection: ref)]
+              h[condition[:name]] = {}
+            else
+              # Save the parent reflection where the condition applies as well (used later to get assoc keys)
+              conditions += [condition.merge(column_prefix: column_prefix, model: model, parent_reflection: parent_reflection)]
+            end
+            
           end
           {associations_hash: h, conditions: conditions}
         end
 
-        def self.add_clause(query:, column_prefix:, column_object:, op:, value:,fuzzy:)
+        def self.add_clause(query:, column_prefix:, column_object:, op:, value:,fuzzy:, association_key_column:)
           likeval = get_like_value(value,fuzzy)
+
+          association_op = nil
           case op
           when '!' # name! means => name IS NOT NULL (and the incoming value is nil)
             op = '!='
             value = nil # Enforce it is indeed nil (should be)
+            association_op = :not_null if association_key_column && !column_object
           when '!!'
             op = '='
             value = nil # Enforce it is indeed nil (should be)
+            association_op = :null if association_key_column && !column_object
+          end
+
+          if association_op
+            neg = association_op == :not_null ? true : false
+            qr = quote_right_part(query: query, value: nil, column_object: association_key_column, negative: neg)
+            return query.where("#{quote_column_path(query: query, prefix: column_prefix, column_object: association_key_column)} #{qr}")
+          end
+
+          # Add an AND along with the condition, which ensures the left outter join 'exists' for it
+          # Normally this wouldn't be necessary as a condition on a given value mathing would imply the related row was there
+          # but this is not the case for NULL conditions, as the foreign column would match a  NULL value, but not because the related column
+          # is NULL, but because the whole missing related row would appear with all fields null
+          # NOTE: we don't need to do it for conditions applying to the root of the tree (there isn't a join to it)
+          if association_key_column
+            qr = quote_right_part(query: query, value: nil, column_object: association_key_column, negative: true)
+            query = query.where("#{quote_column_path(query: query, prefix: column_prefix, column_object: association_key_column)} #{qr}")
           end
 
           case op

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

@@ -222,8 +222,7 @@ module Praxis
             value_type = attr_filters[:value_type]
             next unless value_type == Attributor::String
 
-            value = item[:value]
-            unless value.empty?
+            if item[:value].presence
               fuzzy_match = attr_filters[:fuzzy_match]
               if item[:fuzzy] && !item[:fuzzy].empty? && !fuzzy_match
                 errors << "Fuzzy matching for #{attr_name} is not allowed (yet '*' was found in the value)"

data/lib/praxis/mapper/resource.rb

@@ -46,8 +46,8 @@ module Praxis::Mapper
       end
     end
 
-    def self.property(name, **options)
-      self.properties[name] = options
+    def self.property(name, dependencies: nil, through: nil)
+      self.properties[name] = {dependencies: dependencies, through: through}
     end
 
     def self._finalize!

data/lib/praxis/mapper/selector_generator.rb

@@ -98,10 +98,10 @@ module Praxis::Mapper
       when Symbol
         map_property(dependency, true)
       when String
-        head, tail = dependency.split('.').collect(&:to_sym)
+        head, *tail = dependency.split('.').collect(&:to_sym)
         raise "String dependencies can not be singular" if tail.nil?
 
-        add_association(head, {tail => true})
+        add_association(head, tail.reverse.inject({}) { |hash, dep| { dep => hash } })
       end
     end
 

data/lib/praxis/media_type_identifier.rb

@@ -198,10 +198,20 @@ module Praxis
       obj = self.class.new
       obj.type = self.type
       obj.subtype = self.subtype
-      obj.suffix = suffix || self.suffix || ''
+      target_suffix = suffix || self.suffix
+      obj.suffix = redundant_suffix(target_suffix) ? '' : target_suffix
       obj.parameters = self.parameters.merge(parameters)
 
       obj
     end
+
+    def redundant_suffix(suffix)
+      # application/json does not need to be suffixed with +json (same for application/xml)
+      # we're supporting text/json and text/xml for older formats as well
+      if (self.type == 'application' || self.type == 'text') && self.subtype == suffix
+        return true
+      end
+      false
+    end
   end
 end

data/lib/praxis/request.rb

@@ -142,18 +142,23 @@ module Praxis
     def validate_headers(context)
       return [] unless action.headers
 
+      return ["Attribute #{Attributor.humanize_context(context)} is required."] if action.headers.options[:required] == true && self.headers.nil?
+
       action.headers.validate(self.headers, context)
     end
 
     def validate_params(context)
       return [] unless action.params
 
+      return ["Attribute #{Attributor.humanize_context(context)} is required."] if action.params.options[:required] == true && self.params.nil?
+
       action.params.validate(self.params, context)
     end
 
     def validate_payload(context)
       return [] unless action.payload
 
+      return ["Attribute #{Attributor.humanize_context(context)} is required."] if action.payload.options[:required] == true && self.payload.nil?
       action.payload.validate(self.payload, context)
     end
 

data/lib/praxis/request_stages/validate_params_and_headers.rb

@@ -38,12 +38,6 @@ module Praxis
           )
         end
 
-        attribute_resolver = Attributor::AttributeResolver.new
-        Attributor::AttributeResolver.current = attribute_resolver
-
-        attribute_resolver.register("headers",request.headers)
-        attribute_resolver.register("params",request.params)
-
         errors = request.validate_headers(CONTEXT_FOR[:headers])
         errors += request.validate_params(CONTEXT_FOR[:params])
         if errors.any?

data/lib/praxis/request_stages/validate_payload.rb

@@ -27,7 +27,6 @@ module Praxis
               stage: name
             )
           end
-          Attributor::AttributeResolver.current.register("payload",request.payload)
 
           errors = request.validate_payload(CONTEXT_FOR[:payload])
           if errors.any?

data/lib/praxis/response_definition.rb

@@ -55,52 +55,36 @@ module Praxis
       end
     end
 
-    def location(loc=nil)
-      return @spec[:location] if loc.nil?
-      unless ( loc.is_a?(Regexp) || loc.is_a?(String) )
-        raise Exceptions::InvalidConfiguration.new(
-          "Invalid location specification. Location in response must be either a regular expression or a string."
-        )
-      end
-      @spec[:location] = loc
-    end
+    def location(loc=nil, description: nil)
+      return  headers.dig('Location',:value) if loc.nil?
 
-    def headers(hdrs = nil)
-      return @spec[:headers] if hdrs.nil?
+      header('Location', loc, description: description)
+    end
 
-      case hdrs
-      when Array
-        hdrs.each {|header_name| header(header_name) }
-      when Hash
-        header(hdrs)
-      when String
-        header(hdrs)
-      else
-        raise Exceptions::InvalidConfiguration.new(
-          "Invalid headers specification: Arrays, Hash, or String must be used. Received: #{hdrs.inspect}"
-        )
-      end
+    def headers
+      @spec[:headers]
     end
 
-    def header(hdr)
-      case hdr
-      when String
-        @spec[:headers][hdr] = true
-      when Hash
-        hdr.each do | k, v |
-          unless v.is_a?(Regexp) || v.is_a?(String)
-            raise Exceptions::InvalidConfiguration.new(
-              "Header definitions for #{k.inspect} can only match values of type String or Regexp. Received: #{v.inspect}"
-            )
-          end
-          @spec[:headers][k] = v
-        end
+    def header(name, value, description: nil)
+      the_type, args = case value
+      when nil,String
+        [String, {}]
+      when Regexp
+        # A regexp means it's gonna be a String typed, attached to a regexp
+        [String, { regexp: value }]
       else
         raise Exceptions::InvalidConfiguration.new(
-          "A header definition can only take a String (to match the name) or" +
-          " a Hash (to match both the name and the value). Received: #{hdr.inspect}"
+          "A header definition for a response can only take String, Regexp or nil values (to match anything)." +
+          "Received the following value for header name #{name}: #{value}"
         )
       end
+
+      info = { 
+        value: value, 
+        attribute: Attributor::Attribute.new(the_type, **args)
+      }
+      info[:description] = description if description
+      @spec[:headers][name] = info
     end
 
     def example(context=nil)
@@ -123,13 +107,14 @@ module Praxis
         :status => status,
         :headers => {}
       }
-      content[:location] = _describe_header(location) unless location == nil
 
       unless headers == nil
         headers.each do |name, value|
           content[:headers][name] = _describe_header(value)
         end
       end
+      content[:location] = content[:headers]['Location']
+
 
       if self.media_type
         payload = media_type.describe(true)
@@ -173,14 +158,14 @@ module Praxis
     end
 
     def _describe_header(data)
-      data_type = data.is_a?(Regexp) ? :regexp : :string
-      data_value = data.is_a?(Regexp) ? data.inspect : data
+
+      data_type = data[:value].is_a?(Regexp) ? :regexp : :string
+      data_value = data[:value].is_a?(Regexp) ? data[:value].inspect : data[:value]
       { :value => data_value, :type => data_type }
     end
 
     def validate(response, validate_body: false)
       validate_status!(response)
-      validate_location!(response)
       validate_headers!(response)
       validate_content_type!(response)
       validate_parts!(response)
@@ -222,23 +207,13 @@ module Praxis
       end
     end
 
-
-    # Validates 'Location' header
-    #
-    # @raise [Exceptions::Validation] When location header does not match to the defined one.
-    #
-    def validate_location!(response)
-      return if location.nil? || location === response.headers['Location']
-      raise Exceptions::Validation.new("LOCATION does not match #{location.inspect}")
-    end
-
-
     # Validates Headers
     #
     # @raise [Exceptions::Validation]  When there is a missing required header..
     #
     def validate_headers!(response)
       return unless headers
+
       headers.each do |name, value|
         if name.is_a? Symbol
           raise Exceptions::Validation.new(
@@ -252,20 +227,25 @@ module Praxis
           )
         end
 
-        case value
-        when String
-          if response.headers[name] != value
-            raise Exceptions::Validation.new(
-              "Header #{name.inspect}, with value #{value.inspect} does not match #{response.headers[name]}."
-            )
-          end
-        when Regexp
-          if response.headers[name] !~ value
-            raise Exceptions::Validation.new(
-              "Header #{name.inspect}, with value #{value.inspect} does not match #{response.headers[name].inspect}."
-            )
-          end
+        errors = value[:attribute].validate(response.headers[name])
+
+        unless errors.empty? 
+          raise Exceptions::Validation.new("Header #{name.inspect}, with value #{value.inspect} does not match #{response.headers[name]}.")
         end
+        # case value
+        # when String
+        #   if response.headers[name] != value
+        #     raise Exceptions::Validation.new(
+        #       "Header #{name.inspect}, with value #{value.inspect} does not match #{response.headers[name]}."
+        #     )
+        #   end
+        # when Regexp
+        #   if response.headers[name] !~ value
+        #     raise Exceptions::Validation.new(
+        #       "Header #{name.inspect}, with value #{value.inspect} does not match #{response.headers[name].inspect}."
+        #     )
+        #   end
+        # end
       end
     end
 

data/lib/praxis/responses/http.rb

@@ -160,7 +160,9 @@ module Praxis
 
           media_type media_type if media_type
           location location if location
-          headers headers if headers
+          headers&.each do |(name, value)|
+            header(name: name, value: value)
+          end
         end
       end