praxis 0.22.pre.1 → 2.0.pre.4

data/lib/praxis/bootloader.rb

@@ -47,9 +47,8 @@ module Praxis
       stages << BootloaderStages::WarnUnloadedFiles.new(:warn_unloaded_files, application)
 
       after(:app) do
-        Praxis::Mapper.finalize!
         Praxis::Blueprint.finalize!
-        Praxis::ResourceDefinition.finalize!(application: self.application)
+        Praxis::ResourceDefinition.finalize!
       end
 
     end

data/lib/praxis/bootloader_stages/environment.rb

@@ -8,6 +8,7 @@ module Praxis
       # 1) the environment.rb file    - generic stuff for all environments
       # 2) "Deployer.environment".rb  - environment specific stuff
       def execute
+        setup_initial_config!
 
         env_file = application.root + "config/environment.rb"
         require env_file if File.exists? env_file
@@ -36,6 +37,18 @@ module Praxis
         end
       end
 
+      # TODO: not really sure I like this here... but where else is better?
+      def setup_initial_config!
+        application.config do
+          attribute :praxis do
+            attribute :validate_responses, Attributor::Boolean, default: false
+            attribute :validate_response_bodies, Attributor::Boolean, default: false
+
+            attribute :show_exceptions, Attributor::Boolean, default: false
+            attribute :x_cascade, Attributor::Boolean, default: true
+          end
+        end
+      end
 
     end
 

data/lib/praxis/config.rb

@@ -54,7 +54,7 @@ module Praxis
             )
           end
           top.options.merge!(opts)
-          top.type.attributes(opts, &block)
+          top.type.attributes(**opts, &block)
         else
           @attribute.attributes[key] = Attributor::Attribute.new(type, opts, &block)
         end

data/lib/praxis/controller.rb

@@ -20,8 +20,6 @@ module Praxis
         end
 
         definition.controller = self
-        # `implements` should only be processed while the application initializes/setup
-        # So we will use the `.instance` function to get the "current" application instance
         Application.instance.controllers << self
       end
 

data/lib/praxis/dispatcher.rb

@@ -28,13 +28,11 @@ module Praxis
       @deferred_callbacks[:after] << [conditions, block]
     end
 
-    # Typically, this is only called from the router, and the app will always be known.
-    # But we'll leave the application param as optional if we know there is a dispatcher in the thread
-    def self.current(thread: Thread.current, application: nil)
+    def self.current(thread: Thread.current, application: Application.instance)
       thread[:praxis_dispatcher] ||= self.new(application: application)
     end
 
-    def initialize(application:)
+    def initialize(application: Application.instance)
       @stages = []
       @application = application
       setup_stages!
@@ -106,9 +104,9 @@ module Praxis
           response_stage.run
 
           payload[:response] = controller.response
-          controller.response.finish(application: application)
+          controller.response.finish
         rescue => e
-          @application.error_handler.handle!(request, e, app: application)
+          @application.error_handler.handle!(request, e)
         end
       end
     end

data/lib/praxis/docs/generator.rb

@@ -5,8 +5,7 @@ module Praxis
       require 'active_support/core_ext/enumerable' # For index_by
 
       API_DOCS_DIRNAME = 'docs/api'
-      
-      attr_reader :app_instance
+
       attr_reader :resources_by_version, :types_by_id, :infos_by_version
       attr_reader :doc_root_dir
 
@@ -25,21 +24,13 @@ module Praxis
         Attributor::URI,
       ]).freeze
 
-      def self.generate(root, name:, skip_sub_directory: false)
-        instance = Praxis::Application.registered_apps[name]
-        Thread.current[:praxis_instance] = instance
-        self.new(root, instance: instance, name: name, skip_sub_directory: skip_sub_directory).save!
-        Thread.current[:praxis_instance] = nil
-      end
-      
-      def initialize(root, instance:, name:, skip_sub_directory:)
+
+      def initialize(root)
         require 'yaml'
         @resources_by_version =  Hash.new do |h,k|
           h[k] = Set.new
         end
-        @app_instance = instance
-        subdir = skip_sub_directory ? nil : name
-        initialize_directories(root, subdir: subdir )
+        initialize_directories(root)
 
         Attributor::AttributeResolver.current = Attributor::AttributeResolver.new
         collect_infos
@@ -57,10 +48,9 @@ module Praxis
 
       private
 
-      def initialize_directories(root, subdir: nil )
+      def initialize_directories(root)
         @doc_root_dir = File.join(root, API_DOCS_DIRNAME)
-        @doc_root_dir = File.join(@doc_root_dir, subdir) if subdir
-        
+
         # remove previous data (and reset the directory)
         FileUtils.rm_rf @doc_root_dir if File.exists?(@doc_root_dir)
         FileUtils.mkdir_p @doc_root_dir unless File.exists? @doc_root_dir
@@ -68,7 +58,7 @@ module Praxis
 
       def collect_resources
         # load all resource definitions registered with Praxis
-        app_instance.resource_definitions.map do |resource|
+        Praxis::Application.instance.resource_definitions.map do |resource|
           # skip resources with doc_visibility of :none
           next if resource.metadata[:doc_visibility] == :none
           version = resource.version
@@ -86,7 +76,7 @@ module Praxis
 
       def collect_infos
         # All infos. Including keys for `:global`, "n/a", and any string version
-        @infos_by_version = app_instance.api_definition.describe
+        @infos_by_version = ApiDefinition.instance.describe
       end
 
 

data/lib/praxis/docs/link_builder.rb

@@ -20,7 +20,7 @@ module Praxis
 
       def endpoint
         @endpoint ||= begin
-          endpoint = Application.current_instance.api_definition.global_info.documentation_url
+          endpoint = ApiDefinition.instance.global_info.documentation_url
           endpoint.gsub(/\/index\.html$/i, '/') if endpoint
         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

@@ -159,7 +159,7 @@ module Praxis
               values
             else
               multimatch = false
-              match[:value]
+              values.first
             end
   
             attr_name = match[:attribute].to_sym

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/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