praxis 0.22.pre.2 → 2.0.pre.5

data/lib/praxis/docs/openapi/server_object.rb

@@ -0,0 +1,24 @@
+module Praxis
+  module Docs
+    module OpenApi
+      class ServerObject
+        # https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.2.md#server-object
+        attr_reader :url, :description, :variables
+        def initialize(url: , description: nil, variables: [])
+          @url = url
+          @description = description
+          @variables = variables
+          raise "OpenApi docs require a 'url' for your server object." unless url
+        end
+
+        def dump
+          result = {url: url}
+          result[:description] = description if description
+          result[:variables] = variables unless variables.empty?
+
+          result
+        end
+      end
+    end
+  end
+end

data/lib/praxis/docs/openapi/tag_object.rb

@@ -0,0 +1,21 @@
+module Praxis
+  module Docs
+    module OpenApi
+      class TagObject
+        attr_reader :name, :description
+        def initialize(name:,description: )
+          @name = name
+          @description = description
+        end
+
+        def dump
+          {
+            name: name,
+            description: description,
+            #externalDocs: ???,
+          }
+        end
+      end
+    end
+  end
+end

data/lib/praxis/error_handler.rb

@@ -1,15 +1,15 @@
 module Praxis
   class ErrorHandler
-    
-    def handle!(request, error, app:)
-      app.logger.error error.inspect
+
+    def handle!(request, error)
+      Application.instance.logger.error error.inspect
       error.backtrace.each do |line|
-        app.logger.error line
+        Application.instance.logger.error line
       end
 
       response = Responses::InternalServerError.new(error: error)
       response.request = request
-      response.finish(application: app)
+      response.finish
     end
 
   end

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

@@ -23,7 +23,7 @@ module Praxis
       end
 
       # Base query to build upon
-      def initialize(query: , model: )
+      def initialize(query: , model:)
         @query = query
         @table = model.table_name
         @last_join_alias = model.table_name

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

@@ -62,6 +62,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)

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

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+# rubocop:disable all
+module Praxis
+  module Extensions
+    class SequelFilterQueryBuilder
+      attr_reader :query, :root
+
+      # Abstract class, which needs to be used by subclassing it through the .for method, to set the mapping of attributes
+      class << self
+        def for(definition)
+          Class.new(self) do
+            @attr_to_column = case definition
+                              when Hash
+                                definition
+                              when Array
+                                definition.each_with_object({}) { |item, hash| hash[item.to_sym] = item }
+                              else
+                                raise "Cannot use FilterQueryBuilder.of without passing an array or a hash (Got: #{definition.class.name})"
+                              end
+            class << self
+              attr_reader :attr_to_column
+            end
+          end
+        end
+      end
+
+      # Base query to build upon
+      # table is necessary when use the strin queries, when the query has multiple tables involved
+      # (to disambiguate)
+      def initialize(query:, model: )
+        @query = query
+        @root = model.table_name
+      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
+      def build_clause(filters)
+        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
+          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
+            bindings.each{|col,val| expand_binding(column_name: col, op: spec[:op], value: val )}
+          else
+            expand_binding(column_name: column_name, **spec)
+          end
+        end
+        query
+      end
+
+      def expand_binding(column_name:,op:,value:)
+        assoc_or_field, *rest = column_name.to_s.split('.')
+        if rest.empty?
+          column_name = Sequel.qualify(root,column_name)
+        else
+          puts "Adding eager graph for #{assoc_or_field} due to being used in filter"
+          # Ensure the joined table is aliased properly (to the association name) so we can add the condition appropriately
+          @query = query.eager_graph(Sequel.as(assoc_or_field.to_sym, assoc_or_field.to_sym) )
+          column_name = Sequel.qualify(assoc_or_field, rest.first)
+        end
+        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
+      end
+
+      # Private to try to funnel all column names through `build_clause` that restricts
+      # the attribute names better (to allow more difficult SQL injections )
+      private def add_clause(attr:, op:, value:)
+        # TODO: partial matching
+        #components = attr.to_s.split('.')
+        #attr_selector = Sequel.qualify(*components)
+        attr_selector = attr
+  #      HERE!! if we have "association.name" we should properly join it ...!
+
+  #> ds.eager_graph(:device).where{{device[:name] => 'A%'}}.select(:accountID)
+  #=> #<Sequel::Mysql2::Dataset: "SELECT `accountID` FROM `EventData`
+  #     LEFT OUTER JOIN `Device` AS `device` ON
+  #           ((`device`.`accountID` = `EventData`.`accountID`) AND (`device`.`deviceID` = `EventData`.`deviceID`))
+  #      WHERE (`device`.`name` = 'A%')">
+        likeval = get_like_value(value)
+        @query =  case op
+                  when '='
+                    if likeval
+                      query.where(Sequel.like(attr_selector, likeval))
+                    else
+                      query.where(attr_selector => value)
+                    end
+                  when '!='
+                    if likeval
+                      query.exclude(Sequel.like(attr_selector, likeval))
+                    else
+                      query.exclude(attr_selector => value)
+                    end
+                  when '>'
+                    #query.where(Sequel.lit("#{attr_selector} > ?", value))
+                    query.where{attr_selector > value}
+                  when '<'
+                    query.where{attr_selector < value}
+                  when '>='
+                    query.where{attr_selector >= value}
+                  when '<='
+                    query.where{attr_selector <= value}
+                  else
+                    raise "Unsupported Operator!!! #{op}"
+                  end
+      end
+
+      # Returns nil if the value was not a fuzzzy pattern
+      def get_like_value(value)
+        if value.is_a?(String) && (value[-1] == '*' || value[0] == '*')
+          likeval = value.dup
+          likeval[-1] = '%' if value[-1] == '*'
+          likeval[0] = '%' if value[0] == '*'
+          likeval
+        end
+      end
+    end
+  end
+end
+# rubocop:enable all

data/lib/praxis/extensions/field_selection.rb

@@ -1,13 +1,2 @@
 require 'attributor/extras/field_selector'
-
-require 'praxis/extensions/field_selection/field_selector'
-# TODO: we should conditionally require it based on what ORM/s we want...
-require 'praxis/extensions/field_selection/active_record_query_selector'
-
-
-module Praxis
-  module Extensions
-    module FieldSelection
-    end
-  end
-end
+require 'praxis/extensions/field_selection/field_selector'

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

@@ -3,53 +3,47 @@ module Praxis
   module Extensions
     module FieldSelection
       class ActiveRecordQuerySelector
-        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(ds:, model:, selectors:, resolved:)
+        def initialize(query:, selectors:)
           @selector = selectors
-          @ds = ds
-          @top_model = model
-          @resolved = resolved
-          @seen = Set.new
-          @root = model.table_name
+          @query = query
         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.to_sym]
-            ds.select(*fields)
-          else
-            ds
-          end
-        end
-
-        def generate
+        def generate(debug: false)
           # 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...)
-          @ds = add_select(ds: ds, model: top_model, table_name: root)
+          @query = add_select(query: query, selector_node: selector)
+          eager_hash = _eager(selector)
 
-          @ds.includes(_eager(top_model, resolved) )
+          @query = @query.includes(eager_hash)          
+          explain_query(query, eager_hash) if debug
+
+          @query
         end
 
-        def _eager(model, resolved)
-            # Cannot select fields in included rels...boooo :()
-            # d = add_select(ds: dset, model: model, table_name: model.table_name)
-            tracks = only_assoc_for(model, resolved)
-            tracks.inject([]) do |dataset, track|
-              next dataset if @seen.include?([model, track])
-              @seen << [model, track]
-              assoc_model = model.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.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)
+          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})")
+          query.explain
+          ActiveRecord::Base.logger.debug("Query plan end")
+          ActiveRecord::Base.logger = prev
         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,59 @@
 # 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(ds:, model:, selectors:, resolved:)
+        def initialize(query:, selectors:)
           @selector = selectors
-          @ds = ds
-          @top_model = model
-          @resolved = resolved
-          @seen = Set.new
-          @root = model.table_name
+          @query = query
         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
+        def generate(debug: false)
+          @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
-        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.associations[track][:model]
-            #      hash[track] = _eager(assoc_model, resolved[track])
-            dataset.eager(track => _eager(assoc_model, resolved[track]))
-          end
+          explain_query(query) if debug
+          @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.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.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)
+          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)}")
+          ds.all
+          stdout_logger.debug("Query plan end")
+          Sequel::Model.db.loggers = prev_loggers
         end
       end
     end

data/lib/praxis/extensions/rendering.rb

@@ -24,7 +24,7 @@ module Praxis
         response.body = render(object, include_nil: include_nil)
         response
       rescue Praxis::Renderer::CircularRenderingError => e
-          Praxis::Application.current_instance.validation_handler.handle!(
+          Praxis::Application.instance.validation_handler.handle!(
           summary: "Circular Rendering Error when rendering response. " +
                    "Please especify a view to narrow the dependent fields, or narrow your field set.",
           exception: e,

data/lib/praxis/file_group.rb

@@ -7,7 +7,7 @@ module Praxis
     def initialize(base, &block)
       if base.nil?
         raise ArgumentError, "base must not be nil." \
-          "Have you forgot to call 'setup' on the Praxis application instance?"
+          "Are you missing a call Praxis::Application.instance.setup?"
       end
 
 

data/lib/praxis/handlers/xml.rb

@@ -60,7 +60,7 @@ module Praxis
         when "symbol"
           return node.content.to_sym
         when "decimal"
-          return BigDecimal.new(node.content)
+          return BigDecimal(node.content)
         when "float"
           return Float(node.content)
         when "boolean"