praxis 2.0.pre.4 → 2.0.pre.9

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

@@ -0,0 +1,45 @@
+require_relative 'pagination_handler'
+
+module Praxis
+  module Extensions
+    module Pagination
+      class SequelPaginationHandler < PaginationHandler
+
+        def self.where_lt(query, attr, value)
+          query.where("#{attr} < ?", value)
+        end
+        
+        def self.where_gt(query, attr, value)
+          query.where("#{attr} > ?", value)
+        end
+
+        def self.order(query, order)
+          return query unless order
+          order_clause = order.map do |spec_hash|
+            direction, name = spec_hash.first
+            case direction.to_sym
+            when :desc
+              Sequel.desc(name.to_sym)
+            else
+              Sequel.asc(name.to_sym)
+            end
+          end
+          query = query.order(*order_clause)
+          query
+        end
+        
+        def self.count(query)
+          query.count
+        end
+        
+        def self.offset(query, offset)
+          query.offset(offset)
+        end
+
+        def self.limit(query, limit)
+          query.limit(limit)
+        end        
+      end
+    end
+  end
+end

data/lib/praxis/handlers/json.rb

@@ -17,6 +17,8 @@ module Praxis
       # @param [String] document
       # @return [Hash,Array] the structured-data representation of the document
       def parse(document)
+        # Try to be nice and accept an empty string as an empty payload (seems nice to do for dumb http clients)
+        return nil if (document.nil? || document == '')
         ::JSON.parse(document)
       end
 

data/lib/praxis/handlers/www_form.rb

@@ -1,3 +1,8 @@
+# This is an example of a handler that can load and generate www-url-encoded payloads.
+# Note that if you use your API to pass nil values for attributes as a way to unset their 
+# values, this handler will not work (as there isn't necessarily a defined "null" value in 
+# this encoding (although you can probably define how to encode/decode it and use it as such)
+# Use at your own risk.
 module Praxis
   module Handlers
     class WWWForm

data/lib/praxis/handlers/{xml.rb → xml-sample.rb}

@@ -1,3 +1,9 @@
+# This is an example of a handler that can load and generate 'activesupport-style' xml payloads.
+# Note that if you use your API to pass nil values for attributes as a way to unset their values, 
+# this handler will not work (as there isn't necessarily a defined "null"  value in this encoding 
+# (although you can probably define how to encode/decode it and use it as such)
+# Use at your own risk
+
 module Praxis
   module Handlers
     class XML

data/lib/praxis/links.rb

@@ -54,6 +54,10 @@ module Praxis
       super(false,**opts) # Links must always describe attributes
     end
 
+    def self.json_schema_type
+      @attribute.type.json_schema_type
+    end
+
     def self._finalize!
       super
       if @attribute

data/lib/praxis/mapper/active_model_compat.rb

@@ -3,6 +3,7 @@
 require 'active_support/concern'
 
 require 'praxis/extensions/field_selection/active_record_query_selector'
+require 'praxis/extensions/attribute_filtering/active_record_filter_query_builder'
 
 module Praxis
   module Mapper
@@ -15,7 +16,7 @@ module Praxis
 
       module ClassMethods
         def _filter_query_builder_class
-          Praxis::Extensions::ActiveRecordFilterQueryBuilder
+          Praxis::Extensions::AttributeFiltering::ActiveRecordFilterQueryBuilder
         end
 
         def _field_selector_query_builder_class
@@ -57,19 +58,36 @@ module Praxis
           end
         end
 
+        def _join_foreign_key_for(assoc_reflection)
+          maj, min, _ = ActiveRecord.gem_version.segments
+          if maj >= 6 && min >=1
+            assoc_reflection.join_foreign_key.to_sym
+          else
+            assoc_reflection.join_keys.foreign_key.to_sym
+          end
+        end
+
+        def _join_primary_key_for(assoc_reflection)
+          maj, min, _ = ActiveRecord.gem_version.segments
+          if maj >= 6 && min >=1
+            assoc_reflection.join_primary_key.to_sym
+          else
+            assoc_reflection.join_keys.key.to_sym
+          end
+        end
         private
         def local_columns_used_for_the_association(type, assoc_reflection)
           case type
           when :one_to_many
             # The associated table  will point to us by key (usually the PK, but not always)
-            [assoc_reflection.join_keys.foreign_key.to_sym]
+            [_join_foreign_key_for(assoc_reflection)]
           when :many_to_one
             # We have the FKs to the associated model
-            [assoc_reflection.join_keys.foreign_key.to_sym]
+            [_join_foreign_key_for(assoc_reflection)]
           when :many_to_many
             ref = resolve_closest_through_reflection(assoc_reflection)
             # The associated middle table will point to us by key (usually the PK, but not always)
-            [ref.join_keys.foreign_key.to_sym] # The foreign key that the last through table points to
+            [_join_foreign_key_for(ref)] # The foreign key that the last through table points to
           else 
             raise "association type #{type} not supported"
           end
@@ -80,7 +98,7 @@ module Praxis
           # will always get us the right column
           case type
           when :one_to_many, :many_to_one, :many_to_many
-            [assoc_reflection.join_keys.key.to_sym]
+            [_join_primary_key_for(assoc_reflection)]
           else 
             raise "association type #{type} not supported"
           end

data/lib/praxis/mapper/resource.rb

@@ -196,17 +196,24 @@ module Praxis::Mapper
     end
 
     # TODO: this shouldn't be needed if we incorporate it with the properties of the mapper...
-    def self.filters_mapping(hash)
-      @_filter_query_builder_class = model._filter_query_builder_class.for(**hash)
-    end
-    
-    def self._filter_query_builder_class
-      @_filter_query_builder_class
+    # ...maybe what this means is that we can change it for a better DSL in the resource?
+    def self.filters_mapping(definition)
+      @_filters_map = \
+        case definition
+        when Hash
+          definition
+        when Array
+          definition.each_with_object({}) { |item, hash| hash[item.to_sym] = item }
+        else
+          raise "Resource.filters_mapping only allows a hash or an array"
+        end
     end
 
     def self.craft_filter_query(base_query, filters:) # rubocop:disable Metrics/AbcSize
-      if filters && _filter_query_builder_class
-        base_query = _filter_query_builder_class.new(query: base_query, model: model).build_clause(filters)
+      if filters 
+        raise "Must define the mapping of filters if want to use Filtering for resource: #{self}" unless @_filters_map
+        debug = Praxis::Application.instance.config.mapper.debug_queries
+        base_query = model._filter_query_builder_class.new(query: base_query, model: model, filters_map: @_filters_map, debug: debug).generate(filters)
       end
       
       base_query
@@ -215,7 +222,7 @@ module Praxis::Mapper
     def self.craft_field_selection_query(base_query, selectors:) # rubocop:disable Metrics/AbcSize
       if selectors && model._field_selector_query_builder_class
         debug = Praxis::Application.instance.config.mapper.debug_queries
-        base_query = model._field_selector_query_builder_class.new(query: base_query, selectors: selectors).generate(debug: debug)
+        base_query = model._field_selector_query_builder_class.new(query: base_query, selectors: selectors, debug: debug).generate
       end
       
       base_query

data/lib/praxis/mapper/selector_generator.rb

@@ -42,10 +42,6 @@ module Praxis::Mapper
       association[:local_key_columns].each {|col| add_select(col) }
       
       node = SelectorGeneratorNode.new(associated_resource)
-      if association[:remote_key_columns].nil?
-        binding.pry
-        puts association
-      end
       unless association[:remote_key_columns].empty?
         # Make sure we add the required columns for this association to the remote model query
         fields = {} if fields == true

data/lib/praxis/mapper/sequel_compat.rb

@@ -11,6 +11,7 @@ module Praxis::Mapper
 
     module ClassMethods
       def _filter_query_builder_class
+        # TODO: refactor the query builder, and add the explicit require in this file
         Praxis::Extensions::SequelFilterQueryBuilder
       end
 

data/lib/praxis/media_type.rb

@@ -7,15 +7,12 @@ module Praxis
   # encodings; for example, a controller might respond with an actual Widget object, but a
   # Content-Type header specifying 'application/vnd.acme.widget+json'; Praxis uses the information
   # contained in the media-type definition of Widget to transform the object into an equivalent
-  # JSON representation. If the content type ends with '+xml' instead, and the XML handler is
-  # registered with the framework, Praxis will respond with an XML representation of the
-  # widget. The use of media types allows your application's models to be decoupled from its
+  # JSON representation. The use of media types allows your application's models to be decoupled from its
   # HTTP interface specification.
   #
   # A media type definition consists of:
   #   - a MIME type identifier
   #   - attributes, each of which has a name and a data type
-  #   - named links to other resources
   #   - named views, which expose interesting subsets of attributes
   #
   # @example Declare a widget type that's used by my supply-chain management app
@@ -37,16 +34,6 @@ module Praxis
   #         description: 'The factory in which this widget was produced'
   #     end
   #
-  #     links do
-  #       link :factory,
-  #         description: 'Link to the factory in which this widget was produced'
-  #     end
-  #
-  #     # If widgets can be linked-to by other resources, they should have a link view
-  #     view :link do
-  #       attribute :href
-  #     end
-  #
   #     # All resources should have a default view
   #     view :default do
   #       attribute :id
@@ -58,32 +45,6 @@ module Praxis
 
     include Types::MediaTypeCommon
 
-    class DSLCompiler < Attributor::HashDSLCompiler
-      def links(&block)
-        attribute :links, Praxis::Links.for(options[:reference]), dsl_compiler: Links::DSLCompiler, &block
-      end
-    end
-
-    def self.attributes(opts={}, &block)
-      super(opts.merge(dsl_compiler: MediaType::DSLCompiler), &block)
-    end
-
-    def self._finalize!
-      super
-
-      # Only define our special links accessor if it was setup using the special DSL
-      # (we might have an app defining an attribute called `links` on its own, in which
-      # case we leave it be)
-      if @attribute && self.attributes.key?(:links) && self.attributes[:links].type < Praxis::Links
-        module_eval <<-RUBY, __FILE__, __LINE__ + 1
-        def links
-          self.class::Links.new(@object)
-        end
-        RUBY
-      end
-    end
-
-
     class FieldResolver
       def self.resolve(type,fields)
         self.new.resolve(type,fields)
@@ -118,30 +79,14 @@ module Praxis
 
 
         fields.each do |name, sub_fields|
-          # skip links and do them below
-          next if name == :links && defined?(type::Links)
 
           new_type = type.attributes[name].type
           result[name] = resolve(new_type, sub_fields)
         end
 
-        # now to tackle whatever links there may be
-        if defined?(type::Links) &&(links_fields = fields[:links])
-          resolved_links = resolve_links(type::Links, links_fields)
-          self.deep_merge(result, resolved_links)
-        end
-
         result
       end
 
-      def resolve_links(links_type, links)
-        links.each_with_object({}) do |(name, link_fields), hash|
-          using = links_type.links[name]
-          new_type = links_type.attributes[name].type
-          hash[using] = resolve(new_type, link_fields)
-        end
-      end
-
       # perform a deep recursive *in place* merge
       # form all values in +source+ onto +target+
       #

data/lib/praxis/multipart/part.rb

@@ -28,6 +28,10 @@ module Praxis
       self
     end
 
+    def self.json_schema_type
+      :object
+    end
+
     def self.example(context=nil, options:{})
       if (payload_attribute = options[:payload_attribute])
         payload = payload_attribute.example(context + ['payload'])
@@ -52,8 +56,7 @@ module Praxis
                headers_attribute: headers_attribute,
                filename_attribute: filename_attribute)
     end
-
-
+    
     def self.describe(shallow=true, example: nil, options:{})
       hash = super(shallow, example: example)
 

data/lib/praxis/plugins/mapper_plugin.rb

@@ -1,5 +1,5 @@
 require 'singleton'
-require 'praxis/extensions/attribute_filtering/filtering_params'
+require 'praxis/extensions/attribute_filtering'
 
 module Praxis
   module Plugins

data/lib/praxis/plugins/pagination_plugin.rb

@@ -0,0 +1,71 @@
+require 'singleton'
+require 'praxis/extensions/pagination'
+
+# Simple plugin concept
+# Example configuration for this plugin
+# Praxis::Application.configure do |application|
+#   application.bootloader.use Praxis::Plugins::PaginationPlugin, {
+#     max_items: 500,  # Unlimited by default,
+#     default_page_size: 100,
+#     disallow_paging_by_default: false,
+#     # See all available options below
+#   end
+# end
+#
+# This would be applied to all controllers etc...so if one does not that
+# It can easily add the `include Praxis::Extensions::Pagination` for every controller
+# and use the class `Praxis::Types::PaginationParams.xxx yyy` stanzas to configure defaults
+
+module Praxis
+  module Plugins
+    module PaginationPlugin
+      include Praxis::PluginConcern
+
+      class Plugin < Praxis::Plugin
+        include Singleton
+
+        def config_key
+          :pagination
+        end
+
+        def load_config!
+          @options || {}
+        end
+
+        def prepare_config!(node)
+          node.attributes do
+            attribute :max_items, Integer # Defaults to unlimited
+            attribute :default_page_size, Integer, default: Praxis::Types::PaginationParams.default_page_size
+            attribute :paging_default_mode, Hash, default: Praxis::Types::PaginationParams.paging_default_mode
+            attribute :disallow_paging_by_default, Attributor::Boolean, default: Praxis::Types::PaginationParams.disallow_paging_by_default
+            attribute :disallow_cursor_by_default, Attributor::Boolean, default: Praxis::Types::PaginationParams.disallow_cursor_by_default
+            attribute :disallow_cursor_by_default, Attributor::Boolean, default: Praxis::Types::PaginationParams.disallow_cursor_by_default
+            attribute :sorting do
+              attribute :enforce_all_fields, Attributor::Boolean, default: Praxis::Types::OrderingParams.enforce_all_fields
+            end
+          end
+        end
+
+        def setup!
+          self.config.each do |name, val|
+            if name == :sorting
+              val.each do |ordername, orderval|
+                Praxis::Types::OrderingParams.send(ordername, orderval)
+              end
+            else
+              Praxis::Types::PaginationParams.send(name, val)
+            end
+          end      
+        end
+      end
+
+      module Controller
+        extend ActiveSupport::Concern
+
+        included do
+          include Praxis::Extensions::Pagination
+        end
+      end
+    end
+  end
+end

data/lib/praxis/resource_definition.rb

@@ -95,14 +95,6 @@ module Praxis
         @on_finalize
       end
 
-      # FIXME: this is inconsistent with the rest of the magic DSL convention.
-      def routing(&block)
-        warn "DEPRECATED: ResourceDefinition.routing is deprecated use prefix directly instead."
-
-        # eval this assuming it will only call #prefix
-        self.instance_eval(&block)
-      end
-
       def prefix(prefix=nil)
         return @prefix if prefix.nil?
         @routing_prefix = nil # reset routing_prefix
@@ -125,7 +117,7 @@ module Praxis
         @routing_prefix = nil # reset routing_prefix
 
         parent_action = parent.canonical_path
-        parent_route = parent_action.primary_route.path
+        parent_route = parent_action.route.path
 
         # if a mapping is passed, it *must* resolve any param name conflicts
         unless mapping.any?
@@ -146,7 +138,7 @@ module Praxis
           if mapping.key?(name)
             param = mapping[name]
             # FIXME: this won't handle URI Template type paths, ie '/{parent_id}'
-            prefixed_path = parent_action.primary_route.prefixed_path
+            prefixed_path = parent_action.route.prefixed_path
             @parent_prefix = prefixed_path.gsub(/(:)(#{name})(\W+|$)/, "\\1#{param.to_s}\\3")
           else
             mapping[name] = name
@@ -221,14 +213,14 @@ module Praxis
       end
 
       def to_href( params )
-        canonical_path.primary_route.path.expand(params.transform_values(&:to_s))
+        canonical_path.route.path.expand(params)
       end
 
       def parse_href(path)
         if path.kind_of?(::URI::Generic)
           path = path.path
         end
-        param_values = canonical_path.primary_route.path.params(path)
+        param_values = canonical_path.route.path.params(path)
         attrs = canonical_path.params.attributes
         param_values.each_with_object({}) do |(key,value),hash|
           hash[key.to_sym] = attrs[key.to_sym].load(value,[key])